task

• operation
• residue_selector
• rna

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)

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: pyrosetta.rosetta.core.pack.task.ALLAA) -> None
2. __init__(self: pyrosetta.rosetta.core.pack.task.ALLAA, arg0: pyrosetta.rosetta.core.pack.task.ALLAA) -> None

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

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>

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)

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: pyrosetta.rosetta.core.pack.task.ALLAAwc) -> None
2. __init__(self: pyrosetta.rosetta.core.pack.task.ALLAAwc, arg0: pyrosetta.rosetta.core.pack.task.ALLAAwc) -> None

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

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>

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

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: pyrosetta.rosetta.core.pack.task.ALLAAxc) -> None
2. __init__(self: pyrosetta.rosetta.core.pack.task.ALLAAxc, arg0: pyrosetta.rosetta.core.pack.task.ALLAAxc) -> None

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

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>

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 deprecated, it calls APOLAR to allow nonpolar residues and packing

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: pyrosetta.rosetta.core.pack.task.APOLA) -> None
2. __init__(self: pyrosetta.rosetta.core.pack.task.APOLA, arg0: pyrosetta.rosetta.core.pack.task.APOLA) -> None

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

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>

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

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: pyrosetta.rosetta.core.pack.task.APOLAR) -> None
2. __init__(self: pyrosetta.rosetta.core.pack.task.APOLAR, arg0: pyrosetta.rosetta.core.pack.task.APOLAR) -> None

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

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>

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

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: pyrosetta.rosetta.core.pack.task.AUTO) -> None
2. __init__(self: pyrosetta.rosetta.core.pack.task.AUTO, arg0: pyrosetta.rosetta.core.pack.task.AUTO) -> None

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

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>

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

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

EMPTY disallows all canonical and noncanonical residues

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: pyrosetta.rosetta.core.pack.task.EMPTY) -> None
2. __init__(self: pyrosetta.rosetta.core.pack.task.EMPTY, arg0: pyrosetta.rosetta.core.pack.task.EMPTY) -> None

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

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>

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

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: pyrosetta.rosetta.core.pack.task.EX) -> None
2. __init__(self: pyrosetta.rosetta.core.pack.task.EX, arg0: pyrosetta.rosetta.core.pack.task.EX) -> None

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

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>

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)

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: pyrosetta.rosetta.core.pack.task.EX_CUTOFF) -> None
2. __init__(self: pyrosetta.rosetta.core.pack.task.EX_CUTOFF, arg0: pyrosetta.rosetta.core.pack.task.EX_CUTOFF) -> None

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

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>

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.

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__(*args, **kwargs)

Overloaded function.

1. __eq__(self: pyrosetta.rosetta.core.pack.task.ExtraRotSample, arg0: pyrosetta.rosetta.core.pack.task.ExtraRotSample) -> bool
2. __eq__(self: pyrosetta.rosetta.core.pack.task.ExtraRotSample, arg0: int) -> bool

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__getstate__(self: pyrosetta.rosetta.core.pack.task.ExtraRotSample) → tuple

__gt__

Return self>value.

__hash__(self: pyrosetta.rosetta.core.pack.task.ExtraRotSample) → int

__init__(self: pyrosetta.rosetta.core.pack.task.ExtraRotSample, arg0: int) → None

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__int__(self: pyrosetta.rosetta.core.pack.task.ExtraRotSample) → int

__le__

Return self<=value.

__lt__

Return self<value.

__ne__(*args, **kwargs)

Overloaded function.

1. __ne__(self: pyrosetta.rosetta.core.pack.task.ExtraRotSample, arg0: pyrosetta.rosetta.core.pack.task.ExtraRotSample) -> bool
2. __ne__(self: pyrosetta.rosetta.core.pack.task.ExtraRotSample, arg0: int) -> bool

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__(self: pyrosetta.rosetta.core.pack.task.ExtraRotSample) → str

__setattr__

Implement setattr(self, name, value).

