task_operations¶

Bindings for protocols::toolbox::task_operations namespace

class pyrosetta.rosetta.protocols.toolbox.task_operations.AlignedThreadOperation¶

Bases: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictOperationsBase

this class is a TaskOperation to prevent repacking of residues not near an interface.

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

__init__(self: pyrosetta.rosetta.protocols.toolbox.task_operations.AlignedThreadOperation) -> None
__init__(self: pyrosetta.rosetta.protocols.toolbox.task_operations.AlignedThreadOperation, arg0: pyrosetta.rosetta.protocols.toolbox.task_operations.AlignedThreadOperation) -> 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).

alignment_file(*args, **kwargs)¶

Overloaded function.

alignment_file(self: pyrosetta.rosetta.protocols.toolbox.task_operations.AlignedThreadOperation) -> str

C++: protocols::toolbox::task_operations::AlignedThreadOperation::alignment_file() const –> std::string

alignment_file(self: pyrosetta.rosetta.protocols.toolbox.task_operations.AlignedThreadOperation, s: str) -> None

C++: protocols::toolbox::task_operations::AlignedThreadOperation::alignment_file(const class std::basic_string<char> &) –> void

apply(self: pyrosetta.rosetta.protocols.toolbox.task_operations.AlignedThreadOperation, : pyrosetta.rosetta.core.pose.Pose, : pyrosetta.rosetta.core.pack.task.PackerTask) → None¶: C++: protocols::toolbox::task_operations::AlignedThreadOperation::apply(const class core::pose::Pose &, class core::pack::task::PackerTask &) const –> void

assign(self: pyrosetta.rosetta.protocols.toolbox.task_operations.AlignedThreadOperation, : pyrosetta.rosetta.protocols.toolbox.task_operations.AlignedThreadOperation) → pyrosetta.rosetta.protocols.toolbox.task_operations.AlignedThreadOperation¶: C++: protocols::toolbox::task_operations::AlignedThreadOperation::operator=(const class protocols::toolbox::task_operations::AlignedThreadOperation &) –> class protocols::toolbox::task_operations::AlignedThreadOperation &

clone(self: pyrosetta.rosetta.protocols.toolbox.task_operations.AlignedThreadOperation) → pyrosetta.rosetta.core.pack.task.operation.TaskOperation¶: C++: protocols::toolbox::task_operations::AlignedThreadOperation::clone() const –> class std::shared_ptr<class core::pack::task::operation::TaskOperation>

keyname() → str¶: C++: protocols::toolbox::task_operations::AlignedThreadOperation::keyname() –> std::string

parse_tag(self: pyrosetta.rosetta.protocols.toolbox.task_operations.AlignedThreadOperation, : pyrosetta.rosetta.utility.tag.Tag, : pyrosetta.rosetta.basic.datacache.DataMap) → None¶: C++: protocols::toolbox::task_operations::AlignedThreadOperation::parse_tag(class std::shared_ptr<const class utility::tag::Tag>, class basic::datacache::DataMap &) –> void

provide_xml_schema(xsd: pyrosetta.rosetta.utility.tag.XMLSchemaDefinition) → None¶: C++: protocols::toolbox::task_operations::AlignedThreadOperation::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) –> void

query_name(*args, **kwargs)¶

Overloaded function.

query_name(self: pyrosetta.rosetta.protocols.toolbox.task_operations.AlignedThreadOperation) -> str

C++: protocols::toolbox::task_operations::AlignedThreadOperation::query_name() const –> std::string

query_name(self: pyrosetta.rosetta.protocols.toolbox.task_operations.AlignedThreadOperation, s: str) -> None

C++: protocols::toolbox::task_operations::AlignedThreadOperation::query_name(const class std::basic_string<char> &) –> void

start_res(*args, **kwargs)¶

Overloaded function.

start_res(self: pyrosetta.rosetta.protocols.toolbox.task_operations.AlignedThreadOperation, s: int) -> None

C++: protocols::toolbox::task_operations::AlignedThreadOperation::start_res(const unsigned long) –> void

start_res(self: pyrosetta.rosetta.protocols.toolbox.task_operations.AlignedThreadOperation) -> int

C++: protocols::toolbox::task_operations::AlignedThreadOperation::start_res() const –> unsigned long

template_name(*args, **kwargs)¶

Overloaded function.

template_name(self: pyrosetta.rosetta.protocols.toolbox.task_operations.AlignedThreadOperation) -> str

C++: protocols::toolbox::task_operations::AlignedThreadOperation::template_name() const –> std::string

template_name(self: pyrosetta.rosetta.protocols.toolbox.task_operations.AlignedThreadOperation, s: str) -> None

C++: protocols::toolbox::task_operations::AlignedThreadOperation::template_name(const class std::basic_string<char> &) –> void

class pyrosetta.rosetta.protocols.toolbox.task_operations.ConservativeDesignOperation¶

Bases: pyrosetta.rosetta.core.pack.task.operation.TaskOperation

A TaskOperation that sets the allowed amino acids of designable residues to the native amino acid’s conservative mutations.

Default is to act on all designable residues. Use limit_to_positions to limit this. Default is to replace the allowed_aas with these conservative mutations. Data is loaded from database/sequence/resinfo.db.

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

__init__(self: pyrosetta.rosetta.protocols.toolbox.task_operations.ConservativeDesignOperation) -> None
__init__(self: pyrosetta.rosetta.protocols.toolbox.task_operations.ConservativeDesignOperation, data_source: str) -> None
__init__(self: pyrosetta.rosetta.protocols.toolbox.task_operations.ConservativeDesignOperation, arg0: pyrosetta.rosetta.protocols.toolbox.task_operations.ConservativeDesignOperation) -> 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_to_allowed_aas(self: pyrosetta.rosetta.protocols.toolbox.task_operations.ConservativeDesignOperation, setting: bool) → None¶

Add to the allowed amino acids list instead of replacing it. Default false.

C++: protocols::toolbox::task_operations::ConservativeDesignOperation::add_to_allowed_aas(const bool &) –> void

apply(self: pyrosetta.rosetta.protocols.toolbox.task_operations.ConservativeDesignOperation, pose: pyrosetta.rosetta.core.pose.Pose, task: pyrosetta.rosetta.core.pack.task.PackerTask) → None¶: C++: protocols::toolbox::task_operations::ConservativeDesignOperation::apply(const class core::pose::Pose &, class core::pack::task::PackerTask &) const –> void

assign(self: pyrosetta.rosetta.protocols.toolbox.task_operations.ConservativeDesignOperation, rhs: pyrosetta.rosetta.protocols.toolbox.task_operations.ConservativeDesignOperation) → pyrosetta.rosetta.protocols.toolbox.task_operations.ConservativeDesignOperation¶: C++: protocols::toolbox::task_operations::ConservativeDesignOperation::operator=(const class protocols::toolbox::task_operations::ConservativeDesignOperation &) –> class protocols::toolbox::task_operations::ConservativeDesignOperation &

clear_positions(self: pyrosetta.rosetta.protocols.toolbox.task_operations.ConservativeDesignOperation) → None¶

Clear any set positions.

C++: protocols::toolbox::task_operations::ConservativeDesignOperation::clear_positions() –> void

clone(self: pyrosetta.rosetta.protocols.toolbox.task_operations.ConservativeDesignOperation) → pyrosetta.rosetta.core.pack.task.operation.TaskOperation¶: C++: protocols::toolbox::task_operations::ConservativeDesignOperation::clone() const –> class std::shared_ptr<class core::pack::task::operation::TaskOperation>

include_native_aa(self: pyrosetta.rosetta.protocols.toolbox.task_operations.ConservativeDesignOperation, setting: bool) → None¶

Include native amino acid in the allowed_aas list. Default true.

C++: protocols::toolbox::task_operations::ConservativeDesignOperation::include_native_aa(const bool &) –> void

include_residue(self: pyrosetta.rosetta.protocols.toolbox.task_operations.ConservativeDesignOperation, resnum: int) → None¶: C++: protocols::toolbox::task_operations::ConservativeDesignOperation::include_residue(unsigned long) –> void

keyname() → str¶: C++: protocols::toolbox::task_operations::ConservativeDesignOperation::keyname() –> std::string

limit_to_positions(self: pyrosetta.rosetta.protocols.toolbox.task_operations.ConservativeDesignOperation, positions: pyrosetta.rosetta.utility.vector1_unsigned_long) → None¶

Limit to a subset of residue positions, already set to designable.

C++: protocols::toolbox::task_operations::ConservativeDesignOperation::limit_to_positions(const class utility::vector1<unsigned long, class std::allocator<unsigned long> >) –> void

parse_tag(self: pyrosetta.rosetta.core.pack.task.operation.TaskOperation, : utility::tag::Tag, : pyrosetta.rosetta.basic.datacache.DataMap) → None¶

Used to parse an xml-like tag to load parameters and properties.

C++: core::pack::task::operation::TaskOperation::parse_tag(class std::shared_ptr<const class utility::tag::Tag>, class basic::datacache::DataMap &) –> void

provide_xml_schema(xsd: pyrosetta.rosetta.utility.tag.XMLSchemaDefinition) → None¶: C++: protocols::toolbox::task_operations::ConservativeDesignOperation::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) –> void

set_data_source(self: pyrosetta.rosetta.protocols.toolbox.task_operations.ConservativeDesignOperation, data_source: str) → None¶

Set the source of the data used to define what is conservative.: Options are: chothia_76, and the Blosum matrices from 30 to 100; designated as blosum30, 62, etc. Default is blosum62. The higher the number, the more conservative the set of mutations (numbers are sequence identity cutoffs)

C++: protocols::toolbox::task_operations::ConservativeDesignOperation::set_data_source(const class std::basic_string<char>) –> void

set_native_sequence(self: pyrosetta.rosetta.protocols.toolbox.task_operations.ConservativeDesignOperation, seq: str) → None¶: C++: protocols::toolbox::task_operations::ConservativeDesignOperation::set_native_sequence(class std::basic_string<char>) –> void

use_pose_sequence_as_native(self: pyrosetta.rosetta.protocols.toolbox.task_operations.ConservativeDesignOperation, pose: pyrosetta.rosetta.core.pose.Pose) → None¶

Will use native residues from the this pose to determine conserved aa.

C++: protocols::toolbox::task_operations::ConservativeDesignOperation::use_pose_sequence_as_native(const class core::pose::Pose &) –> void

class pyrosetta.rosetta.protocols.toolbox.task_operations.DatabaseThread¶

Bases: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictOperationsBase

this class is a TaskOperation to thread sequences from a database.

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

__init__(self: pyrosetta.rosetta.protocols.toolbox.task_operations.DatabaseThread) -> None
__init__(self: pyrosetta.rosetta.protocols.toolbox.task_operations.DatabaseThread, arg0: pyrosetta.rosetta.protocols.toolbox.task_operations.DatabaseThread) -> 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).

allow_design_around(*args, **kwargs)¶

Overloaded function.

allow_design_around(self: pyrosetta.rosetta.protocols.toolbox.task_operations.DatabaseThread) -> bool

C++: protocols::toolbox::task_operations::DatabaseThread::allow_design_around() const –> bool

allow_design_around(self: pyrosetta.rosetta.protocols.toolbox.task_operations.DatabaseThread, b: bool) -> None

C++: protocols::toolbox::task_operations::DatabaseThread::allow_design_around(const bool) –> void

apply(self: pyrosetta.rosetta.protocols.toolbox.task_operations.DatabaseThread, : pyrosetta.rosetta.core.pose.Pose, : pyrosetta.rosetta.core.pack.task.PackerTask) → None¶: C++: protocols::toolbox::task_operations::DatabaseThread::apply(const class core::pose::Pose &, class core::pack::task::PackerTask &) const –> void

assign(self: pyrosetta.rosetta.protocols.toolbox.task_operations.DatabaseThread, : pyrosetta.rosetta.protocols.toolbox.task_operations.DatabaseThread) → pyrosetta.rosetta.protocols.toolbox.task_operations.DatabaseThread¶: C++: protocols::toolbox::task_operations::DatabaseThread::operator=(const class protocols::toolbox::task_operations::DatabaseThread &) –> class protocols::toolbox::task_operations::DatabaseThread &

clone(self: pyrosetta.rosetta.protocols.toolbox.task_operations.DatabaseThread) → pyrosetta.rosetta.core.pack.task.operation.TaskOperation¶: C++: protocols::toolbox::task_operations::DatabaseThread::clone() const –> class std::shared_ptr<class core::pack::task::operation::TaskOperation>

database_fname(*args, **kwargs)¶

Overloaded function.

database_fname(self: pyrosetta.rosetta.protocols.toolbox.task_operations.DatabaseThread) -> str

C++: protocols::toolbox::task_operations::DatabaseThread::database_fname() const –> std::string

database_fname(self: pyrosetta.rosetta.protocols.toolbox.task_operations.DatabaseThread, d: str) -> None

C++: protocols::toolbox::task_operations::DatabaseThread::database_fname(const class std::basic_string<char> &) –> void

designable(*args, **kwargs)¶

Overloaded function.

designable(self: pyrosetta.rosetta.protocols.toolbox.task_operations.DatabaseThread) -> pyrosetta.rosetta.utility.vector1_unsigned_long

C++: protocols::toolbox::task_operations::DatabaseThread::designable() const –> class utility::vector1<unsigned long, class std::allocator<unsigned long> >

designable(self: pyrosetta.rosetta.protocols.toolbox.task_operations.DatabaseThread, vector: pyrosetta.rosetta.utility.vector1_unsigned_long) -> None

C++: protocols::toolbox::task_operations::DatabaseThread::designable(const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &) –> void

end_res(*args, **kwargs)¶

Overloaded function.

end_res(self: pyrosetta.rosetta.protocols.toolbox.task_operations.DatabaseThread) -> int

C++: protocols::toolbox::task_operations::DatabaseThread::end_res() const –> unsigned long

end_res(self: pyrosetta.rosetta.protocols.toolbox.task_operations.DatabaseThread, s: int) -> None

C++: protocols::toolbox::task_operations::DatabaseThread::end_res(const unsigned long) –> void

find_length(self: pyrosetta.rosetta.protocols.toolbox.task_operations.DatabaseThread, pose: pyrosetta.rosetta.core.pose.Pose) → int¶: C++: protocols::toolbox::task_operations::DatabaseThread::find_length(const class core::pose::Pose &) const –> unsigned long

keyname() → str¶: C++: protocols::toolbox::task_operations::DatabaseThread::keyname() –> std::string

leave_as_is(*args, **kwargs)¶

Overloaded function.

leave_as_is(self: pyrosetta.rosetta.protocols.toolbox.task_operations.DatabaseThread) -> pyrosetta.rosetta.utility.vector1_unsigned_long

C++: protocols::toolbox::task_operations::DatabaseThread::leave_as_is() const –> class utility::vector1<unsigned long, class std::allocator<unsigned long> >

leave_as_is(self: pyrosetta.rosetta.protocols.toolbox.task_operations.DatabaseThread, vector: pyrosetta.rosetta.utility.vector1_unsigned_long) -> None

C++: protocols::toolbox::task_operations::DatabaseThread::leave_as_is(const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &) –> void

mark_designable(self: pyrosetta.rosetta.protocols.toolbox.task_operations.DatabaseThread, sequence: str, : pyrosetta.rosetta.core.pose.Pose) → None¶: C++: protocols::toolbox::task_operations::DatabaseThread::mark_designable(class std::basic_string<char> &, const class core::pose::Pose &) const –> void

mark_leave_as_is(self: pyrosetta.rosetta.protocols.toolbox.task_operations.DatabaseThread, sequence: str, : pyrosetta.rosetta.core.pose.Pose) → None¶: C++: protocols::toolbox::task_operations::DatabaseThread::mark_leave_as_is(class std::basic_string<char> &, const class core::pose::Pose &) const –> void

parse_tag(self: pyrosetta.rosetta.protocols.toolbox.task_operations.DatabaseThread, : pyrosetta.rosetta.utility.tag.Tag, : pyrosetta.rosetta.basic.datacache.DataMap) → None¶: C++: protocols::toolbox::task_operations::DatabaseThread::parse_tag(class std::shared_ptr<const class utility::tag::Tag>, class basic::datacache::DataMap &) –> void

pick_sequence_from_database(self: pyrosetta.rosetta.protocols.toolbox.task_operations.DatabaseThread, pose: pyrosetta.rosetta.core.pose.Pose) → str¶: C++: protocols::toolbox::task_operations::DatabaseThread::pick_sequence_from_database(const class core::pose::Pose &) const –> std::string

provide_xml_schema(xsd: pyrosetta.rosetta.utility.tag.XMLSchemaDefinition) → None¶: C++: protocols::toolbox::task_operations::DatabaseThread::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) –> void

start_res(*args, **kwargs)¶

Overloaded function.

start_res(self: pyrosetta.rosetta.protocols.toolbox.task_operations.DatabaseThread) -> int

C++: protocols::toolbox::task_operations::DatabaseThread::start_res() const –> unsigned long

start_res(self: pyrosetta.rosetta.protocols.toolbox.task_operations.DatabaseThread, s: int) -> None

C++: protocols::toolbox::task_operations::DatabaseThread::start_res(const unsigned long) –> void

target_sequence(*args, **kwargs)¶

Overloaded function.

target_sequence(self: pyrosetta.rosetta.protocols.toolbox.task_operations.DatabaseThread, seq: str) -> None

C++: protocols::toolbox::task_operations::DatabaseThread::target_sequence(const class std::basic_string<char> &) –> void

target_sequence(self: pyrosetta.rosetta.protocols.toolbox.task_operations.DatabaseThread) -> str

C++: protocols::toolbox::task_operations::DatabaseThread::target_sequence() const –> std::string

template_file(*args, **kwargs)¶

Overloaded function.

template_file(self: pyrosetta.rosetta.protocols.toolbox.task_operations.DatabaseThread) -> str

C++: protocols::toolbox::task_operations::DatabaseThread::template_file() const –> std::string

template_file(self: pyrosetta.rosetta.protocols.toolbox.task_operations.DatabaseThread, s: str) -> None

C++: protocols::toolbox::task_operations::DatabaseThread::template_file(const class std::basic_string<char> &) –> void

class pyrosetta.rosetta.protocols.toolbox.task_operations.DsspDesignOperation¶

Bases: pyrosetta.rosetta.core.pack.task.operation.TaskOperation

TaskOperation that can be used to restrict AAs allowed at each position based on DSSP-assigned secondary structure

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

__init__(self: pyrosetta.rosetta.protocols.toolbox.task_operations.DsspDesignOperation) -> None
__init__(self: pyrosetta.rosetta.protocols.toolbox.task_operations.DsspDesignOperation, arg0: pyrosetta.rosetta.protocols.toolbox.task_operations.DsspDesignOperation) -> 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).