__setstate__(self: pyrosetta.rosetta.core.pack.task.ExtraRotSample, arg0: tuple) → None

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

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

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: pyrosetta.rosetta.core.pack.task.FIX_HIS_TAUTOMER) -> None
2. __init__(self: pyrosetta.rosetta.core.pack.task.FIX_HIS_TAUTOMER, arg0: pyrosetta.rosetta.core.pack.task.FIX_HIS_TAUTOMER) -> None

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

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>

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

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(self: pyrosetta.rosetta.core.pack.task.IGEdgeReweightContainer, nres: int) → None

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

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

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: pyrosetta.rosetta.core.pack.task.IGEdgeReweighter) -> None
2. __init__(self: pyrosetta.rosetta.core.pack.task.IGEdgeReweighter, arg0: pyrosetta.rosetta.core.pack.task.IGEdgeReweighter) -> None

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

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)

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: pyrosetta.rosetta.core.pack.task.NATAA) -> None
2. __init__(self: pyrosetta.rosetta.core.pack.task.NATAA, arg0: pyrosetta.rosetta.core.pack.task.NATAA) -> None

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

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>

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

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: pyrosetta.rosetta.core.pack.task.NATRO) -> None
2. __init__(self: pyrosetta.rosetta.core.pack.task.NATRO, arg0: pyrosetta.rosetta.core.pack.task.NATRO) -> None

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

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>

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

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: pyrosetta.rosetta.core.pack.task.NC, arg0: pyrosetta.rosetta.core.pack.task.NC) -> None
2. __init__(self: pyrosetta.rosetta.core.pack.task.NC) -> None

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

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>

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

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: pyrosetta.rosetta.core.pack.task.NOTAA) -> None
2. __init__(self: pyrosetta.rosetta.core.pack.task.NOTAA, arg0: pyrosetta.rosetta.core.pack.task.NOTAA) -> None

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

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>

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

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: pyrosetta.rosetta.core.pack.task.NO_ADDUCTS) -> None
2. __init__(self: pyrosetta.rosetta.core.pack.task.NO_ADDUCTS, arg0: pyrosetta.rosetta.core.pack.task.NO_ADDUCTS) -> None

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

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>

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

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: pyrosetta.rosetta.core.pack.task.PIKAA) -> None
2. __init__(self: pyrosetta.rosetta.core.pack.task.PIKAA, arg0: pyrosetta.rosetta.core.pack.task.PIKAA) -> None

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

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>

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

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: pyrosetta.rosetta.core.pack.task.PIKNA) -> None
2. __init__(self: pyrosetta.rosetta.core.pack.task.PIKNA, arg0: pyrosetta.rosetta.core.pack.task.PIKNA) -> None

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

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>

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

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: pyrosetta.rosetta.core.pack.task.PIKRNA) -> None
2. __init__(self: pyrosetta.rosetta.core.pack.task.PIKRNA, arg0: pyrosetta.rosetta.core.pack.task.PIKRNA) -> None

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

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>

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

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: pyrosetta.rosetta.core.pack.task.POLAR) -> None
2. __init__(self: pyrosetta.rosetta.core.pack.task.POLAR, arg0: pyrosetta.rosetta.core.pack.task.POLAR) -> None

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

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>

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

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__

Initialize self. See help(type(self)) for accurate signature.

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

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

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

add_behavior(*args, **kwargs)

Overloaded function.

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

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

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

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

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

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

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

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

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

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

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

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

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

has_behavior(*args, **kwargs)

Overloaded function.

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

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

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

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

high_temp(*args, **kwargs)

Overloaded function.

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

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

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

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

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.

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

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

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

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

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

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

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

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

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

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

nonconst_residue_task(self: pyrosetta.rosetta.core.pack.task.PackerTask, resid: int) → 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.

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

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

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

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

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

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

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

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

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

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

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

or_include_current(*args, **kwargs)

Overloaded function.

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

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

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

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

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

Activate a LazyInteractionGraph that computes rotamer pair energies at most once

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

rotamer_links(*args, **kwargs)

Overloaded function.

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

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

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

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

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

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

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.

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

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

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

show_all_residue_tasks(*args, **kwargs)

Overloaded function.

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

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

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

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

show_residue_task(*args, **kwargs)

Overloaded function.

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

C++: core::pack::task::PackerTask::show_residue_task(class std::basic_ostream<char> &, unsigned long) const –> void

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

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

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

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: pyrosetta.rosetta.core.pack.task.PackerTask_) -> None
2. __init__(self: pyrosetta.rosetta.core.pack.task.PackerTask_, pose: pyrosetta.rosetta.core.pose.Pose) -> None
3. __init__(self: pyrosetta.rosetta.core.pack.task.PackerTask_, arg0: pyrosetta.rosetta.core.pack.task.PackerTask_) -> None

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

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

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

add_behavior(*args, **kwargs)

Overloaded function.

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

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

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

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

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

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

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

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

Returns the double-lazy interaction graph flag

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

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

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

signifies an unrestricted limit.

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

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

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

has_behavior(*args, **kwargs)

Overloaded function.

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

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

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

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

high_temp(*args, **kwargs)

Overloaded function.

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

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

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

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

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.

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

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

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

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

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

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

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

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

use MultiCoolAnnealer?

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

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

returns the requested size for the MultiCoolAnnealer

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

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

nonconst access to underlying ResidueLevelTask object

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

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

get function: how many positions can have rotamer changes?

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

or_adducts(*args, **kwargs)

Overloaded function.

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

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

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

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

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

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

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

Activate the DoubleLazyInteractionGraph, which is particularly useful

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

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

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

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

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

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

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

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

or_include_current(*args, **kwargs)

Overloaded function.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

const accessor for the RotamerCouplings object

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

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

setter for the RotamerCouplings object

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

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

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

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

rotamer_links(*args, **kwargs)

Overloaded function.

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

const accessor for the RotamerLinks object

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

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

setter for the RotamerLinks object

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

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

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

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

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.

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

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

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

show_all_residue_tasks(*args, **kwargs)

Overloaded function.

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

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

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

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

show_residue_task(*args, **kwargs)

Overloaded function.

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

C++: core::pack::task::PackerTask_::show_residue_task(class std::basic_ostream<char> &, unsigned long) const –> void

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

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

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

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: pyrosetta.rosetta.core.pack.task.RESET) -> None
2. __init__(self: pyrosetta.rosetta.core.pack.task.RESET, arg0: pyrosetta.rosetta.core.pack.task.RESET) -> None

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

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>

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

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: pyrosetta.rosetta.core.pack.task.ResfileCommand, arg0: pyrosetta.rosetta.core.pack.task.ResfileCommand) -> None
2. __init__(self: pyrosetta.rosetta.core.pack.task.ResfileCommand) -> None

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

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>

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

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask_, original_residue: pyrosetta.rosetta.core.conformation.Residue, pose: pyrosetta.rosetta.core.pose.Pose) -> None
2. __init__(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask_) -> None

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

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.

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

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

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

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

2. has_behavior(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask_) -> bool

C++: core::pack::task::ResidueLevelTask_::has_behavior() const –> bool

include_current(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask_) → bool

is the pre-existing rotamer specifically allowed while packing?

C++: core::pack::task::ResidueLevelTask_::include_current() const –> bool

include_virtual_side_chain(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask_) → bool

C++: core::pack::task::ResidueLevelTask_::include_virtual_side_chain() const –> bool

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

Initialize only the extra rotamer building flags from the command line;

invoked by intialize_from_command_line();

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

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

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

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

initialize options from command line flags

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

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

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

is_original_type(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask_, type: pyrosetta.rosetta.core.chemical.ResidueType) → bool

C++: core::pack::task::ResidueLevelTask_::is_original_type(class std::shared_ptr<const class core::chemical::ResidueType>) const –> bool

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.

1. restrict_absent_canonical_aas(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask_, : pyrosetta.rosetta.utility.vector1_bool) -> None

disables designing to residues not in the passed list

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

2. restrict_absent_canonical_aas(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask_, allowed_aas: pyrosetta.rosetta.utility.vector1_bool, mode: str) -> None

disables designing to residues not in the passed list–and specifies the resfile command that made this list