apply(self: pyrosetta.rosetta.protocols.toolbox.task_operations.DsspDesignOperation, pose: pyrosetta.rosetta.core.pose.Pose, task: pyrosetta.rosetta.core.pack.task.PackerTask) → None¶

apply

C++: protocols::toolbox::task_operations::DsspDesignOperation::apply(const class core::pose::Pose &, class core::pack::task::PackerTask &) const –> void

assign(self: pyrosetta.rosetta.protocols.toolbox.task_operations.DsspDesignOperation, : pyrosetta.rosetta.protocols.toolbox.task_operations.DsspDesignOperation) → pyrosetta.rosetta.protocols.toolbox.task_operations.DsspDesignOperation¶: C++: protocols::toolbox::task_operations::DsspDesignOperation::operator=(const class protocols::toolbox::task_operations::DsspDesignOperation &) –> class protocols::toolbox::task_operations::DsspDesignOperation &

clone(self: pyrosetta.rosetta.protocols.toolbox.task_operations.DsspDesignOperation) → pyrosetta.rosetta.core.pack.task.operation.TaskOperation¶

make clone

C++: protocols::toolbox::task_operations::DsspDesignOperation::clone() const –> class std::shared_ptr<class core::pack::task::operation::TaskOperation>

keyname() → str¶: C++: protocols::toolbox::task_operations::DsspDesignOperation::keyname() –> std::string

parse_tag(self: pyrosetta.rosetta.protocols.toolbox.task_operations.DsspDesignOperation, tag: pyrosetta.rosetta.utility.tag.Tag, : pyrosetta.rosetta.basic.datacache.DataMap) → None¶

parse RosettaScripts XML

C++: protocols::toolbox::task_operations::DsspDesignOperation::parse_tag(class std::shared_ptr<const class utility::tag::Tag>, class basic::datacache::DataMap &) –> void

provide_xml_schema(xsd: pyrosetta.rosetta.utility.tag.XMLSchemaDefinition) → None¶: C++: protocols::toolbox::task_operations::DsspDesignOperation::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) –> void

set_blueprint(self: pyrosetta.rosetta.protocols.toolbox.task_operations.DsspDesignOperation, bp: pyrosetta.rosetta.protocols.parser.BluePrint) → None¶

define secondary structure from a blueprint

C++: protocols::toolbox::task_operations::DsspDesignOperation::set_blueprint(const class std::shared_ptr<class protocols::parser::BluePrint>) –> void

set_restrictions_aa(self: pyrosetta.rosetta.protocols.toolbox.task_operations.DsspDesignOperation, sse: str, aas: str) → None¶

define allowed residues for some SSE

C++: protocols::toolbox::task_operations::DsspDesignOperation::set_restrictions_aa(const class std::basic_string<char> &, const class std::basic_string<char> &) –> void

set_restrictions_append(self: pyrosetta.rosetta.protocols.toolbox.task_operations.DsspDesignOperation, sse: str, aas: str) → None¶

append allowed residues for some SSE

C++: protocols::toolbox::task_operations::DsspDesignOperation::set_restrictions_append(const class std::basic_string<char> &, const class std::basic_string<char> &) –> void

set_restrictions_exclude(self: pyrosetta.rosetta.protocols.toolbox.task_operations.DsspDesignOperation, sse: str, aas: str) → None¶

exclude allowed residues for some SSE

C++: protocols::toolbox::task_operations::DsspDesignOperation::set_restrictions_exclude(const class std::basic_string<char> &, const class std::basic_string<char> &) –> void

class pyrosetta.rosetta.protocols.toolbox.task_operations.InteractingRotamerExplosion¶

Bases: pyrosetta.rosetta.core.pack.task.operation.TaskOperation

: taskop to oversample rotamers that make good interactions with a (set of) specified target residue(s) similar to Rosetta 2.x rotamer explosion

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

__init__(self: pyrosetta.rosetta.protocols.toolbox.task_operations.InteractingRotamerExplosion) -> None
__init__(self: pyrosetta.rosetta.protocols.toolbox.task_operations.InteractingRotamerExplosion, arg0: pyrosetta.rosetta.protocols.toolbox.task_operations.InteractingRotamerExplosion) -> 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).

apply(self: pyrosetta.rosetta.protocols.toolbox.task_operations.InteractingRotamerExplosion, pose: pyrosetta.rosetta.core.pose.Pose, task: pyrosetta.rosetta.core.pack.task.PackerTask) → None¶: C++: protocols::toolbox::task_operations::InteractingRotamerExplosion::apply(const class core::pose::Pose &, class core::pack::task::PackerTask &) const –> void

assign(self: pyrosetta.rosetta.protocols.toolbox.task_operations.InteractingRotamerExplosion, : pyrosetta.rosetta.protocols.toolbox.task_operations.InteractingRotamerExplosion) → pyrosetta.rosetta.protocols.toolbox.task_operations.InteractingRotamerExplosion¶: C++: protocols::toolbox::task_operations::InteractingRotamerExplosion::operator=(const class protocols::toolbox::task_operations::InteractingRotamerExplosion &) –> class protocols::toolbox::task_operations::InteractingRotamerExplosion &

clone(self: pyrosetta.rosetta.protocols.toolbox.task_operations.InteractingRotamerExplosion) → pyrosetta.rosetta.core.pack.task.operation.TaskOperation¶: C++: protocols::toolbox::task_operations::InteractingRotamerExplosion::clone() const –> class std::shared_ptr<class core::pack::task::operation::TaskOperation>

keyname() → str¶: C++: protocols::toolbox::task_operations::InteractingRotamerExplosion::keyname() –> std::string

parse_tag(self: pyrosetta.rosetta.protocols.toolbox.task_operations.InteractingRotamerExplosion, tag: pyrosetta.rosetta.utility.tag.Tag, datamap: pyrosetta.rosetta.basic.datacache.DataMap) → None¶: C++: protocols::toolbox::task_operations::InteractingRotamerExplosion::parse_tag(class std::shared_ptr<const class utility::tag::Tag>, class basic::datacache::DataMap &) –> void

provide_xml_schema(xsd: pyrosetta.rosetta.utility.tag.XMLSchemaDefinition) → None¶: C++: protocols::toolbox::task_operations::InteractingRotamerExplosion::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) –> void

class pyrosetta.rosetta.protocols.toolbox.task_operations.LimitAromaChi2Operation¶

Bases: pyrosetta.rosetta.core.pack.task.operation.TaskOperation

__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.protocols.toolbox.task_operations.LimitAromaChi2Operation) → 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).

apply(self: pyrosetta.rosetta.protocols.toolbox.task_operations.LimitAromaChi2Operation, pose: pyrosetta.rosetta.core.pose.Pose, task: pyrosetta.rosetta.core.pack.task.PackerTask) → None¶

apply

C++: protocols::toolbox::task_operations::LimitAromaChi2Operation::apply(const class core::pose::Pose &, class core::pack::task::PackerTask &) const –> void

assign(self: pyrosetta.rosetta.protocols.toolbox.task_operations.LimitAromaChi2Operation, : pyrosetta.rosetta.protocols.toolbox.task_operations.LimitAromaChi2Operation) → pyrosetta.rosetta.protocols.toolbox.task_operations.LimitAromaChi2Operation¶: C++: protocols::toolbox::task_operations::LimitAromaChi2Operation::operator=(const class protocols::toolbox::task_operations::LimitAromaChi2Operation &) –> class protocols::toolbox::task_operations::LimitAromaChi2Operation &

chi2max(*args, **kwargs)¶

Overloaded function.

chi2max(self: pyrosetta.rosetta.protocols.toolbox.task_operations.LimitAromaChi2Operation) -> float

max chi2 for picking rotamers of YFH

C++: protocols::toolbox::task_operations::LimitAromaChi2Operation::chi2max() const –> double

chi2max(self: pyrosetta.rosetta.protocols.toolbox.task_operations.LimitAromaChi2Operation, r: float) -> None

max chi2 for picking rotamers of YFH

C++: protocols::toolbox::task_operations::LimitAromaChi2Operation::chi2max(const double) –> void

chi2min(*args, **kwargs)¶

Overloaded function.

chi2min(self: pyrosetta.rosetta.protocols.toolbox.task_operations.LimitAromaChi2Operation) -> float

min chi2 for picking rotamers of YFH

C++: protocols::toolbox::task_operations::LimitAromaChi2Operation::chi2min() const –> double

chi2min(self: pyrosetta.rosetta.protocols.toolbox.task_operations.LimitAromaChi2Operation, r: float) -> None

min chi2 for picking rotamers of YFH

C++: protocols::toolbox::task_operations::LimitAromaChi2Operation::chi2min(const double) –> void

clone(self: pyrosetta.rosetta.protocols.toolbox.task_operations.LimitAromaChi2Operation) → pyrosetta.rosetta.core.pack.task.operation.TaskOperation¶

make clone

C++: protocols::toolbox::task_operations::LimitAromaChi2Operation::clone() const –> class std::shared_ptr<class core::pack::task::operation::TaskOperation>

include_trp(*args, **kwargs)¶

Overloaded function.

include_trp(self: pyrosetta.rosetta.protocols.toolbox.task_operations.LimitAromaChi2Operation) -> bool

include TRP ?

C++: protocols::toolbox::task_operations::LimitAromaChi2Operation::include_trp() const –> bool

include_trp(self: pyrosetta.rosetta.protocols.toolbox.task_operations.LimitAromaChi2Operation, b: bool) -> None

include TRP ?

C++: protocols::toolbox::task_operations::LimitAromaChi2Operation::include_trp(const bool) –> void

keyname() → str¶: C++: protocols::toolbox::task_operations::LimitAromaChi2Operation::keyname() –> std::string

parse_tag(self: pyrosetta.rosetta.protocols.toolbox.task_operations.LimitAromaChi2Operation, tag: pyrosetta.rosetta.utility.tag.Tag, : pyrosetta.rosetta.basic.datacache.DataMap) → None¶: C++: protocols::toolbox::task_operations::LimitAromaChi2Operation::parse_tag(class std::shared_ptr<const class utility::tag::Tag>, class basic::datacache::DataMap &) –> void

provide_xml_schema(xsd: pyrosetta.rosetta.utility.tag.XMLSchemaDefinition) → None¶: C++: protocols::toolbox::task_operations::LimitAromaChi2Operation::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) –> void

class pyrosetta.rosetta.protocols.toolbox.task_operations.LinkResidues¶

Bases: pyrosetta.rosetta.core.pack.task.operation.TaskOperation

this class is a TaskOperation to prevent repacking of residues not near an interface.

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

__init__(self: pyrosetta.rosetta.protocols.toolbox.task_operations.LinkResidues) -> None
__init__(self: pyrosetta.rosetta.protocols.toolbox.task_operations.LinkResidues, arg0: pyrosetta.rosetta.protocols.toolbox.task_operations.LinkResidues) -> 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_group(self: pyrosetta.rosetta.protocols.toolbox.task_operations.LinkResidues, group: str) → None¶: C++: protocols::toolbox::task_operations::LinkResidues::add_group(class std::basic_string<char>) –> void

apply(self: pyrosetta.rosetta.protocols.toolbox.task_operations.LinkResidues, : pyrosetta.rosetta.core.pose.Pose, : pyrosetta.rosetta.core.pack.task.PackerTask) → None¶: C++: protocols::toolbox::task_operations::LinkResidues::apply(const class core::pose::Pose &, class core::pack::task::PackerTask &) const –> void

assign(self: pyrosetta.rosetta.protocols.toolbox.task_operations.LinkResidues, : pyrosetta.rosetta.protocols.toolbox.task_operations.LinkResidues) → pyrosetta.rosetta.protocols.toolbox.task_operations.LinkResidues¶: C++: protocols::toolbox::task_operations::LinkResidues::operator=(const class protocols::toolbox::task_operations::LinkResidues &) –> class protocols::toolbox::task_operations::LinkResidues &

clone(self: pyrosetta.rosetta.protocols.toolbox.task_operations.LinkResidues) → pyrosetta.rosetta.core.pack.task.operation.TaskOperation¶: C++: protocols::toolbox::task_operations::LinkResidues::clone() const –> class std::shared_ptr<class core::pack::task::operation::TaskOperation>

keyname() → str¶: C++: protocols::toolbox::task_operations::LinkResidues::keyname() –> std::string

parse_tag(self: pyrosetta.rosetta.protocols.toolbox.task_operations.LinkResidues, tag: pyrosetta.rosetta.utility.tag.Tag, : pyrosetta.rosetta.basic.datacache.DataMap) → None¶: C++: protocols::toolbox::task_operations::LinkResidues::parse_tag(class std::shared_ptr<const class utility::tag::Tag>, class basic::datacache::DataMap &) –> void

provide_xml_schema(xsd: pyrosetta.rosetta.utility.tag.XMLSchemaDefinition) → None¶: C++: protocols::toolbox::task_operations::LinkResidues::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) –> void

remap_allowed_residues_to_template(self: pyrosetta.rosetta.protocols.toolbox.task_operations.LinkResidues, pose: pyrosetta.rosetta.core.pose.Pose, links: pyrosetta.rosetta.core.pack.rotamer_set.RotamerLinks) → None¶: C++: protocols::toolbox::task_operations::LinkResidues::remap_allowed_residues_to_template(const class core::pose::Pose &, class std::shared_ptr<class core::pack::rotamer_set::RotamerLinks> &) const –> void

class pyrosetta.rosetta.protocols.toolbox.task_operations.MutationSetDesignOperation¶

Bases: pyrosetta.rosetta.core.pack.task.operation.TaskOperation

Sample a set of mutations each time packer is generated. A MutationSet is a simple map of resnum:aa. Each apply will sample a set either at random, or with a set of weights.

Does not enable/disable packing or design by default. Simply controls what the design set will be. Typically each set would be of the same resnums, but this is not necessary. Iterative Sampling can be achieved somewhat by setting the sample index with each pack.

Does not touch any resnums not in a sampled mutation set.

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

__init__(self: pyrosetta.rosetta.protocols.toolbox.task_operations.MutationSetDesignOperation) -> None
__init__(self: pyrosetta.rosetta.protocols.toolbox.task_operations.MutationSetDesignOperation, arg0: pyrosetta.rosetta.protocols.toolbox.task_operations.MutationSetDesignOperation) -> 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_to_allowed_aas(self: pyrosetta.rosetta.protocols.toolbox.task_operations.MutationSetDesignOperation, setting: bool) → None¶

Add to the allowed amino acids list instead of replacing them. Default false.

C++: protocols::toolbox::task_operations::MutationSetDesignOperation::add_to_allowed_aas(const bool &) –> void

apply(self: pyrosetta.rosetta.protocols.toolbox.task_operations.MutationSetDesignOperation, pose: pyrosetta.rosetta.core.pose.Pose, task: pyrosetta.rosetta.core.pack.task.PackerTask) → None¶: C++: protocols::toolbox::task_operations::MutationSetDesignOperation::apply(const class core::pose::Pose &, class core::pack::task::PackerTask &) const –> void

assign(self: pyrosetta.rosetta.protocols.toolbox.task_operations.MutationSetDesignOperation, : pyrosetta.rosetta.protocols.toolbox.task_operations.MutationSetDesignOperation) → pyrosetta.rosetta.protocols.toolbox.task_operations.MutationSetDesignOperation¶: C++: protocols::toolbox::task_operations::MutationSetDesignOperation::operator=(const class protocols::toolbox::task_operations::MutationSetDesignOperation &) –> class protocols::toolbox::task_operations::MutationSetDesignOperation &

clear_mutation_sets(self: pyrosetta.rosetta.protocols.toolbox.task_operations.MutationSetDesignOperation) → None¶

Clear any stored mutation sets and weights.

C++: protocols::toolbox::task_operations::MutationSetDesignOperation::clear_mutation_sets() –> void

clone(self: pyrosetta.rosetta.protocols.toolbox.task_operations.MutationSetDesignOperation) → pyrosetta.rosetta.core.pack.task.operation.TaskOperation¶: C++: protocols::toolbox::task_operations::MutationSetDesignOperation::clone() const –> class std::shared_ptr<class core::pack::task::operation::TaskOperation>

get_sample_index(self: pyrosetta.rosetta.protocols.toolbox.task_operations.MutationSetDesignOperation) → int¶: C++: protocols::toolbox::task_operations::MutationSetDesignOperation::get_sample_index() const –> unsigned long

get_total_mutation_sets(self: pyrosetta.rosetta.protocols.toolbox.task_operations.MutationSetDesignOperation) → int¶

Get the total number of mutation sets housed.

C++: protocols::toolbox::task_operations::MutationSetDesignOperation::get_total_mutation_sets() const –> unsigned long

include_native_aa(self: pyrosetta.rosetta.protocols.toolbox.task_operations.MutationSetDesignOperation, setting: bool) → None¶

Include native amino acid in the allowed_aas list. Default False.

C++: protocols::toolbox::task_operations::MutationSetDesignOperation::include_native_aa(const bool &) –> void

keyname() → str¶: C++: protocols::toolbox::task_operations::MutationSetDesignOperation::keyname() –> std::string

parse_tag(self: pyrosetta.rosetta.core.pack.task.operation.TaskOperation, : utility::tag::Tag, : pyrosetta.rosetta.basic.datacache.DataMap) → None¶

Used to parse an xml-like tag to load parameters and properties.

C++: core::pack::task::operation::TaskOperation::parse_tag(class std::shared_ptr<const class utility::tag::Tag>, class basic::datacache::DataMap &) –> void

provide_xml_schema(xsd: pyrosetta.rosetta.utility.tag.XMLSchemaDefinition) → None¶: C++: protocols::toolbox::task_operations::MutationSetDesignOperation::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) –> void

reset_sample_index(self: pyrosetta.rosetta.protocols.toolbox.task_operations.MutationSetDesignOperation) → None¶

Set the sample index back to zero - which means we will sample from all of them according to weights.

C++: protocols::toolbox::task_operations::MutationSetDesignOperation::reset_sample_index() –> void

set_picking_rounds(self: pyrosetta.rosetta.protocols.toolbox.task_operations.MutationSetDesignOperation, picking_rounds: int) → None¶

Number of times we sample from our sets. Default 1/apply.: The more rounds, the closer the final amino acid set for each position will be to the full profile for that position. If using weights for the residue sets, this would increase variability.

C++: protocols::toolbox::task_operations::MutationSetDesignOperation::set_picking_rounds(unsigned long) –> void

set_sample_index(self: pyrosetta.rosetta.protocols.toolbox.task_operations.MutationSetDesignOperation, sample_index: int) → None¶

Used to sample particular indexes, since we can’t do this iteratively due to const apply. 1 through n: Set to 0 in order to sample from the weights.

C++: protocols::toolbox::task_operations::MutationSetDesignOperation::set_sample_index(unsigned long) –> void

class pyrosetta.rosetta.protocols.toolbox.task_operations.PreventChainFromRepackingOperation¶

Bases: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictOperationsBase

this class is a TaskOperation to prevent repacking of residues not near an interface.

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

__init__(self: pyrosetta.rosetta.protocols.toolbox.task_operations.PreventChainFromRepackingOperation) -> None
__init__(self: pyrosetta.rosetta.protocols.toolbox.task_operations.PreventChainFromRepackingOperation, chain: 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).

apply(self: pyrosetta.rosetta.protocols.toolbox.task_operations.PreventChainFromRepackingOperation, : pyrosetta.rosetta.core.pose.Pose, : pyrosetta.rosetta.core.pack.task.PackerTask) → None¶: C++: protocols::toolbox::task_operations::PreventChainFromRepackingOperation::apply(const class core::pose::Pose &, class core::pack::task::PackerTask &) const –> void

assign(self: pyrosetta.rosetta.protocols.toolbox.task_operations.PreventChainFromRepackingOperation, : pyrosetta.rosetta.protocols.toolbox.task_operations.PreventChainFromRepackingOperation) → pyrosetta.rosetta.protocols.toolbox.task_operations.PreventChainFromRepackingOperation¶: C++: protocols::toolbox::task_operations::PreventChainFromRepackingOperation::operator=(const class protocols::toolbox::task_operations::PreventChainFromRepackingOperation &) –> class protocols::toolbox::task_operations::PreventChainFromRepackingOperation &

chain(*args, **kwargs)¶

Overloaded function.

chain(self: pyrosetta.rosetta.protocols.toolbox.task_operations.PreventChainFromRepackingOperation, chain: int) -> None

C++: protocols::toolbox::task_operations::PreventChainFromRepackingOperation::chain(const unsigned long) –> void

chain(self: pyrosetta.rosetta.protocols.toolbox.task_operations.PreventChainFromRepackingOperation) -> int

C++: protocols::toolbox::task_operations::PreventChainFromRepackingOperation::chain() const –> unsigned long

clone(self: pyrosetta.rosetta.protocols.toolbox.task_operations.PreventChainFromRepackingOperation) → pyrosetta.rosetta.core.pack.task.operation.TaskOperation¶: C++: protocols::toolbox::task_operations::PreventChainFromRepackingOperation::clone() const –> class std::shared_ptr<class core::pack::task::operation::TaskOperation>

keyname() → str¶: C++: protocols::toolbox::task_operations::PreventChainFromRepackingOperation::keyname() –> std::string

parse_tag(self: pyrosetta.rosetta.protocols.toolbox.task_operations.PreventChainFromRepackingOperation, : pyrosetta.rosetta.utility.tag.Tag, : pyrosetta.rosetta.basic.datacache.DataMap) → None¶: C++: protocols::toolbox::task_operations::PreventChainFromRepackingOperation::parse_tag(class std::shared_ptr<const class utility::tag::Tag>, class basic::datacache::DataMap &) –> void

provide_xml_schema(xsd: pyrosetta.rosetta.utility.tag.XMLSchemaDefinition) → None¶: C++: protocols::toolbox::task_operations::PreventChainFromRepackingOperation::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) –> void

class pyrosetta.rosetta.protocols.toolbox.task_operations.PreventResiduesFromRepackingOperation¶

Bases: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictOperationsBase

this class is a TaskOperation to prevent repacking of residues not near an interface.

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

__init__(self: pyrosetta.rosetta.protocols.toolbox.task_operations.PreventResiduesFromRepackingOperation) -> None
__init__(self: pyrosetta.rosetta.protocols.toolbox.task_operations.PreventResiduesFromRepackingOperation, residues: pyrosetta.rosetta.utility.vector1_unsigned_long) -> None
__init__(self: pyrosetta.rosetta.protocols.toolbox.task_operations.PreventResiduesFromRepackingOperation, arg0: pyrosetta.rosetta.protocols.toolbox.task_operations.PreventResiduesFromRepackingOperation) -> 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).

apply(self: pyrosetta.rosetta.protocols.toolbox.task_operations.PreventResiduesFromRepackingOperation, : pyrosetta.rosetta.core.pose.Pose, : pyrosetta.rosetta.core.pack.task.PackerTask) → None¶: C++: protocols::toolbox::task_operations::PreventResiduesFromRepackingOperation::apply(const class core::pose::Pose &, class core::pack::task::PackerTask &) const –> void

assign(self: pyrosetta.rosetta.protocols.toolbox.task_operations.PreventResiduesFromRepackingOperation, : pyrosetta.rosetta.protocols.toolbox.task_operations.PreventResiduesFromRepackingOperation) → pyrosetta.rosetta.protocols.toolbox.task_operations.PreventResiduesFromRepackingOperation¶: C++: protocols::toolbox::task_operations::PreventResiduesFromRepackingOperation::operator=(const class protocols::toolbox::task_operations::PreventResiduesFromRepackingOperation &) –> class protocols::toolbox::task_operations::PreventResiduesFromRepackingOperation &

clone(self: pyrosetta.rosetta.protocols.toolbox.task_operations.PreventResiduesFromRepackingOperation) → pyrosetta.rosetta.core.pack.task.operation.TaskOperation¶: C++: protocols::toolbox::task_operations::PreventResiduesFromRepackingOperation::clone() const –> class std::shared_ptr<class core::pack::task::operation::TaskOperation>

get_residues(self: pyrosetta.rosetta.protocols.toolbox.task_operations.PreventResiduesFromRepackingOperation) → pyrosetta.rosetta.utility.vector1_unsigned_long¶: C++: protocols::toolbox::task_operations::PreventResiduesFromRepackingOperation::get_residues() const –> class utility::vector1<unsigned long, class std::allocator<unsigned long> >

keyname() → str¶: C++: protocols::toolbox::task_operations::PreventResiduesFromRepackingOperation::keyname() –> std::string

parse_tag(self: pyrosetta.rosetta.protocols.toolbox.task_operations.PreventResiduesFromRepackingOperation, : pyrosetta.rosetta.utility.tag.Tag, : pyrosetta.rosetta.basic.datacache.DataMap) → None¶: C++: protocols::toolbox::task_operations::PreventResiduesFromRepackingOperation::parse_tag(class std::shared_ptr<const class utility::tag::Tag>, class basic::datacache::DataMap &) –> void

provide_xml_schema(xsd: pyrosetta.rosetta.utility.tag.XMLSchemaDefinition) → None¶: C++: protocols::toolbox::task_operations::PreventResiduesFromRepackingOperation::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) –> void

reference_pdb_id(*args, **kwargs)¶

Overloaded function.

reference_pdb_id(self: pyrosetta.rosetta.protocols.toolbox.task_operations.PreventResiduesFromRepackingOperation) -> str

C++: protocols::toolbox::task_operations::PreventResiduesFromRepackingOperation::reference_pdb_id() const –> std::string

reference_pdb_id(self: pyrosetta.rosetta.protocols.toolbox.task_operations.PreventResiduesFromRepackingOperation, s: str) -> None

C++: protocols::toolbox::task_operations::PreventResiduesFromRepackingOperation::reference_pdb_id(const class std::basic_string<char> &) –> void

set_residues(self: pyrosetta.rosetta.protocols.toolbox.task_operations.PreventResiduesFromRepackingOperation, residues_vec: pyrosetta.rosetta.utility.vector1_unsigned_long) → None¶: C++: protocols::toolbox::task_operations::PreventResiduesFromRepackingOperation::set_residues(class utility::vector1<unsigned long, class std::allocator<unsigned long> >) –> void

class pyrosetta.rosetta.protocols.toolbox.task_operations.ProteinInterfaceDesignOperation¶

Bases: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictOperationsBase

this class is a TaskOperation to prevent repacking of residues not near an interface.

__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.protocols.toolbox.task_operations.ProteinInterfaceDesignOperation) → 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).

allow_all_aas(self: pyrosetta.rosetta.protocols.toolbox.task_operations.ProteinInterfaceDesignOperation, allow: bool) → None¶

allow all amino acids to be designed at all positions, do not exclude C, G, P

C++: protocols::toolbox::task_operations::ProteinInterfaceDesignOperation::allow_all_aas(const bool) –> void

apply(self: pyrosetta.rosetta.protocols.toolbox.task_operations.ProteinInterfaceDesignOperation, : pyrosetta.rosetta.core.pose.Pose, : pyrosetta.rosetta.core.pack.task.PackerTask) → None¶: C++: protocols::toolbox::task_operations::ProteinInterfaceDesignOperation::apply(const class core::pose::Pose &, class core::pack::task::PackerTask &) const –> void

assign(self: pyrosetta.rosetta.protocols.toolbox.task_operations.ProteinInterfaceDesignOperation, : pyrosetta.rosetta.protocols.toolbox.task_operations.ProteinInterfaceDesignOperation) → pyrosetta.rosetta.protocols.toolbox.task_operations.ProteinInterfaceDesignOperation¶: C++: protocols::toolbox::task_operations::ProteinInterfaceDesignOperation::operator=(const class protocols::toolbox::task_operations::ProteinInterfaceDesignOperation &) –> class protocols::toolbox::task_operations::ProteinInterfaceDesignOperation &

clone(self: pyrosetta.rosetta.protocols.toolbox.task_operations.ProteinInterfaceDesignOperation) → pyrosetta.rosetta.core.pack.task.operation.TaskOperation¶: C++: protocols::toolbox::task_operations::ProteinInterfaceDesignOperation::clone() const –> class std::shared_ptr<class core::pack::task::operation::TaskOperation>

design_all_aas(self: pyrosetta.rosetta.protocols.toolbox.task_operations.ProteinInterfaceDesignOperation, design_all: bool) → None¶

allow design of all residues on input pose, do not exclude G,P

C++: protocols::toolbox::task_operations::ProteinInterfaceDesignOperation::design_all_aas(const bool) –> void

design_chain1(self: pyrosetta.rosetta.protocols.toolbox.task_operations.ProteinInterfaceDesignOperation, design: bool) → None¶: C++: protocols::toolbox::task_operations::ProteinInterfaceDesignOperation::design_chain1(const bool) –> void

design_chain2(self: pyrosetta.rosetta.protocols.toolbox.task_operations.ProteinInterfaceDesignOperation, design: bool) → None¶: C++: protocols::toolbox::task_operations::ProteinInterfaceDesignOperation::design_chain2(const bool) –> void

interface_distance_cutoff(self: pyrosetta.rosetta.protocols.toolbox.task_operations.ProteinInterfaceDesignOperation, dist: float) → None¶

distance cutoff for atom distance in an interface.: All residues an atoms less than the distance cutoff from an atom in the other chain are defined as interface.

C++: protocols::toolbox::task_operations::ProteinInterfaceDesignOperation::interface_distance_cutoff(const double) –> void

jump(*args, **kwargs)¶

Overloaded function.

jump(self: pyrosetta.rosetta.protocols.toolbox.task_operations.ProteinInterfaceDesignOperation, j: int) -> None

C++: protocols::toolbox::task_operations::ProteinInterfaceDesignOperation::jump(const unsigned long) –> void

jump(self: pyrosetta.rosetta.protocols.toolbox.task_operations.ProteinInterfaceDesignOperation) -> int

C++: protocols::toolbox::task_operations::ProteinInterfaceDesignOperation::jump() const –> unsigned long

keyname() → str¶: C++: protocols::toolbox::task_operations::ProteinInterfaceDesignOperation::keyname() –> std::string

modify_after_jump(*args, **kwargs)¶

Overloaded function.

modify_after_jump(self: pyrosetta.rosetta.protocols.toolbox.task_operations.ProteinInterfaceDesignOperation) -> bool

C++: protocols::toolbox::task_operations::ProteinInterfaceDesignOperation::modify_after_jump() const –> bool

modify_after_jump(self: pyrosetta.rosetta.protocols.toolbox.task_operations.ProteinInterfaceDesignOperation, m: bool) -> None

C++: protocols::toolbox::task_operations::ProteinInterfaceDesignOperation::modify_after_jump(const bool) –> void

modify_before_jump(*args, **kwargs)¶

Overloaded function.

modify_before_jump(self: pyrosetta.rosetta.protocols.toolbox.task_operations.ProteinInterfaceDesignOperation) -> bool

C++: protocols::toolbox::task_operations::ProteinInterfaceDesignOperation::modify_before_jump() const –> bool

modify_before_jump(self: pyrosetta.rosetta.protocols.toolbox.task_operations.ProteinInterfaceDesignOperation, m: bool) -> None

C++: protocols::toolbox::task_operations::ProteinInterfaceDesignOperation::modify_before_jump(const bool) –> void

parse_tag(self: pyrosetta.rosetta.protocols.toolbox.task_operations.ProteinInterfaceDesignOperation, : pyrosetta.rosetta.utility.tag.Tag, : pyrosetta.rosetta.basic.datacache.DataMap) → None¶: C++: protocols::toolbox::task_operations::ProteinInterfaceDesignOperation::parse_tag(class std::shared_ptr<const class utility::tag::Tag>, class basic::datacache::DataMap &) –> void

provide_xml_schema(xsd: pyrosetta.rosetta.utility.tag.XMLSchemaDefinition) → None¶: C++: protocols::toolbox::task_operations::ProteinInterfaceDesignOperation::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) –> void

repack_chain1(self: pyrosetta.rosetta.protocols.toolbox.task_operations.ProteinInterfaceDesignOperation, repack: bool) → None¶: C++: protocols::toolbox::task_operations::ProteinInterfaceDesignOperation::repack_chain1(const bool) –> void

repack_chain2(self: pyrosetta.rosetta.protocols.toolbox.task_operations.ProteinInterfaceDesignOperation, repack: bool) → None¶: C++: protocols::toolbox::task_operations::ProteinInterfaceDesignOperation::repack_chain2(const bool) –> void

class pyrosetta.rosetta.protocols.toolbox.task_operations.ResidueProbDesignOperation¶

Bases: pyrosetta.rosetta.core.pack.task.operation.TaskOperation

A TaskOperation that allows amino acids at designable positions through a set of aa probabilities (aa profile).

Each time a task is generated, it will choose one amino acid from the set for that position and add it to (or replace)

the set of packable residues chosen for that position. Decreases number of rotamers for packing and the space for design. Instead of using energy for profiles, we use selection of residues through probabilities at each task generation. If picking rounds is higher can result in more than one additional residue in the task from the native.

Default is for the TaskOp to control the allowed amino acids only if the class has probabilities to use for that resnum. If no probabilities were set in general, it will not do anything. Probabilities should add to one, but if not, they will act as weights. Does NOT control which positions are set to design or repack, only what can be designed into.

If probabilities/weights for a particular residue are not present in the map, will not modify that residues task.

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

__init__(self: pyrosetta.rosetta.protocols.toolbox.task_operations.ResidueProbDesignOperation) -> None
__init__(self: pyrosetta.rosetta.protocols.toolbox.task_operations.ResidueProbDesignOperation, arg0: pyrosetta.rosetta.protocols.toolbox.task_operations.ResidueProbDesignOperation) -> 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).

apply(self: pyrosetta.rosetta.protocols.toolbox.task_operations.ResidueProbDesignOperation, pose: pyrosetta.rosetta.core.pose.Pose, task: pyrosetta.rosetta.core.pack.task.PackerTask) → None¶: C++: protocols::toolbox::task_operations::ResidueProbDesignOperation::apply(const class core::pose::Pose &, class core::pack::task::PackerTask &) const –> void

assign(self: pyrosetta.rosetta.protocols.toolbox.task_operations.ResidueProbDesignOperation, : pyrosetta.rosetta.protocols.toolbox.task_operations.ResidueProbDesignOperation) → pyrosetta.rosetta.protocols.toolbox.task_operations.ResidueProbDesignOperation¶: C++: protocols::toolbox::task_operations::ResidueProbDesignOperation::operator=(const class protocols::toolbox::task_operations::ResidueProbDesignOperation &) –> class protocols::toolbox::task_operations::ResidueProbDesignOperation &

clear_overall_prob_set(self: pyrosetta.rosetta.protocols.toolbox.task_operations.ResidueProbDesignOperation) → None¶

Clears the overall probabilities if any are set.

C++: protocols::toolbox::task_operations::ResidueProbDesignOperation::clear_overall_prob_set() –> void

clear_prob_set(self: pyrosetta.rosetta.protocols.toolbox.task_operations.ResidueProbDesignOperation) → None¶

Clears the probability matrix

C++: protocols::toolbox::task_operations::ResidueProbDesignOperation::clear_prob_set() –> void

clone(self: pyrosetta.rosetta.protocols.toolbox.task_operations.ResidueProbDesignOperation) → pyrosetta.rosetta.core.pack.task.operation.TaskOperation¶: C++: protocols::toolbox::task_operations::ResidueProbDesignOperation::clone() const –> class std::shared_ptr<class core::pack::task::operation::TaskOperation>

include_native_restype(self: pyrosetta.rosetta.protocols.toolbox.task_operations.ResidueProbDesignOperation) → bool¶: C++: protocols::toolbox::task_operations::ResidueProbDesignOperation::include_native_restype() const –> bool

keep_task_allowed_aas(self: pyrosetta.rosetta.protocols.toolbox.task_operations.ResidueProbDesignOperation) → bool¶: C++: protocols::toolbox::task_operations::ResidueProbDesignOperation::keep_task_allowed_aas() const –> bool

keyname() → str¶: C++: protocols::toolbox::task_operations::ResidueProbDesignOperation::keyname() –> std::string

parse_tag(self: pyrosetta.rosetta.protocols.toolbox.task_operations.ResidueProbDesignOperation, tag: pyrosetta.rosetta.utility.tag.Tag, : pyrosetta.rosetta.basic.datacache.DataMap) → None¶: C++: protocols::toolbox::task_operations::ResidueProbDesignOperation::parse_tag(class std::shared_ptr<const class utility::tag::Tag>, class basic::datacache::DataMap &) –> void

picking_rounds(self: pyrosetta.rosetta.protocols.toolbox.task_operations.ResidueProbDesignOperation) → int¶: C++: protocols::toolbox::task_operations::ResidueProbDesignOperation::picking_rounds() const –> unsigned long

provide_xml_schema(xsd: pyrosetta.rosetta.utility.tag.XMLSchemaDefinition) → None¶: C++: protocols::toolbox::task_operations::ResidueProbDesignOperation::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) –> void

resnum_exists_in_set(self: pyrosetta.rosetta.protocols.toolbox.task_operations.ResidueProbDesignOperation, resnum: int) → bool¶: C++: protocols::toolbox::task_operations::ResidueProbDesignOperation::resnum_exists_in_set(const unsigned long) const –> bool

sample_zero_probs_at(self: pyrosetta.rosetta.protocols.toolbox.task_operations.ResidueProbDesignOperation) → float¶: C++: protocols::toolbox::task_operations::ResidueProbDesignOperation::sample_zero_probs_at() const –> double

set_aa_probabilities(self: pyrosetta.rosetta.protocols.toolbox.task_operations.ResidueProbDesignOperation, resnum: int, aa_probs: pyrosetta.rosetta.std.map_core_chemical_AA_double) → None¶