C++: core::pack::task::ResidueLevelTask_::restrict_absent_canonical_aas(const class utility::vector1<bool, class std::allocator<bool> > &, const 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.

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

sample proton chi.

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

2. sample_proton_chi(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask_) -> bool

sample proton chi.

C++: core::pack::task::ResidueLevelTask_::sample_proton_chi() const –> bool

target_type(*args, **kwargs)

Overloaded function.

1. target_type(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask_, type: pyrosetta.rosetta.core.chemical.ResidueType) -> None

C++: core::pack::task::ResidueLevelTask_::target_type(class std::shared_ptr<const class core::chemical::ResidueType>) –> void

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

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

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

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

4. target_type(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask_) -> pyrosetta.rosetta.core.chemical.ResidueType

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

update_commutative(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask_, res_task_in: pyrosetta.rosetta.core.pack.task.ResidueLevelTask) → None

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

update_intersection(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask_, res_task_in: pyrosetta.rosetta.core.pack.task.ResidueLevelTask) → None

C++: core::pack::task::ResidueLevelTask_::update_intersection(const class core::pack::task::ResidueLevelTask &) –> void

update_union(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask_, res_task_in: pyrosetta.rosetta.core.pack.task.ResidueLevelTask) → None

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

C++: core::pack::task::ResidueLevelTask_::update_union(const class core::pack::task::ResidueLevelTask &) –> void

class pyrosetta.rosetta.core.pack.task.SCAN

Bases: 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

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: pyrosetta.rosetta.core.pack.task.SCAN) -> None
2. __init__(self: pyrosetta.rosetta.core.pack.task.SCAN, arg0: pyrosetta.rosetta.core.pack.task.SCAN) -> None

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

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>

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

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: pyrosetta.rosetta.core.pack.task.TARGET, arg0: pyrosetta.rosetta.core.pack.task.TARGET) -> None
2. __init__(self: pyrosetta.rosetta.core.pack.task.TARGET) -> None

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

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>

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

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: pyrosetta.rosetta.core.pack.task.TaskFactory) -> None
2. __init__(self: pyrosetta.rosetta.core.pack.task.TaskFactory, arg0: pyrosetta.rosetta.core.pack.task.TaskFactory) -> None

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

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

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: pyrosetta.rosetta.core.pack.task.USE_INPUT_SC) -> None
2. __init__(self: pyrosetta.rosetta.core.pack.task.USE_INPUT_SC, arg0: pyrosetta.rosetta.core.pack.task.USE_INPUT_SC) -> None

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

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>

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.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.get_token(*args, **kwargs)

Overloaded function.

1. get_token(which_token: int, tokens: pyrosetta.rosetta.utility.vector1_std_string) -> str
2. get_token(which_token: int, tokens: pyrosetta.rosetta.utility.vector1_std_string, make_upper_case: bool) -> str

utility function to increment next token to be parsed

C++: core::pack::task::get_token(const unsigned long, const class utility::vector1<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_resfile(*args, **kwargs)

Overloaded function.

1. parse_resfile(pose: pyrosetta.rosetta.core.pose.Pose, the_task: pyrosetta.rosetta.core.pack.task.PackerTask) -> None

changes the state of the given PackerTask according to the commands in the resfile at read in from the -pack:resfile option system.

C++: core::pack::task::parse_resfile(const class core::pose::Pose &, class core::pack::task::PackerTask &) –> void

2. parse_resfile(pose: pyrosetta.rosetta.core.pose.Pose, the_task: pyrosetta.rosetta.core.pack.task.PackerTask, filename: str) -> None

changes the state of the given PackerTask according to the commands in the resfile at filename

C++: core::pack::task::parse_resfile(const class core::pose::Pose &, class core::pack::task::PackerTask &, const class std::basic_string<char> &) –> void

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

Overloaded function.

1. parse_resfile_string(pose: pyrosetta.rosetta.core.pose.Pose, the_task: pyrosetta.rosetta.core.pack.task.PackerTask, resfile_fname: str, resfile_string: str) -> None

changes the state of the given PackerTask according to the commands in the resfile.

This version calls the overloaded parse_resfile_string and just passes it a ResidueSubset that’s set to “true” for every residue of the pose.

C++: core::pack::task::parse_resfile_string(const class core::pose::Pose &, class core::pack::task::PackerTask &, const class std::basic_string<char> &, const class std::basic_string<char> &) –> void

2. parse_resfile_string(pose: pyrosetta.rosetta.core.pose.Pose, the_task: pyrosetta.rosetta.core.pack.task.PackerTask, resfile_fname: str, resfile_string: str, mask: pyrosetta.rosetta.utility.vector1_bool) -> None

changes the state of the given PackerTask according to the commands in the resfile.

This version accepts a ResidueSubset (a utility::vector1<bool>) that serves as a mask. Residues set to “false” don’t have their packer behaviour altered by this TaskOperation.

C++: core::pack::task::parse_resfile_string(const class core::pose::Pose &, class core::pack::task::PackerTask &, const 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.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(inputstream: pyrosetta.rosetta.std.istream) → pyrosetta.rosetta.utility.vector1_std_string

utility function for resfile reader

C++: core::pack::task::tokenize_line(class std::basic_istream<char> &) –> class utility::vector1<std::string, class std::allocator<std::string > >