Sets aa probabilities for a particular resnum

C++: protocols::toolbox::task_operations::ResidueProbDesignOperation::set_aa_probabilities(const unsigned long, class std::map<enum core::chemical::AA, double, struct std::less<enum core::chemical::AA>, class std::allocator<struct std::pair<const enum core::chemical::AA, double> > >) –> void

set_aa_probabilities_from_file(self: pyrosetta.rosetta.protocols.toolbox.task_operations.ResidueProbDesignOperation, weights_file: str) → None¶

Reads weights for each posenum and residue type. Format for each line in the file is: POSENUM RESIDUETYPE WEIGHT. With weight as a real between 0 and 1

C++: protocols::toolbox::task_operations::ResidueProbDesignOperation::set_aa_probabilities_from_file(const class std::basic_string<char> &) –> void

set_aa_probability_set(self: pyrosetta.rosetta.protocols.toolbox.task_operations.ResidueProbDesignOperation, per_res_aa_probs: pyrosetta.rosetta.std.map_unsigned_long_std_map_core_chemical_AA_double_std_less_core_chemical_AA_std_allocator_std_pair_const_core_chemical_AA_double_t) → None¶

Sets the whole aa probability set.

C++: protocols::toolbox::task_operations::ResidueProbDesignOperation::set_aa_probability_set(class std::map<unsigned long, class std::map<enum core::chemical::AA, double, struct std::less<enum core::chemical::AA>, class std::allocator<struct std::pair<const enum core::chemical::AA, double> > >, struct std::less<unsigned long>, class std::allocator<struct std::pair<const unsigned long, class std::map<enum core::chemical::AA, double, struct std::less<enum core::chemical::AA>, class std::allocator<struct std::pair<const enum core::chemical::AA, double> > > > > >) –> void

set_defaults(self: pyrosetta.rosetta.protocols.toolbox.task_operations.ResidueProbDesignOperation) → None¶: C++: protocols::toolbox::task_operations::ResidueProbDesignOperation::set_defaults() –> void

set_include_native_restype(self: pyrosetta.rosetta.protocols.toolbox.task_operations.ResidueProbDesignOperation, include: bool) → None¶

Include current residuetype in packer in addition to selected mutation. Default is true.

C++: protocols::toolbox::task_operations::ResidueProbDesignOperation::set_include_native_restype(bool) –> void

set_keep_task_allowed_aas(self: pyrosetta.rosetta.protocols.toolbox.task_operations.ResidueProbDesignOperation, setting: bool) → None¶

Add the aa types chosen from the probabilities to the allowed aa at the position instead of overwriting it.

Will result in very different results.

C++: protocols::toolbox::task_operations::ResidueProbDesignOperation::set_keep_task_allowed_aas(bool) –> void

set_overall_aa_probabilities(self: pyrosetta.rosetta.protocols.toolbox.task_operations.ResidueProbDesignOperation, aa_probs: pyrosetta.rosetta.std.map_core_chemical_AA_double) → None¶

Sets aa probabilities for all positions not given specifically. All designable residues will use these probabilities this if not specified through other functions.

C++: protocols::toolbox::task_operations::ResidueProbDesignOperation::set_overall_aa_probabilities(class std::map<enum core::chemical::AA, double, struct std::less<enum core::chemical::AA>, class std::allocator<struct std::pair<const enum core::chemical::AA, double> > >) –> void

set_picking_rounds(self: pyrosetta.rosetta.protocols.toolbox.task_operations.ResidueProbDesignOperation, picking_rounds: int) → None¶

Max number of times to sample from the probability distribution. Default is once.

This is to increase variability. Too many rounds will even out the distribution. Can also run the PackRotamers mover or equivalent multiple times for sampling.

C++: protocols::toolbox::task_operations::ResidueProbDesignOperation::set_picking_rounds(unsigned long) –> void

set_sample_zero_probs_at(self: pyrosetta.rosetta.protocols.toolbox.task_operations.ResidueProbDesignOperation, probability: float) → None¶

Sample any zero probabilities at this probability instead of not using them.

C++: protocols::toolbox::task_operations::ResidueProbDesignOperation::set_sample_zero_probs_at(const double) –> void

class pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictByCalculatorsOperation¶

Bases: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictOperationsBase

this class is a TaskOperation to prevent repacking of residues according to std::set< core::Size >-returning PoseMetricCalculators

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

__init__(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictByCalculatorsOperation) -> None
__init__(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictByCalculatorsOperation, calcs_and_calcns: pyrosetta.rosetta.utility.vector1_std_pair_std_string_std_string_t) -> 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).

apply(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictByCalculatorsOperation, : pyrosetta.rosetta.core.pose.Pose, : pyrosetta.rosetta.core.pack.task.PackerTask) → None¶: C++: protocols::toolbox::task_operations::RestrictByCalculatorsOperation::apply(const class core::pose::Pose &, class core::pack::task::PackerTask &) const –> void

assign(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictOperationsBase, : pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictOperationsBase) → pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictOperationsBase¶: C++: protocols::toolbox::task_operations::RestrictOperationsBase::operator=(const class protocols::toolbox::task_operations::RestrictOperationsBase &) –> class protocols::toolbox::task_operations::RestrictOperationsBase &

clone(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictByCalculatorsOperation) → pyrosetta.rosetta.core.pack.task.operation.TaskOperation¶: C++: protocols::toolbox::task_operations::RestrictByCalculatorsOperation::clone() const –> class std::shared_ptr<class core::pack::task::operation::TaskOperation>

keyname() → str¶: C++: protocols::toolbox::task_operations::RestrictByCalculatorsOperation::keyname() –> std::string

parse_tag(self: pyrosetta.rosetta.core.pack.task.operation.TaskOperation, : utility::tag::Tag, : pyrosetta.rosetta.basic.datacache.DataMap) → None¶

Used to parse an xml-like tag to load parameters and properties.

C++: core::pack::task::operation::TaskOperation::parse_tag(class std::shared_ptr<const class utility::tag::Tag>, class basic::datacache::DataMap &) –> void

provide_xml_schema(xsd: pyrosetta.rosetta.utility.tag.XMLSchemaDefinition) → None¶: C++: protocols::toolbox::task_operations::RestrictByCalculatorsOperation::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) –> void

class pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictChainToRepackingOperation¶

Bases: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictOperationsBase

this class is a TaskOperation to prevent repacking of residues not near an interface.

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

__init__(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictChainToRepackingOperation) -> None
__init__(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictChainToRepackingOperation, chain: 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).

apply(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictChainToRepackingOperation, : pyrosetta.rosetta.core.pose.Pose, : pyrosetta.rosetta.core.pack.task.PackerTask) → None¶: C++: protocols::toolbox::task_operations::RestrictChainToRepackingOperation::apply(const class core::pose::Pose &, class core::pack::task::PackerTask &) const –> void

assign(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictChainToRepackingOperation, : pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictChainToRepackingOperation) → pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictChainToRepackingOperation¶: C++: protocols::toolbox::task_operations::RestrictChainToRepackingOperation::operator=(const class protocols::toolbox::task_operations::RestrictChainToRepackingOperation &) –> class protocols::toolbox::task_operations::RestrictChainToRepackingOperation &

chain(*args, **kwargs)¶

Overloaded function.

chain(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictChainToRepackingOperation, chain: int) -> None

C++: protocols::toolbox::task_operations::RestrictChainToRepackingOperation::chain(const unsigned long) –> void

chain(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictChainToRepackingOperation) -> int

C++: protocols::toolbox::task_operations::RestrictChainToRepackingOperation::chain() const –> unsigned long

clone(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictChainToRepackingOperation) → pyrosetta.rosetta.core.pack.task.operation.TaskOperation¶: C++: protocols::toolbox::task_operations::RestrictChainToRepackingOperation::clone() const –> class std::shared_ptr<class core::pack::task::operation::TaskOperation>

keyname() → str¶: C++: protocols::toolbox::task_operations::RestrictChainToRepackingOperation::keyname() –> std::string

parse_tag(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictChainToRepackingOperation, : pyrosetta.rosetta.utility.tag.Tag, : pyrosetta.rosetta.basic.datacache.DataMap) → None¶: C++: protocols::toolbox::task_operations::RestrictChainToRepackingOperation::parse_tag(class std::shared_ptr<const class utility::tag::Tag>, class basic::datacache::DataMap &) –> void

provide_xml_schema(xsd: pyrosetta.rosetta.utility.tag.XMLSchemaDefinition) → None¶: C++: protocols::toolbox::task_operations::RestrictChainToRepackingOperation::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) –> void

class pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictConservedLowDdgOperation¶

Bases: pyrosetta.rosetta.protocols.toolbox.task_operations.SeqprofConsensusOperation

a Task operation that will check whether the amino acid at a position is conserved in the sequence profile and has an unfavorable ddG when mutated to ala. all positions that match this criterion will get set to repacking.

wt ala positions are set to repacking based on seqprof criterion only. If the input pose contains a forbidden (i.e. non wildtype ) residue at an untouchable position, the residue currently in the pose is also allowed.

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

__init__(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictConservedLowDdgOperation) -> None
__init__(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictConservedLowDdgOperation, arg0: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictConservedLowDdgOperation) -> 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).

apply(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictConservedLowDdgOperation, pose: pyrosetta.rosetta.core.pose.Pose, task: pyrosetta.rosetta.core.pack.task.PackerTask) → None¶: C++: protocols::toolbox::task_operations::RestrictConservedLowDdgOperation::apply(const class core::pose::Pose &, class core::pack::task::PackerTask &) const –> void

assign(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictConservedLowDdgOperation, : pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictConservedLowDdgOperation) → pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictConservedLowDdgOperation¶: C++: protocols::toolbox::task_operations::RestrictConservedLowDdgOperation::operator=(const class protocols::toolbox::task_operations::RestrictConservedLowDdgOperation &) –> class protocols::toolbox::task_operations::RestrictConservedLowDdgOperation &

chain_num(*args, **kwargs)¶

Overloaded function.

chain_num(self: pyrosetta.rosetta.protocols.toolbox.task_operations.SeqprofConsensusOperation) -> int

C++: protocols::toolbox::task_operations::SeqprofConsensusOperation::chain_num() const –> unsigned long

chain_num(self: pyrosetta.rosetta.protocols.toolbox.task_operations.SeqprofConsensusOperation, d: int) -> None

C++: protocols::toolbox::task_operations::SeqprofConsensusOperation::chain_num(const unsigned long) –> void

clone(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictConservedLowDdgOperation) → pyrosetta.rosetta.core.pack.task.operation.TaskOperation¶: C++: protocols::toolbox::task_operations::RestrictConservedLowDdgOperation::clone() const –> class std::shared_ptr<class core::pack::task::operation::TaskOperation>

conservation_cutoff_aligned_segments(*args, **kwargs)¶

Overloaded function.

conservation_cutoff_aligned_segments(self: pyrosetta.rosetta.protocols.toolbox.task_operations.SeqprofConsensusOperation) -> float

C++: protocols::toolbox::task_operations::SeqprofConsensusOperation::conservation_cutoff_aligned_segments() const –> double

conservation_cutoff_aligned_segments(self: pyrosetta.rosetta.protocols.toolbox.task_operations.SeqprofConsensusOperation, c: float) -> None

C++: protocols::toolbox::task_operations::SeqprofConsensusOperation::conservation_cutoff_aligned_segments(const double) –> void

conservation_cutoff_protein_interface_design(*args, **kwargs)¶

Overloaded function.

conservation_cutoff_protein_interface_design(self: pyrosetta.rosetta.protocols.toolbox.task_operations.SeqprofConsensusOperation) -> float

C++: protocols::toolbox::task_operations::SeqprofConsensusOperation::conservation_cutoff_protein_interface_design() const –> double

conservation_cutoff_protein_interface_design(self: pyrosetta.rosetta.protocols.toolbox.task_operations.SeqprofConsensusOperation, c: float) -> None

C++: protocols::toolbox::task_operations::SeqprofConsensusOperation::conservation_cutoff_protein_interface_design(const double) –> void

convert_scores_to_probabilities(*args, **kwargs)¶

Overloaded function.

convert_scores_to_probabilities(self: pyrosetta.rosetta.protocols.toolbox.task_operations.SeqprofConsensusOperation, c: bool) -> None

C++: protocols::toolbox::task_operations::SeqprofConsensusOperation::convert_scores_to_probabilities(const bool) –> void

convert_scores_to_probabilities(self: pyrosetta.rosetta.protocols.toolbox.task_operations.SeqprofConsensusOperation) -> bool

C++: protocols::toolbox::task_operations::SeqprofConsensusOperation::convert_scores_to_probabilities() const –> bool

create_complex_type_generator(xsd: pyrosetta.rosetta.utility.tag.XMLSchemaDefinition) → pyrosetta.rosetta.utility.tag.XMLSchemaComplexTypeGenerator¶: C++: protocols::toolbox::task_operations::RestrictConservedLowDdgOperation::create_complex_type_generator(class utility::tag::XMLSchemaDefinition &) –> class std::shared_ptr<class utility::tag::XMLSchemaComplexTypeGenerator>

debug(*args, **kwargs)¶

Overloaded function.

debug(self: pyrosetta.rosetta.protocols.toolbox.task_operations.SeqprofConsensusOperation, b: bool) -> None

C++: protocols::toolbox::task_operations::SeqprofConsensusOperation::debug(const bool) –> void

debug(self: pyrosetta.rosetta.protocols.toolbox.task_operations.SeqprofConsensusOperation) -> bool

C++: protocols::toolbox::task_operations::SeqprofConsensusOperation::debug() const –> bool

keep_native(*args, **kwargs)¶

Overloaded function.

keep_native(self: pyrosetta.rosetta.protocols.toolbox.task_operations.SeqprofConsensusOperation) -> bool

C++: protocols::toolbox::task_operations::SeqprofConsensusOperation::keep_native() const –> bool

keep_native(self: pyrosetta.rosetta.protocols.toolbox.task_operations.SeqprofConsensusOperation, b: bool) -> None

C++: protocols::toolbox::task_operations::SeqprofConsensusOperation::keep_native(const bool) –> void

keyname() → str¶: C++: protocols::toolbox::task_operations::RestrictConservedLowDdgOperation::keyname() –> std::string

parse_tag(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictConservedLowDdgOperation, tag: pyrosetta.rosetta.utility.tag.Tag, : pyrosetta.rosetta.basic.datacache.DataMap) → None¶: C++: protocols::toolbox::task_operations::RestrictConservedLowDdgOperation::parse_tag(class std::shared_ptr<const class utility::tag::Tag>, class basic::datacache::DataMap &) –> void

position_ala_ddG(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictConservedLowDdgOperation, seqpos: int) → float¶

convenience function to query: what the ddG is for a to ala mutation at a certain position

C++: protocols::toolbox::task_operations::RestrictConservedLowDdgOperation::position_ala_ddG(unsigned long) const –> double

position_untouchable(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictConservedLowDdgOperation, seqpos: int, seqprof_wt: pyrosetta.rosetta.core.chemical.AA) → bool¶

returns true if seqpos has a sequence profile: frequency > conservation_cutoff_ and an X->A ddG of > ddG_cutoff_

C++: protocols::toolbox::task_operations::RestrictConservedLowDdgOperation::position_untouchable(unsigned long, enum core::chemical::AA) const –> bool

protein_interface_design(*args, **kwargs)¶

Overloaded function.

protein_interface_design(self: pyrosetta.rosetta.protocols.toolbox.task_operations.SeqprofConsensusOperation) -> pyrosetta.rosetta.protocols.toolbox.task_operations.ProteinInterfaceDesignOperation

C++: protocols::toolbox::task_operations::SeqprofConsensusOperation::protein_interface_design() const –> class std::shared_ptr<class protocols::toolbox::task_operations::ProteinInterfaceDesignOperation>

protein_interface_design(self: pyrosetta.rosetta.protocols.toolbox.task_operations.SeqprofConsensusOperation, pido: pyrosetta.rosetta.protocols.toolbox.task_operations.ProteinInterfaceDesignOperation) -> None

C++: protocols::toolbox::task_operations::SeqprofConsensusOperation::protein_interface_design(class std::shared_ptr<class protocols::toolbox::task_operations::ProteinInterfaceDesignOperation>) –> void

provide_xml_schema(xsd: pyrosetta.rosetta.utility.tag.XMLSchemaDefinition) → None¶: C++: protocols::toolbox::task_operations::RestrictConservedLowDdgOperation::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) –> void

restrict_to_aligned_segments(*args, **kwargs)¶

Overloaded function.

restrict_to_aligned_segments(self: pyrosetta.rosetta.protocols.toolbox.task_operations.SeqprofConsensusOperation) -> pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictToAlignedSegmentsOperation

C++: protocols::toolbox::task_operations::SeqprofConsensusOperation::restrict_to_aligned_segments() const –> class std::shared_ptr<class protocols::toolbox::task_operations::RestrictToAlignedSegmentsOperation>

restrict_to_aligned_segments(self: pyrosetta.rosetta.protocols.toolbox.task_operations.SeqprofConsensusOperation, rtas: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictToAlignedSegmentsOperation) -> None

C++: protocols::toolbox::task_operations::SeqprofConsensusOperation::restrict_to_aligned_segments(class std::shared_ptr<class protocols::toolbox::task_operations::RestrictToAlignedSegmentsOperation>) –> void

seqprof(self: pyrosetta.rosetta.protocols.toolbox.task_operations.SeqprofConsensusOperation) → pyrosetta.rosetta.core.sequence.SequenceProfile¶: C++: protocols::toolbox::task_operations::SeqprofConsensusOperation::seqprof() const –> class std::shared_ptr<const class core::sequence::SequenceProfile>

seqprof_wt_aa(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictConservedLowDdgOperation, seqpos: int) → pyrosetta.rosetta.core.chemical.AA¶: C++: protocols::toolbox::task_operations::RestrictConservedLowDdgOperation::seqprof_wt_aa(unsigned long) const –> enum core::chemical::AA

set_ignore_pose_profile_length_mismatch(self: pyrosetta.rosetta.protocols.toolbox.task_operations.SeqprofConsensusOperation, setting: bool) → None¶: C++: protocols::toolbox::task_operations::SeqprofConsensusOperation::set_ignore_pose_profile_length_mismatch(const bool) –> void

set_seqprof(*args, **kwargs)¶

Overloaded function.

set_seqprof(self: pyrosetta.rosetta.protocols.toolbox.task_operations.SeqprofConsensusOperation, seqprof: pyrosetta.rosetta.core.sequence.SequenceProfile) -> None
set_seqprof(self: pyrosetta.rosetta.protocols.toolbox.task_operations.SeqprofConsensusOperation, seqprof: pyrosetta.rosetta.core.sequence.SequenceProfile, reweight: bool) -> None

Set the sequence profile. If reweight is true, convert the profile into per-residue probabilities first

C++: protocols::toolbox::task_operations::SeqprofConsensusOperation::set_seqprof(class std::shared_ptr<class core::sequence::SequenceProfile>, bool) –> void

verbose(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictConservedLowDdgOperation) → bool¶: C++: protocols::toolbox::task_operations::RestrictConservedLowDdgOperation::verbose() const –> bool

class pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictIdentitiesAtAlignedPositionsOperation¶

Bases: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictOperationsBase

this class is a TaskOperation to prevent repacking of residues not near an interface.

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

__init__(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictIdentitiesAtAlignedPositionsOperation) -> None
__init__(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictIdentitiesAtAlignedPositionsOperation, arg0: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictIdentitiesAtAlignedPositionsOperation) -> 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).

apply(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictIdentitiesAtAlignedPositionsOperation, : pyrosetta.rosetta.core.pose.Pose, : pyrosetta.rosetta.core.pack.task.PackerTask) → None¶: C++: protocols::toolbox::task_operations::RestrictIdentitiesAtAlignedPositionsOperation::apply(const class core::pose::Pose &, class core::pack::task::PackerTask &) const –> void

assign(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictIdentitiesAtAlignedPositionsOperation, : pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictIdentitiesAtAlignedPositionsOperation) → pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictIdentitiesAtAlignedPositionsOperation¶: C++: protocols::toolbox::task_operations::RestrictIdentitiesAtAlignedPositionsOperation::operator=(const class protocols::toolbox::task_operations::RestrictIdentitiesAtAlignedPositionsOperation &) –> class protocols::toolbox::task_operations::RestrictIdentitiesAtAlignedPositionsOperation &

chain(*args, **kwargs)¶

Overloaded function.

chain(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictIdentitiesAtAlignedPositionsOperation, c: int) -> None

C++: protocols::toolbox::task_operations::RestrictIdentitiesAtAlignedPositionsOperation::chain(const unsigned long) –> void

chain(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictIdentitiesAtAlignedPositionsOperation) -> int

C++: protocols::toolbox::task_operations::RestrictIdentitiesAtAlignedPositionsOperation::chain() const –> unsigned long

clone(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictIdentitiesAtAlignedPositionsOperation) → pyrosetta.rosetta.core.pack.task.operation.TaskOperation¶: C++: protocols::toolbox::task_operations::RestrictIdentitiesAtAlignedPositionsOperation::clone() const –> class std::shared_ptr<class core::pack::task::operation::TaskOperation>

design_only_target_residues(*args, **kwargs)¶

Overloaded function.

design_only_target_residues(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictIdentitiesAtAlignedPositionsOperation, b: bool) -> None

C++: protocols::toolbox::task_operations::RestrictIdentitiesAtAlignedPositionsOperation::design_only_target_residues(const bool) –> void

design_only_target_residues(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictIdentitiesAtAlignedPositionsOperation) -> bool

C++: protocols::toolbox::task_operations::RestrictIdentitiesAtAlignedPositionsOperation::design_only_target_residues() const –> bool

keep_aas(*args, **kwargs)¶

Overloaded function.

keep_aas(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictIdentitiesAtAlignedPositionsOperation, s: str) -> None

C++: protocols::toolbox::task_operations::RestrictIdentitiesAtAlignedPositionsOperation::keep_aas(const class std::basic_string<char> &) –> void

keep_aas(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictIdentitiesAtAlignedPositionsOperation) -> str

C++: protocols::toolbox::task_operations::RestrictIdentitiesAtAlignedPositionsOperation::keep_aas() const –> std::string

keyname() → str¶: C++: protocols::toolbox::task_operations::RestrictIdentitiesAtAlignedPositionsOperation::keyname() –> std::string

parse_tag(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictIdentitiesAtAlignedPositionsOperation, : pyrosetta.rosetta.utility.tag.Tag, : pyrosetta.rosetta.basic.datacache.DataMap) → None¶: C++: protocols::toolbox::task_operations::RestrictIdentitiesAtAlignedPositionsOperation::parse_tag(class std::shared_ptr<const class utility::tag::Tag>, class basic::datacache::DataMap &) –> void

prevent_repacking(*args, **kwargs)¶

Overloaded function.

prevent_repacking(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictIdentitiesAtAlignedPositionsOperation) -> bool

C++: protocols::toolbox::task_operations::RestrictIdentitiesAtAlignedPositionsOperation::prevent_repacking() const –> bool

prevent_repacking(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictIdentitiesAtAlignedPositionsOperation, b: bool) -> None

C++: protocols::toolbox::task_operations::RestrictIdentitiesAtAlignedPositionsOperation::prevent_repacking(const bool) –> void

provide_xml_schema(xsd: pyrosetta.rosetta.utility.tag.XMLSchemaDefinition) → None¶: C++: protocols::toolbox::task_operations::RestrictIdentitiesAtAlignedPositionsOperation::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) –> void

res_ids(*args, **kwargs)¶

Overloaded function.

res_ids(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictIdentitiesAtAlignedPositionsOperation) -> pyrosetta.rosetta.utility.vector1_unsigned_long

C++: protocols::toolbox::task_operations::RestrictIdentitiesAtAlignedPositionsOperation::res_ids() const –> class utility::vector1<unsigned long, class std::allocator<unsigned long> >

res_ids(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictIdentitiesAtAlignedPositionsOperation, s: pyrosetta.rosetta.utility.vector1_unsigned_long) -> None

C++: protocols::toolbox::task_operations::RestrictIdentitiesAtAlignedPositionsOperation::res_ids(const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &) –> void

restrict_identities(*args, **kwargs)¶

Overloaded function.

restrict_identities(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictIdentitiesAtAlignedPositionsOperation, b: bool) -> None

C++: protocols::toolbox::task_operations::RestrictIdentitiesAtAlignedPositionsOperation::restrict_identities(const bool) –> void

restrict_identities(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictIdentitiesAtAlignedPositionsOperation) -> bool

C++: protocols::toolbox::task_operations::RestrictIdentitiesAtAlignedPositionsOperation::restrict_identities() const –> bool

source_pose(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictIdentitiesAtAlignedPositionsOperation, s: str) → None¶: C++: protocols::toolbox::task_operations::RestrictIdentitiesAtAlignedPositionsOperation::source_pose(const class std::basic_string<char> &) –> void

class pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictIdentitiesOperation¶

Bases: pyrosetta.rosetta.core.pack.task.operation.TaskOperation

this class is a TaskOperation to prevent repacking of residues not near an interface.

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

__init__(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictIdentitiesOperation) -> None
__init__(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictIdentitiesOperation, identities: pyrosetta.rosetta.utility.vector1_std_string, prevent_repacking: bool) -> None
__init__(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictIdentitiesOperation, arg0: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictIdentitiesOperation) -> 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).

apply(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictIdentitiesOperation, : pyrosetta.rosetta.core.pose.Pose, : pyrosetta.rosetta.core.pack.task.PackerTask) → None¶: C++: protocols::toolbox::task_operations::RestrictIdentitiesOperation::apply(const class core::pose::Pose &, class core::pack::task::PackerTask &) const –> void

assign(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictIdentitiesOperation, : pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictIdentitiesOperation) → pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictIdentitiesOperation¶: C++: protocols::toolbox::task_operations::RestrictIdentitiesOperation::operator=(const class protocols::toolbox::task_operations::RestrictIdentitiesOperation &) –> class protocols::toolbox::task_operations::RestrictIdentitiesOperation &

clone(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictIdentitiesOperation) → pyrosetta.rosetta.core.pack.task.operation.TaskOperation¶: C++: protocols::toolbox::task_operations::RestrictIdentitiesOperation::clone() const –> class std::shared_ptr<class core::pack::task::operation::TaskOperation>

identities(*args, **kwargs)¶

Overloaded function.

identities(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictIdentitiesOperation) -> pyrosetta.rosetta.utility.vector1_std_string

C++: protocols::toolbox::task_operations::RestrictIdentitiesOperation::identities() const –> class utility::vector1<std::string, class std::allocator<std::string > >

identities(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictIdentitiesOperation, residues_vec: pyrosetta.rosetta.utility.vector1_std_string) -> None

C++: protocols::toolbox::task_operations::RestrictIdentitiesOperation::identities(class utility::vector1<class std::basic_string<char>, class std::allocator<class std::basic_string<char> > >) –> void

keyname() → str¶: C++: protocols::toolbox::task_operations::RestrictIdentitiesOperation::keyname() –> std::string

parse_tag(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictIdentitiesOperation, : pyrosetta.rosetta.utility.tag.Tag, : pyrosetta.rosetta.basic.datacache.DataMap) → None¶: C++: protocols::toolbox::task_operations::RestrictIdentitiesOperation::parse_tag(class std::shared_ptr<const class utility::tag::Tag>, class basic::datacache::DataMap &) –> void

prevent_repacking(*args, **kwargs)¶

Overloaded function.

prevent_repacking(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictIdentitiesOperation) -> bool

C++: protocols::toolbox::task_operations::RestrictIdentitiesOperation::prevent_repacking() const –> bool

prevent_repacking(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictIdentitiesOperation, prevent_repacking: bool) -> None

C++: protocols::toolbox::task_operations::RestrictIdentitiesOperation::prevent_repacking(const bool) –> void

provide_xml_schema(xsd: pyrosetta.rosetta.utility.tag.XMLSchemaDefinition) → None¶: C++: protocols::toolbox::task_operations::RestrictIdentitiesOperation::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) –> void

class pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictNonSurfaceToRepackingOperation¶

Bases: pyrosetta.rosetta.core.pack.task.operation.TaskOperation

this class is a TaskOperation to allow design of only surface exposed positions

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

__init__(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictNonSurfaceToRepackingOperation) -> None
__init__(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictNonSurfaceToRepackingOperation, nb_cutoff: 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).

apply(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictNonSurfaceToRepackingOperation, pose: pyrosetta.rosetta.core.pose.Pose, task: pyrosetta.rosetta.core.pack.task.PackerTask) → None¶: C++: protocols::toolbox::task_operations::RestrictNonSurfaceToRepackingOperation::apply(const class core::pose::Pose &, class core::pack::task::PackerTask &) const –> void

assign(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictNonSurfaceToRepackingOperation, : pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictNonSurfaceToRepackingOperation) → pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictNonSurfaceToRepackingOperation¶: C++: protocols::toolbox::task_operations::RestrictNonSurfaceToRepackingOperation::operator=(const class protocols::toolbox::task_operations::RestrictNonSurfaceToRepackingOperation &) –> class protocols::toolbox::task_operations::RestrictNonSurfaceToRepackingOperation &

clone(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictNonSurfaceToRepackingOperation) → pyrosetta.rosetta.core.pack.task.operation.TaskOperation¶: C++: protocols::toolbox::task_operations::RestrictNonSurfaceToRepackingOperation::clone() const –> class std::shared_ptr<class core::pack::task::operation::TaskOperation>

keyname() → str¶: C++: protocols::toolbox::task_operations::RestrictNonSurfaceToRepackingOperation::keyname() –> std::string

parse_tag(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictNonSurfaceToRepackingOperation, tag: pyrosetta.rosetta.utility.tag.Tag, dm: pyrosetta.rosetta.basic.datacache.DataMap) → None¶: C++: protocols::toolbox::task_operations::RestrictNonSurfaceToRepackingOperation::parse_tag(class std::shared_ptr<const class utility::tag::Tag>, class basic::datacache::DataMap &) –> void

provide_xml_schema(xsd: pyrosetta.rosetta.utility.tag.XMLSchemaDefinition) → None¶: C++: protocols::toolbox::task_operations::RestrictNonSurfaceToRepackingOperation::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) –> void

surface_exposed_nb_cutoff(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictNonSurfaceToRepackingOperation, nb_count: int) → None¶: C++: protocols::toolbox::task_operations::RestrictNonSurfaceToRepackingOperation::surface_exposed_nb_cutoff(const unsigned long) –> void

class pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictOperationsBase¶

Bases: pyrosetta.rosetta.core.pack.task.operation.TaskOperation

This base class defines an interface for TaskOperations which use PoseMetricCalculators to pick out certain residues in a pose. The apply function takes a vector of PoseMetricCalculators and a vector of calculation queries, and uses those queries to shape the PackerTask. This was designed to work with NeighborsByDistanceCalculator, NeighborhoodByDistanceCalculator, and InterfaceNeighborDefinitionCalculator; in general it works when the calculators can return MetricValue< std::set< core::Size > > (a std::set of resids).

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

__init__(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictOperationsBase) -> None
__init__(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictOperationsBase, arg0: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictOperationsBase) -> 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).

apply(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictOperationsBase, : pyrosetta.rosetta.core.pose.Pose, : pyrosetta.rosetta.core.pack.task.PackerTask) → None¶: C++: protocols::toolbox::task_operations::RestrictOperationsBase::apply(const class core::pose::Pose &, class core::pack::task::PackerTask &) const –> void

assign(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictOperationsBase, : pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictOperationsBase) → pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictOperationsBase¶: C++: protocols::toolbox::task_operations::RestrictOperationsBase::operator=(const class protocols::toolbox::task_operations::RestrictOperationsBase &) –> class protocols::toolbox::task_operations::RestrictOperationsBase &

clone(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictOperationsBase) → pyrosetta.rosetta.core.pack.task.operation.TaskOperation¶: C++: protocols::toolbox::task_operations::RestrictOperationsBase::clone() const –> class std::shared_ptr<class core::pack::task::operation::TaskOperation>

parse_tag(self: pyrosetta.rosetta.core.pack.task.operation.TaskOperation, : utility::tag::Tag, : pyrosetta.rosetta.basic.datacache.DataMap) → None¶

Used to parse an xml-like tag to load parameters and properties.

C++: core::pack::task::operation::TaskOperation::parse_tag(class std::shared_ptr<const class utility::tag::Tag>, class basic::datacache::DataMap &) –> void

class pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictResiduesToRepackingOperation¶

Bases: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictOperationsBase

this class is a TaskOperation to prevent repacking of residues not near an interface.

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

__init__(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictResiduesToRepackingOperation) -> None
__init__(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictResiduesToRepackingOperation, residues: pyrosetta.rosetta.utility.vector1_unsigned_long) -> None
__init__(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictResiduesToRepackingOperation, arg0: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictResiduesToRepackingOperation) -> 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).

apply(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictResiduesToRepackingOperation, : pyrosetta.rosetta.core.pose.Pose, : pyrosetta.rosetta.core.pack.task.PackerTask) → None¶: C++: protocols::toolbox::task_operations::RestrictResiduesToRepackingOperation::apply(const class core::pose::Pose &, class core::pack::task::PackerTask &) const –> void

assign(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictResiduesToRepackingOperation, : pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictResiduesToRepackingOperation) → pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictResiduesToRepackingOperation¶: C++: protocols::toolbox::task_operations::RestrictResiduesToRepackingOperation::operator=(const class protocols::toolbox::task_operations::RestrictResiduesToRepackingOperation &) –> class protocols::toolbox::task_operations::RestrictResiduesToRepackingOperation &

clone(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictResiduesToRepackingOperation) → pyrosetta.rosetta.core.pack.task.operation.TaskOperation¶: C++: protocols::toolbox::task_operations::RestrictResiduesToRepackingOperation::clone() const –> class std::shared_ptr<class core::pack::task::operation::TaskOperation>

get_residues(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictResiduesToRepackingOperation) → pyrosetta.rosetta.utility.vector1_unsigned_long¶: C++: protocols::toolbox::task_operations::RestrictResiduesToRepackingOperation::get_residues() const –> class utility::vector1<unsigned long, class std::allocator<unsigned long> >

keyname() → str¶: C++: protocols::toolbox::task_operations::RestrictResiduesToRepackingOperation::keyname() –> std::string

parse_tag(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictResiduesToRepackingOperation, : pyrosetta.rosetta.utility.tag.Tag, : pyrosetta.rosetta.basic.datacache.DataMap) → None¶: C++: protocols::toolbox::task_operations::RestrictResiduesToRepackingOperation::parse_tag(class std::shared_ptr<const class utility::tag::Tag>, class basic::datacache::DataMap &) –> void

provide_xml_schema(xsd: pyrosetta.rosetta.utility.tag.XMLSchemaDefinition) → None¶: C++: protocols::toolbox::task_operations::RestrictResiduesToRepackingOperation::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) –> void

reference_pdb_id(*args, **kwargs)¶

Overloaded function.

reference_pdb_id(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictResiduesToRepackingOperation) -> str

C++: protocols::toolbox::task_operations::RestrictResiduesToRepackingOperation::reference_pdb_id() const –> std::string

reference_pdb_id(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictResiduesToRepackingOperation, s: str) -> None

C++: protocols::toolbox::task_operations::RestrictResiduesToRepackingOperation::reference_pdb_id(const class std::basic_string<char> &) –> void

set_residues(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictResiduesToRepackingOperation, residues_vec: pyrosetta.rosetta.utility.vector1_unsigned_long) → None¶: C++: protocols::toolbox::task_operations::RestrictResiduesToRepackingOperation::set_residues(class utility::vector1<unsigned long, class std::allocator<unsigned long> >) –> void

class pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictToAlignedSegmentsOperation¶

Bases: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictOperationsBase

this class is a TaskOperation to prevent repacking of residues not near an interface.

__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.protocols.toolbox.task_operations.RestrictToAlignedSegmentsOperation) → 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).

apply(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictToAlignedSegmentsOperation, : pyrosetta.rosetta.core.pose.Pose, : pyrosetta.rosetta.core.pack.task.PackerTask) → None¶: C++: protocols::toolbox::task_operations::RestrictToAlignedSegmentsOperation::apply(const class core::pose::Pose &, class core::pack::task::PackerTask &) const –> void

assign(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictToAlignedSegmentsOperation, : pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictToAlignedSegmentsOperation) → pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictToAlignedSegmentsOperation¶: C++: protocols::toolbox::task_operations::RestrictToAlignedSegmentsOperation::operator=(const class protocols::toolbox::task_operations::RestrictToAlignedSegmentsOperation &) –> class protocols::toolbox::task_operations::RestrictToAlignedSegmentsOperation &

chain(*args, **kwargs)¶

Overloaded function.

chain(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictToAlignedSegmentsOperation) -> int

C++: protocols::toolbox::task_operations::RestrictToAlignedSegmentsOperation::chain() const –> unsigned long

chain(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictToAlignedSegmentsOperation, c: int) -> None

C++: protocols::toolbox::task_operations::RestrictToAlignedSegmentsOperation::chain(const unsigned long) –> void

clone(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictToAlignedSegmentsOperation) → pyrosetta.rosetta.core.pack.task.operation.TaskOperation¶: C++: protocols::toolbox::task_operations::RestrictToAlignedSegmentsOperation::clone() const –> class std::shared_ptr<class core::pack::task::operation::TaskOperation>

keyname() → str¶: C++: protocols::toolbox::task_operations::RestrictToAlignedSegmentsOperation::keyname() –> std::string

parse_tag(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictToAlignedSegmentsOperation, : pyrosetta.rosetta.utility.tag.Tag, : pyrosetta.rosetta.basic.datacache.DataMap) → None¶: C++: protocols::toolbox::task_operations::RestrictToAlignedSegmentsOperation::parse_tag(class std::shared_ptr<const class utility::tag::Tag>, class basic::datacache::DataMap &) –> void

provide_xml_schema(xsd: pyrosetta.rosetta.utility.tag.XMLSchemaDefinition) → None¶: C++: protocols::toolbox::task_operations::RestrictToAlignedSegmentsOperation::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) –> void

repack_shell(*args, **kwargs)¶

Overloaded function.

repack_shell(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictToAlignedSegmentsOperation) -> float

C++: protocols::toolbox::task_operations::RestrictToAlignedSegmentsOperation::repack_shell() const –> double

repack_shell(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictToAlignedSegmentsOperation, r: float) -> None

C++: protocols::toolbox::task_operations::RestrictToAlignedSegmentsOperation::repack_shell(const double) –> void

start_res(*args, **kwargs)¶

Overloaded function.

start_res(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictToAlignedSegmentsOperation) -> pyrosetta.rosetta.utility.vector1_unsigned_long

C++: protocols::toolbox::task_operations::RestrictToAlignedSegmentsOperation::start_res() const –> class utility::vector1<unsigned long, class std::allocator<unsigned long> >

start_res(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictToAlignedSegmentsOperation, s: pyrosetta.rosetta.utility.vector1_unsigned_long) -> None

C++: protocols::toolbox::task_operations::RestrictToAlignedSegmentsOperation::start_res(const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &) –> void

stop_res(*args, **kwargs)¶

Overloaded function.

stop_res(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictToAlignedSegmentsOperation) -> pyrosetta.rosetta.utility.vector1_unsigned_long

C++: protocols::toolbox::task_operations::RestrictToAlignedSegmentsOperation::stop_res() const –> class utility::vector1<unsigned long, class std::allocator<unsigned long> >

stop_res(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictToAlignedSegmentsOperation, s: pyrosetta.rosetta.utility.vector1_unsigned_long) -> None

C++: protocols::toolbox::task_operations::RestrictToAlignedSegmentsOperation::stop_res(const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &) –> void

class pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictToInterfaceOperation¶

Bases: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictOperationsBase

this class is a TaskOperation to prevent repacking of residues not near an interface.

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

__init__(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictToInterfaceOperation) -> None

doc

__init__(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictToInterfaceOperation, arg0: int) -> None

doc

__init__(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictToInterfaceOperation, upper_chain: int, lower_chain: int) -> None
__init__(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictToInterfaceOperation, calculator: str) -> None
__init__(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictToInterfaceOperation, arg0: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictToInterfaceOperation) -> 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).

apply(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictToInterfaceOperation, : pyrosetta.rosetta.core.pose.Pose, : pyrosetta.rosetta.core.pack.task.PackerTask) → None¶: C++: protocols::toolbox::task_operations::RestrictToInterfaceOperation::apply(const class core::pose::Pose &, class core::pack::task::PackerTask &) const –> void

assign(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictToInterfaceOperation, : pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictToInterfaceOperation) → pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictToInterfaceOperation¶: C++: protocols::toolbox::task_operations::RestrictToInterfaceOperation::operator=(const class protocols::toolbox::task_operations::RestrictToInterfaceOperation &) –> class protocols::toolbox::task_operations::RestrictToInterfaceOperation &

clone(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictToInterfaceOperation) → pyrosetta.rosetta.core.pack.task.operation.TaskOperation¶: C++: protocols::toolbox::task_operations::RestrictToInterfaceOperation::clone() const –> class std::shared_ptr<class core::pack::task::operation::TaskOperation>

keyname() → str¶: C++: protocols::toolbox::task_operations::RestrictToInterfaceOperation::keyname() –> std::string

parse_tag(self: pyrosetta.rosetta.core.pack.task.operation.TaskOperation, : utility::tag::Tag, : pyrosetta.rosetta.basic.datacache.DataMap) → None¶

Used to parse an xml-like tag to load parameters and properties.

C++: core::pack::task::operation::TaskOperation::parse_tag(class std::shared_ptr<const class utility::tag::Tag>, class basic::datacache::DataMap &) –> void

provide_xml_schema(xsd: pyrosetta.rosetta.utility.tag.XMLSchemaDefinition) → None¶: C++: protocols::toolbox::task_operations::RestrictToInterfaceOperation::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) –> void

class pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictToInterfaceVectorOperation¶

Bases: pyrosetta.rosetta.protocols.toolbox.task_operations.InterfaceTaskOperation

this class is a TaskOperation to prevent repacking of residues not near an interface.

CB_dist_cutoff(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictToInterfaceVectorOperation, CB_dist_cutoff: float) → None¶

Commenting out to fix PyRosetta build void jump_num( int jump_num);

C++: protocols::toolbox::task_operations::RestrictToInterfaceVectorOperation::CB_dist_cutoff(double) –> void

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

__init__(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictToInterfaceVectorOperation) -> None
__init__(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictToInterfaceVectorOperation, lower_chain_id: int, upper_chain_id: int) -> None
__init__(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictToInterfaceVectorOperation, lower_chain: int, upper_chain: int, CB_dist_cutoff: float, nearby_atom_cutoff: float, vector_angle_cutoff: float, vector_dist_cutoff: float) -> None
__init__(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictToInterfaceVectorOperation, movable_jumps: pyrosetta.rosetta.utility.vector1_int) -> None
__init__(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictToInterfaceVectorOperation, movable_jumps: pyrosetta.rosetta.utility.vector1_int, CB_dist_cutoff: float, nearby_atom_cutoff: float, vector_angle_cutoff: float, vector_dist_cutoff: float) -> 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_movable_jump(self: pyrosetta.rosetta.protocols.toolbox.task_operations.InterfaceTaskOperation, additional_jump: int) → None¶: C++: protocols::toolbox::task_operations::InterfaceTaskOperation::add_movable_jump(const int) –> void

apply(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictToInterfaceVectorOperation, : pyrosetta.rosetta.core.pose.Pose, : pyrosetta.rosetta.core.pack.task.PackerTask) → None¶: C++: protocols::toolbox::task_operations::RestrictToInterfaceVectorOperation::apply(const class core::pose::Pose &, class core::pack::task::PackerTask &) const –> void

assign(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictToInterfaceVectorOperation, : pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictToInterfaceVectorOperation) → pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictToInterfaceVectorOperation¶: C++: protocols::toolbox::task_operations::RestrictToInterfaceVectorOperation::operator=(const class protocols::toolbox::task_operations::RestrictToInterfaceVectorOperation &) –> class protocols::toolbox::task_operations::RestrictToInterfaceVectorOperation &

clone(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictToInterfaceVectorOperation) → pyrosetta.rosetta.core.pack.task.operation.TaskOperation¶: C++: protocols::toolbox::task_operations::RestrictToInterfaceVectorOperation::clone() const –> class std::shared_ptr<class core::pack::task::operation::TaskOperation>

keyname() → str¶: C++: protocols::toolbox::task_operations::RestrictToInterfaceVectorOperation::keyname() –> std::string

lower_chain(*args, **kwargs)¶

Overloaded function.

lower_chain(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictToInterfaceVectorOperation, lower_chain: int) -> None

C++: protocols::toolbox::task_operations::RestrictToInterfaceVectorOperation::lower_chain(unsigned long) –> void

lower_chain(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictToInterfaceVectorOperation, lower_chain: pyrosetta.rosetta.utility.vector1_unsigned_long) -> None

C++: protocols::toolbox::task_operations::RestrictToInterfaceVectorOperation::lower_chain(class utility::vector1<unsigned long, class std::allocator<unsigned long> >) –> void

movable_jumps(self: pyrosetta.rosetta.protocols.toolbox.task_operations.InterfaceTaskOperation) → pyrosetta.rosetta.utility.vector1_int¶: C++: protocols::toolbox::task_operations::InterfaceTaskOperation::movable_jumps() const –> const class utility::vector1<int, class std::allocator<int> > &

nearby_atom_cutoff(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictToInterfaceVectorOperation, nearby_atom_cutoff: float) → None¶: C++: protocols::toolbox::task_operations::RestrictToInterfaceVectorOperation::nearby_atom_cutoff(double) –> void

parse_tag(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictToInterfaceVectorOperation, tag: pyrosetta.rosetta.utility.tag.Tag, : pyrosetta.rosetta.basic.datacache.DataMap) → None¶

parse_tag function for rosetta scripts

C++: protocols::toolbox::task_operations::RestrictToInterfaceVectorOperation::parse_tag(class std::shared_ptr<const class utility::tag::Tag>, class basic::datacache::DataMap &) –> void

provide_xml_schema(xsd: pyrosetta.rosetta.utility.tag.XMLSchemaDefinition) → None¶: C++: protocols::toolbox::task_operations::RestrictToInterfaceVectorOperation::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) –> void

set_movable_jumps(self: pyrosetta.rosetta.protocols.toolbox.task_operations.InterfaceTaskOperation, movable_jumps: pyrosetta.rosetta.utility.vector1_int) → None¶: C++: protocols::toolbox::task_operations::InterfaceTaskOperation::set_movable_jumps(const class utility::vector1<int, class std::allocator<int> > &) –> void

upper_chain(*args, **kwargs)¶

Overloaded function.

upper_chain(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictToInterfaceVectorOperation, upper_chain: int) -> None

C++: protocols::toolbox::task_operations::RestrictToInterfaceVectorOperation::upper_chain(unsigned long) –> void

upper_chain(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictToInterfaceVectorOperation, upper_chain: pyrosetta.rosetta.utility.vector1_unsigned_long) -> None

C++: protocols::toolbox::task_operations::RestrictToInterfaceVectorOperation::upper_chain(class utility::vector1<unsigned long, class std::allocator<unsigned long> >) –> void

vector_angle_cutoff(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictToInterfaceVectorOperation, vector_angle_cutoff: float) → None¶: C++: protocols::toolbox::task_operations::RestrictToInterfaceVectorOperation::vector_angle_cutoff(double) –> void

vector_dist_cutoff(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictToInterfaceVectorOperation, vector_dist_cutoff: float) → None¶: C++: protocols::toolbox::task_operations::RestrictToInterfaceVectorOperation::vector_dist_cutoff(double) –> void

class pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictToLoopsAndNeighbors¶

Bases: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictToLoops

This class allows the selection for packing (and possibly design) of residues contained in a Loops object as well as the neighbors within a specified cutoff distance, with the default and maximum cutoff at 10.0 A.

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

__init__(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictToLoopsAndNeighbors) -> None
__init__(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictToLoopsAndNeighbors, arg0: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictToLoopsAndNeighbors) -> 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).

apply(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictToLoopsAndNeighbors, pose: pyrosetta.rosetta.core.pose.Pose, task: pyrosetta.rosetta.core.pack.task.PackerTask) → None¶: C++: protocols::toolbox::task_operations::RestrictToLoopsAndNeighbors::apply(const class core::pose::Pose &, class core::pack::task::PackerTask &) const –> void

assign(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictToLoopsAndNeighbors, rhs: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictToLoopsAndNeighbors) → pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictToLoopsAndNeighbors¶

Assignment operator.

C++: protocols::toolbox::task_operations::RestrictToLoopsAndNeighbors::operator=(const class protocols::toolbox::task_operations::RestrictToLoopsAndNeighbors &) –> class protocols::toolbox::task_operations::RestrictToLoopsAndNeighbors &

clone(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictToLoopsAndNeighbors) → pyrosetta.rosetta.core.pack.task.operation.TaskOperation¶

RestrictToLoops::clone

C++: protocols::toolbox::task_operations::RestrictToLoopsAndNeighbors::clone() const –> class std::shared_ptr<class core::pack::task::operation::TaskOperation>

cutoff_distance(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictToLoopsAndNeighbors) → float¶: C++: protocols::toolbox::task_operations::RestrictToLoopsAndNeighbors::cutoff_distance() const –> double

design_loop(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictToLoops) → bool¶

Return true if design is allowed.

C++: protocols::toolbox::task_operations::RestrictToLoops::design_loop() const –> bool

design_neighbors(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictToLoopsAndNeighbors) → bool¶: C++: protocols::toolbox::task_operations::RestrictToLoopsAndNeighbors::design_neighbors() const –> bool

include_neighbors(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictToLoopsAndNeighbors) → bool¶: C++: protocols::toolbox::task_operations::RestrictToLoopsAndNeighbors::include_neighbors() const –> bool

keyname() → str¶: C++: protocols::toolbox::task_operations::RestrictToLoopsAndNeighbors::keyname() –> std::string

loops(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictToLoops) → pyrosetta.rosetta.protocols.loops.Loops¶

Return the loops allowed to pack.

C++: protocols::toolbox::task_operations::RestrictToLoops::loops() const –> class std::shared_ptr<const class protocols::loops::Loops>

parse_tag(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictToLoopsAndNeighbors, tag: pyrosetta.rosetta.utility.tag.Tag, : pyrosetta.rosetta.basic.datacache.DataMap) → None¶

RestrictToLoops::parse_tag

C++: protocols::toolbox::task_operations::RestrictToLoopsAndNeighbors::parse_tag(class std::shared_ptr<const class utility::tag::Tag>, class basic::datacache::DataMap &) –> void

provide_attributes(attributes: pyrosetta.rosetta.std.list_utility_tag_XMLSchemaAttribute_t) → None¶: C++: protocols::toolbox::task_operations::RestrictToLoops::provide_attributes(class std::list<class utility::tag::XMLSchemaAttribute, class std::allocator<class utility::tag::XMLSchemaAttribute> > &) –> void

provide_xml_schema(xsd: pyrosetta.rosetta.utility.tag.XMLSchemaDefinition) → None¶: C++: protocols::toolbox::task_operations::RestrictToLoopsAndNeighbors::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) –> void

restrict_only_design_to_loops(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictToLoops) → bool¶

Return true if we are restricting to only design.: AKA RestrictDesignToLoops.

C++: protocols::toolbox::task_operations::RestrictToLoops::restrict_only_design_to_loops() const –> bool

set_cutoff_distance(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictToLoopsAndNeighbors, cutoff_distance: float) → None¶: C++: protocols::toolbox::task_operations::RestrictToLoopsAndNeighbors::set_cutoff_distance(double) –> void

set_design_loop(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictToLoops, design_loop: bool) → None¶

Specify whether or not design is allowed.

C++: protocols::toolbox::task_operations::RestrictToLoops::set_design_loop(bool) –> void

set_design_neighbors(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictToLoopsAndNeighbors, design_neighbors: bool) → None¶: C++: protocols::toolbox::task_operations::RestrictToLoopsAndNeighbors::set_design_neighbors(bool) –> void

set_include_neighbors(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictToLoopsAndNeighbors, include_neighbors: bool) → None¶: C++: protocols::toolbox::task_operations::RestrictToLoopsAndNeighbors::set_include_neighbors(bool) –> void

set_loops(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictToLoops, loops: pyrosetta.rosetta.protocols.loops.Loops) → None¶

Specify the loops that will be allowed to pack.

C++: protocols::toolbox::task_operations::RestrictToLoops::set_loops(class std::shared_ptr<const class protocols::loops::Loops>) –> void

set_loops_from_file(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictToLoops, loops_file: str) → None¶

Specify the loops that will be allowed to pack.

C++: protocols::toolbox::task_operations::RestrictToLoops::set_loops_from_file(class std::basic_string<char>) –> void

set_restrict_only_design_to_loops(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictToLoops, restrict_only_design: bool) → None¶

Specify whether to restrict only design to loops/neighbors: AKA RestrictDesignToLoops. Does not disable packing for any residue. Implies and sets design_loop to true.

C++: protocols::toolbox::task_operations::RestrictToLoops::set_restrict_only_design_to_loops(bool) –> void

class pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictToMoveMapChiOperation¶

Bases: pyrosetta.rosetta.core.pack.task.operation.TaskOperation

A TaskOperation that accepts a movemap and restricts chi that are false to either packing or design. Does not turn anything on, just like the rest of the RestrictTo operations.

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

__init__(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictToMoveMapChiOperation) -> None
__init__(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictToMoveMapChiOperation, movemap: pyrosetta.rosetta.core.kinematics.MoveMap) -> None
__init__(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictToMoveMapChiOperation, arg0: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictToMoveMapChiOperation) -> 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).

apply(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictToMoveMapChiOperation, pose: pyrosetta.rosetta.core.pose.Pose, task: pyrosetta.rosetta.core.pack.task.PackerTask) → None¶: C++: protocols::toolbox::task_operations::RestrictToMoveMapChiOperation::apply(const class core::pose::Pose &, class core::pack::task::PackerTask &) const –> void

assign(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictToMoveMapChiOperation, : pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictToMoveMapChiOperation) → pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictToMoveMapChiOperation¶: C++: protocols::toolbox::task_operations::RestrictToMoveMapChiOperation::operator=(const class protocols::toolbox::task_operations::RestrictToMoveMapChiOperation &) –> class protocols::toolbox::task_operations::RestrictToMoveMapChiOperation &

clone(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictToMoveMapChiOperation) → pyrosetta.rosetta.core.pack.task.operation.TaskOperation¶: C++: protocols::toolbox::task_operations::RestrictToMoveMapChiOperation::clone() const –> class std::shared_ptr<class core::pack::task::operation::TaskOperation>

keyname() → str¶: C++: protocols::toolbox::task_operations::RestrictToMoveMapChiOperation::keyname() –> std::string

parse_tag(self: pyrosetta.rosetta.core.pack.task.operation.TaskOperation, : utility::tag::Tag, : pyrosetta.rosetta.basic.datacache.DataMap) → None¶

Used to parse an xml-like tag to load parameters and properties.

C++: core::pack::task::operation::TaskOperation::parse_tag(class std::shared_ptr<const class utility::tag::Tag>, class basic::datacache::DataMap &) –> void

provide_xml_schema(xsd: pyrosetta.rosetta.utility.tag.XMLSchemaDefinition) → None¶: C++: protocols::toolbox::task_operations::RestrictToMoveMapChiOperation::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) –> void

set_cutoff_distance(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictToMoveMapChiOperation, cutoff: float) → None¶

Cutoff distance for neighbor detection. Default is 10 A.

C++: protocols::toolbox::task_operations::RestrictToMoveMapChiOperation::set_cutoff_distance(double) –> void

set_design(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictToMoveMapChiOperation, setting: bool) → None¶

Set residues from movemap to designable. Default false.

C++: protocols::toolbox::task_operations::RestrictToMoveMapChiOperation::set_design(bool) –> void

set_include_neighbors(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictToMoveMapChiOperation, setting: bool) → None¶

Set to use neighbor residues in vacinity of movemap chi residues for packing. Default False.

C++: protocols::toolbox::task_operations::RestrictToMoveMapChiOperation::set_include_neighbors(bool) –> void

set_movemap(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictToMoveMapChiOperation, movemap: pyrosetta.rosetta.core.kinematics.MoveMap) → None¶: C++: protocols::toolbox::task_operations::RestrictToMoveMapChiOperation::set_movemap(class std::shared_ptr<const class core::kinematics::MoveMap>) –> void

class pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictToNeighborhoodOperation¶

Bases: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictOperationsBase

this class is a TaskOperation to prevent repacking of residues not near a neighborhood. Internally it just user NeighborhoodByDistanceCalculator to do all the work. You are allowed a “calculator name” interface to tell it which you-constructed calculator to use, or you can give it a set of residues and a desired distance cutoff to have it define the calculator itself. (There is no need to use both interfaces).

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

__init__(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictToNeighborhoodOperation) -> None
__init__(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictToNeighborhoodOperation, arg0: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictToNeighborhoodOperation) -> None
__init__(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictToNeighborhoodOperation, central_residues: pyrosetta.rosetta.std.set_unsigned_long_t, dist_cutoff: float) -> None
__init__(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictToNeighborhoodOperation, central_residues: pyrosetta.rosetta.std.set_unsigned_long_t) -> None
__init__(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictToNeighborhoodOperation, calculator: str) -> 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).

apply(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictToNeighborhoodOperation, : pyrosetta.rosetta.core.pose.Pose, : pyrosetta.rosetta.core.pack.task.PackerTask) → None¶: C++: protocols::toolbox::task_operations::RestrictToNeighborhoodOperation::apply(const class core::pose::Pose &, class core::pack::task::PackerTask &) const –> void

assign(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictToNeighborhoodOperation, rhs: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictToNeighborhoodOperation) → pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictToNeighborhoodOperation¶

assignment operator

C++: protocols::toolbox::task_operations::RestrictToNeighborhoodOperation::operator=(const class protocols::toolbox::task_operations::RestrictToNeighborhoodOperation &) –> class protocols::toolbox::task_operations::RestrictToNeighborhoodOperation &

clone(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictToNeighborhoodOperation) → pyrosetta.rosetta.core.pack.task.operation.TaskOperation¶: C++: protocols::toolbox::task_operations::RestrictToNeighborhoodOperation::clone() const –> class std::shared_ptr<class core::pack::task::operation::TaskOperation>

get_calculator(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictToNeighborhoodOperation) → pyrosetta.rosetta.protocols.toolbox.pose_metric_calculators.NeighborhoodByDistanceCalculator¶

look up actual calculator object

C++: protocols::toolbox::task_operations::RestrictToNeighborhoodOperation::get_calculator() const –> class std::shared_ptr<const class protocols::toolbox::pose_metric_calculators::NeighborhoodByDistanceCalculator>

get_calculator_name(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictToNeighborhoodOperation) → str¶

trivially returns underlying calculator string name

C++: protocols::toolbox::task_operations::RestrictToNeighborhoodOperation::get_calculator_name() const –> const std::string &

get_central_residues(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictToNeighborhoodOperation) → pyrosetta.rosetta.std.set_unsigned_long_t¶

this nontrivially checks the underlying calculator

C++: protocols::toolbox::task_operations::RestrictToNeighborhoodOperation::get_central_residues() const –> const class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> > &

get_distance_cutoff(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictToNeighborhoodOperation) → float¶

this nontrivially checks the underlying calculator

C++: protocols::toolbox::task_operations::RestrictToNeighborhoodOperation::get_distance_cutoff() const –> double

keyname() → str¶: C++: protocols::toolbox::task_operations::RestrictToNeighborhoodOperation::keyname() –> std::string

parse_tag(self: pyrosetta.rosetta.core.pack.task.operation.TaskOperation, : utility::tag::Tag, : pyrosetta.rosetta.basic.datacache.DataMap) → None¶

Used to parse an xml-like tag to load parameters and properties.

C++: core::pack::task::operation::TaskOperation::parse_tag(class std::shared_ptr<const class utility::tag::Tag>, class basic::datacache::DataMap &) –> void

provide_xml_schema(xsd: pyrosetta.rosetta.utility.tag.XMLSchemaDefinition) → None¶: C++: protocols::toolbox::task_operations::RestrictToNeighborhoodOperation::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) –> void

set_calculator_by_name(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictToNeighborhoodOperation, calculator_name: str) → None¶: C++: protocols::toolbox::task_operations::RestrictToNeighborhoodOperation::set_calculator_by_name(const class std::basic_string<char> &) –> void

set_neighborhood_parameters(*args, **kwargs)¶

Overloaded function.

set_neighborhood_parameters(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictToNeighborhoodOperation, central_residues: pyrosetta.rosetta.std.set_unsigned_long_t, dist_cutoff: float) -> None

reskin of normal make_calculator

C++: protocols::toolbox::task_operations::RestrictToNeighborhoodOperation::set_neighborhood_parameters(const class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> > &, double) –> void

set_neighborhood_parameters(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictToNeighborhoodOperation, central_residues: pyrosetta.rosetta.std.set_unsigned_long_t) -> None

reskin of normal make_calculator

C++: protocols::toolbox::task_operations::RestrictToNeighborhoodOperation::set_neighborhood_parameters(const class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> > &) –> void

class pyrosetta.rosetta.protocols.toolbox.task_operations.RetrieveStoredTaskOperation¶

Bases: pyrosetta.rosetta.core.pack.task.operation.TaskOperation

this class is a TaskOperation to prevent repacking of residues not near an interface.

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

__init__(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RetrieveStoredTaskOperation) -> None
__init__(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RetrieveStoredTaskOperation, arg0: pyrosetta.rosetta.protocols.toolbox.task_operations.RetrieveStoredTaskOperation) -> 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).

apply(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RetrieveStoredTaskOperation, : pyrosetta.rosetta.core.pose.Pose, : pyrosetta.rosetta.core.pack.task.PackerTask) → None¶: C++: protocols::toolbox::task_operations::RetrieveStoredTaskOperation::apply(const class core::pose::Pose &, class core::pack::task::PackerTask &) const –> void

assign(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RetrieveStoredTaskOperation, : pyrosetta.rosetta.protocols.toolbox.task_operations.RetrieveStoredTaskOperation) → pyrosetta.rosetta.protocols.toolbox.task_operations.RetrieveStoredTaskOperation¶: C++: protocols::toolbox::task_operations::RetrieveStoredTaskOperation::operator=(const class protocols::toolbox::task_operations::RetrieveStoredTaskOperation &) –> class protocols::toolbox::task_operations::RetrieveStoredTaskOperation &

clone(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RetrieveStoredTaskOperation) → pyrosetta.rosetta.core.pack.task.operation.TaskOperation¶: C++: protocols::toolbox::task_operations::RetrieveStoredTaskOperation::clone() const –> class std::shared_ptr<class core::pack::task::operation::TaskOperation>

keyname() → str¶: C++: protocols::toolbox::task_operations::RetrieveStoredTaskOperation::keyname() –> std::string

parse_tag(self: pyrosetta.rosetta.protocols.toolbox.task_operations.RetrieveStoredTaskOperation, : pyrosetta.rosetta.utility.tag.Tag, : pyrosetta.rosetta.basic.datacache.DataMap) → None¶: C++: protocols::toolbox::task_operations::RetrieveStoredTaskOperation::parse_tag(class std::shared_ptr<const class utility::tag::Tag>, class basic::datacache::DataMap &) –> void

provide_xml_schema(xsd: pyrosetta.rosetta.utility.tag.XMLSchemaDefinition) → None¶: C++: protocols::toolbox::task_operations::RetrieveStoredTaskOperation::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) –> void

class pyrosetta.rosetta.protocols.toolbox.task_operations.SelectResiduesWithinChainOperation¶

Bases: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictOperationsBase

this class is a TaskOperation to prevent repacking of residues not near an interface.

__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.protocols.toolbox.task_operations.SelectResiduesWithinChainOperation) → 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_res(self: pyrosetta.rosetta.protocols.toolbox.task_operations.SelectResiduesWithinChainOperation, resid: int) → None¶: C++: protocols::toolbox::task_operations::SelectResiduesWithinChainOperation::add_res(const unsigned long) –> void

allow_design(*args, **kwargs)¶

Overloaded function.

allow_design(self: pyrosetta.rosetta.protocols.toolbox.task_operations.SelectResiduesWithinChainOperation, b: bool) -> None

C++: protocols::toolbox::task_operations::SelectResiduesWithinChainOperation::allow_design(const bool) –> void

allow_design(self: pyrosetta.rosetta.protocols.toolbox.task_operations.SelectResiduesWithinChainOperation) -> bool

C++: protocols::toolbox::task_operations::SelectResiduesWithinChainOperation::allow_design() const –> bool

allow_repacking(*args, **kwargs)¶

Overloaded function.

allow_repacking(self: pyrosetta.rosetta.protocols.toolbox.task_operations.SelectResiduesWithinChainOperation, b: bool) -> None

C++: protocols::toolbox::task_operations::SelectResiduesWithinChainOperation::allow_repacking(const bool) –> void

allow_repacking(self: pyrosetta.rosetta.protocols.toolbox.task_operations.SelectResiduesWithinChainOperation) -> bool

C++: protocols::toolbox::task_operations::SelectResiduesWithinChainOperation::allow_repacking() const –> bool

apply(self: pyrosetta.rosetta.protocols.toolbox.task_operations.SelectResiduesWithinChainOperation, : pyrosetta.rosetta.core.pose.Pose, : pyrosetta.rosetta.core.pack.task.PackerTask) → None¶: C++: protocols::toolbox::task_operations::SelectResiduesWithinChainOperation::apply(const class core::pose::Pose &, class core::pack::task::PackerTask &) const –> void

assign(self: pyrosetta.rosetta.protocols.toolbox.task_operations.SelectResiduesWithinChainOperation, : pyrosetta.rosetta.protocols.toolbox.task_operations.SelectResiduesWithinChainOperation) → pyrosetta.rosetta.protocols.toolbox.task_operations.SelectResiduesWithinChainOperation¶: C++: protocols::toolbox::task_operations::SelectResiduesWithinChainOperation::operator=(const class protocols::toolbox::task_operations::SelectResiduesWithinChainOperation &) –> class protocols::toolbox::task_operations::SelectResiduesWithinChainOperation &

chain(*args, **kwargs)¶

Overloaded function.

chain(self: pyrosetta.rosetta.protocols.toolbox.task_operations.SelectResiduesWithinChainOperation) -> int

C++: protocols::toolbox::task_operations::SelectResiduesWithinChainOperation::chain() const –> unsigned long

chain(self: pyrosetta.rosetta.protocols.toolbox.task_operations.SelectResiduesWithinChainOperation, c: int) -> None

C++: protocols::toolbox::task_operations::SelectResiduesWithinChainOperation::chain(const unsigned long) –> void

clone(self: pyrosetta.rosetta.protocols.toolbox.task_operations.SelectResiduesWithinChainOperation) → pyrosetta.rosetta.core.pack.task.operation.TaskOperation¶: C++: protocols::toolbox::task_operations::SelectResiduesWithinChainOperation::clone() const –> class std::shared_ptr<class core::pack::task::operation::TaskOperation>

keyname() → str¶: C++: protocols::toolbox::task_operations::SelectResiduesWithinChainOperation::keyname() –> std::string

modify_unselected_residues(*args, **kwargs)¶

Overloaded function.

modify_unselected_residues(self: pyrosetta.rosetta.protocols.toolbox.task_operations.SelectResiduesWithinChainOperation, b: bool) -> None

C++: protocols::toolbox::task_operations::SelectResiduesWithinChainOperation::modify_unselected_residues(const bool) –> void

modify_unselected_residues(self: pyrosetta.rosetta.protocols.toolbox.task_operations.SelectResiduesWithinChainOperation) -> bool

C++: protocols::toolbox::task_operations::SelectResiduesWithinChainOperation::modify_unselected_residues() const –> bool

parse_tag(self: pyrosetta.rosetta.protocols.toolbox.task_operations.SelectResiduesWithinChainOperation, : pyrosetta.rosetta.utility.tag.Tag, : pyrosetta.rosetta.basic.datacache.DataMap) → None¶: C++: protocols::toolbox::task_operations::SelectResiduesWithinChainOperation::parse_tag(class std::shared_ptr<const class utility::tag::Tag>, class basic::datacache::DataMap &) –> void

provide_xml_schema(xsd: pyrosetta.rosetta.utility.tag.XMLSchemaDefinition) → None¶: C++: protocols::toolbox::task_operations::SelectResiduesWithinChainOperation::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) –> void

resid(self: pyrosetta.rosetta.protocols.toolbox.task_operations.SelectResiduesWithinChainOperation) → pyrosetta.rosetta.utility.vector1_unsigned_long¶: C++: protocols::toolbox::task_operations::SelectResiduesWithinChainOperation::resid() –> class utility::vector1<unsigned long, class std::allocator<unsigned long> >

class pyrosetta.rosetta.protocols.toolbox.task_operations.StoreCombinedStoredTasksMover¶

Bases: pyrosetta.rosetta.protocols.moves.Mover

mover that can be used to save or restore a task at an arbitrary point during a rosetta scripts protocol. other task operations, movers, or filters can be set up to access tasks saved by this mover during their apply calls.

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

__init__(self: pyrosetta.rosetta.protocols.toolbox.task_operations.StoreCombinedStoredTasksMover) -> None
__init__(self: pyrosetta.rosetta.protocols.toolbox.task_operations.StoreCombinedStoredTasksMover, arg0: pyrosetta.rosetta.protocols.toolbox.task_operations.StoreCombinedStoredTasksMover) -> 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).

apply(self: pyrosetta.rosetta.protocols.toolbox.task_operations.StoreCombinedStoredTasksMover, pose: pyrosetta.rosetta.core.pose.Pose) → None¶: C++: protocols::toolbox::task_operations::StoreCombinedStoredTasksMover::apply(class core::pose::Pose &) –> void

assign(self: pyrosetta.rosetta.protocols.toolbox.task_operations.StoreCombinedStoredTasksMover, : pyrosetta.rosetta.protocols.toolbox.task_operations.StoreCombinedStoredTasksMover) → pyrosetta.rosetta.protocols.toolbox.task_operations.StoreCombinedStoredTasksMover¶: C++: protocols::toolbox::task_operations::StoreCombinedStoredTasksMover::operator=(const class protocols::toolbox::task_operations::StoreCombinedStoredTasksMover &) –> class protocols::toolbox::task_operations::StoreCombinedStoredTasksMover &

clear_info(self: pyrosetta.rosetta.protocols.moves.Mover) → None¶

Strings container can be used to return miscellaneous info (as std::string) from a mover, such as notes about the results of apply(). The job distributor (Apr 09 vintage) will check this function to see if your protocol wants to add string info to the Job that ran this mover. One way this can be useful is that later, a JobOutputter may include/append this info to an output file.

clear_info is called by jd2 before calling apply

C++: protocols::moves::Mover::clear_info() –> void

clone(self: pyrosetta.rosetta.protocols.toolbox.task_operations.StoreCombinedStoredTasksMover) → pyrosetta.rosetta.protocols.moves.Mover¶: C++: protocols::toolbox::task_operations::StoreCombinedStoredTasksMover::clone() const –> class std::shared_ptr<class protocols::moves::Mover>

create(self: pyrosetta.rosetta.protocols.moves.Mover) → pyrosetta.rosetta.protocols.moves.Mover¶: C++: protocols::moves::Mover::create() –> class std::shared_ptr<class protocols::moves::Mover>

fresh_instance(self: pyrosetta.rosetta.protocols.toolbox.task_operations.StoreCombinedStoredTasksMover) → pyrosetta.rosetta.protocols.moves.Mover¶: C++: protocols::toolbox::task_operations::StoreCombinedStoredTasksMover::fresh_instance() const –> class std::shared_ptr<class protocols::moves::Mover>

get_additional_output(self: pyrosetta.rosetta.protocols.moves.Mover) → pyrosetta.rosetta.core.pose.Pose¶

fpd

Mechanism by which a mover may return multiple output poses from a single input pose.

C++: protocols::moves::Mover::get_additional_output() –> class std::shared_ptr<class core::pose::Pose>

get_current_job(self: pyrosetta.rosetta.protocols.moves.Mover) → protocols::jobdist::BasicJob¶: C++: protocols::moves::Mover::get_current_job() const –> class std::shared_ptr<const class protocols::jobdist::BasicJob>

get_current_tag(self: pyrosetta.rosetta.protocols.moves.Mover) → str¶

A tag is a unique identifier used to identify structures produced: by this Mover. get_current_tag() returns the tag, and set_current_tag( std::string tag ) sets the tag. This functionality is not intended for use with the 2008 job distributor.

C++: protocols::moves::Mover::get_current_tag() const –> std::string

get_input_pose(self: pyrosetta.rosetta.protocols.moves.Mover) → pyrosetta.rosetta.core.pose.Pose¶: C++: protocols::moves::Mover::get_input_pose() const –> class std::shared_ptr<const class core::pose::Pose>

get_last_move_status(self: pyrosetta.rosetta.protocols.moves.Mover) → pyrosetta.rosetta.protocols.moves.MoverStatus¶

returns status after an apply(). The job distributor (august 08 vintage) will check this function to see if your protocol wants to filter its results - if your protocol wants to say “that run was no good, skip it” then use the protected last_move_status(MoverStatus) to change the value that this function will return.

C++: protocols::moves::Mover::get_last_move_status() const –> enum protocols::moves::MoverStatus

get_name(self: pyrosetta.rosetta.protocols.toolbox.task_operations.StoreCombinedStoredTasksMover) → str¶: C++: protocols::toolbox::task_operations::StoreCombinedStoredTasksMover::get_name() const –> std::string

get_native_pose(self: pyrosetta.rosetta.protocols.moves.Mover) → pyrosetta.rosetta.core.pose.Pose¶: C++: protocols::moves::Mover::get_native_pose() const –> class std::shared_ptr<const class core::pose::Pose>

get_self_ptr(self: pyrosetta.rosetta.protocols.moves.Mover) → pyrosetta.rosetta.protocols.moves.Mover¶: C++: protocols::moves::Mover::get_self_ptr() –> class std::shared_ptr<class protocols::moves::Mover>

get_self_weak_ptr(self: pyrosetta.rosetta.protocols.moves.Mover) → pyrosetta.rosetta.std.weak_ptr_protocols_moves_Mover_t¶: C++: protocols::moves::Mover::get_self_weak_ptr() –> class std::weak_ptr<class protocols::moves::Mover>

get_type(self: pyrosetta.rosetta.protocols.moves.Mover) → str¶: C++: protocols::moves::Mover::get_type() const –> std::string

info(self: pyrosetta.rosetta.protocols.moves.Mover) → pyrosetta.rosetta.std.list_std_string_std_allocator_std_string_t¶

non-const accessor

C++: protocols::moves::Mover::info() –> class std::list<std::string, class std::allocator<std::string > > &

last_proposal_density_ratio(self: pyrosetta.rosetta.protocols.moves.Mover) → float¶: C++: protocols::moves::Mover::last_proposal_density_ratio() –> double

mover_name() → str¶: C++: protocols::toolbox::task_operations::StoreCombinedStoredTasksMover::mover_name() –> std::string

name() → str¶: C++: protocols::moves::Mover::name() –> std::string

provide_xml_schema(xsd: pyrosetta.rosetta.utility.tag.XMLSchemaDefinition) → None¶: C++: protocols::toolbox::task_operations::StoreCombinedStoredTasksMover::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) –> void

register_options() → None¶

Overload this static method if you access options within the mover.

These options will end up in -help of your application if users of this mover call register_options. Do this recursively! If you use movers within your mover, call their register_options in your register_options() method.

C++: protocols::moves::Mover::register_options() –> void

reinitialize_for_each_job(self: pyrosetta.rosetta.protocols.moves.Mover) → bool¶

Inform the Job Distributor (August ‘08 vintage) whether this object needs to be freshly regenerated on: each use.

C++: protocols::moves::Mover::reinitialize_for_each_job() const –> bool

reinitialize_for_new_input(self: pyrosetta.rosetta.protocols.moves.Mover) → bool¶

Inform the Job Distributor (August ‘08 vintage) whether this object needs to be regenerated when the input: pose is about to change, (for example, if the Mover has special code on the first apply() that is only valid for that one input pose).

C++: protocols::moves::Mover::reinitialize_for_new_input() const –> bool

reset_status(self: pyrosetta.rosetta.protocols.moves.Mover) → None¶

resets status to SUCCESS, meant to be used before an apply(). The job distributor (august 08 vintage) uses this to ensure non-accumulation of status across apply()s.

C++: protocols::moves::Mover::reset_status() –> void

set_current_job(self: pyrosetta.rosetta.protocols.moves.Mover, job: protocols::jobdist::BasicJob) → None¶

////////////////////////////end Job Distributor interface////////////////////////////////////////

C++: protocols::moves::Mover::set_current_job(class std::shared_ptr<const class protocols::jobdist::BasicJob>) –> void

set_current_tag(self: pyrosetta.rosetta.protocols.moves.Mover, new_tag: str) → None¶: C++: protocols::moves::Mover::set_current_tag(const class std::basic_string<char> &) –> void

set_input_pose(self: pyrosetta.rosetta.protocols.moves.Mover, pose: pyrosetta.rosetta.core.pose.Pose) → None¶

setter for poses contained for rms

C++: protocols::moves::Mover::set_input_pose(class std::shared_ptr<const class core::pose::Pose>) –> void

set_native_pose(self: pyrosetta.rosetta.protocols.moves.Mover, pose: pyrosetta.rosetta.core.pose.Pose) → None¶

setter for native poses contained for rms —- we should get rid of this method? it is widely used, but a bit unsafe

C++: protocols::moves::Mover::set_native_pose(class std::shared_ptr<const class core::pose::Pose>) –> void

set_type(self: pyrosetta.rosetta.protocols.moves.Mover, setting: str) → None¶: C++: protocols::moves::Mover::set_type(const class std::basic_string<char> &) –> void

show(*args, **kwargs)¶

Overloaded function.

show(self: pyrosetta.rosetta.protocols.moves.Mover) -> None
show(self: pyrosetta.rosetta.protocols.moves.Mover, output: pyrosetta.rosetta.std.ostream) -> None

Outputs details about the Mover, including current settings.

C++: protocols::moves::Mover::show(class std::basic_ostream<char> &) const –> void

test_move(self: pyrosetta.rosetta.protocols.moves.Mover, pose: pyrosetta.rosetta.core.pose.Pose) → None¶

: Unit test support function. Apply one move to a given pose.: Allows extra test specific functions to be called before applying

C++: protocols::moves::Mover::test_move(class core::pose::Pose &) –> void

type(*args, **kwargs)¶

Overloaded function.

type(self: pyrosetta.rosetta.protocols.moves.Mover) -> str

C++: protocols::moves::Mover::type() const –> const std::string &

type(self: pyrosetta.rosetta.protocols.moves.Mover, type_in: str) -> None

C++: protocols::moves::Mover::type(const class std::basic_string<char> &) –> void

class pyrosetta.rosetta.protocols.toolbox.task_operations.StoreTaskMover¶

Bases: pyrosetta.rosetta.protocols.moves.Mover

mover that can be used to save or restore a task at an arbitrary point during a rosetta scripts protocol. other task operations, movers, or filters can be set up to access tasks saved by this mover during their apply calls.

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

__init__(self: pyrosetta.rosetta.protocols.toolbox.task_operations.StoreTaskMover) -> None
__init__(self: pyrosetta.rosetta.protocols.toolbox.task_operations.StoreTaskMover, arg0: pyrosetta.rosetta.protocols.toolbox.task_operations.StoreTaskMover) -> 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).

apply(self: pyrosetta.rosetta.protocols.toolbox.task_operations.StoreTaskMover, pose: pyrosetta.rosetta.core.pose.Pose) → None¶: C++: protocols::toolbox::task_operations::StoreTaskMover::apply(class core::pose::Pose &) –> void

assign(self: pyrosetta.rosetta.protocols.toolbox.task_operations.StoreTaskMover, : pyrosetta.rosetta.protocols.toolbox.task_operations.StoreTaskMover) → pyrosetta.rosetta.protocols.toolbox.task_operations.StoreTaskMover¶: C++: protocols::toolbox::task_operations::StoreTaskMover::operator=(const class protocols::toolbox::task_operations::StoreTaskMover &) –> class protocols::toolbox::task_operations::StoreTaskMover &

clear_info(self: pyrosetta.rosetta.protocols.moves.Mover) → None¶

Strings container can be used to return miscellaneous info (as std::string) from a mover, such as notes about the results of apply(). The job distributor (Apr 09 vintage) will check this function to see if your protocol wants to add string info to the Job that ran this mover. One way this can be useful is that later, a JobOutputter may include/append this info to an output file.

clear_info is called by jd2 before calling apply

C++: protocols::moves::Mover::clear_info() –> void

clone(self: pyrosetta.rosetta.protocols.toolbox.task_operations.StoreTaskMover) → pyrosetta.rosetta.protocols.moves.Mover¶: C++: protocols::toolbox::task_operations::StoreTaskMover::clone() const –> class std::shared_ptr<class protocols::moves::Mover>

create(self: pyrosetta.rosetta.protocols.moves.Mover) → pyrosetta.rosetta.protocols.moves.Mover¶: C++: protocols::moves::Mover::create() –> class std::shared_ptr<class protocols::moves::Mover>

fresh_instance(self: pyrosetta.rosetta.protocols.toolbox.task_operations.StoreTaskMover) → pyrosetta.rosetta.protocols.moves.Mover¶: C++: protocols::toolbox::task_operations::StoreTaskMover::fresh_instance() const –> class std::shared_ptr<class protocols::moves::Mover>

get_additional_output(self: pyrosetta.rosetta.protocols.moves.Mover) → pyrosetta.rosetta.core.pose.Pose¶

fpd

Mechanism by which a mover may return multiple output poses from a single input pose.

C++: protocols::moves::Mover::get_additional_output() –> class std::shared_ptr<class core::pose::Pose>

get_current_job(self: pyrosetta.rosetta.protocols.moves.Mover) → protocols::jobdist::BasicJob¶: C++: protocols::moves::Mover::get_current_job() const –> class std::shared_ptr<const class protocols::jobdist::BasicJob>

get_current_tag(self: pyrosetta.rosetta.protocols.moves.Mover) → str¶

A tag is a unique identifier used to identify structures produced: by this Mover. get_current_tag() returns the tag, and set_current_tag( std::string tag ) sets the tag. This functionality is not intended for use with the 2008 job distributor.

C++: protocols::moves::Mover::get_current_tag() const –> std::string

get_input_pose(self: pyrosetta.rosetta.protocols.moves.Mover) → pyrosetta.rosetta.core.pose.Pose¶: C++: protocols::moves::Mover::get_input_pose() const –> class std::shared_ptr<const class core::pose::Pose>

get_last_move_status(self: pyrosetta.rosetta.protocols.moves.Mover) → pyrosetta.rosetta.protocols.moves.MoverStatus¶

returns status after an apply(). The job distributor (august 08 vintage) will check this function to see if your protocol wants to filter its results - if your protocol wants to say “that run was no good, skip it” then use the protected last_move_status(MoverStatus) to change the value that this function will return.

C++: protocols::moves::Mover::get_last_move_status() const –> enum protocols::moves::MoverStatus

get_name(self: pyrosetta.rosetta.protocols.toolbox.task_operations.StoreTaskMover) → str¶: C++: protocols::toolbox::task_operations::StoreTaskMover::get_name() const –> std::string

get_native_pose(self: pyrosetta.rosetta.protocols.moves.Mover) → pyrosetta.rosetta.core.pose.Pose¶: C++: protocols::moves::Mover::get_native_pose() const –> class std::shared_ptr<const class core::pose::Pose>

get_self_ptr(self: pyrosetta.rosetta.protocols.moves.Mover) → pyrosetta.rosetta.protocols.moves.Mover¶: C++: protocols::moves::Mover::get_self_ptr() –> class std::shared_ptr<class protocols::moves::Mover>

get_self_weak_ptr(self: pyrosetta.rosetta.protocols.moves.Mover) → pyrosetta.rosetta.std.weak_ptr_protocols_moves_Mover_t¶: C++: protocols::moves::Mover::get_self_weak_ptr() –> class std::weak_ptr<class protocols::moves::Mover>

get_type(self: pyrosetta.rosetta.protocols.moves.Mover) → str¶: C++: protocols::moves::Mover::get_type() const –> std::string

info(self: pyrosetta.rosetta.protocols.moves.Mover) → pyrosetta.rosetta.std.list_std_string_std_allocator_std_string_t¶

non-const accessor

C++: protocols::moves::Mover::info() –> class std::list<std::string, class std::allocator<std::string > > &

last_proposal_density_ratio(self: pyrosetta.rosetta.protocols.moves.Mover) → float¶: C++: protocols::moves::Mover::last_proposal_density_ratio() –> double

mover_name() → str¶: C++: protocols::toolbox::task_operations::StoreTaskMover::mover_name() –> std::string

name() → str¶: C++: protocols::moves::Mover::name() –> std::string

provide_xml_schema(xsd: pyrosetta.rosetta.utility.tag.XMLSchemaDefinition) → None¶: C++: protocols::toolbox::task_operations::StoreTaskMover::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) –> void

register_options() → None¶

Overload this static method if you access options within the mover.

These options will end up in -help of your application if users of this mover call register_options. Do this recursively! If you use movers within your mover, call their register_options in your register_options() method.

C++: protocols::moves::Mover::register_options() –> void

reinitialize_for_each_job(self: pyrosetta.rosetta.protocols.moves.Mover) → bool¶

Inform the Job Distributor (August ‘08 vintage) whether this object needs to be freshly regenerated on: each use.

C++: protocols::moves::Mover::reinitialize_for_each_job() const –> bool

reinitialize_for_new_input(self: pyrosetta.rosetta.protocols.moves.Mover) → bool¶

Inform the Job Distributor (August ‘08 vintage) whether this object needs to be regenerated when the input: pose is about to change, (for example, if the Mover has special code on the first apply() that is only valid for that one input pose).

C++: protocols::moves::Mover::reinitialize_for_new_input() const –> bool

reset_status(self: pyrosetta.rosetta.protocols.moves.Mover) → None¶

resets status to SUCCESS, meant to be used before an apply(). The job distributor (august 08 vintage) uses this to ensure non-accumulation of status across apply()s.

C++: protocols::moves::Mover::reset_status() –> void

set_current_job(self: pyrosetta.rosetta.protocols.moves.Mover, job: protocols::jobdist::BasicJob) → None¶

////////////////////////////end Job Distributor interface////////////////////////////////////////

C++: protocols::moves::Mover::set_current_job(class std::shared_ptr<const class protocols::jobdist::BasicJob>) –> void

set_current_tag(self: pyrosetta.rosetta.protocols.moves.Mover, new_tag: str) → None¶: C++: protocols::moves::Mover::set_current_tag(const class std::basic_string<char> &) –> void

set_input_pose(self: pyrosetta.rosetta.protocols.moves.Mover, pose: pyrosetta.rosetta.core.pose.Pose) → None¶

setter for poses contained for rms

C++: protocols::moves::Mover::set_input_pose(class std::shared_ptr<const class core::pose::Pose>) –> void

set_native_pose(self: pyrosetta.rosetta.protocols.moves.Mover, pose: pyrosetta.rosetta.core.pose.Pose) → None¶

setter for native poses contained for rms —- we should get rid of this method? it is widely used, but a bit unsafe

C++: protocols::moves::Mover::set_native_pose(class std::shared_ptr<const class core::pose::Pose>) –> void

set_type(self: pyrosetta.rosetta.protocols.moves.Mover, setting: str) → None¶: C++: protocols::moves::Mover::set_type(const class std::basic_string<char> &) –> void

show(*args, **kwargs)¶

Overloaded function.

show(self: pyrosetta.rosetta.protocols.moves.Mover) -> None
show(self: pyrosetta.rosetta.protocols.moves.Mover, output: pyrosetta.rosetta.std.ostream) -> None

Outputs details about the Mover, including current settings.

C++: protocols::moves::Mover::show(class std::basic_ostream<char> &) const –> void

test_move(self: pyrosetta.rosetta.protocols.moves.Mover, pose: pyrosetta.rosetta.core.pose.Pose) → None¶

: Unit test support function. Apply one move to a given pose.: Allows extra test specific functions to be called before applying

C++: protocols::moves::Mover::test_move(class core::pose::Pose &) –> void

type(*args, **kwargs)¶

Overloaded function.

type(self: pyrosetta.rosetta.protocols.moves.Mover) -> str

C++: protocols::moves::Mover::type() const –> const std::string &

type(self: pyrosetta.rosetta.protocols.moves.Mover, type_in: str) -> None

C++: protocols::moves::Mover::type(const class std::basic_string<char> &) –> void

class pyrosetta.rosetta.protocols.toolbox.task_operations.ThreadSequenceOperation¶

Bases: pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictOperationsBase

this class is a TaskOperation to prevent repacking of residues not near an interface.

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

__init__(self: pyrosetta.rosetta.protocols.toolbox.task_operations.ThreadSequenceOperation) -> None
__init__(self: pyrosetta.rosetta.protocols.toolbox.task_operations.ThreadSequenceOperation, seq: str) -> None
__init__(self: pyrosetta.rosetta.protocols.toolbox.task_operations.ThreadSequenceOperation, arg0: pyrosetta.rosetta.protocols.toolbox.task_operations.ThreadSequenceOperation) -> 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).

allow_design_around(*args, **kwargs)¶

Overloaded function.

allow_design_around(self: pyrosetta.rosetta.protocols.toolbox.task_operations.ThreadSequenceOperation) -> bool

C++: protocols::toolbox::task_operations::ThreadSequenceOperation::allow_design_around() const –> bool

allow_design_around(self: pyrosetta.rosetta.protocols.toolbox.task_operations.ThreadSequenceOperation, b: bool) -> None

C++: protocols::toolbox::task_operations::ThreadSequenceOperation::allow_design_around(const bool) –> void

apply(self: pyrosetta.rosetta.protocols.toolbox.task_operations.ThreadSequenceOperation, : pyrosetta.rosetta.core.pose.Pose, : pyrosetta.rosetta.core.pack.task.PackerTask) → None¶: C++: protocols::toolbox::task_operations::ThreadSequenceOperation::apply(const class core::pose::Pose &, class core::pack::task::PackerTask &) const –> void

assign(self: pyrosetta.rosetta.protocols.toolbox.task_operations.ThreadSequenceOperation, : pyrosetta.rosetta.protocols.toolbox.task_operations.ThreadSequenceOperation) → pyrosetta.rosetta.protocols.toolbox.task_operations.ThreadSequenceOperation¶: C++: protocols::toolbox::task_operations::ThreadSequenceOperation::operator=(const class protocols::toolbox::task_operations::ThreadSequenceOperation &) –> class protocols::toolbox::task_operations::ThreadSequenceOperation &

clone(self: pyrosetta.rosetta.protocols.toolbox.task_operations.ThreadSequenceOperation) → pyrosetta.rosetta.core.pack.task.operation.TaskOperation¶: C++: protocols::toolbox::task_operations::ThreadSequenceOperation::clone() const –> class std::shared_ptr<class core::pack::task::operation::TaskOperation>

keyname() → str¶: C++: protocols::toolbox::task_operations::ThreadSequenceOperation::keyname() –> std::string

parse_tag(self: pyrosetta.rosetta.protocols.toolbox.task_operations.ThreadSequenceOperation, : pyrosetta.rosetta.utility.tag.Tag, : pyrosetta.rosetta.basic.datacache.DataMap) → None¶: C++: protocols::toolbox::task_operations::ThreadSequenceOperation::parse_tag(class std::shared_ptr<const class utility::tag::Tag>, class basic::datacache::DataMap &) –> void

provide_xml_schema(xsd: pyrosetta.rosetta.utility.tag.XMLSchemaDefinition) → None¶: C++: protocols::toolbox::task_operations::ThreadSequenceOperation::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) –> void

start_res(*args, **kwargs)¶

Overloaded function.

start_res(self: pyrosetta.rosetta.protocols.toolbox.task_operations.ThreadSequenceOperation) -> int

C++: protocols::toolbox::task_operations::ThreadSequenceOperation::start_res() const –> unsigned long

start_res(self: pyrosetta.rosetta.protocols.toolbox.task_operations.ThreadSequenceOperation, s: int) -> None

C++: protocols::toolbox::task_operations::ThreadSequenceOperation::start_res(const unsigned long) –> void

target_sequence(*args, **kwargs)¶

Overloaded function.

target_sequence(self: pyrosetta.rosetta.protocols.toolbox.task_operations.ThreadSequenceOperation, seq: str) -> None

C++: protocols::toolbox::task_operations::ThreadSequenceOperation::target_sequence(const class std::basic_string<char> &) –> void

target_sequence(self: pyrosetta.rosetta.protocols.toolbox.task_operations.ThreadSequenceOperation) -> str

C++: protocols::toolbox::task_operations::ThreadSequenceOperation::target_sequence() const –> std::string