build

• BuildInstructionState
• SegmentInsertConnectionScheme

Bindings for protocols::forge::build namespace

class pyrosetta.rosetta.protocols.forge.build.Bridge

Bases: pyrosetta.rosetta.protocols.forge.build.BuildInstruction

connect two contiguous but disjoint sections of a Pose into one

continuous section

Anchor residues [i,j] to bridge must be adjacent to each other in the

Pose (i+1 = j) and adjacent to a cutpoint. Both i and j will be idealized and marked as new moveable positions since the psi @ i and the phi @ j are undefined. Depending on the fold tree, this will cause a random swing either downstream or upstream of the bridge!

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: pyrosetta.rosetta.protocols.forge.build.Bridge) -> None
2. __init__(self: pyrosetta.rosetta.protocols.forge.build.Bridge, arg0: pyrosetta.rosetta.protocols.forge.build.Interval, arg1: str) -> None

doc

3. __init__(self: pyrosetta.rosetta.protocols.forge.build.Bridge, i: pyrosetta.rosetta.protocols.forge.build.Interval, ss: str, rts: pyrosetta.rosetta.std.weak_ptr_const_core_chemical_ResidueTypeSet_t) -> None
4. __init__(self: pyrosetta.rosetta.protocols.forge.build.Bridge, arg0: pyrosetta.rosetta.protocols.forge.build.Interval, arg1: str, arg2: str) -> None

doc

5. __init__(self: pyrosetta.rosetta.protocols.forge.build.Bridge, i: pyrosetta.rosetta.protocols.forge.build.Interval, ss: str, aa: str, rts: pyrosetta.rosetta.std.weak_ptr_const_core_chemical_ResidueTypeSet_t) -> None
6. __init__(self: pyrosetta.rosetta.protocols.forge.build.Bridge, arg0: pyrosetta.rosetta.protocols.forge.build.Bridge) -> 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_dependency_to(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction, i: pyrosetta.rosetta.std.weak_ptr_const_protocols_forge_build_BuildInstruction_t) → None

add an instruction to this BuildInstruction’s dependency list

before this instruction’s modify() may complete properly, all

instructions in the dependency list must have completed modify() first

C++: protocols::forge::build::BuildInstruction::add_dependency_to(class std::weak_ptr<const class protocols::forge::build::BuildInstruction>) –> void

assign(self: pyrosetta.rosetta.protocols.forge.build.Bridge, rval: pyrosetta.rosetta.protocols.forge.build.Bridge) → pyrosetta.rosetta.protocols.forge.build.Bridge

copy assignment

C++: protocols::forge::build::Bridge::operator=(const class protocols::forge::build::Bridge &) –> class protocols::forge::build::Bridge &

attach_to(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction, pose: pyrosetta.rosetta.core.pose.Pose) → None

attach to a Pose’s conformation

C++: protocols::forge::build::BuildInstruction::attach_to(class core::pose::Pose &) –> void

clear_dependencies(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → None

clear the list of dependencies

C++: protocols::forge::build::BuildInstruction::clear_dependencies() –> void

clone(self: pyrosetta.rosetta.protocols.forge.build.Bridge) → pyrosetta.rosetta.protocols.forge.build.BuildInstruction

clone this object

C++: protocols::forge::build::Bridge::clone() const –> class std::shared_ptr<class protocols::forge::build::BuildInstruction>

compatible_with(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction, rval: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → bool

compares fixed and mutable positions to determine compatibility with

another instruction

override this to obtain custom compatibility check

C++: protocols::forge::build::BuildInstruction::compatible_with(const class protocols::forge::build::BuildInstruction &) const –> bool

creates_undefined_backbone(self: pyrosetta.rosetta.protocols.forge.build.Bridge) → bool

does this object create undefined backbone in the modified region?

C++: protocols::forge::build::Bridge::creates_undefined_backbone() const –> bool

defined_positions(self: pyrosetta.rosetta.protocols.forge.build.Bridge) → pyrosetta.rosetta.std.set_unsigned_long_t

return a copy of the set of positions within the newly modified

region that has a defined conformation. E.g. existing or copied residues.

A set containing two positions – interval.left and interval.right.

This set can change wrt length changes in Pose/Conformation being

watched.

C++: protocols::forge::build::Bridge::defined_positions() const –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

dependencies(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → pyrosetta.rosetta.utility.vector1_std_weak_ptr_const_protocols_forge_build_BuildInstruction_t

the list of instructions whose modify() must complete before

the modify() for this instruction may be called successfully

C++: protocols::forge::build::BuildInstruction::dependencies() const –> const class utility::vector1<class std::weak_ptr<const class protocols::forge::build::BuildInstruction>, class std::allocator<class std::weak_ptr<const class protocols::forge::build::BuildInstruction> > > &

dependent_on(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction, i: pyrosetta.rosetta.std.weak_ptr_const_protocols_forge_build_BuildInstruction_t) → bool

is this instruction dependent upon the given instruction?

C++: protocols::forge::build::BuildInstruction::dependent_on(class std::weak_ptr<const class protocols::forge::build::BuildInstruction>) const –> bool

detach_after_modify(*args, **kwargs)

Overloaded function.

1. detach_after_modify(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) -> bool

detach after modify()?

Ordinarily a modify() call consists of attaching as a

length obs of the Pose, actually doing the modify, and then detaching as a length obs of the Pose. This flag governs whether the last detach occurs.

C++: protocols::forge::build::BuildInstruction::detach_after_modify() const –> bool

2. detach_after_modify(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction, flag: bool) -> None

set detach after modify()

Ordinarily a modify() call consists of attaching as a

length obs of the Pose, actually doing the modify, and then detaching as a length obs of the Pose. This flag governs whether the last detach occurs.

C++: protocols::forge::build::BuildInstruction::detach_after_modify(const bool) –> void

detach_from(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → None

detach from a Pose’s conformation

C++: protocols::forge::build::BuildInstruction::detach_from() –> void

has_dependencies(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → bool

does this BuildInstruction have dependencies?

C++: protocols::forge::build::BuildInstruction::has_dependencies() const –> bool

interval(self: pyrosetta.rosetta.protocols.forge.build.Bridge) → pyrosetta.rosetta.protocols.forge.build.Interval

a copy of the working range of residues specifying the bridged region

including the anchors

This residue range can change wrt length changes in Pose /Conformation

being watched.

C++: protocols::forge::build::Bridge::interval() const –> struct protocols::forge::build::Interval

modify(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction, pose: pyrosetta.rosetta.core.pose.Pose) → pyrosetta.rosetta.protocols.forge.build.BuildInstructionState.Enum

modify this pose

the state of the BuildInstruction

C++: protocols::forge::build::BuildInstruction::modify(class core::pose::Pose &) –> enum protocols::forge::build::BuildInstructionState::Enum

modify_was_successful(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → bool

Is the BuildInstruction’s state at MODIFY_WAS_SUCCESSFUL?

MODIFY_WAS_SUCCESSFUL indicates the BuildInstruction has

finished modifications to the Pose, and its residue indexing is now consistent with the newly modified Pose.

C++: protocols::forge::build::BuildInstruction::modify_was_successful() const –> bool

movemap(self: pyrosetta.rosetta.protocols.forge.build.Bridge) → pyrosetta.rosetta.core.kinematics.MoveMap

return a copy of the MoveMap that defines the moveable/fixed

positions/dofs for this instruction

a MoveMap with [interval.left, interval.right] bb & chi set to true

at the MoveMapTorsionID level

This set can change wrt length changes in Pose/Conformation being

watched.

C++: protocols::forge::build::Bridge::movemap() const –> class core::kinematics::MoveMap

n_dependencies(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → int

the number of dependencies this BuildInstruction has

C++: protocols::forge::build::BuildInstruction::n_dependencies() const –> unsigned long

new_positions(self: pyrosetta.rosetta.protocols.forge.build.Bridge) → pyrosetta.rosetta.std.set_unsigned_long_t

return a copy of the set of positions that are “new” and did

not exist in the original Pose.

A set containing positions spanning [interval.left+1, interval.right-1].

C++: protocols::forge::build::Bridge::new_positions() const –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

on_length_change(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction, event: pyrosetta.rosetta.core.conformation.signals.LengthEvent) → None

update any indexing wrt length change to Pose/Conformation being watched

C++: protocols::forge::build::BuildInstruction::on_length_change(const struct core::conformation::signals::LengthEvent &) –> void

on_residue_append(self: pyrosetta.rosetta.protocols.forge.build.Bridge, event: pyrosetta.rosetta.core.conformation.signals.LengthEvent) → None

update indexing on residue append

C++: protocols::forge::build::Bridge::on_residue_append(const struct core::conformation::signals::LengthEvent &) –> void

on_residue_delete(self: pyrosetta.rosetta.protocols.forge.build.Bridge, event: pyrosetta.rosetta.core.conformation.signals.LengthEvent) → None

update indexing on residue delete

C++: protocols::forge::build::Bridge::on_residue_delete(const struct core::conformation::signals::LengthEvent &) –> void

on_residue_prepend(self: pyrosetta.rosetta.protocols.forge.build.Bridge, event: pyrosetta.rosetta.core.conformation.signals.LengthEvent) → None

update indexing on residue prepend

C++: protocols::forge::build::Bridge::on_residue_prepend(const struct core::conformation::signals::LengthEvent &) –> void

original_deleted_positions(self: pyrosetta.rosetta.protocols.forge.build.Bridge) → pyrosetta.rosetta.std.set_unsigned_long_t

return set of positions within the original interval that will

be deleted in this BuildInstruction

A set containing the positions in [original.left+1, original.right-1].

C++: protocols::forge::build::Bridge::original_deleted_positions() const –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

original_fixed_positions(self: pyrosetta.rosetta.protocols.forge.build.Bridge) → pyrosetta.rosetta.std.set_unsigned_long_t

return set of any fixed positions necessary with respect to the original

interval and original Pose numbering

Used for ensuring build regions for instructions do not overlap and

so that jumps may be placed correctly.

empty set if no fixed positions necessary

C++: protocols::forge::build::Bridge::original_fixed_positions() const –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

original_interval(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → pyrosetta.rosetta.protocols.forge.build.Interval

return original residue range of this instruction

C++: protocols::forge::build::BuildInstruction::original_interval() const –> const struct protocols::forge::build::Interval &

original_interval_valid(self: pyrosetta.rosetta.protocols.forge.build.Bridge) → bool

is the original interval storing valid information, or is empty

or being used for something else?

true, stores valid interval

C++: protocols::forge::build::Bridge::original_interval_valid() const –> bool

original_kept_positions(self: pyrosetta.rosetta.protocols.forge.build.Bridge) → pyrosetta.rosetta.std.set_unsigned_long_t

return the set of positions within the original interval that

will be kept in this BuildInstruction

A set containing the endpoints of the original interval.

C++: protocols::forge::build::Bridge::original_kept_positions() const –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

original_mutable_positions(self: pyrosetta.rosetta.protocols.forge.build.Bridge) → pyrosetta.rosetta.std.set_unsigned_long_t

return set of any mutable positions necessary with respect to the original

interval and original Pose numbering

Used for ensuring build regions for instructions do not overlap and

so that jumps may be placed correctly.

C++: protocols::forge::build::Bridge::original_mutable_positions() const –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

preexisting_positions(self: pyrosetta.rosetta.protocols.forge.build.Bridge) → pyrosetta.rosetta.std.set_unsigned_long_t

return a copy of the set of positions within the new region

that were pre-existing in the original Pose prior to modify()

A set containing two positions – interval.left and interval.right.

C++: protocols::forge::build::Bridge::preexisting_positions() const –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

ready(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → bool

Is the BuildInstruction’s state at READY?

READY indicates the BuildInstruction has been reset

and is ready to modify a Pose.

C++: protocols::forge::build::BuildInstruction::ready() const –> bool

reset_accounting(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → None

reset intervals, positions, etc to initial state and drop

observers. State set to READY.

C++: protocols::forge::build::BuildInstruction::reset_accounting() –> void

residue_type_set(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → pyrosetta.rosetta.core.chemical.ResidueTypeSet

the residue type set being used

C++: protocols::forge::build::BuildInstruction::residue_type_set() const –> const class core::chemical::ResidueTypeSet &

state(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → pyrosetta.rosetta.protocols.forge.build.BuildInstructionState.Enum

return the state of this BuildInstruction

C++: protocols::forge::build::BuildInstruction::state() const –> enum protocols::forge::build::BuildInstructionState::Enum

undefined_positions(self: pyrosetta.rosetta.protocols.forge.build.Bridge) → pyrosetta.rosetta.std.set_unsigned_long_t

return a copy of the set of positions within the newly modified

region that has an undefined conformation. E.g. newly created residues.

A set containing positions spanning [interval.left+1, interval.right-1].

This set can change wrt length changes in Pose/Conformation being

watched.

C++: protocols::forge::build::Bridge::undefined_positions() const –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

waiting_on_dependencies(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → bool

Is the BuildInstruction’s state at WAITING_ON_DEPENDENCIES?

WAITING_ON_DEPENDENCIES indicates

the BuildInstruction is waiting for its dependencies to be satisfied before allowing modifications to proceed.

C++: protocols::forge::build::BuildInstruction::waiting_on_dependencies() const –> bool

class pyrosetta.rosetta.protocols.forge.build.BuildInstruction

Bases: pybind11_builtins.pybind11_object

tracks modifications to be made and is capable of making residue length changes on a Pose

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) -> None
2. __init__(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction, arg0: pyrosetta.rosetta.protocols.forge.build.Interval) -> None

doc

3. __init__(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction, i: pyrosetta.rosetta.protocols.forge.build.Interval, rts: pyrosetta.rosetta.std.weak_ptr_const_core_chemical_ResidueTypeSet_t) -> None
4. __init__(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction, arg0: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) -> 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_dependency_to(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction, i: pyrosetta.rosetta.std.weak_ptr_const_protocols_forge_build_BuildInstruction_t) → None

add an instruction to this BuildInstruction’s dependency list

before this instruction’s modify() may complete properly, all

instructions in the dependency list must have completed modify() first

C++: protocols::forge::build::BuildInstruction::add_dependency_to(class std::weak_ptr<const class protocols::forge::build::BuildInstruction>) –> void

assign(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction, rval: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → pyrosetta.rosetta.protocols.forge.build.BuildInstruction

copy assignment

C++: protocols::forge::build::BuildInstruction::operator=(const class protocols::forge::build::BuildInstruction &) –> class protocols::forge::build::BuildInstruction &

attach_to(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction, pose: pyrosetta.rosetta.core.pose.Pose) → None

attach to a Pose’s conformation

C++: protocols::forge::build::BuildInstruction::attach_to(class core::pose::Pose &) –> void

clear_dependencies(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → None

clear the list of dependencies

C++: protocols::forge::build::BuildInstruction::clear_dependencies() –> void

clone(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → pyrosetta.rosetta.protocols.forge.build.BuildInstruction

clone this object

C++: protocols::forge::build::BuildInstruction::clone() const –> class std::shared_ptr<class protocols::forge::build::BuildInstruction>

compatible_with(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction, rval: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → bool

compares fixed and mutable positions to determine compatibility with

another instruction

override this to obtain custom compatibility check

C++: protocols::forge::build::BuildInstruction::compatible_with(const class protocols::forge::build::BuildInstruction &) const –> bool

creates_undefined_backbone(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → bool

does this object create undefined backbone in the modified region?

C++: protocols::forge::build::BuildInstruction::creates_undefined_backbone() const –> bool

defined_positions(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → pyrosetta.rosetta.std.set_unsigned_long_t

return a copy of the set of positions within the newly modified

region that has a defined conformation. E.g. existing or copied residues.

This set can change wrt length changes in Pose/Conformation being

watched.

C++: protocols::forge::build::BuildInstruction::defined_positions() const –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

dependencies(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → pyrosetta.rosetta.utility.vector1_std_weak_ptr_const_protocols_forge_build_BuildInstruction_t

the list of instructions whose modify() must complete before

the modify() for this instruction may be called successfully

C++: protocols::forge::build::BuildInstruction::dependencies() const –> const class utility::vector1<class std::weak_ptr<const class protocols::forge::build::BuildInstruction>, class std::allocator<class std::weak_ptr<const class protocols::forge::build::BuildInstruction> > > &

dependent_on(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction, i: pyrosetta.rosetta.std.weak_ptr_const_protocols_forge_build_BuildInstruction_t) → bool

is this instruction dependent upon the given instruction?

C++: protocols::forge::build::BuildInstruction::dependent_on(class std::weak_ptr<const class protocols::forge::build::BuildInstruction>) const –> bool

detach_after_modify(*args, **kwargs)

Overloaded function.

1. detach_after_modify(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) -> bool

detach after modify()?

Ordinarily a modify() call consists of attaching as a

length obs of the Pose, actually doing the modify, and then detaching as a length obs of the Pose. This flag governs whether the last detach occurs.

C++: protocols::forge::build::BuildInstruction::detach_after_modify() const –> bool

2. detach_after_modify(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction, flag: bool) -> None

set detach after modify()

Ordinarily a modify() call consists of attaching as a

length obs of the Pose, actually doing the modify, and then detaching as a length obs of the Pose. This flag governs whether the last detach occurs.

C++: protocols::forge::build::BuildInstruction::detach_after_modify(const bool) –> void

detach_from(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → None

detach from a Pose’s conformation

C++: protocols::forge::build::BuildInstruction::detach_from() –> void

has_dependencies(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → bool

does this BuildInstruction have dependencies?

C++: protocols::forge::build::BuildInstruction::has_dependencies() const –> bool

interval(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → pyrosetta.rosetta.protocols.forge.build.Interval

a copy of the working range of residues specifying the modified region

This residue range can change wrt length changes in Pose /Conformation

being watched.

C++: protocols::forge::build::BuildInstruction::interval() const –> struct protocols::forge::build::Interval

modify(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction, pose: pyrosetta.rosetta.core.pose.Pose) → pyrosetta.rosetta.protocols.forge.build.BuildInstructionState.Enum

modify this pose

the state of the BuildInstruction

C++: protocols::forge::build::BuildInstruction::modify(class core::pose::Pose &) –> enum protocols::forge::build::BuildInstructionState::Enum

modify_was_successful(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → bool

Is the BuildInstruction’s state at MODIFY_WAS_SUCCESSFUL?

MODIFY_WAS_SUCCESSFUL indicates the BuildInstruction has

finished modifications to the Pose, and its residue indexing is now consistent with the newly modified Pose.

C++: protocols::forge::build::BuildInstruction::modify_was_successful() const –> bool

movemap(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → pyrosetta.rosetta.core.kinematics.MoveMap

return a copy of the MoveMap that defines the moveable/fixed

positions/dofs for this instruction

This set can change wrt length changes in Pose/Conformation being

watched.

C++: protocols::forge::build::BuildInstruction::movemap() const –> class core::kinematics::MoveMap

n_dependencies(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → int

the number of dependencies this BuildInstruction has

C++: protocols::forge::build::BuildInstruction::n_dependencies() const –> unsigned long

new_positions(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → pyrosetta.rosetta.std.set_unsigned_long_t

return a copy of the set of positions that are “new” and did

not exist in the original Pose.

C++: protocols::forge::build::BuildInstruction::new_positions() const –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

on_length_change(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction, event: pyrosetta.rosetta.core.conformation.signals.LengthEvent) → None

update any indexing wrt length change to Pose/Conformation being watched

C++: protocols::forge::build::BuildInstruction::on_length_change(const struct core::conformation::signals::LengthEvent &) –> void

on_residue_append(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction, event: pyrosetta.rosetta.core.conformation.signals.LengthEvent) → None

update indexing on residue append

C++: protocols::forge::build::BuildInstruction::on_residue_append(const struct core::conformation::signals::LengthEvent &) –> void

on_residue_delete(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction, event: pyrosetta.rosetta.core.conformation.signals.LengthEvent) → None

update indexing on residue delete

C++: protocols::forge::build::BuildInstruction::on_residue_delete(const struct core::conformation::signals::LengthEvent &) –> void

on_residue_prepend(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction, event: pyrosetta.rosetta.core.conformation.signals.LengthEvent) → None

update indexing on residue prepend

C++: protocols::forge::build::BuildInstruction::on_residue_prepend(const struct core::conformation::signals::LengthEvent &) –> void

original_deleted_positions(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → pyrosetta.rosetta.std.set_unsigned_long_t

return set of positions within the original interval that will

be deleted in this BuildInstruction

C++: protocols::forge::build::BuildInstruction::original_deleted_positions() const –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

original_fixed_positions(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → pyrosetta.rosetta.std.set_unsigned_long_t

return set of any fixed positions necessary with respect to the original

interval and original Pose numbering

Used for ensuring build regions for instructions do not overlap and

so that jumps may be placed correctly.

empty set if no fixed positions necessary

C++: protocols::forge::build::BuildInstruction::original_fixed_positions() const –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

original_interval(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → pyrosetta.rosetta.protocols.forge.build.Interval

return original residue range of this instruction

C++: protocols::forge::build::BuildInstruction::original_interval() const –> const struct protocols::forge::build::Interval &

original_interval_valid(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → bool

is the original interval storing valid information, or is empty

or being used for something else?

C++: protocols::forge::build::BuildInstruction::original_interval_valid() const –> bool

original_kept_positions(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → pyrosetta.rosetta.std.set_unsigned_long_t

return the set of positions within the original interval that

will be kept in this BuildInstruction

C++: protocols::forge::build::BuildInstruction::original_kept_positions() const –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

original_mutable_positions(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → pyrosetta.rosetta.std.set_unsigned_long_t

return set of any mutable positions necessary with respect to the original

interval and original Pose numbering

Used for ensuring build regions for instructions do not overlap and

so that jumps may be placed correctly.

C++: protocols::forge::build::BuildInstruction::original_mutable_positions() const –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

preexisting_positions(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → pyrosetta.rosetta.std.set_unsigned_long_t

return a copy of the set of positions within the new region

that were pre-existing in the original Pose prior to modify()

C++: protocols::forge::build::BuildInstruction::preexisting_positions() const –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

ready(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → bool

Is the BuildInstruction’s state at READY?

READY indicates the BuildInstruction has been reset

and is ready to modify a Pose.

C++: protocols::forge::build::BuildInstruction::ready() const –> bool

reset_accounting(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → None

reset intervals, positions, etc to initial state and drop

observers. State set to READY.

C++: protocols::forge::build::BuildInstruction::reset_accounting() –> void

residue_type_set(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → pyrosetta.rosetta.core.chemical.ResidueTypeSet

the residue type set being used

C++: protocols::forge::build::BuildInstruction::residue_type_set() const –> const class core::chemical::ResidueTypeSet &

state(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → pyrosetta.rosetta.protocols.forge.build.BuildInstructionState.Enum

return the state of this BuildInstruction

C++: protocols::forge::build::BuildInstruction::state() const –> enum protocols::forge::build::BuildInstructionState::Enum

undefined_positions(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → pyrosetta.rosetta.std.set_unsigned_long_t

return a copy of the set of positions within the newly modified

region that has an undefined conformation. E.g. newly created residues.

This set can change wrt length changes in Pose/Conformation being

watched.

C++: protocols::forge::build::BuildInstruction::undefined_positions() const –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

waiting_on_dependencies(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → bool

Is the BuildInstruction’s state at WAITING_ON_DEPENDENCIES?

WAITING_ON_DEPENDENCIES indicates

the BuildInstruction is waiting for its dependencies to be satisfied before allowing modifications to proceed.

C++: protocols::forge::build::BuildInstruction::waiting_on_dependencies() const –> bool

class pyrosetta.rosetta.protocols.forge.build.BuildManager

Bases: pybind11_builtins.pybind11_object

a container for managing BuildInstructions

Compatibility checks wrt dependencies currently do not exist.

It remains to be seen how to handle this.

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: pyrosetta.rosetta.protocols.forge.build.BuildManager) -> None
2. __init__(self: pyrosetta.rosetta.protocols.forge.build.BuildManager, arg0: pyrosetta.rosetta.protocols.forge.build.BuildManager) -> 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(self: pyrosetta.rosetta.protocols.forge.build.BuildManager, bi: protocols::forge::build::BuildInstruction) → None

add an instruction directly (no copy)

C++: protocols::forge::build::BuildManager::add(class std::shared_ptr<class protocols::forge::build::BuildInstruction>) –> void

assign(self: pyrosetta.rosetta.protocols.forge.build.BuildManager, rval: pyrosetta.rosetta.protocols.forge.build.BuildManager) → pyrosetta.rosetta.protocols.forge.build.BuildManager

copy assignment

C++: protocols::forge::build::BuildManager::operator=(const class protocols::forge::build::BuildManager &) –> class protocols::forge::build::BuildManager &

begin(self: pyrosetta.rosetta.protocols.forge.build.BuildManager) → __gnu_cxx::__normal_iterator<std::shared_ptr<protocols::forge::build::BuildInstruction> const*, std::vector<std::shared_ptr<protocols::forge::build::BuildInstruction>, std::allocator<std::shared_ptr<protocols::forge::build::BuildInstruction> > > >

const iterator pointing to the first instruction

C++: protocols::forge::build::BuildManager::begin() const –> class __gnu_cxx::__normal_iterator<const class std::shared_ptr<class protocols::forge::build::BuildInstruction> *, class std::vector<class std::shared_ptr<class protocols::forge::build::BuildInstruction>, class std::allocator<class std::shared_ptr<class protocols::forge::build::BuildInstruction> > > >

clear(self: pyrosetta.rosetta.protocols.forge.build.BuildManager) → None

clear all instructions

C++: protocols::forge::build::BuildManager::clear() –> void

clear_dependencies(self: pyrosetta.rosetta.protocols.forge.build.BuildManager) → int

clear all dependencies

number of dependencies dropped

C++: protocols::forge::build::BuildManager::clear_dependencies() –> unsigned long

clone(self: pyrosetta.rosetta.protocols.forge.build.BuildManager) → pyrosetta.rosetta.protocols.forge.build.BuildManager

clone this object

C++: protocols::forge::build::BuildManager::clone() const –> class std::shared_ptr<class protocols::forge::build::BuildManager>

compatibility_check(self: pyrosetta.rosetta.protocols.forge.build.BuildManager) → bool

check if instruction regions are compatible with each other

true if regions compatible, false if regions incompatible

C++: protocols::forge::build::BuildManager::compatibility_check() const –> bool

create(self: pyrosetta.rosetta.protocols.forge.build.BuildManager) → pyrosetta.rosetta.protocols.forge.build.BuildManager

create a new instance of this type of object

C++: protocols::forge::build::BuildManager::create() const –> class std::shared_ptr<class protocols::forge::build::BuildManager>

create_directed_dependency(self: pyrosetta.rosetta.protocols.forge.build.BuildManager, u: protocols::forge::build::BuildInstruction, v: protocols::forge::build::BuildInstruction) → None

create a directed dependency: instruction ‘u’ must complete

before instruction ‘v’ can complete, i.e. ‘v’ depends on ‘u’

C++: protocols::forge::build::BuildManager::create_directed_dependency(class std::shared_ptr<class protocols::forge::build::BuildInstruction>, class std::shared_ptr<class protocols::forge::build::BuildInstruction>) –> void

defined_positions(self: pyrosetta.rosetta.protocols.forge.build.BuildManager) → pyrosetta.rosetta.std.set_unsigned_long_t

return a copy of the set of positions within the newly modified

regions that have a defined conformation. E.g. existing or copied residues.

If modify() has not been called will return an empty set.

C++: protocols::forge::build::BuildManager::defined_positions() const –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

dependencies_exist(self: pyrosetta.rosetta.protocols.forge.build.BuildManager) → bool

have dependencies been defined?

C++: protocols::forge::build::BuildManager::dependencies_exist() const –> bool

dummy_modify(self: pyrosetta.rosetta.protocols.forge.build.BuildManager, nres: int) → int

a dry run of modify() with an all-ala helical Pose of the given

length

The length of the dummy structure to use.

The final length of the modified Pose.

Use this to do a fake run of modify() if you need any

position or mapping information prior to actually calling modify().

C++: protocols::forge::build::BuildManager::dummy_modify(const unsigned long) –> unsigned long

empty(self: pyrosetta.rosetta.protocols.forge.build.BuildManager) → bool

no instructions?

C++: protocols::forge::build::BuildManager::empty() const –> bool

end(self: pyrosetta.rosetta.protocols.forge.build.BuildManager) → __gnu_cxx::__normal_iterator<std::shared_ptr<protocols::forge::build::BuildInstruction> const*, std::vector<std::shared_ptr<protocols::forge::build::BuildInstruction>, std::allocator<std::shared_ptr<protocols::forge::build::BuildInstruction> > > >

const iterator pointing just beyond the last instruction

C++: protocols::forge::build::BuildManager::end() const –> class __gnu_cxx::__normal_iterator<const class std::shared_ptr<class protocols::forge::build::BuildInstruction> *, class std::vector<class std::shared_ptr<class protocols::forge::build::BuildInstruction>, class std::allocator<class std::shared_ptr<class protocols::forge::build::BuildInstruction> > > >

modified2original_interval_endpoints(self: pyrosetta.rosetta.protocols.forge.build.BuildManager) → pyrosetta.rosetta.std.map_unsigned_long_unsigned_long

return a map translating modified interval endpoints to original

interval endpoints

modified intervals with no equivalent original interval (e.g. cases

such as insertions) will not appear in this map

map; empty if modify() has not yet been called

C++: protocols::forge::build::BuildManager::modified2original_interval_endpoints() const –> class std::map<unsigned long, unsigned long, struct std::less<unsigned long>, class std::allocator<struct std::pair<const unsigned long, unsigned long> > >

modify(self: pyrosetta.rosetta.protocols.forge.build.BuildManager, pose: pyrosetta.rosetta.core.pose.Pose) → pyrosetta.rosetta.std.map_unsigned_long_unsigned_long

modify the pose using the instructions in this container

the Pose to modify

a map translating original residue -> modified residue for

positions that existed within both the original Pose and modified Pose

C++: protocols::forge::build::BuildManager::modify(class core::pose::Pose &) –> class std::map<unsigned long, unsigned long, struct std::less<unsigned long>, class std::allocator<struct std::pair<const unsigned long, unsigned long> > >

movemap(self: pyrosetta.rosetta.protocols.forge.build.BuildManager) → pyrosetta.rosetta.core.kinematics.MoveMap

return the combined movemap from all instructions in this manager

If modify() has not been called will return an empty MoveMap.

C++: protocols::forge::build::BuildManager::movemap() const –> class core::kinematics::MoveMap

movemap_as_OP(self: pyrosetta.rosetta.protocols.forge.build.BuildManager) → pyrosetta.rosetta.core.kinematics.MoveMap

C++: protocols::forge::build::BuildManager::movemap_as_OP() const –> class std::shared_ptr<class core::kinematics::MoveMap>

n_dependencies(self: pyrosetta.rosetta.protocols.forge.build.BuildManager) → int

the number of dependencies currently defined (i.e. # of edges in

the dependency graph)

C++: protocols::forge::build::BuildManager::n_dependencies() const –> unsigned long

new_positions(self: pyrosetta.rosetta.protocols.forge.build.BuildManager) → pyrosetta.rosetta.std.set_unsigned_long_t

return a copy of the set of positions that are “new” and did

not exist in the original Pose.

If modify() has not been called will return an empty set.

C++: protocols::forge::build::BuildManager::new_positions() const –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

original2modified(self: pyrosetta.rosetta.protocols.forge.build.BuildManager) → pyrosetta.rosetta.std.map_unsigned_long_unsigned_long

return a map translating original residue -> modified residue for

positions that existed within both the original Pose and modified Pose

map; empty if modify() has not yet been called

C++: protocols::forge::build::BuildManager::original2modified() const –> const class std::map<unsigned long, unsigned long, struct std::less<unsigned long>, class std::allocator<struct std::pair<const unsigned long, unsigned long> > > &

original2modified_interval_endpoints(self: pyrosetta.rosetta.protocols.forge.build.BuildManager) → pyrosetta.rosetta.std.map_unsigned_long_unsigned_long

return a map translating original interval endpoints to modified

interval endpoints

modified intervals with no equivalent original interval (e.g. cases

such as insertions) will not appear in this map

map; empty if modify() has not yet been called

C++: protocols::forge::build::BuildManager::original2modified_interval_endpoints() const –> class std::map<unsigned long, unsigned long, struct std::less<unsigned long>, class std::allocator<struct std::pair<const unsigned long, unsigned long> > >

original_deleted_positions(self: pyrosetta.rosetta.protocols.forge.build.BuildManager) → pyrosetta.rosetta.std.set_unsigned_long_t

return set of positions within the original intervals that will

be deleted by the BuildInstructions

returns valid data even without calling modify()

C++: protocols::forge::build::BuildManager::original_deleted_positions() const –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

original_kept_positions(self: pyrosetta.rosetta.protocols.forge.build.BuildManager) → pyrosetta.rosetta.std.set_unsigned_long_t

return the set of positions within the original intervals that

will be kept by the BuildInstructions

returns valid data even without calling modify()

C++: protocols::forge::build::BuildManager::original_kept_positions() const –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

positions(self: pyrosetta.rosetta.protocols.forge.build.BuildManager) → pyrosetta.rosetta.std.set_unsigned_long_t

return all positions within the modified intervals

Since this encompasses everything this is typically not useful

except for overall tracking purposes.

If modify() has not been called will return an empty set.

C++: protocols::forge::build::BuildManager::positions() const –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

preexisting_positions(self: pyrosetta.rosetta.protocols.forge.build.BuildManager) → pyrosetta.rosetta.std.set_unsigned_long_t

return the set of positions within the new regions that were

pre-existing in the original Pose prior to calling modify()

If modify() has not been called will return an empty set.

C++: protocols::forge::build::BuildManager::preexisting_positions() const –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

reset_accounting(self: pyrosetta.rosetta.protocols.forge.build.BuildManager) → None

reset all accounting info (intervals, positions, etc) to initial

state

C++: protocols::forge::build::BuildManager::reset_accounting() –> void

sequence_mapping(self: pyrosetta.rosetta.protocols.forge.build.BuildManager) → pyrosetta.rosetta.core.id.SequenceMapping

SequenceMapping consistent with the original -> modified mapping from the

most recent modify() call

valid Sequence mapping if modify() was called; otherwise returns

NULL

This mapping contains the same information as original2modified()

combined with original2modified_interval_endpoints().

C++: protocols::forge::build::BuildManager::sequence_mapping() const –> class std::shared_ptr<const class core::id::SequenceMapping>

size(self: pyrosetta.rosetta.protocols.forge.build.BuildManager) → int

current number of instructions

C++: protocols::forge::build::BuildManager::size() const –> unsigned long

undefined_positions(self: pyrosetta.rosetta.protocols.forge.build.BuildManager) → pyrosetta.rosetta.std.set_unsigned_long_t

return a copy of the set of positions within the newly modified

regions that have an undefined conformation. E.g. newly created residues.

If modify() has not been called will return an empty set.

C++: protocols::forge::build::BuildManager::undefined_positions() const –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

union_of_intervals_containing_undefined_positions(self: pyrosetta.rosetta.protocols.forge.build.BuildManager) → pyrosetta.rosetta.std.set_unsigned_long_t

the positions representing the union of all intervals containing

positions with undefined conformation

Useful as a reference for defining neighborhoods around

loop modeled regions.

If modify() has not been called will return an empty set.

C++: protocols::forge::build::BuildManager::union_of_intervals_containing_undefined_positions() const –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

class pyrosetta.rosetta.protocols.forge.build.ConnectRight

Bases: pyrosetta.rosetta.protocols.forge.build.BuildInstruction

instruction to connect one Pose onto the right side of another

Denote pose_left = [a,b] and pose_right = [c,d] and the newly

connected pose_left + pose_right = pose_total = [a,d]. If ‘b’ of pose_left is an upper terminus or ‘c’ of pose_right is a lower terminus, then ConnectRight will start a new chain in the Conformation at ‘c’ when constructing pose_total, otherwise it will continue the chain at ‘b’.

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: pyrosetta.rosetta.protocols.forge.build.ConnectRight) -> None
2. __init__(self: pyrosetta.rosetta.protocols.forge.build.ConnectRight, left_position: int, right_position: int, pose_right: pyrosetta.rosetta.core.pose.Pose) -> None
3. __init__(self: pyrosetta.rosetta.protocols.forge.build.ConnectRight, arg0: pyrosetta.rosetta.protocols.forge.build.ConnectRight) -> 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_dependency_to(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction, i: pyrosetta.rosetta.std.weak_ptr_const_protocols_forge_build_BuildInstruction_t) → None

add an instruction to this BuildInstruction’s dependency list

before this instruction’s modify() may complete properly, all

instructions in the dependency list must have completed modify() first

C++: protocols::forge::build::BuildInstruction::add_dependency_to(class std::weak_ptr<const class protocols::forge::build::BuildInstruction>) –> void

assign(self: pyrosetta.rosetta.protocols.forge.build.ConnectRight, rval: pyrosetta.rosetta.protocols.forge.build.ConnectRight) → pyrosetta.rosetta.protocols.forge.build.ConnectRight

copy assignment

C++: protocols::forge::build::ConnectRight::operator=(const class protocols::forge::build::ConnectRight &) –> class protocols::forge::build::ConnectRight &

attach_to(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction, pose: pyrosetta.rosetta.core.pose.Pose) → None

attach to a Pose’s conformation

C++: protocols::forge::build::BuildInstruction::attach_to(class core::pose::Pose &) –> void

clear_dependencies(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → None

clear the list of dependencies

C++: protocols::forge::build::BuildInstruction::clear_dependencies() –> void

clone(self: pyrosetta.rosetta.protocols.forge.build.ConnectRight) → pyrosetta.rosetta.protocols.forge.build.BuildInstruction

clone this object

C++: protocols::forge::build::ConnectRight::clone() const –> class std::shared_ptr<class protocols::forge::build::BuildInstruction>

compatible_with(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction, rval: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → bool

compares fixed and mutable positions to determine compatibility with

another instruction

override this to obtain custom compatibility check

C++: protocols::forge::build::BuildInstruction::compatible_with(const class protocols::forge::build::BuildInstruction &) const –> bool

creates_undefined_backbone(self: pyrosetta.rosetta.protocols.forge.build.ConnectRight) → bool

does this object create undefined backbone in the modified region?

false

C++: protocols::forge::build::ConnectRight::creates_undefined_backbone() const –> bool

defined_positions(self: pyrosetta.rosetta.protocols.forge.build.ConnectRight) → pyrosetta.rosetta.std.set_unsigned_long_t

return a copy of the set of positions within the newly modified

region that has a defined conformation. E.g. existing or copied residues.

A set spanning the entire interval – all positions are defined.

This set can change wrt length changes in Pose/Conformation being

watched.

C++: protocols::forge::build::ConnectRight::defined_positions() const –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

dependencies(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → pyrosetta.rosetta.utility.vector1_std_weak_ptr_const_protocols_forge_build_BuildInstruction_t

the list of instructions whose modify() must complete before

the modify() for this instruction may be called successfully

C++: protocols::forge::build::BuildInstruction::dependencies() const –> const class utility::vector1<class std::weak_ptr<const class protocols::forge::build::BuildInstruction>, class std::allocator<class std::weak_ptr<const class protocols::forge::build::BuildInstruction> > > &

dependent_on(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction, i: pyrosetta.rosetta.std.weak_ptr_const_protocols_forge_build_BuildInstruction_t) → bool

is this instruction dependent upon the given instruction?

C++: protocols::forge::build::BuildInstruction::dependent_on(class std::weak_ptr<const class protocols::forge::build::BuildInstruction>) const –> bool

detach_after_modify(*args, **kwargs)

Overloaded function.

1. detach_after_modify(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) -> bool

detach after modify()?

Ordinarily a modify() call consists of attaching as a

length obs of the Pose, actually doing the modify, and then detaching as a length obs of the Pose. This flag governs whether the last detach occurs.

C++: protocols::forge::build::BuildInstruction::detach_after_modify() const –> bool

2. detach_after_modify(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction, flag: bool) -> None

set detach after modify()

Ordinarily a modify() call consists of attaching as a

length obs of the Pose, actually doing the modify, and then detaching as a length obs of the Pose. This flag governs whether the last detach occurs.

C++: protocols::forge::build::BuildInstruction::detach_after_modify(const bool) –> void

detach_from(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → None

detach from a Pose’s conformation

C++: protocols::forge::build::BuildInstruction::detach_from() –> void

extract_rt(self: pyrosetta.rosetta.protocols.forge.build.ConnectRight, pose: pyrosetta.rosetta.core.pose.Pose, jump_start_residue: int, jump_stop_residue: int) → None

extract appropriately computed transform between two stubs that

represent a jump in the given Pose between the two residues and set it as the rt for this ConnectRight

The Pose to use.

The starting residue of the jump.

This residue should be the equivalent of the jump position on pose_left.

The stopping residue of the jump.

This residue should be the equivalent of the jump position on pose_right.

Uses left_stub_atoms() and right_stub_atoms() as the stub atoms

to compute the transform. Remember to set use_rt() to True after calling this function if you want to actually use the transform during modify().

C++: protocols::forge::build::ConnectRight::extract_rt(const class core::pose::Pose &, const unsigned long, const unsigned long) –> void

has_dependencies(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → bool

does this BuildInstruction have dependencies?

C++: protocols::forge::build::BuildInstruction::has_dependencies() const –> bool

interval(self: pyrosetta.rosetta.protocols.forge.build.ConnectRight) → pyrosetta.rosetta.protocols.forge.build.Interval

a copy of the working range of residues specifying the modified region

before modify() holds [1, pose_right.size()]; after

modify() holds [1 + pose_left.size(), pose_right.n_residue + pose_left.size()]

This can change if listening to Conformation LengthEvents

C++: protocols::forge::build::ConnectRight::interval() const –> struct protocols::forge::build::Interval

left_stub_atoms(*args, **kwargs)

Overloaded function.

1. left_stub_atoms(self: pyrosetta.rosetta.protocols.forge.build.ConnectRight) -> pyrosetta.rosetta.utility.vector1_std_string

Use these atoms to compute the stub on pose_left.

Default [“CA”, “N”, “CA”, “C”].

This is an array with 4 elements in the same order as Stub

initialization: ‘center atom’, ‘point1’, ‘point2’, ‘point3’. See Stub docs for more details.

C++: protocols::forge::build::ConnectRight::left_stub_atoms() const –> const class utility::vector1<std::string, class std::allocator<std::string > > &

2. left_stub_atoms(self: pyrosetta.rosetta.protocols.forge.build.ConnectRight, atoms: pyrosetta.rosetta.utility.vector1_std_string) -> None

Use these atoms to compute the stub on pose_left.

Default [“CA”, “N”, “CA”, “C”].

This is an array with 4 elements in the same order as Stub

initialization: ‘center atom’, ‘point1’, ‘point2’, ‘point3’. See Stub docs for more details.

C++: protocols::forge::build::ConnectRight::left_stub_atoms(const class utility::vector1<class std::basic_string<char>, class std::allocator<class std::basic_string<char> > > &) –> void

modify(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction, pose: pyrosetta.rosetta.core.pose.Pose) → pyrosetta.rosetta.protocols.forge.build.BuildInstructionState.Enum

modify this pose

the state of the BuildInstruction

C++: protocols::forge::build::BuildInstruction::modify(class core::pose::Pose &) –> enum protocols::forge::build::BuildInstructionState::Enum

modify_was_successful(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → bool

Is the BuildInstruction’s state at MODIFY_WAS_SUCCESSFUL?

MODIFY_WAS_SUCCESSFUL indicates the BuildInstruction has

finished modifications to the Pose, and its residue indexing is now consistent with the newly modified Pose.

C++: protocols::forge::build::BuildInstruction::modify_was_successful() const –> bool

movemap(self: pyrosetta.rosetta.protocols.forge.build.ConnectRight) → pyrosetta.rosetta.core.kinematics.MoveMap

return a copy of the MoveMap that defines the moveable/fixed

positions/dofs for this instruction

a MoveMap with [interval.left, interval.right] bb set to false

at the MoveMapTorsionID level

This set can change wrt length changes in Pose/Conformation being

watched.

C++: protocols::forge::build::ConnectRight::movemap() const –> class core::kinematics::MoveMap

n_dependencies(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → int

the number of dependencies this BuildInstruction has

C++: protocols::forge::build::BuildInstruction::n_dependencies() const –> unsigned long

new_positions(self: pyrosetta.rosetta.protocols.forge.build.ConnectRight) → pyrosetta.rosetta.std.set_unsigned_long_t

return a copy of the set of positions that are “new” and did

not exist in the original Pose.

A set spanning the entire interval – all positions are new.

C++: protocols::forge::build::ConnectRight::new_positions() const –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

on_length_change(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction, event: pyrosetta.rosetta.core.conformation.signals.LengthEvent) → None

update any indexing wrt length change to Pose/Conformation being watched

C++: protocols::forge::build::BuildInstruction::on_length_change(const struct core::conformation::signals::LengthEvent &) –> void

on_residue_append(self: pyrosetta.rosetta.protocols.forge.build.ConnectRight, event: pyrosetta.rosetta.core.conformation.signals.LengthEvent) → None

update indexing on residue append

C++: protocols::forge::build::ConnectRight::on_residue_append(const struct core::conformation::signals::LengthEvent &) –> void

on_residue_delete(self: pyrosetta.rosetta.protocols.forge.build.ConnectRight, event: pyrosetta.rosetta.core.conformation.signals.LengthEvent) → None

update indexing on residue delete

C++: protocols::forge::build::ConnectRight::on_residue_delete(const struct core::conformation::signals::LengthEvent &) –> void

on_residue_prepend(self: pyrosetta.rosetta.protocols.forge.build.ConnectRight, event: pyrosetta.rosetta.core.conformation.signals.LengthEvent) → None

update indexing on residue prepend

C++: protocols::forge::build::ConnectRight::on_residue_prepend(const struct core::conformation::signals::LengthEvent &) –> void

original_deleted_positions(self: pyrosetta.rosetta.protocols.forge.build.ConnectRight) → pyrosetta.rosetta.std.set_unsigned_long_t

return set of positions within the original interval that will

be deleted in this BuildInstruction

An empty set – no positions are deleted.

C++: protocols::forge::build::ConnectRight::original_deleted_positions() const –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

original_fixed_positions(self: pyrosetta.rosetta.protocols.forge.build.ConnectRight) → pyrosetta.rosetta.std.set_unsigned_long_t

return set of any fixed positions necessary with respect to the original

interval and original Pose numbering

Used for ensuring build regions for instructions do not overlap and

so that jumps may be placed correctly.

empty set if no fixed positions

C++: protocols::forge::build::ConnectRight::original_fixed_positions() const –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

original_interval(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → pyrosetta.rosetta.protocols.forge.build.Interval

return original residue range of this instruction

C++: protocols::forge::build::BuildInstruction::original_interval() const –> const struct protocols::forge::build::Interval &

original_interval_valid(self: pyrosetta.rosetta.protocols.forge.build.ConnectRight) → bool

is the original interval storing valid information, or is empty

or being used for something else?

false, stores invalid interval

C++: protocols::forge::build::ConnectRight::original_interval_valid() const –> bool

original_kept_positions(self: pyrosetta.rosetta.protocols.forge.build.ConnectRight) → pyrosetta.rosetta.std.set_unsigned_long_t

return the set of positions within the original interval that

will be kept in this BuildInstruction

An empty set – no positions are kept.

C++: protocols::forge::build::ConnectRight::original_kept_positions() const –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

original_mutable_positions(self: pyrosetta.rosetta.protocols.forge.build.ConnectRight) → pyrosetta.rosetta.std.set_unsigned_long_t

return set of any mutable positions necessary with respect to the original

interval and original Pose numbering

Used for ensuring build regions for instructions do not overlap and

so that jumps may be placed correctly.

empty set if no mutable positions

C++: protocols::forge::build::ConnectRight::original_mutable_positions() const –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

pose_right(self: pyrosetta.rosetta.protocols.forge.build.ConnectRight) → pyrosetta.rosetta.core.pose.Pose

connect this pose to the right of pose_left when modify( pose_left )

is called

C++: protocols::forge::build::ConnectRight::pose_right() –> const class core::pose::Pose &

preexisting_positions(self: pyrosetta.rosetta.protocols.forge.build.ConnectRight) → pyrosetta.rosetta.std.set_unsigned_long_t

return a copy of the set of positions within the new region

that were pre-existing in the original Pose prior to modify()

An empty set – no positions are pre-existing.

C++: protocols::forge::build::ConnectRight::preexisting_positions() const –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

ready(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → bool

Is the BuildInstruction’s state at READY?

READY indicates the BuildInstruction has been reset

and is ready to modify a Pose.

C++: protocols::forge::build::BuildInstruction::ready() const –> bool

reset_accounting(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → None

reset intervals, positions, etc to initial state and drop

observers. State set to READY.

C++: protocols::forge::build::BuildInstruction::reset_accounting() –> void

residue_type_set(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → pyrosetta.rosetta.core.chemical.ResidueTypeSet

the residue type set being used

C++: protocols::forge::build::BuildInstruction::residue_type_set() const –> const class core::chemical::ResidueTypeSet &

right_stub_atoms(*args, **kwargs)

Overloaded function.

1. right_stub_atoms(self: pyrosetta.rosetta.protocols.forge.build.ConnectRight) -> pyrosetta.rosetta.utility.vector1_std_string

Use these atoms to compute the stub on pose_right.

Default [“CA”, “N”, “CA”, “C”].

This is an array with 4 elements in the same order as Stub

initialization: ‘center atom’, ‘point1’, ‘point2’, ‘point3’. See Stub docs for more details.

C++: protocols::forge::build::ConnectRight::right_stub_atoms() const –> const class utility::vector1<std::string, class std::allocator<std::string > > &

2. right_stub_atoms(self: pyrosetta.rosetta.protocols.forge.build.ConnectRight, atoms: pyrosetta.rosetta.utility.vector1_std_string) -> None

Use these atoms to compute the stub on pose_right.

Default [“CA”, “N”, “CA”, “C”].

This is an array with 4 elements in the same order as Stub

initialization: ‘center atom’, ‘point1’, ‘point2’, ‘point3’. See Stub docs for more details.

C++: protocols::forge::build::ConnectRight::right_stub_atoms(const class utility::vector1<class std::basic_string<char>, class std::allocator<class std::basic_string<char> > > &) –> void

rt(*args, **kwargs)

Overloaded function.

1. rt(self: pyrosetta.rosetta.protocols.forge.build.ConnectRight) -> pyrosetta.rosetta.core.kinematics.RT

the rotation-translation representing an explicit transform from

the stub on pose_left to the stub on pose_right, i.e. the representation of the “jump”

C++: protocols::forge::build::ConnectRight::rt() –> const class core::kinematics::RT &

2. rt(self: pyrosetta.rosetta.protocols.forge.build.ConnectRight, transform: pyrosetta.rosetta.core.kinematics.RT) -> None

the rotation-translation representing an explicit transform from

the stub on pose_left to the stub on pose_right, i.e. the representation of the “jump”

C++: protocols::forge::build::ConnectRight::rt(const class core::kinematics::RT &) –> void

state(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → pyrosetta.rosetta.protocols.forge.build.BuildInstructionState.Enum

return the state of this BuildInstruction

C++: protocols::forge::build::BuildInstruction::state() const –> enum protocols::forge::build::BuildInstructionState::Enum

undefined_positions(self: pyrosetta.rosetta.protocols.forge.build.ConnectRight) → pyrosetta.rosetta.std.set_unsigned_long_t

return a copy of the set of positions within the newly modified

region that has an undefined conformation. E.g. newly created residues.

An empty set – no undefined positions.

This set can change wrt length changes in Pose/Conformation being

watched.

C++: protocols::forge::build::ConnectRight::undefined_positions() const –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

use_rt(*args, **kwargs)

Overloaded function.

1. use_rt(self: pyrosetta.rosetta.protocols.forge.build.ConnectRight) -> bool

apply the transform over the jump connection between pose_left and

pose_right? default False

C++: protocols::forge::build::ConnectRight::use_rt() const –> bool

2. use_rt(self: pyrosetta.rosetta.protocols.forge.build.ConnectRight, flag: bool) -> None

apply the transform over the jump connection between pose_left and

pose_right? default False

C++: protocols::forge::build::ConnectRight::use_rt(const bool) –> void

waiting_on_dependencies(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → bool

Is the BuildInstruction’s state at WAITING_ON_DEPENDENCIES?

WAITING_ON_DEPENDENCIES indicates

the BuildInstruction is waiting for its dependencies to be satisfied before allowing modifications to proceed.

C++: protocols::forge::build::BuildInstruction::waiting_on_dependencies() const –> bool

class pyrosetta.rosetta.protocols.forge.build.CountFromLeft

Bases: pyrosetta.rosetta.protocols.forge.build.RelativeSequencePosition

count starting from interval().left in a BuildInstruction

__call__(self: pyrosetta.rosetta.protocols.forge.build.CountFromLeft, i: pyrosetta.rosetta.std.weak_ptr_const_protocols_forge_build_BuildInstruction_t) → int

C++: protocols::forge::build::CountFromLeft::operator()(class std::weak_ptr<const class protocols::forge::build::BuildInstruction>) const –> unsigned long

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: pyrosetta.rosetta.protocols.forge.build.CountFromLeft) -> None
2. __init__(self: pyrosetta.rosetta.protocols.forge.build.CountFromLeft, arg0: pyrosetta.rosetta.protocols.forge.build.CountFromLeft) -> None

__init_subclass__()

This method is called when a class is subclassed.

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

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

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

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

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

assign(self: pyrosetta.rosetta.protocols.forge.build.CountFromLeft, : pyrosetta.rosetta.protocols.forge.build.CountFromLeft) → pyrosetta.rosetta.protocols.forge.build.CountFromLeft

C++: protocols::forge::build::CountFromLeft::operator=(const struct protocols::forge::build::CountFromLeft &) –> struct protocols::forge::build::CountFromLeft &

clone(self: pyrosetta.rosetta.protocols.forge.build.CountFromLeft) → pyrosetta.rosetta.protocols.forge.build.RelativeSequencePosition

C++: protocols::forge::build::CountFromLeft::clone() const –> class std::shared_ptr<struct protocols::forge::build::RelativeSequencePosition>

class pyrosetta.rosetta.protocols.forge.build.GrowLeft

Bases: pyrosetta.rosetta.protocols.forge.build.BuildInstruction

instruction to create an n-side extension

Use this for n-side insertions, but typically not n-terminal

extensions unless necessary. It does not automatically cover the additional residue on the right endpoint that needs to move during n-terminal extensions due to invalid phi torsion. For that case, use the SegmentRebuild class replacing the n-terminal residue with desired length+1.

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: pyrosetta.rosetta.protocols.forge.build.GrowLeft) -> None
2. __init__(self: pyrosetta.rosetta.protocols.forge.build.GrowLeft, arg0: int, arg1: str) -> None

doc

3. __init__(self: pyrosetta.rosetta.protocols.forge.build.GrowLeft, arg0: int, arg1: str, arg2: str) -> None

doc

4. __init__(self: pyrosetta.rosetta.protocols.forge.build.GrowLeft, pos: int, ss: str, aa: str, rts: pyrosetta.rosetta.std.weak_ptr_const_core_chemical_ResidueTypeSet_t) -> None
5. __init__(self: pyrosetta.rosetta.protocols.forge.build.GrowLeft, arg0: pyrosetta.rosetta.protocols.forge.build.GrowLeft) -> 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).

aa(self: pyrosetta.rosetta.protocols.forge.build.GrowLeft) → str

get annotated amino acid string

C++: protocols::forge::build::GrowLeft::aa() const –> const std::string &

add_dependency_to(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction, i: pyrosetta.rosetta.std.weak_ptr_const_protocols_forge_build_BuildInstruction_t) → None

add an instruction to this BuildInstruction’s dependency list

before this instruction’s modify() may complete properly, all

instructions in the dependency list must have completed modify() first

C++: protocols::forge::build::BuildInstruction::add_dependency_to(class std::weak_ptr<const class protocols::forge::build::BuildInstruction>) –> void

assign(self: pyrosetta.rosetta.protocols.forge.build.GrowLeft, rval: pyrosetta.rosetta.protocols.forge.build.GrowLeft) → pyrosetta.rosetta.protocols.forge.build.GrowLeft

copy assignment

C++: protocols::forge::build::GrowLeft::operator=(const class protocols::forge::build::GrowLeft &) –> class protocols::forge::build::GrowLeft &

attach_to(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction, pose: pyrosetta.rosetta.core.pose.Pose) → None

attach to a Pose’s conformation

C++: protocols::forge::build::BuildInstruction::attach_to(class core::pose::Pose &) –> void

clear_dependencies(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → None

clear the list of dependencies

C++: protocols::forge::build::BuildInstruction::clear_dependencies() –> void

clone(self: pyrosetta.rosetta.protocols.forge.build.GrowLeft) → pyrosetta.rosetta.protocols.forge.build.BuildInstruction

clone this object

C++: protocols::forge::build::GrowLeft::clone() const –> class std::shared_ptr<class protocols::forge::build::BuildInstruction>

compatible_with(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction, rval: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → bool

compares fixed and mutable positions to determine compatibility with

another instruction

override this to obtain custom compatibility check

C++: protocols::forge::build::BuildInstruction::compatible_with(const class protocols::forge::build::BuildInstruction &) const –> bool

creates_undefined_backbone(self: pyrosetta.rosetta.protocols.forge.build.GrowLeft) → bool

does this object create undefined backbone in the modified region?

true

C++: protocols::forge::build::GrowLeft::creates_undefined_backbone() const –> bool

defined_positions(self: pyrosetta.rosetta.protocols.forge.build.GrowLeft) → pyrosetta.rosetta.std.set_unsigned_long_t

return a copy of the set of positions within the newly modified

region that has a defined conformation. E.g. existing or copied residues.

An empty set – no positions are defined.

This set can change wrt length changes in Pose/Conformation being

watched.

C++: protocols::forge::build::GrowLeft::defined_positions() const –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

dependencies(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → pyrosetta.rosetta.utility.vector1_std_weak_ptr_const_protocols_forge_build_BuildInstruction_t

the list of instructions whose modify() must complete before

the modify() for this instruction may be called successfully

C++: protocols::forge::build::BuildInstruction::dependencies() const –> const class utility::vector1<class std::weak_ptr<const class protocols::forge::build::BuildInstruction>, class std::allocator<class std::weak_ptr<const class protocols::forge::build::BuildInstruction> > > &

dependent_on(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction, i: pyrosetta.rosetta.std.weak_ptr_const_protocols_forge_build_BuildInstruction_t) → bool

is this instruction dependent upon the given instruction?

C++: protocols::forge::build::BuildInstruction::dependent_on(class std::weak_ptr<const class protocols::forge::build::BuildInstruction>) const –> bool

detach_after_modify(*args, **kwargs)

Overloaded function.

1. detach_after_modify(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) -> bool

detach after modify()?

Ordinarily a modify() call consists of attaching as a

length obs of the Pose, actually doing the modify, and then detaching as a length obs of the Pose. This flag governs whether the last detach occurs.

C++: protocols::forge::build::BuildInstruction::detach_after_modify() const –> bool

2. detach_after_modify(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction, flag: bool) -> None

set detach after modify()

Ordinarily a modify() call consists of attaching as a

length obs of the Pose, actually doing the modify, and then detaching as a length obs of the Pose. This flag governs whether the last detach occurs.

C++: protocols::forge::build::BuildInstruction::detach_after_modify(const bool) –> void

detach_from(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → None

detach from a Pose’s conformation

C++: protocols::forge::build::BuildInstruction::detach_from() –> void

has_dependencies(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → bool

does this BuildInstruction have dependencies?

C++: protocols::forge::build::BuildInstruction::has_dependencies() const –> bool

interval(self: pyrosetta.rosetta.protocols.forge.build.GrowLeft) → pyrosetta.rosetta.protocols.forge.build.Interval

a copy of the working range of residues specifying the modified region

This can change if listening to Conformation LengthEvents

C++: protocols::forge::build::GrowLeft::interval() const –> struct protocols::forge::build::Interval

modify(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction, pose: pyrosetta.rosetta.core.pose.Pose) → pyrosetta.rosetta.protocols.forge.build.BuildInstructionState.Enum

modify this pose

the state of the BuildInstruction

C++: protocols::forge::build::BuildInstruction::modify(class core::pose::Pose &) –> enum protocols::forge::build::BuildInstructionState::Enum

modify_was_successful(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → bool

Is the BuildInstruction’s state at MODIFY_WAS_SUCCESSFUL?

MODIFY_WAS_SUCCESSFUL indicates the BuildInstruction has

finished modifications to the Pose, and its residue indexing is now consistent with the newly modified Pose.

C++: protocols::forge::build::BuildInstruction::modify_was_successful() const –> bool

movemap(self: pyrosetta.rosetta.protocols.forge.build.GrowLeft) → pyrosetta.rosetta.core.kinematics.MoveMap

return a copy of the MoveMap that defines the moveable/fixed

positions/dofs for this instruction

a MoveMap with [interval.left, interval.right] bb & chi set to true

at the MoveMapTorsionID level

This set can change wrt length changes in Pose/Conformation being

watched.

C++: protocols::forge::build::GrowLeft::movemap() const –> class core::kinematics::MoveMap

n_dependencies(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → int

the number of dependencies this BuildInstruction has

C++: protocols::forge::build::BuildInstruction::n_dependencies() const –> unsigned long

new_positions(self: pyrosetta.rosetta.protocols.forge.build.GrowLeft) → pyrosetta.rosetta.std.set_unsigned_long_t

return a copy of the set of positions that are “new” and did

not exist in the original Pose.

A set of positions spanning the entire region – all positions

are new.

C++: protocols::forge::build::GrowLeft::new_positions() const –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

on_length_change(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction, event: pyrosetta.rosetta.core.conformation.signals.LengthEvent) → None

update any indexing wrt length change to Pose/Conformation being watched

C++: protocols::forge::build::BuildInstruction::on_length_change(const struct core::conformation::signals::LengthEvent &) –> void

on_residue_append(self: pyrosetta.rosetta.protocols.forge.build.GrowLeft, event: pyrosetta.rosetta.core.conformation.signals.LengthEvent) → None

update indexing on residue append

C++: protocols::forge::build::GrowLeft::on_residue_append(const struct core::conformation::signals::LengthEvent &) –> void

on_residue_delete(self: pyrosetta.rosetta.protocols.forge.build.GrowLeft, event: pyrosetta.rosetta.core.conformation.signals.LengthEvent) → None

update indexing on residue delete

C++: protocols::forge::build::GrowLeft::on_residue_delete(const struct core::conformation::signals::LengthEvent &) –> void

on_residue_prepend(self: pyrosetta.rosetta.protocols.forge.build.GrowLeft, event: pyrosetta.rosetta.core.conformation.signals.LengthEvent) → None

update indexing on residue prepend

C++: protocols::forge::build::GrowLeft::on_residue_prepend(const struct core::conformation::signals::LengthEvent &) –> void

original_deleted_positions(self: pyrosetta.rosetta.protocols.forge.build.GrowLeft) → pyrosetta.rosetta.std.set_unsigned_long_t

return set of positions within the original interval that will

be deleted in this BuildInstruction

An empty set – no positions are deleted.

C++: protocols::forge::build::GrowLeft::original_deleted_positions() const –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

original_fixed_positions(self: pyrosetta.rosetta.protocols.forge.build.GrowLeft) → pyrosetta.rosetta.std.set_unsigned_long_t

return set of any fixed positions necessary with respect to the original

interval and original Pose numbering

Used for ensuring build regions for instructions do not overlap and

so that jumps may be placed correctly.

empty set if no fixed positions

C++: protocols::forge::build::GrowLeft::original_fixed_positions() const –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

original_interval(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → pyrosetta.rosetta.protocols.forge.build.Interval

return original residue range of this instruction

C++: protocols::forge::build::BuildInstruction::original_interval() const –> const struct protocols::forge::build::Interval &

original_interval_valid(self: pyrosetta.rosetta.protocols.forge.build.GrowLeft) → bool

is the original interval storing valid information, or is empty

or being used for something else?

false, stores invalid interval

C++: protocols::forge::build::GrowLeft::original_interval_valid() const –> bool

original_kept_positions(self: pyrosetta.rosetta.protocols.forge.build.GrowLeft) → pyrosetta.rosetta.std.set_unsigned_long_t

return the set of positions within the original interval that

will be kept in this BuildInstruction

An empty set – no positions are kept.

C++: protocols::forge::build::GrowLeft::original_kept_positions() const –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

original_mutable_positions(self: pyrosetta.rosetta.protocols.forge.build.GrowLeft) → pyrosetta.rosetta.std.set_unsigned_long_t

return set of any mutable positions necessary with respect to the original

interval and original Pose numbering

Used for ensuring build regions for instructions do not overlap and

so that jumps may be placed correctly.

empty set if no mutable positions

C++: protocols::forge::build::GrowLeft::original_mutable_positions() const –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

pos(self: pyrosetta.rosetta.protocols.forge.build.GrowLeft) → int

grow left from this anchor position

this can change if listening to Conformation LengthEvents

Use original_interval() to get the original anchor position.

C++: protocols::forge::build::GrowLeft::pos() const –> unsigned long

preexisting_positions(self: pyrosetta.rosetta.protocols.forge.build.GrowLeft) → pyrosetta.rosetta.std.set_unsigned_long_t

return a copy of the set of positions within the new region

that were pre-existing in the original Pose prior to modify()

An empty set – no positions are pre-existing.

C++: protocols::forge::build::GrowLeft::preexisting_positions() const –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

ready(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → bool

Is the BuildInstruction’s state at READY?

READY indicates the BuildInstruction has been reset

and is ready to modify a Pose.

C++: protocols::forge::build::BuildInstruction::ready() const –> bool

reset_accounting(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → None

reset intervals, positions, etc to initial state and drop

observers. State set to READY.

C++: protocols::forge::build::BuildInstruction::reset_accounting() –> void

residue_type_set(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → pyrosetta.rosetta.core.chemical.ResidueTypeSet

the residue type set being used

C++: protocols::forge::build::BuildInstruction::residue_type_set() const –> const class core::chemical::ResidueTypeSet &

ss(self: pyrosetta.rosetta.protocols.forge.build.GrowLeft) → str

get secondary structure string

C++: protocols::forge::build::GrowLeft::ss() const –> const std::string &

state(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → pyrosetta.rosetta.protocols.forge.build.BuildInstructionState.Enum

return the state of this BuildInstruction

C++: protocols::forge::build::BuildInstruction::state() const –> enum protocols::forge::build::BuildInstructionState::Enum

undefined_positions(self: pyrosetta.rosetta.protocols.forge.build.GrowLeft) → pyrosetta.rosetta.std.set_unsigned_long_t

return a copy of the set of positions within the newly modified

region that has an undefined conformation. E.g. newly created residues.

A set of positions spanning the entire region – all positions

are undefined.

This set can change wrt length changes in Pose/Conformation being

watched.

C++: protocols::forge::build::GrowLeft::undefined_positions() const –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

waiting_on_dependencies(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → bool

Is the BuildInstruction’s state at WAITING_ON_DEPENDENCIES?

WAITING_ON_DEPENDENCIES indicates

the BuildInstruction is waiting for its dependencies to be satisfied before allowing modifications to proceed.

C++: protocols::forge::build::BuildInstruction::waiting_on_dependencies() const –> bool

class pyrosetta.rosetta.protocols.forge.build.GrowRight

Bases: pyrosetta.rosetta.protocols.forge.build.BuildInstruction

instruction to create a c-side extension

Use this for c-side insertions but typically not c-terminal

extensions unless necessary. It does not automatically cover the additional residue on the left endpoint that needs to move during c-terminal extensions due to invalid psi torsion. For that case, use the SegmentRebuild class replacing the c-terminal residue with desired length+1.

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: pyrosetta.rosetta.protocols.forge.build.GrowRight) -> None
2. __init__(self: pyrosetta.rosetta.protocols.forge.build.GrowRight, arg0: int, arg1: str) -> None

doc

3. __init__(self: pyrosetta.rosetta.protocols.forge.build.GrowRight, arg0: int, arg1: str, arg2: str) -> None

doc

4. __init__(self: pyrosetta.rosetta.protocols.forge.build.GrowRight, pos: int, ss: str, aa: str, rts: pyrosetta.rosetta.std.weak_ptr_const_core_chemical_ResidueTypeSet_t) -> None
5. __init__(self: pyrosetta.rosetta.protocols.forge.build.GrowRight, arg0: pyrosetta.rosetta.protocols.forge.build.GrowRight) -> 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).

aa(self: pyrosetta.rosetta.protocols.forge.build.GrowRight) → str

get annotated amino acid string

C++: protocols::forge::build::GrowRight::aa() const –> const std::string &

add_dependency_to(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction, i: pyrosetta.rosetta.std.weak_ptr_const_protocols_forge_build_BuildInstruction_t) → None

add an instruction to this BuildInstruction’s dependency list

before this instruction’s modify() may complete properly, all

instructions in the dependency list must have completed modify() first

C++: protocols::forge::build::BuildInstruction::add_dependency_to(class std::weak_ptr<const class protocols::forge::build::BuildInstruction>) –> void

assign(self: pyrosetta.rosetta.protocols.forge.build.GrowRight, rval: pyrosetta.rosetta.protocols.forge.build.GrowRight) → pyrosetta.rosetta.protocols.forge.build.GrowRight

copy assignment

C++: protocols::forge::build::GrowRight::operator=(const class protocols::forge::build::GrowRight &) –> class protocols::forge::build::GrowRight &

attach_to(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction, pose: pyrosetta.rosetta.core.pose.Pose) → None

attach to a Pose’s conformation

C++: protocols::forge::build::BuildInstruction::attach_to(class core::pose::Pose &) –> void

clear_dependencies(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → None

clear the list of dependencies

C++: protocols::forge::build::BuildInstruction::clear_dependencies() –> void

clone(self: pyrosetta.rosetta.protocols.forge.build.GrowRight) → pyrosetta.rosetta.protocols.forge.build.BuildInstruction

clone this object

C++: protocols::forge::build::GrowRight::clone() const –> class std::shared_ptr<class protocols::forge::build::BuildInstruction>

compatible_with(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction, rval: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → bool

compares fixed and mutable positions to determine compatibility with

another instruction

override this to obtain custom compatibility check

C++: protocols::forge::build::BuildInstruction::compatible_with(const class protocols::forge::build::BuildInstruction &) const –> bool

creates_undefined_backbone(self: pyrosetta.rosetta.protocols.forge.build.GrowRight) → bool

does this object create undefined backbone in the modified region?

true

C++: protocols::forge::build::GrowRight::creates_undefined_backbone() const –> bool

defined_positions(self: pyrosetta.rosetta.protocols.forge.build.GrowRight) → pyrosetta.rosetta.std.set_unsigned_long_t

return a copy of the set of positions within the newly modified

region that has a defined conformation. E.g. existing or copied residues.

An empty set – no positions are defined.

This set can change wrt length changes in Pose/Conformation being

watched.

C++: protocols::forge::build::GrowRight::defined_positions() const –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

dependencies(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → pyrosetta.rosetta.utility.vector1_std_weak_ptr_const_protocols_forge_build_BuildInstruction_t

the list of instructions whose modify() must complete before

the modify() for this instruction may be called successfully

C++: protocols::forge::build::BuildInstruction::dependencies() const –> const class utility::vector1<class std::weak_ptr<const class protocols::forge::build::BuildInstruction>, class std::allocator<class std::weak_ptr<const class protocols::forge::build::BuildInstruction> > > &

dependent_on(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction, i: pyrosetta.rosetta.std.weak_ptr_const_protocols_forge_build_BuildInstruction_t) → bool

is this instruction dependent upon the given instruction?

C++: protocols::forge::build::BuildInstruction::dependent_on(class std::weak_ptr<const class protocols::forge::build::BuildInstruction>) const –> bool

detach_after_modify(*args, **kwargs)

Overloaded function.

1. detach_after_modify(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) -> bool

detach after modify()?

Ordinarily a modify() call consists of attaching as a

length obs of the Pose, actually doing the modify, and then detaching as a length obs of the Pose. This flag governs whether the last detach occurs.

C++: protocols::forge::build::BuildInstruction::detach_after_modify() const –> bool

2. detach_after_modify(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction, flag: bool) -> None

set detach after modify()

Ordinarily a modify() call consists of attaching as a

length obs of the Pose, actually doing the modify, and then detaching as a length obs of the Pose. This flag governs whether the last detach occurs.

C++: protocols::forge::build::BuildInstruction::detach_after_modify(const bool) –> void

detach_from(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → None

detach from a Pose’s conformation

C++: protocols::forge::build::BuildInstruction::detach_from() –> void

has_dependencies(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → bool

does this BuildInstruction have dependencies?

C++: protocols::forge::build::BuildInstruction::has_dependencies() const –> bool

interval(self: pyrosetta.rosetta.protocols.forge.build.GrowRight) → pyrosetta.rosetta.protocols.forge.build.Interval

a copy of the working range of residues specifying the modified region

This can change if listening to Conformation LengthEvents

C++: protocols::forge::build::GrowRight::interval() const –> struct protocols::forge::build::Interval

modify(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction, pose: pyrosetta.rosetta.core.pose.Pose) → pyrosetta.rosetta.protocols.forge.build.BuildInstructionState.Enum

modify this pose

the state of the BuildInstruction

C++: protocols::forge::build::BuildInstruction::modify(class core::pose::Pose &) –> enum protocols::forge::build::BuildInstructionState::Enum

modify_was_successful(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → bool

Is the BuildInstruction’s state at MODIFY_WAS_SUCCESSFUL?

MODIFY_WAS_SUCCESSFUL indicates the BuildInstruction has

finished modifications to the Pose, and its residue indexing is now consistent with the newly modified Pose.

C++: protocols::forge::build::BuildInstruction::modify_was_successful() const –> bool

movemap(self: pyrosetta.rosetta.protocols.forge.build.GrowRight) → pyrosetta.rosetta.core.kinematics.MoveMap

return a copy of the MoveMap that defines the moveable/fixed

positions/dofs for this instruction

a MoveMap with [interval.left, interval.right] bb & chi set to true

at the MoveMapTorsionID level

This set can change wrt length changes in Pose/Conformation being

watched.

C++: protocols::forge::build::GrowRight::movemap() const –> class core::kinematics::MoveMap

n_dependencies(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → int

the number of dependencies this BuildInstruction has

C++: protocols::forge::build::BuildInstruction::n_dependencies() const –> unsigned long

new_positions(self: pyrosetta.rosetta.protocols.forge.build.GrowRight) → pyrosetta.rosetta.std.set_unsigned_long_t

return a copy of the set of positions that are “new” and did

not exist in the original Pose.

A set of positions spanning the entire region – all positions

are new.

C++: protocols::forge::build::GrowRight::new_positions() const –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

on_length_change(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction, event: pyrosetta.rosetta.core.conformation.signals.LengthEvent) → None

update any indexing wrt length change to Pose/Conformation being watched

C++: protocols::forge::build::BuildInstruction::on_length_change(const struct core::conformation::signals::LengthEvent &) –> void

on_residue_append(self: pyrosetta.rosetta.protocols.forge.build.GrowRight, event: pyrosetta.rosetta.core.conformation.signals.LengthEvent) → None

update indexing on residue append

C++: protocols::forge::build::GrowRight::on_residue_append(const struct core::conformation::signals::LengthEvent &) –> void

on_residue_delete(self: pyrosetta.rosetta.protocols.forge.build.GrowRight, event: pyrosetta.rosetta.core.conformation.signals.LengthEvent) → None

update indexing on residue delete

C++: protocols::forge::build::GrowRight::on_residue_delete(const struct core::conformation::signals::LengthEvent &) –> void

on_residue_prepend(self: pyrosetta.rosetta.protocols.forge.build.GrowRight, event: pyrosetta.rosetta.core.conformation.signals.LengthEvent) → None

update indexing on residue prepend

C++: protocols::forge::build::GrowRight::on_residue_prepend(const struct core::conformation::signals::LengthEvent &) –> void

original_deleted_positions(self: pyrosetta.rosetta.protocols.forge.build.GrowRight) → pyrosetta.rosetta.std.set_unsigned_long_t

return set of positions within the original interval that will

be deleted in this BuildInstruction

An empty set – no positions are deleted.

C++: protocols::forge::build::GrowRight::original_deleted_positions() const –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

original_fixed_positions(self: pyrosetta.rosetta.protocols.forge.build.GrowRight) → pyrosetta.rosetta.std.set_unsigned_long_t

return set of any fixed positions necessary with respect to the original

interval and original Pose numbering

Used for ensuring build regions for instructions do not overlap and

so that jumps may be placed correctly.

empty set if no fixed positions

C++: protocols::forge::build::GrowRight::original_fixed_positions() const –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

original_interval(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → pyrosetta.rosetta.protocols.forge.build.Interval

return original residue range of this instruction

C++: protocols::forge::build::BuildInstruction::original_interval() const –> const struct protocols::forge::build::Interval &

original_interval_valid(self: pyrosetta.rosetta.protocols.forge.build.GrowRight) → bool

is the original interval storing valid information, or is empty

or being used for something else?

false, stores invalid interval

C++: protocols::forge::build::GrowRight::original_interval_valid() const –> bool

original_kept_positions(self: pyrosetta.rosetta.protocols.forge.build.GrowRight) → pyrosetta.rosetta.std.set_unsigned_long_t

return the set of positions within the original interval that

will be kept in this BuildInstruction

An empty set – no positions are kept.

C++: protocols::forge::build::GrowRight::original_kept_positions() const –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

original_mutable_positions(self: pyrosetta.rosetta.protocols.forge.build.GrowRight) → pyrosetta.rosetta.std.set_unsigned_long_t

return set of any mutable positions necessary with respect to the original

interval and original Pose numbering

Used for ensuring build regions for instructions do not overlap and

so that jumps may be placed correctly.

empty set if no mutable positions

C++: protocols::forge::build::GrowRight::original_mutable_positions() const –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

pos(self: pyrosetta.rosetta.protocols.forge.build.GrowRight) → int

grow right from this anchor position

This can change if listening to Conformation LengthEvents.

Use original_interval() to get the original anchor position.

C++: protocols::forge::build::GrowRight::pos() const –> unsigned long

preexisting_positions(self: pyrosetta.rosetta.protocols.forge.build.GrowRight) → pyrosetta.rosetta.std.set_unsigned_long_t

return a copy of the set of positions within the new region

that were pre-existing in the original Pose prior to modify()

An empty set – no positions are pre-existing.

C++: protocols::forge::build::GrowRight::preexisting_positions() const –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

ready(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → bool

Is the BuildInstruction’s state at READY?

READY indicates the BuildInstruction has been reset

and is ready to modify a Pose.

C++: protocols::forge::build::BuildInstruction::ready() const –> bool

reset_accounting(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → None

reset intervals, positions, etc to initial state and drop

observers. State set to READY.

C++: protocols::forge::build::BuildInstruction::reset_accounting() –> void

residue_type_set(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → pyrosetta.rosetta.core.chemical.ResidueTypeSet

the residue type set being used

C++: protocols::forge::build::BuildInstruction::residue_type_set() const –> const class core::chemical::ResidueTypeSet &

ss(self: pyrosetta.rosetta.protocols.forge.build.GrowRight) → str

get secondary structure string

C++: protocols::forge::build::GrowRight::ss() const –> const std::string &

state(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → pyrosetta.rosetta.protocols.forge.build.BuildInstructionState.Enum

return the state of this BuildInstruction

C++: protocols::forge::build::BuildInstruction::state() const –> enum protocols::forge::build::BuildInstructionState::Enum

undefined_positions(self: pyrosetta.rosetta.protocols.forge.build.GrowRight) → pyrosetta.rosetta.std.set_unsigned_long_t

return a copy of the set of positions within the newly modified

region that has an undefined conformation. E.g. newly created residues.

A set of positions spanning the entire region – all positions

are undefined.

This set can change wrt length changes in Pose/Conformation being

watched.

C++: protocols::forge::build::GrowRight::undefined_positions() const –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

waiting_on_dependencies(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → bool

Is the BuildInstruction’s state at WAITING_ON_DEPENDENCIES?

WAITING_ON_DEPENDENCIES indicates

the BuildInstruction is waiting for its dependencies to be satisfied before allowing modifications to proceed.

C++: protocols::forge::build::BuildInstruction::waiting_on_dependencies() const –> bool

class pyrosetta.rosetta.protocols.forge.build.Interval

Bases: pybind11_builtins.pybind11_object

simple struct defining a closed interval of residues [left, right] where left <= right

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__(self: pyrosetta.rosetta.protocols.forge.build.Interval, rval: pyrosetta.rosetta.protocols.forge.build.Interval) → bool

operator ==

C++: protocols::forge::build::Interval::operator==(const struct protocols::forge::build::Interval &) const –> bool

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: pyrosetta.rosetta.protocols.forge.build.Interval) -> None
2. __init__(self: pyrosetta.rosetta.protocols.forge.build.Interval, l: int, r: int) -> None
3. __init__(self: pyrosetta.rosetta.protocols.forge.build.Interval, arg0: pyrosetta.rosetta.protocols.forge.build.Interval) -> None

__init_subclass__()

This method is called when a class is subclassed.

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

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

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

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

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

assign(self: pyrosetta.rosetta.protocols.forge.build.Interval, rval: pyrosetta.rosetta.protocols.forge.build.Interval) → pyrosetta.rosetta.protocols.forge.build.Interval

copy assignment

C++: protocols::forge::build::Interval::operator=(const struct protocols::forge::build::Interval &) –> struct protocols::forge::build::Interval &

contains(self: pyrosetta.rosetta.protocols.forge.build.Interval, point: int) → bool

is a point contained in this interval?

C++: protocols::forge::build::Interval::contains(const unsigned long) const –> bool

intersects(self: pyrosetta.rosetta.protocols.forge.build.Interval, rval: pyrosetta.rosetta.protocols.forge.build.Interval) → bool

do the two intervals intersect?

C++: protocols::forge::build::Interval::intersects(const struct protocols::forge::build::Interval &) const –> bool

length(self: pyrosetta.rosetta.protocols.forge.build.Interval) → int

length of the interval

C++: protocols::forge::build::Interval::length() const –> unsigned long

class pyrosetta.rosetta.protocols.forge.build.RelativeConnectRight

Bases: pyrosetta.rosetta.protocols.forge.build.ConnectRight

version of ConnectRight instruction that depends upon results from another BuildInstruction

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: pyrosetta.rosetta.protocols.forge.build.RelativeConnectRight) -> None
2. __init__(self: pyrosetta.rosetta.protocols.forge.build.RelativeConnectRight, rp: protocols::forge::build::RelativeSequencePosition, right_position: int, pose_right: pyrosetta.rosetta.core.pose.Pose) -> None
3. __init__(self: pyrosetta.rosetta.protocols.forge.build.RelativeConnectRight, arg0: pyrosetta.rosetta.protocols.forge.build.RelativeConnectRight) -> 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_dependency_to(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction, i: pyrosetta.rosetta.std.weak_ptr_const_protocols_forge_build_BuildInstruction_t) → None

add an instruction to this BuildInstruction’s dependency list

before this instruction’s modify() may complete properly, all

instructions in the dependency list must have completed modify() first

C++: protocols::forge::build::BuildInstruction::add_dependency_to(class std::weak_ptr<const class protocols::forge::build::BuildInstruction>) –> void

assign(self: pyrosetta.rosetta.protocols.forge.build.RelativeConnectRight, rval: pyrosetta.rosetta.protocols.forge.build.RelativeConnectRight) → pyrosetta.rosetta.protocols.forge.build.RelativeConnectRight

copy assignment

C++: protocols::forge::build::RelativeConnectRight::operator=(const class protocols::forge::build::RelativeConnectRight &) –> class protocols::forge::build::RelativeConnectRight &

attach_to(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction, pose: pyrosetta.rosetta.core.pose.Pose) → None

attach to a Pose’s conformation

C++: protocols::forge::build::BuildInstruction::attach_to(class core::pose::Pose &) –> void

clear_dependencies(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → None

clear the list of dependencies

C++: protocols::forge::build::BuildInstruction::clear_dependencies() –> void

clone(self: pyrosetta.rosetta.protocols.forge.build.RelativeConnectRight) → pyrosetta.rosetta.protocols.forge.build.BuildInstruction

clone this object

C++: protocols::forge::build::RelativeConnectRight::clone() const –> class std::shared_ptr<class protocols::forge::build::BuildInstruction>

compatible_with(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction, rval: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → bool

compares fixed and mutable positions to determine compatibility with

another instruction

override this to obtain custom compatibility check

C++: protocols::forge::build::BuildInstruction::compatible_with(const class protocols::forge::build::BuildInstruction &) const –> bool

creates_undefined_backbone(self: pyrosetta.rosetta.protocols.forge.build.ConnectRight) → bool

does this object create undefined backbone in the modified region?

false

C++: protocols::forge::build::ConnectRight::creates_undefined_backbone() const –> bool

defined_positions(self: pyrosetta.rosetta.protocols.forge.build.ConnectRight) → pyrosetta.rosetta.std.set_unsigned_long_t

return a copy of the set of positions within the newly modified

region that has a defined conformation. E.g. existing or copied residues.

A set spanning the entire interval – all positions are defined.

This set can change wrt length changes in Pose/Conformation being

watched.

C++: protocols::forge::build::ConnectRight::defined_positions() const –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

dependencies(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → pyrosetta.rosetta.utility.vector1_std_weak_ptr_const_protocols_forge_build_BuildInstruction_t

the list of instructions whose modify() must complete before

the modify() for this instruction may be called successfully

C++: protocols::forge::build::BuildInstruction::dependencies() const –> const class utility::vector1<class std::weak_ptr<const class protocols::forge::build::BuildInstruction>, class std::allocator<class std::weak_ptr<const class protocols::forge::build::BuildInstruction> > > &

dependent_on(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction, i: pyrosetta.rosetta.std.weak_ptr_const_protocols_forge_build_BuildInstruction_t) → bool

is this instruction dependent upon the given instruction?

C++: protocols::forge::build::BuildInstruction::dependent_on(class std::weak_ptr<const class protocols::forge::build::BuildInstruction>) const –> bool

detach_after_modify(*args, **kwargs)

Overloaded function.

1. detach_after_modify(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) -> bool

detach after modify()?

Ordinarily a modify() call consists of attaching as a

length obs of the Pose, actually doing the modify, and then detaching as a length obs of the Pose. This flag governs whether the last detach occurs.

C++: protocols::forge::build::BuildInstruction::detach_after_modify() const –> bool

2. detach_after_modify(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction, flag: bool) -> None

set detach after modify()

Ordinarily a modify() call consists of attaching as a

length obs of the Pose, actually doing the modify, and then detaching as a length obs of the Pose. This flag governs whether the last detach occurs.

C++: protocols::forge::build::BuildInstruction::detach_after_modify(const bool) –> void

detach_from(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → None

detach from a Pose’s conformation

C++: protocols::forge::build::BuildInstruction::detach_from() –> void

extract_rt(self: pyrosetta.rosetta.protocols.forge.build.ConnectRight, pose: pyrosetta.rosetta.core.pose.Pose, jump_start_residue: int, jump_stop_residue: int) → None

extract appropriately computed transform between two stubs that

represent a jump in the given Pose between the two residues and set it as the rt for this ConnectRight

The Pose to use.

The starting residue of the jump.

This residue should be the equivalent of the jump position on pose_left.

The stopping residue of the jump.

This residue should be the equivalent of the jump position on pose_right.

Uses left_stub_atoms() and right_stub_atoms() as the stub atoms

to compute the transform. Remember to set use_rt() to True after calling this function if you want to actually use the transform during modify().

C++: protocols::forge::build::ConnectRight::extract_rt(const class core::pose::Pose &, const unsigned long, const unsigned long) –> void

has_dependencies(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → bool

does this BuildInstruction have dependencies?

C++: protocols::forge::build::BuildInstruction::has_dependencies() const –> bool

interval(self: pyrosetta.rosetta.protocols.forge.build.ConnectRight) → pyrosetta.rosetta.protocols.forge.build.Interval

a copy of the working range of residues specifying the modified region

before modify() holds [1, pose_right.size()]; after

modify() holds [1 + pose_left.size(), pose_right.n_residue + pose_left.size()]

This can change if listening to Conformation LengthEvents

C++: protocols::forge::build::ConnectRight::interval() const –> struct protocols::forge::build::Interval

left_stub_atoms(*args, **kwargs)

Overloaded function.

1. left_stub_atoms(self: pyrosetta.rosetta.protocols.forge.build.ConnectRight) -> pyrosetta.rosetta.utility.vector1_std_string

Use these atoms to compute the stub on pose_left.

Default [“CA”, “N”, “CA”, “C”].

This is an array with 4 elements in the same order as Stub

initialization: ‘center atom’, ‘point1’, ‘point2’, ‘point3’. See Stub docs for more details.

C++: protocols::forge::build::ConnectRight::left_stub_atoms() const –> const class utility::vector1<std::string, class std::allocator<std::string > > &

2. left_stub_atoms(self: pyrosetta.rosetta.protocols.forge.build.ConnectRight, atoms: pyrosetta.rosetta.utility.vector1_std_string) -> None

Use these atoms to compute the stub on pose_left.

Default [“CA”, “N”, “CA”, “C”].

This is an array with 4 elements in the same order as Stub

initialization: ‘center atom’, ‘point1’, ‘point2’, ‘point3’. See Stub docs for more details.

C++: protocols::forge::build::ConnectRight::left_stub_atoms(const class utility::vector1<class std::basic_string<char>, class std::allocator<class std::basic_string<char> > > &) –> void

modify(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction, pose: pyrosetta.rosetta.core.pose.Pose) → pyrosetta.rosetta.protocols.forge.build.BuildInstructionState.Enum

modify this pose

the state of the BuildInstruction

C++: protocols::forge::build::BuildInstruction::modify(class core::pose::Pose &) –> enum protocols::forge::build::BuildInstructionState::Enum

modify_impl(self: pyrosetta.rosetta.protocols.forge.build.RelativeConnectRight, pose_left: pyrosetta.rosetta.core.pose.Pose) → None

do the actual work of modifying the Pose

C++: protocols::forge::build::RelativeConnectRight::modify_impl(class core::pose::Pose &) –> void

modify_was_successful(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → bool

Is the BuildInstruction’s state at MODIFY_WAS_SUCCESSFUL?

MODIFY_WAS_SUCCESSFUL indicates the BuildInstruction has

finished modifications to the Pose, and its residue indexing is now consistent with the newly modified Pose.

C++: protocols::forge::build::BuildInstruction::modify_was_successful() const –> bool

movemap(self: pyrosetta.rosetta.protocols.forge.build.ConnectRight) → pyrosetta.rosetta.core.kinematics.MoveMap

return a copy of the MoveMap that defines the moveable/fixed

positions/dofs for this instruction

a MoveMap with [interval.left, interval.right] bb set to false

at the MoveMapTorsionID level

This set can change wrt length changes in Pose/Conformation being

watched.

C++: protocols::forge::build::ConnectRight::movemap() const –> class core::kinematics::MoveMap

n_dependencies(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → int

the number of dependencies this BuildInstruction has

C++: protocols::forge::build::BuildInstruction::n_dependencies() const –> unsigned long

new_positions(self: pyrosetta.rosetta.protocols.forge.build.ConnectRight) → pyrosetta.rosetta.std.set_unsigned_long_t

return a copy of the set of positions that are “new” and did

not exist in the original Pose.

A set spanning the entire interval – all positions are new.

C++: protocols::forge::build::ConnectRight::new_positions() const –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

on_length_change(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction, event: pyrosetta.rosetta.core.conformation.signals.LengthEvent) → None

update any indexing wrt length change to Pose/Conformation being watched

C++: protocols::forge::build::BuildInstruction::on_length_change(const struct core::conformation::signals::LengthEvent &) –> void

on_residue_append(self: pyrosetta.rosetta.protocols.forge.build.ConnectRight, event: pyrosetta.rosetta.core.conformation.signals.LengthEvent) → None

update indexing on residue append

C++: protocols::forge::build::ConnectRight::on_residue_append(const struct core::conformation::signals::LengthEvent &) –> void

on_residue_delete(self: pyrosetta.rosetta.protocols.forge.build.ConnectRight, event: pyrosetta.rosetta.core.conformation.signals.LengthEvent) → None

update indexing on residue delete

C++: protocols::forge::build::ConnectRight::on_residue_delete(const struct core::conformation::signals::LengthEvent &) –> void

on_residue_prepend(self: pyrosetta.rosetta.protocols.forge.build.ConnectRight, event: pyrosetta.rosetta.core.conformation.signals.LengthEvent) → None

update indexing on residue prepend

C++: protocols::forge::build::ConnectRight::on_residue_prepend(const struct core::conformation::signals::LengthEvent &) –> void

original_deleted_positions(self: pyrosetta.rosetta.protocols.forge.build.ConnectRight) → pyrosetta.rosetta.std.set_unsigned_long_t

return set of positions within the original interval that will

be deleted in this BuildInstruction

An empty set – no positions are deleted.

C++: protocols::forge::build::ConnectRight::original_deleted_positions() const –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

original_fixed_positions(self: pyrosetta.rosetta.protocols.forge.build.RelativeConnectRight) → pyrosetta.rosetta.std.set_unsigned_long_t

return set of any fixed positions necessary with respect to the original

interval and original Pose numbering

always empty set, no fixed positions

Used for ensuring build regions for instructions do not overlap and

so that jumps may be placed correctly. There is currently no way to represent the dependent fixed position, so we’re forced to return an empty set.

C++: protocols::forge::build::RelativeConnectRight::original_fixed_positions() const –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

original_interval(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → pyrosetta.rosetta.protocols.forge.build.Interval

return original residue range of this instruction

C++: protocols::forge::build::BuildInstruction::original_interval() const –> const struct protocols::forge::build::Interval &

original_interval_valid(self: pyrosetta.rosetta.protocols.forge.build.ConnectRight) → bool

is the original interval storing valid information, or is empty

or being used for something else?

false, stores invalid interval

C++: protocols::forge::build::ConnectRight::original_interval_valid() const –> bool

original_kept_positions(self: pyrosetta.rosetta.protocols.forge.build.ConnectRight) → pyrosetta.rosetta.std.set_unsigned_long_t

return the set of positions within the original interval that

will be kept in this BuildInstruction

An empty set – no positions are kept.

C++: protocols::forge::build::ConnectRight::original_kept_positions() const –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

original_mutable_positions(self: pyrosetta.rosetta.protocols.forge.build.ConnectRight) → pyrosetta.rosetta.std.set_unsigned_long_t

return set of any mutable positions necessary with respect to the original

interval and original Pose numbering

Used for ensuring build regions for instructions do not overlap and

so that jumps may be placed correctly.

empty set if no mutable positions

C++: protocols::forge::build::ConnectRight::original_mutable_positions() const –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

pose_right(self: pyrosetta.rosetta.protocols.forge.build.ConnectRight) → pyrosetta.rosetta.core.pose.Pose

connect this pose to the right of pose_left when modify( pose_left )

is called

C++: protocols::forge::build::ConnectRight::pose_right() –> const class core::pose::Pose &

preexisting_positions(self: pyrosetta.rosetta.protocols.forge.build.ConnectRight) → pyrosetta.rosetta.std.set_unsigned_long_t

return a copy of the set of positions within the new region

that were pre-existing in the original Pose prior to modify()

An empty set – no positions are pre-existing.

C++: protocols::forge::build::ConnectRight::preexisting_positions() const –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

ready(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → bool

Is the BuildInstruction’s state at READY?

READY indicates the BuildInstruction has been reset

and is ready to modify a Pose.

C++: protocols::forge::build::BuildInstruction::ready() const –> bool

reset_accounting(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → None

reset intervals, positions, etc to initial state and drop

observers. State set to READY.

C++: protocols::forge::build::BuildInstruction::reset_accounting() –> void

residue_type_set(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → pyrosetta.rosetta.core.chemical.ResidueTypeSet

the residue type set being used

C++: protocols::forge::build::BuildInstruction::residue_type_set() const –> const class core::chemical::ResidueTypeSet &

right_stub_atoms(*args, **kwargs)

Overloaded function.

1. right_stub_atoms(self: pyrosetta.rosetta.protocols.forge.build.ConnectRight) -> pyrosetta.rosetta.utility.vector1_std_string

Use these atoms to compute the stub on pose_right.

Default [“CA”, “N”, “CA”, “C”].

This is an array with 4 elements in the same order as Stub

initialization: ‘center atom’, ‘point1’, ‘point2’, ‘point3’. See Stub docs for more details.

C++: protocols::forge::build::ConnectRight::right_stub_atoms() const –> const class utility::vector1<std::string, class std::allocator<std::string > > &

2. right_stub_atoms(self: pyrosetta.rosetta.protocols.forge.build.ConnectRight, atoms: pyrosetta.rosetta.utility.vector1_std_string) -> None

Use these atoms to compute the stub on pose_right.

Default [“CA”, “N”, “CA”, “C”].

This is an array with 4 elements in the same order as Stub

initialization: ‘center atom’, ‘point1’, ‘point2’, ‘point3’. See Stub docs for more details.

C++: protocols::forge::build::ConnectRight::right_stub_atoms(const class utility::vector1<class std::basic_string<char>, class std::allocator<class std::basic_string<char> > > &) –> void

rt(*args, **kwargs)

Overloaded function.

1. rt(self: pyrosetta.rosetta.protocols.forge.build.ConnectRight) -> pyrosetta.rosetta.core.kinematics.RT

the rotation-translation representing an explicit transform from

the stub on pose_left to the stub on pose_right, i.e. the representation of the “jump”

C++: protocols::forge::build::ConnectRight::rt() –> const class core::kinematics::RT &

2. rt(self: pyrosetta.rosetta.protocols.forge.build.ConnectRight, transform: pyrosetta.rosetta.core.kinematics.RT) -> None

the rotation-translation representing an explicit transform from

the stub on pose_left to the stub on pose_right, i.e. the representation of the “jump”

C++: protocols::forge::build::ConnectRight::rt(const class core::kinematics::RT &) –> void

state(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → pyrosetta.rosetta.protocols.forge.build.BuildInstructionState.Enum

return the state of this BuildInstruction

C++: protocols::forge::build::BuildInstruction::state() const –> enum protocols::forge::build::BuildInstructionState::Enum

undefined_positions(self: pyrosetta.rosetta.protocols.forge.build.ConnectRight) → pyrosetta.rosetta.std.set_unsigned_long_t

return a copy of the set of positions within the newly modified

region that has an undefined conformation. E.g. newly created residues.

An empty set – no undefined positions.

This set can change wrt length changes in Pose/Conformation being

watched.

C++: protocols::forge::build::ConnectRight::undefined_positions() const –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

use_rt(*args, **kwargs)

Overloaded function.

1. use_rt(self: pyrosetta.rosetta.protocols.forge.build.ConnectRight) -> bool

apply the transform over the jump connection between pose_left and

pose_right? default False

C++: protocols::forge::build::ConnectRight::use_rt() const –> bool

2. use_rt(self: pyrosetta.rosetta.protocols.forge.build.ConnectRight, flag: bool) -> None

apply the transform over the jump connection between pose_left and

pose_right? default False

C++: protocols::forge::build::ConnectRight::use_rt(const bool) –> void

waiting_on_dependencies(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → bool

Is the BuildInstruction’s state at WAITING_ON_DEPENDENCIES?

WAITING_ON_DEPENDENCIES indicates

the BuildInstruction is waiting for its dependencies to be satisfied before allowing modifications to proceed.

C++: protocols::forge::build::BuildInstruction::waiting_on_dependencies() const –> bool

class pyrosetta.rosetta.protocols.forge.build.RelativeSequencePosition

Bases: pybind11_builtins.pybind11_object

computes a position wrt values in given BuildInstruction

__call__(self: pyrosetta.rosetta.protocols.forge.build.RelativeSequencePosition, i: pyrosetta.rosetta.std.weak_ptr_const_protocols_forge_build_BuildInstruction_t) → int

C++: protocols::forge::build::RelativeSequencePosition::operator()(class std::weak_ptr<const class protocols::forge::build::BuildInstruction>) const –> unsigned long

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: pyrosetta.rosetta.protocols.forge.build.RelativeSequencePosition, arg0: pyrosetta.rosetta.protocols.forge.build.RelativeSequencePosition) -> None
2. __init__(self: pyrosetta.rosetta.protocols.forge.build.RelativeSequencePosition) -> None

__init_subclass__()

This method is called when a class is subclassed.

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

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

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

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

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

assign(self: pyrosetta.rosetta.protocols.forge.build.RelativeSequencePosition, : pyrosetta.rosetta.protocols.forge.build.RelativeSequencePosition) → pyrosetta.rosetta.protocols.forge.build.RelativeSequencePosition

C++: protocols::forge::build::RelativeSequencePosition::operator=(const struct protocols::forge::build::RelativeSequencePosition &) –> struct protocols::forge::build::RelativeSequencePosition &

clone(self: pyrosetta.rosetta.protocols.forge.build.RelativeSequencePosition) → pyrosetta.rosetta.protocols.forge.build.RelativeSequencePosition

C++: protocols::forge::build::RelativeSequencePosition::clone() const –> class std::shared_ptr<struct protocols::forge::build::RelativeSequencePosition>

class pyrosetta.rosetta.protocols.forge.build.SegmentInsert

Bases: pyrosetta.rosetta.protocols.forge.build.BuildInstruction

insert an external segment flanked by new regions

Similar to SegmentRebuild, but with the addition of a defined

segment located in the modified region.

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: pyrosetta.rosetta.protocols.forge.build.SegmentInsert) -> None
2. __init__(self: pyrosetta.rosetta.protocols.forge.build.SegmentInsert, arg0: pyrosetta.rosetta.protocols.forge.build.Interval, arg1: str, arg2: pyrosetta.rosetta.core.pose.Pose) -> None

doc

3. __init__(self: pyrosetta.rosetta.protocols.forge.build.SegmentInsert, arg0: pyrosetta.rosetta.protocols.forge.build.Interval, arg1: str, arg2: pyrosetta.rosetta.core.pose.Pose, arg3: bool) -> None

doc

4. __init__(self: pyrosetta.rosetta.protocols.forge.build.SegmentInsert, i: pyrosetta.rosetta.protocols.forge.build.Interval, ss: str, insert: pyrosetta.rosetta.core.pose.Pose, keep_known_bb_torsions_at_junctions: bool, connection_scheme: pyrosetta.rosetta.protocols.forge.build.SegmentInsertConnectionScheme.Enum) -> None
5. __init__(self: pyrosetta.rosetta.protocols.forge.build.SegmentInsert, arg0: pyrosetta.rosetta.protocols.forge.build.Interval, arg1: str, arg2: str, arg3: pyrosetta.rosetta.core.pose.Pose) -> None

doc

6. __init__(self: pyrosetta.rosetta.protocols.forge.build.SegmentInsert, arg0: pyrosetta.rosetta.protocols.forge.build.Interval, arg1: str, arg2: str, arg3: pyrosetta.rosetta.core.pose.Pose, arg4: bool) -> None

doc

7. __init__(self: pyrosetta.rosetta.protocols.forge.build.SegmentInsert, i: pyrosetta.rosetta.protocols.forge.build.Interval, ss: str, aa: str, insert: pyrosetta.rosetta.core.pose.Pose, keep_known_bb_torsions_at_junctions: bool, connection_scheme: pyrosetta.rosetta.protocols.forge.build.SegmentInsertConnectionScheme.Enum) -> None
8. __init__(self: pyrosetta.rosetta.protocols.forge.build.SegmentInsert, arg0: pyrosetta.rosetta.protocols.forge.build.SegmentInsert) -> 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).

aa(self: pyrosetta.rosetta.protocols.forge.build.SegmentInsert) → str

get annotated amino acid string (includes insertion point as ‘^’)

C++: protocols::forge::build::SegmentInsert::aa() const –> const std::string &

add_dependency_to(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction, i: pyrosetta.rosetta.std.weak_ptr_const_protocols_forge_build_BuildInstruction_t) → None

add an instruction to this BuildInstruction’s dependency list

before this instruction’s modify() may complete properly, all

instructions in the dependency list must have completed modify() first

C++: protocols::forge::build::BuildInstruction::add_dependency_to(class std::weak_ptr<const class protocols::forge::build::BuildInstruction>) –> void

assign(self: pyrosetta.rosetta.protocols.forge.build.SegmentInsert, rval: pyrosetta.rosetta.protocols.forge.build.SegmentInsert) → pyrosetta.rosetta.protocols.forge.build.SegmentInsert

copy assignment

C++: protocols::forge::build::SegmentInsert::operator=(const class protocols::forge::build::SegmentInsert &) –> class protocols::forge::build::SegmentInsert &

attach_to(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction, pose: pyrosetta.rosetta.core.pose.Pose) → None

attach to a Pose’s conformation

C++: protocols::forge::build::BuildInstruction::attach_to(class core::pose::Pose &) –> void

clear_dependencies(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → None

clear the list of dependencies

C++: protocols::forge::build::BuildInstruction::clear_dependencies() –> void

clone(self: pyrosetta.rosetta.protocols.forge.build.SegmentInsert) → pyrosetta.rosetta.protocols.forge.build.BuildInstruction

clone this object

C++: protocols::forge::build::SegmentInsert::clone() const –> class std::shared_ptr<class protocols::forge::build::BuildInstruction>

compatible_with(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction, rval: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → bool

compares fixed and mutable positions to determine compatibility with

another instruction

override this to obtain custom compatibility check

C++: protocols::forge::build::BuildInstruction::compatible_with(const class protocols::forge::build::BuildInstruction &) const –> bool

creates_undefined_backbone(self: pyrosetta.rosetta.protocols.forge.build.SegmentInsert) → bool

does this object create undefined backbone in the modified region?

C++: protocols::forge::build::SegmentInsert::creates_undefined_backbone() const –> bool

defined_positions(self: pyrosetta.rosetta.protocols.forge.build.SegmentInsert) → pyrosetta.rosetta.std.set_unsigned_long_t

return a copy of the set of positions within the newly modified

region that has a defined conformation. E.g. existing or copied residues.

This set can change wrt length changes in Pose/Conformation being

watched.

C++: protocols::forge::build::SegmentInsert::defined_positions() const –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

dependencies(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → pyrosetta.rosetta.utility.vector1_std_weak_ptr_const_protocols_forge_build_BuildInstruction_t

the list of instructions whose modify() must complete before

the modify() for this instruction may be called successfully

C++: protocols::forge::build::BuildInstruction::dependencies() const –> const class utility::vector1<class std::weak_ptr<const class protocols::forge::build::BuildInstruction>, class std::allocator<class std::weak_ptr<const class protocols::forge::build::BuildInstruction> > > &

dependent_on(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction, i: pyrosetta.rosetta.std.weak_ptr_const_protocols_forge_build_BuildInstruction_t) → bool

is this instruction dependent upon the given instruction?

C++: protocols::forge::build::BuildInstruction::dependent_on(class std::weak_ptr<const class protocols::forge::build::BuildInstruction>) const –> bool

detach_after_modify(*args, **kwargs)

Overloaded function.

1. detach_after_modify(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) -> bool

detach after modify()?

Ordinarily a modify() call consists of attaching as a

length obs of the Pose, actually doing the modify, and then detaching as a length obs of the Pose. This flag governs whether the last detach occurs.

C++: protocols::forge::build::BuildInstruction::detach_after_modify() const –> bool

2. detach_after_modify(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction, flag: bool) -> None

set detach after modify()

Ordinarily a modify() call consists of attaching as a

length obs of the Pose, actually doing the modify, and then detaching as a length obs of the Pose. This flag governs whether the last detach occurs.

C++: protocols::forge::build::BuildInstruction::detach_after_modify(const bool) –> void

detach_from(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → None

detach from a Pose’s conformation

C++: protocols::forge::build::BuildInstruction::detach_from() –> void

flanking_left_aa(self: pyrosetta.rosetta.protocols.forge.build.SegmentInsert) → str

get the annotated aa string of the flanking residues to the left

of the insertion point

C++: protocols::forge::build::SegmentInsert::flanking_left_aa() const –> std::string

flanking_left_nres(self: pyrosetta.rosetta.protocols.forge.build.SegmentInsert) → int

get the number of flanking residues to the left of the insertion

point

C++: protocols::forge::build::SegmentInsert::flanking_left_nres() const –> unsigned long

flanking_left_ss(self: pyrosetta.rosetta.protocols.forge.build.SegmentInsert) → str

get the ss string of the flanking residues to the left of the

insertion point

C++: protocols::forge::build::SegmentInsert::flanking_left_ss() const –> std::string

flanking_right_aa(self: pyrosetta.rosetta.protocols.forge.build.SegmentInsert) → str

get the annotated aa string of the flanking residues to the right

of the insertion point

C++: protocols::forge::build::SegmentInsert::flanking_right_aa() const –> std::string

flanking_right_nres(self: pyrosetta.rosetta.protocols.forge.build.SegmentInsert) → int

get the number of flanking residues to the right of the insertion

point

C++: protocols::forge::build::SegmentInsert::flanking_right_nres() const –> unsigned long

flanking_right_ss(self: pyrosetta.rosetta.protocols.forge.build.SegmentInsert) → str

get the ss string of the flanking residues to the right of the

insertion point

C++: protocols::forge::build::SegmentInsert::flanking_right_ss() const –> std::string

has_dependencies(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → bool

does this BuildInstruction have dependencies?

C++: protocols::forge::build::BuildInstruction::has_dependencies() const –> bool

insert_connection_scheme(self: pyrosetta.rosetta.protocols.forge.build.SegmentInsert) → pyrosetta.rosetta.protocols.forge.build.SegmentInsertConnectionScheme.Enum

get the insert connection scheme – whether the insertion will

be glued on the N-side, C-side, or if SegmentInsert will pick randomly between the two

C++: protocols::forge::build::SegmentInsert::insert_connection_scheme() const –> enum protocols::forge::build::SegmentInsertConnectionScheme::Enum

insert_pose(self: pyrosetta.rosetta.protocols.forge.build.SegmentInsert) → pyrosetta.rosetta.core.pose.Pose

the pose to insert

C++: protocols::forge::build::SegmentInsert::insert_pose() const –> const class core::pose::Pose &

insert_pose_torsion_override_movemap(*args, **kwargs)

Overloaded function.

1. insert_pose_torsion_override_movemap(self: pyrosetta.rosetta.protocols.forge.build.SegmentInsert) -> pyrosetta.rosetta.core.kinematics.MoveMap

a torsion (bb/chi) specific override movemap indexed wrt the insert Pose

(residue indices may only be within the range [1, insert_pose.size()]

When generating the movemap(), this torsion movemap will be enforced.

Only explicit settings of TorsionType, MoveMapTorsionID, and TorsionID will be honored. Implicit false settings are ignored.

C++: protocols::forge::build::SegmentInsert::insert_pose_torsion_override_movemap() const –> const class core::kinematics::MoveMap &

2. insert_pose_torsion_override_movemap(self: pyrosetta.rosetta.protocols.forge.build.SegmentInsert, mm: pyrosetta.rosetta.core.kinematics.MoveMap) -> None

set a torsion (bb/chi) specific override movemap indexed wrt the insert

Pose (residue indices may only be within the range [1, insert_pose.size()]

When generating the movemap(), this torsion movemap will be enforced.

Only explicit settings of TorsionType, MoveMapTorsionID, and TorsionID will be honored. Implicit false settings are ignored.

C++: protocols::forge::build::SegmentInsert::insert_pose_torsion_override_movemap(const class core::kinematics::MoveMap &) –> void

insertion_char() → str

the character representing the insertion point

‘^’

C++: protocols::forge::build::SegmentInsert::insertion_char() –> char

insertion_end_residue(self: pyrosetta.rosetta.protocols.forge.build.SegmentInsert) → int

get the residue at the end of the insertion relative to the

modified interval (flanking positions are not part of the insertion!)

C++: protocols::forge::build::SegmentInsert::insertion_end_residue() const –> unsigned long

insertion_point_absolute_index(self: pyrosetta.rosetta.protocols.forge.build.SegmentInsert) → int

get the absolute index of the insertion point with respect to the

flanking regions (i.e. the index inside the ss string)

C++: protocols::forge::build::SegmentInsert::insertion_point_absolute_index() const –> unsigned long

insertion_start_residue(self: pyrosetta.rosetta.protocols.forge.build.SegmentInsert) → int

get the residue at the start of the insertion relative to the

modified interval (flanking positions are not part of the insertion!)

C++: protocols::forge::build::SegmentInsert::insertion_start_residue() const –> unsigned long

interval(self: pyrosetta.rosetta.protocols.forge.build.SegmentInsert) → pyrosetta.rosetta.protocols.forge.build.Interval

a copy of the working range of residues specifying the modified region

This residue range can change wrt length changes in Pose /Conformation

being watched.

C++: protocols::forge::build::SegmentInsert::interval() const –> struct protocols::forge::build::Interval

keep_known_bb_torsions_at_junctions(self: pyrosetta.rosetta.protocols.forge.build.SegmentInsert) → bool

Attempt to keep the phi at original_interval().left and the psi+omega

at original_interval().right present from the original Pose in the modified Pose? Not applicable for pure insertions. Default False.

C++: protocols::forge::build::SegmentInsert::keep_known_bb_torsions_at_junctions() const –> bool

modify(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction, pose: pyrosetta.rosetta.core.pose.Pose) → pyrosetta.rosetta.protocols.forge.build.BuildInstructionState.Enum

modify this pose

the state of the BuildInstruction

C++: protocols::forge::build::BuildInstruction::modify(class core::pose::Pose &) –> enum protocols::forge::build::BuildInstructionState::Enum

modify_was_successful(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → bool

Is the BuildInstruction’s state at MODIFY_WAS_SUCCESSFUL?

MODIFY_WAS_SUCCESSFUL indicates the BuildInstruction has

finished modifications to the Pose, and its residue indexing is now consistent with the newly modified Pose.

C++: protocols::forge::build::BuildInstruction::modify_was_successful() const –> bool

movemap(self: pyrosetta.rosetta.protocols.forge.build.SegmentInsert) → pyrosetta.rosetta.core.kinematics.MoveMap

return a copy of the MoveMap that defines the moveable/fixed

positions/dofs for this instruction

TO BE FILLED IN

This set can change wrt length changes in Pose/Conformation being

watched.

C++: protocols::forge::build::SegmentInsert::movemap() const –> class core::kinematics::MoveMap

n_dependencies(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → int

the number of dependencies this BuildInstruction has

C++: protocols::forge::build::BuildInstruction::n_dependencies() const –> unsigned long

new_positions(self: pyrosetta.rosetta.protocols.forge.build.SegmentInsert) → pyrosetta.rosetta.std.set_unsigned_long_t

return a copy of the set of positions that are “new” and did

not exist in the original Pose.

C++: protocols::forge::build::SegmentInsert::new_positions() const –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

on_length_change(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction, event: pyrosetta.rosetta.core.conformation.signals.LengthEvent) → None

update any indexing wrt length change to Pose/Conformation being watched

C++: protocols::forge::build::BuildInstruction::on_length_change(const struct core::conformation::signals::LengthEvent &) –> void

on_residue_append(self: pyrosetta.rosetta.protocols.forge.build.SegmentInsert, event: pyrosetta.rosetta.core.conformation.signals.LengthEvent) → None

update indexing on residue append

C++: protocols::forge::build::SegmentInsert::on_residue_append(const struct core::conformation::signals::LengthEvent &) –> void

on_residue_delete(self: pyrosetta.rosetta.protocols.forge.build.SegmentInsert, event: pyrosetta.rosetta.core.conformation.signals.LengthEvent) → None

update indexing on residue delete

C++: protocols::forge::build::SegmentInsert::on_residue_delete(const struct core::conformation::signals::LengthEvent &) –> void

on_residue_prepend(self: pyrosetta.rosetta.protocols.forge.build.SegmentInsert, event: pyrosetta.rosetta.core.conformation.signals.LengthEvent) → None

update indexing on residue prepend

C++: protocols::forge::build::SegmentInsert::on_residue_prepend(const struct core::conformation::signals::LengthEvent &) –> void

original_deleted_positions(self: pyrosetta.rosetta.protocols.forge.build.SegmentInsert) → pyrosetta.rosetta.std.set_unsigned_long_t

return set of positions within the original interval that will

be deleted in this BuildInstruction

C++: protocols::forge::build::SegmentInsert::original_deleted_positions() const –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

original_fixed_positions(self: pyrosetta.rosetta.protocols.forge.build.SegmentInsert) → pyrosetta.rosetta.std.set_unsigned_long_t

return set of any fixed positions necessary with respect to the original

interval and original Pose numbering

Used for ensuring build regions for instructions do not overlap and

so that jumps may be placed correctly.

empty set if no fixed positions necessary

C++: protocols::forge::build::SegmentInsert::original_fixed_positions() const –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

original_interval(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → pyrosetta.rosetta.protocols.forge.build.Interval

return original residue range of this instruction

C++: protocols::forge::build::BuildInstruction::original_interval() const –> const struct protocols::forge::build::Interval &

original_interval_valid(self: pyrosetta.rosetta.protocols.forge.build.SegmentInsert) → bool

is the original interval storing valid information, or is empty

or being used for something else?

always false, original interval invalid

C++: protocols::forge::build::SegmentInsert::original_interval_valid() const –> bool

original_kept_positions(self: pyrosetta.rosetta.protocols.forge.build.SegmentInsert) → pyrosetta.rosetta.std.set_unsigned_long_t

return the set of positions within the original interval that

will be kept in this BuildInstruction

An empty set – no positions are kept.

C++: protocols::forge::build::SegmentInsert::original_kept_positions() const –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

original_mutable_positions(self: pyrosetta.rosetta.protocols.forge.build.SegmentInsert) → pyrosetta.rosetta.std.set_unsigned_long_t

return set of any mutable positions necessary with respect to the original

interval and original Pose numbering

Used for ensuring build regions for instructions do not overlap and

so that jumps may be placed correctly.

C++: protocols::forge::build::SegmentInsert::original_mutable_positions() const –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

performing_pure_insertion(self: pyrosetta.rosetta.protocols.forge.build.SegmentInsert) → bool

performing a pure insertion/extension?

True if SegmentInsert was initialized with an interval whose

left endpoint == 0, False otherwise.

C++: protocols::forge::build::SegmentInsert::performing_pure_insertion() const –> bool

preexisting_positions(self: pyrosetta.rosetta.protocols.forge.build.SegmentInsert) → pyrosetta.rosetta.std.set_unsigned_long_t

return a copy of the set of positions within the new region

that were pre-existing in the original Pose prior to modify()

An empty set, there are no pre-existing positions.

C++: protocols::forge::build::SegmentInsert::preexisting_positions() const –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

ready(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → bool

Is the BuildInstruction’s state at READY?

READY indicates the BuildInstruction has been reset

and is ready to modify a Pose.

C++: protocols::forge::build::BuildInstruction::ready() const –> bool

reset_accounting(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → None

reset intervals, positions, etc to initial state and drop

observers. State set to READY.

C++: protocols::forge::build::BuildInstruction::reset_accounting() –> void

residue_type_set(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → pyrosetta.rosetta.core.chemical.ResidueTypeSet

the residue type set being used

C++: protocols::forge::build::BuildInstruction::residue_type_set() const –> const class core::chemical::ResidueTypeSet &

ss(self: pyrosetta.rosetta.protocols.forge.build.SegmentInsert) → str

get secondary structure string (includes insertion point as ‘^’)

C++: protocols::forge::build::SegmentInsert::ss() const –> const std::string &

state(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → pyrosetta.rosetta.protocols.forge.build.BuildInstructionState.Enum

return the state of this BuildInstruction

C++: protocols::forge::build::BuildInstruction::state() const –> enum protocols::forge::build::BuildInstructionState::Enum

undefined_positions(self: pyrosetta.rosetta.protocols.forge.build.SegmentInsert) → pyrosetta.rosetta.std.set_unsigned_long_t

return a copy of the set of positions within the newly modified

region that has an undefined conformation. E.g. newly created residues.

This set can change wrt length changes in Pose/Conformation being

watched.

C++: protocols::forge::build::SegmentInsert::undefined_positions() const –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

waiting_on_dependencies(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → bool

Is the BuildInstruction’s state at WAITING_ON_DEPENDENCIES?

WAITING_ON_DEPENDENCIES indicates

the BuildInstruction is waiting for its dependencies to be satisfied before allowing modifications to proceed.

C++: protocols::forge::build::BuildInstruction::waiting_on_dependencies() const –> bool

class pyrosetta.rosetta.protocols.forge.build.SegmentRebuild

Bases: pyrosetta.rosetta.protocols.forge.build.BuildInstruction

instruction to rebuild a segment

Handles both cut based rebuilding (i.e. loops) and continuous

rebuilding adjacent to the boundary of a chain, such as n-term/c-term extensions.

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: pyrosetta.rosetta.protocols.forge.build.SegmentRebuild) -> None
2. __init__(self: pyrosetta.rosetta.protocols.forge.build.SegmentRebuild, arg0: pyrosetta.rosetta.protocols.forge.build.Interval, arg1: str) -> None

doc

3. __init__(self: pyrosetta.rosetta.protocols.forge.build.SegmentRebuild, arg0: pyrosetta.rosetta.protocols.forge.build.Interval, arg1: str, arg2: pyrosetta.rosetta.std.weak_ptr_const_core_chemical_ResidueTypeSet_t) -> None

doc

4. __init__(self: pyrosetta.rosetta.protocols.forge.build.SegmentRebuild, i: pyrosetta.rosetta.protocols.forge.build.Interval, ss: str, rts: pyrosetta.rosetta.std.weak_ptr_const_core_chemical_ResidueTypeSet_t, keep_known_bb_torsions_at_junctions: bool) -> None
5. __init__(self: pyrosetta.rosetta.protocols.forge.build.SegmentRebuild, arg0: pyrosetta.rosetta.protocols.forge.build.Interval, arg1: str, arg2: str) -> None

doc

6. __init__(self: pyrosetta.rosetta.protocols.forge.build.SegmentRebuild, arg0: pyrosetta.rosetta.protocols.forge.build.Interval, arg1: str, arg2: str, arg3: pyrosetta.rosetta.std.weak_ptr_const_core_chemical_ResidueTypeSet_t) -> None

doc

7. __init__(self: pyrosetta.rosetta.protocols.forge.build.SegmentRebuild, i: pyrosetta.rosetta.protocols.forge.build.Interval, ss: str, aa: str, rts: pyrosetta.rosetta.std.weak_ptr_const_core_chemical_ResidueTypeSet_t, keep_known_bb_torsions_at_junctions: bool) -> None
8. __init__(self: pyrosetta.rosetta.protocols.forge.build.SegmentRebuild, arg0: pyrosetta.rosetta.protocols.forge.build.SegmentRebuild) -> 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).

aa(self: pyrosetta.rosetta.protocols.forge.build.SegmentRebuild) → str

get annotated amino acid string

C++: protocols::forge::build::SegmentRebuild::aa() const –> const std::string &

add_dependency_to(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction, i: pyrosetta.rosetta.std.weak_ptr_const_protocols_forge_build_BuildInstruction_t) → None

add an instruction to this BuildInstruction’s dependency list

before this instruction’s modify() may complete properly, all

instructions in the dependency list must have completed modify() first

C++: protocols::forge::build::BuildInstruction::add_dependency_to(class std::weak_ptr<const class protocols::forge::build::BuildInstruction>) –> void

assign(self: pyrosetta.rosetta.protocols.forge.build.SegmentRebuild, rval: pyrosetta.rosetta.protocols.forge.build.SegmentRebuild) → pyrosetta.rosetta.protocols.forge.build.SegmentRebuild

copy assignment

C++: protocols::forge::build::SegmentRebuild::operator=(const class protocols::forge::build::SegmentRebuild &) –> class protocols::forge::build::SegmentRebuild &

attach_to(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction, pose: pyrosetta.rosetta.core.pose.Pose) → None

attach to a Pose’s conformation

C++: protocols::forge::build::BuildInstruction::attach_to(class core::pose::Pose &) –> void

clear_dependencies(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → None

clear the list of dependencies

C++: protocols::forge::build::BuildInstruction::clear_dependencies() –> void

clone(self: pyrosetta.rosetta.protocols.forge.build.SegmentRebuild) → pyrosetta.rosetta.protocols.forge.build.BuildInstruction

clone this object

C++: protocols::forge::build::SegmentRebuild::clone() const –> class std::shared_ptr<class protocols::forge::build::BuildInstruction>

compatible_with(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction, rval: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → bool

compares fixed and mutable positions to determine compatibility with

another instruction

override this to obtain custom compatibility check

C++: protocols::forge::build::BuildInstruction::compatible_with(const class protocols::forge::build::BuildInstruction &) const –> bool

creates_undefined_backbone(self: pyrosetta.rosetta.protocols.forge.build.SegmentRebuild) → bool

does this object create undefined backbone in the modified region?

true

C++: protocols::forge::build::SegmentRebuild::creates_undefined_backbone() const –> bool

defined_positions(self: pyrosetta.rosetta.protocols.forge.build.SegmentRebuild) → pyrosetta.rosetta.std.set_unsigned_long_t

return a copy of the set of positions within the newly modified

region that has a defined conformation. E.g. existing or copied residues.

An empty set – no positions are defined.

This set can change wrt length changes in Pose/Conformation being

watched.

C++: protocols::forge::build::SegmentRebuild::defined_positions() const –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

dependencies(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → pyrosetta.rosetta.utility.vector1_std_weak_ptr_const_protocols_forge_build_BuildInstruction_t

the list of instructions whose modify() must complete before

the modify() for this instruction may be called successfully

C++: protocols::forge::build::BuildInstruction::dependencies() const –> const class utility::vector1<class std::weak_ptr<const class protocols::forge::build::BuildInstruction>, class std::allocator<class std::weak_ptr<const class protocols::forge::build::BuildInstruction> > > &

dependent_on(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction, i: pyrosetta.rosetta.std.weak_ptr_const_protocols_forge_build_BuildInstruction_t) → bool

is this instruction dependent upon the given instruction?

C++: protocols::forge::build::BuildInstruction::dependent_on(class std::weak_ptr<const class protocols::forge::build::BuildInstruction>) const –> bool

detach_after_modify(*args, **kwargs)

Overloaded function.

1. detach_after_modify(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) -> bool

detach after modify()?

Ordinarily a modify() call consists of attaching as a

length obs of the Pose, actually doing the modify, and then detaching as a length obs of the Pose. This flag governs whether the last detach occurs.

C++: protocols::forge::build::BuildInstruction::detach_after_modify() const –> bool

2. detach_after_modify(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction, flag: bool) -> None

set detach after modify()

Ordinarily a modify() call consists of attaching as a

length obs of the Pose, actually doing the modify, and then detaching as a length obs of the Pose. This flag governs whether the last detach occurs.

C++: protocols::forge::build::BuildInstruction::detach_after_modify(const bool) –> void

detach_from(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → None

detach from a Pose’s conformation

C++: protocols::forge::build::BuildInstruction::detach_from() –> void

has_dependencies(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → bool

does this BuildInstruction have dependencies?

C++: protocols::forge::build::BuildInstruction::has_dependencies() const –> bool

interval(self: pyrosetta.rosetta.protocols.forge.build.SegmentRebuild) → pyrosetta.rosetta.protocols.forge.build.Interval

a copy of the working range of residues specifying the modified region

this can change if listening to Conformation LengthEvents

C++: protocols::forge::build::SegmentRebuild::interval() const –> struct protocols::forge::build::Interval

keep_known_bb_torsions_at_junctions(self: pyrosetta.rosetta.protocols.forge.build.SegmentRebuild) → bool

Attempt to keep the omega at original_interval().left-1, the phi

at original_interval().left and the psi+omega at original_interval().right present from the original Pose in the modified Pose? Default False

C++: protocols::forge::build::SegmentRebuild::keep_known_bb_torsions_at_junctions() const –> bool

modify(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction, pose: pyrosetta.rosetta.core.pose.Pose) → pyrosetta.rosetta.protocols.forge.build.BuildInstructionState.Enum

modify this pose

the state of the BuildInstruction

C++: protocols::forge::build::BuildInstruction::modify(class core::pose::Pose &) –> enum protocols::forge::build::BuildInstructionState::Enum

modify_was_successful(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → bool

Is the BuildInstruction’s state at MODIFY_WAS_SUCCESSFUL?

MODIFY_WAS_SUCCESSFUL indicates the BuildInstruction has

finished modifications to the Pose, and its residue indexing is now consistent with the newly modified Pose.

C++: protocols::forge::build::BuildInstruction::modify_was_successful() const –> bool

movemap(self: pyrosetta.rosetta.protocols.forge.build.SegmentRebuild) → pyrosetta.rosetta.core.kinematics.MoveMap

return a copy of the MoveMap that defines the moveable/fixed

positions/dofs for this instruction

a MoveMap with [interval.left, interval.right] bb & chi set to true

at the MoveMapTorsionID level

This set can change wrt length changes in Pose/Conformation being

watched.

C++: protocols::forge::build::SegmentRebuild::movemap() const –> class core::kinematics::MoveMap

n_dependencies(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → int

the number of dependencies this BuildInstruction has

C++: protocols::forge::build::BuildInstruction::n_dependencies() const –> unsigned long

new_positions(self: pyrosetta.rosetta.protocols.forge.build.SegmentRebuild) → pyrosetta.rosetta.std.set_unsigned_long_t

return a copy of the set of positions that are “new” and did

not exist in the original Pose.

A set of positions spanning the entire modified interval – all

positions are undefined.

C++: protocols::forge::build::SegmentRebuild::new_positions() const –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

on_length_change(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction, event: pyrosetta.rosetta.core.conformation.signals.LengthEvent) → None

update any indexing wrt length change to Pose/Conformation being watched

C++: protocols::forge::build::BuildInstruction::on_length_change(const struct core::conformation::signals::LengthEvent &) –> void

on_residue_append(self: pyrosetta.rosetta.protocols.forge.build.SegmentRebuild, event: pyrosetta.rosetta.core.conformation.signals.LengthEvent) → None

update indexing on residue append

C++: protocols::forge::build::SegmentRebuild::on_residue_append(const struct core::conformation::signals::LengthEvent &) –> void

on_residue_delete(self: pyrosetta.rosetta.protocols.forge.build.SegmentRebuild, event: pyrosetta.rosetta.core.conformation.signals.LengthEvent) → None

update indexing on residue delete

C++: protocols::forge::build::SegmentRebuild::on_residue_delete(const struct core::conformation::signals::LengthEvent &) –> void

on_residue_prepend(self: pyrosetta.rosetta.protocols.forge.build.SegmentRebuild, event: pyrosetta.rosetta.core.conformation.signals.LengthEvent) → None

update indexing on residue prepend

C++: protocols::forge::build::SegmentRebuild::on_residue_prepend(const struct core::conformation::signals::LengthEvent &) –> void

original_deleted_positions(self: pyrosetta.rosetta.protocols.forge.build.SegmentRebuild) → pyrosetta.rosetta.std.set_unsigned_long_t

return set of positions within the original interval that will

be deleted in this BuildInstruction

A set containing all positions in the original interval.

C++: protocols::forge::build::SegmentRebuild::original_deleted_positions() const –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

original_fixed_positions(self: pyrosetta.rosetta.protocols.forge.build.SegmentRebuild) → pyrosetta.rosetta.std.set_unsigned_long_t

return set of any fixed positions necessary with respect to the original

interval and original Pose numbering

Used for ensuring build regions for instructions do not overlap and

so that jumps may be placed correctly. If SegmentRebuild has dependencies, the set of positions shrinks from the endpoints of [original_left - 1, original_right + 1] down to an empty set in the assumption that the user is requesting an advanced feature and knows what they’re doing around the endpoints, e.g. rebuilding directly adjacent to a swapped out section.

empty set if no fixed positions

C++: protocols::forge::build::SegmentRebuild::original_fixed_positions() const –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

original_interval(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → pyrosetta.rosetta.protocols.forge.build.Interval

return original residue range of this instruction

C++: protocols::forge::build::BuildInstruction::original_interval() const –> const struct protocols::forge::build::Interval &

original_interval_valid(self: pyrosetta.rosetta.protocols.forge.build.SegmentRebuild) → bool

is the original interval storing valid information, or is empty

or being used for something else?

true, stores valid interval

C++: protocols::forge::build::SegmentRebuild::original_interval_valid() const –> bool

original_kept_positions(self: pyrosetta.rosetta.protocols.forge.build.SegmentRebuild) → pyrosetta.rosetta.std.set_unsigned_long_t

return the set of positions within the original interval that

will be kept in this BuildInstruction

An empty set – no positions are kept.

C++: protocols::forge::build::SegmentRebuild::original_kept_positions() const –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

original_mutable_positions(self: pyrosetta.rosetta.protocols.forge.build.SegmentRebuild) → pyrosetta.rosetta.std.set_unsigned_long_t

return set of any mutable positions necessary with respect to the original

interval and original Pose numbering

Used for ensuring build regions for instructions do not overlap and

so that jumps may be placed correctly.

empty set if no mutable positions

C++: protocols::forge::build::SegmentRebuild::original_mutable_positions() const –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

preexisting_positions(self: pyrosetta.rosetta.protocols.forge.build.SegmentRebuild) → pyrosetta.rosetta.std.set_unsigned_long_t

return a copy of the set of positions within the new region

that were pre-existing in the original Pose prior to modify()

An empty set – no positions are pre-existing.

C++: protocols::forge::build::SegmentRebuild::preexisting_positions() const –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

ready(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → bool

Is the BuildInstruction’s state at READY?

READY indicates the BuildInstruction has been reset

and is ready to modify a Pose.

C++: protocols::forge::build::BuildInstruction::ready() const –> bool

reset_accounting(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → None

reset intervals, positions, etc to initial state and drop

observers. State set to READY.

C++: protocols::forge::build::BuildInstruction::reset_accounting() –> void

residue_type_set(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → pyrosetta.rosetta.core.chemical.ResidueTypeSet

the residue type set being used

C++: protocols::forge::build::BuildInstruction::residue_type_set() const –> const class core::chemical::ResidueTypeSet &

ss(self: pyrosetta.rosetta.protocols.forge.build.SegmentRebuild) → str

get secondary structure string

C++: protocols::forge::build::SegmentRebuild::ss() const –> const std::string &

state(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → pyrosetta.rosetta.protocols.forge.build.BuildInstructionState.Enum

return the state of this BuildInstruction

C++: protocols::forge::build::BuildInstruction::state() const –> enum protocols::forge::build::BuildInstructionState::Enum

undefined_positions(self: pyrosetta.rosetta.protocols.forge.build.SegmentRebuild) → pyrosetta.rosetta.std.set_unsigned_long_t

return a copy of the set of positions within the newly modified

region that has an undefined conformation. E.g. newly created residues.

A set of positions spanning the entire modified interval – all

positions are undefined.

This set can change wrt length changes in Pose/Conformation being

watched.

C++: protocols::forge::build::SegmentRebuild::undefined_positions() const –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

waiting_on_dependencies(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → bool

Is the BuildInstruction’s state at WAITING_ON_DEPENDENCIES?

WAITING_ON_DEPENDENCIES indicates

the BuildInstruction is waiting for its dependencies to be satisfied before allowing modifications to proceed.

C++: protocols::forge::build::BuildInstruction::waiting_on_dependencies() const –> bool

class pyrosetta.rosetta.protocols.forge.build.SegmentSwap

Bases: pyrosetta.rosetta.protocols.forge.build.BuildInstruction

instruction to swap a segment with an external segment

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: pyrosetta.rosetta.protocols.forge.build.SegmentSwap) -> None
2. __init__(self: pyrosetta.rosetta.protocols.forge.build.SegmentSwap, i: pyrosetta.rosetta.protocols.forge.build.Interval, swap_in_movemap: pyrosetta.rosetta.core.kinematics.MoveMap, swap_in: pyrosetta.rosetta.core.pose.Pose) -> None
3. __init__(self: pyrosetta.rosetta.protocols.forge.build.SegmentSwap, arg0: pyrosetta.rosetta.protocols.forge.build.SegmentSwap) -> 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_dependency_to(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction, i: pyrosetta.rosetta.std.weak_ptr_const_protocols_forge_build_BuildInstruction_t) → None

add an instruction to this BuildInstruction’s dependency list

before this instruction’s modify() may complete properly, all

instructions in the dependency list must have completed modify() first

C++: protocols::forge::build::BuildInstruction::add_dependency_to(class std::weak_ptr<const class protocols::forge::build::BuildInstruction>) –> void

assign(self: pyrosetta.rosetta.protocols.forge.build.SegmentSwap, rval: pyrosetta.rosetta.protocols.forge.build.SegmentSwap) → pyrosetta.rosetta.protocols.forge.build.SegmentSwap

copy assignment

C++: protocols::forge::build::SegmentSwap::operator=(const class protocols::forge::build::SegmentSwap &) –> class protocols::forge::build::SegmentSwap &

attach_to(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction, pose: pyrosetta.rosetta.core.pose.Pose) → None

attach to a Pose’s conformation

C++: protocols::forge::build::BuildInstruction::attach_to(class core::pose::Pose &) –> void

clear_dependencies(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → None

clear the list of dependencies

C++: protocols::forge::build::BuildInstruction::clear_dependencies() –> void

clone(self: pyrosetta.rosetta.protocols.forge.build.SegmentSwap) → pyrosetta.rosetta.protocols.forge.build.BuildInstruction

clone this object

C++: protocols::forge::build::SegmentSwap::clone() const –> class std::shared_ptr<class protocols::forge::build::BuildInstruction>

compatible_with(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction, rval: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → bool

compares fixed and mutable positions to determine compatibility with

another instruction

override this to obtain custom compatibility check

C++: protocols::forge::build::BuildInstruction::compatible_with(const class protocols::forge::build::BuildInstruction &) const –> bool

creates_undefined_backbone(self: pyrosetta.rosetta.protocols.forge.build.SegmentSwap) → bool

does this object create undefined backbone in the modified region?

C++: protocols::forge::build::SegmentSwap::creates_undefined_backbone() const –> bool

defined_positions(self: pyrosetta.rosetta.protocols.forge.build.SegmentSwap) → pyrosetta.rosetta.std.set_unsigned_long_t

return a copy of the set of positions within the newly modified

region that has a defined conformation. E.g. existing or copied residues.

A set of positions spanning the interval – all positions are

are defined.

This set can change wrt length changes in Pose/Conformation being

watched.

C++: protocols::forge::build::SegmentSwap::defined_positions() const –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

dependencies(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → pyrosetta.rosetta.utility.vector1_std_weak_ptr_const_protocols_forge_build_BuildInstruction_t

the list of instructions whose modify() must complete before

the modify() for this instruction may be called successfully

C++: protocols::forge::build::BuildInstruction::dependencies() const –> const class utility::vector1<class std::weak_ptr<const class protocols::forge::build::BuildInstruction>, class std::allocator<class std::weak_ptr<const class protocols::forge::build::BuildInstruction> > > &

dependent_on(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction, i: pyrosetta.rosetta.std.weak_ptr_const_protocols_forge_build_BuildInstruction_t) → bool

is this instruction dependent upon the given instruction?

C++: protocols::forge::build::BuildInstruction::dependent_on(class std::weak_ptr<const class protocols::forge::build::BuildInstruction>) const –> bool

detach_after_modify(*args, **kwargs)

Overloaded function.

1. detach_after_modify(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) -> bool

detach after modify()?

Ordinarily a modify() call consists of attaching as a

length obs of the Pose, actually doing the modify, and then detaching as a length obs of the Pose. This flag governs whether the last detach occurs.

C++: protocols::forge::build::BuildInstruction::detach_after_modify() const –> bool

2. detach_after_modify(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction, flag: bool) -> None

set detach after modify()

Ordinarily a modify() call consists of attaching as a

length obs of the Pose, actually doing the modify, and then detaching as a length obs of the Pose. This flag governs whether the last detach occurs.

C++: protocols::forge::build::BuildInstruction::detach_after_modify(const bool) –> void

detach_from(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → None

detach from a Pose’s conformation

C++: protocols::forge::build::BuildInstruction::detach_from() –> void

has_dependencies(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → bool

does this BuildInstruction have dependencies?

C++: protocols::forge::build::BuildInstruction::has_dependencies() const –> bool

interval(self: pyrosetta.rosetta.protocols.forge.build.SegmentSwap) → pyrosetta.rosetta.protocols.forge.build.Interval

a copy of the working range of residues specifying the swapped region

This residue range can change wrt length changes in Pose /Conformation

being watched.

C++: protocols::forge::build::SegmentSwap::interval() const –> struct protocols::forge::build::Interval

modify(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction, pose: pyrosetta.rosetta.core.pose.Pose) → pyrosetta.rosetta.protocols.forge.build.BuildInstructionState.Enum

modify this pose

the state of the BuildInstruction

C++: protocols::forge::build::BuildInstruction::modify(class core::pose::Pose &) –> enum protocols::forge::build::BuildInstructionState::Enum

modify_was_successful(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → bool

Is the BuildInstruction’s state at MODIFY_WAS_SUCCESSFUL?

MODIFY_WAS_SUCCESSFUL indicates the BuildInstruction has

finished modifications to the Pose, and its residue indexing is now consistent with the newly modified Pose.

C++: protocols::forge::build::BuildInstruction::modify_was_successful() const –> bool

movemap(self: pyrosetta.rosetta.protocols.forge.build.SegmentSwap) → pyrosetta.rosetta.core.kinematics.MoveMap

return a copy of the MoveMap that defines the moveable/fixed

positions/dofs for this instruction

a MoveMap with [interval.left, interval.right] bb set to false

at the MoveMapTorsionID level

This set can change wrt length changes in Pose/Conformation being

watched.

C++: protocols::forge::build::SegmentSwap::movemap() const –> class core::kinematics::MoveMap

n_dependencies(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → int

the number of dependencies this BuildInstruction has

C++: protocols::forge::build::BuildInstruction::n_dependencies() const –> unsigned long

new_positions(self: pyrosetta.rosetta.protocols.forge.build.SegmentSwap) → pyrosetta.rosetta.std.set_unsigned_long_t

return a copy of the set of positions that are “new” and did

not exist in the original Pose.

A set of positions spanning the interval – all positions are

are defined.

C++: protocols::forge::build::SegmentSwap::new_positions() const –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

on_length_change(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction, event: pyrosetta.rosetta.core.conformation.signals.LengthEvent) → None

update any indexing wrt length change to Pose/Conformation being watched

C++: protocols::forge::build::BuildInstruction::on_length_change(const struct core::conformation::signals::LengthEvent &) –> void

on_residue_append(self: pyrosetta.rosetta.protocols.forge.build.SegmentSwap, event: pyrosetta.rosetta.core.conformation.signals.LengthEvent) → None

update indexing on residue append

C++: protocols::forge::build::SegmentSwap::on_residue_append(const struct core::conformation::signals::LengthEvent &) –> void

on_residue_delete(self: pyrosetta.rosetta.protocols.forge.build.SegmentSwap, event: pyrosetta.rosetta.core.conformation.signals.LengthEvent) → None

update indexing on residue delete

C++: protocols::forge::build::SegmentSwap::on_residue_delete(const struct core::conformation::signals::LengthEvent &) –> void

on_residue_prepend(self: pyrosetta.rosetta.protocols.forge.build.SegmentSwap, event: pyrosetta.rosetta.core.conformation.signals.LengthEvent) → None

update indexing on residue prepend

C++: protocols::forge::build::SegmentSwap::on_residue_prepend(const struct core::conformation::signals::LengthEvent &) –> void

original_deleted_positions(self: pyrosetta.rosetta.protocols.forge.build.SegmentSwap) → pyrosetta.rosetta.std.set_unsigned_long_t

return set of positions within the original interval that will

be deleted in this BuildInstruction

An empty set – no positions are deleted.

C++: protocols::forge::build::SegmentSwap::original_deleted_positions() const –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

original_fixed_positions(self: pyrosetta.rosetta.protocols.forge.build.SegmentSwap) → pyrosetta.rosetta.std.set_unsigned_long_t

return set of any fixed positions necessary with respect to the original

interval and original Pose numbering

Used for ensuring build regions for instructions do not overlap and

so that jumps may be placed correctly.

empty set if no fixed positions necessary

C++: protocols::forge::build::SegmentSwap::original_fixed_positions() const –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

original_interval(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → pyrosetta.rosetta.protocols.forge.build.Interval

return original residue range of this instruction

C++: protocols::forge::build::BuildInstruction::original_interval() const –> const struct protocols::forge::build::Interval &

original_interval_valid(self: pyrosetta.rosetta.protocols.forge.build.SegmentSwap) → bool

is the original interval storing valid information, or is empty

or being used for something else?

true, stores valid interval

C++: protocols::forge::build::SegmentSwap::original_interval_valid() const –> bool

original_kept_positions(self: pyrosetta.rosetta.protocols.forge.build.SegmentSwap) → pyrosetta.rosetta.std.set_unsigned_long_t

return the set of positions within the original interval that

will be kept in this BuildInstruction

An empty set – no positions are kept.

C++: protocols::forge::build::SegmentSwap::original_kept_positions() const –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

original_mutable_positions(self: pyrosetta.rosetta.protocols.forge.build.SegmentSwap) → pyrosetta.rosetta.std.set_unsigned_long_t

return set of any mutable positions necessary with respect to the original

interval and original Pose numbering

Used for ensuring build regions for instructions do not overlap and

so that jumps may be placed correctly.

C++: protocols::forge::build::SegmentSwap::original_mutable_positions() const –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

preexisting_positions(self: pyrosetta.rosetta.protocols.forge.build.SegmentSwap) → pyrosetta.rosetta.std.set_unsigned_long_t

return a copy of the set of positions within the new region

that were pre-existing in the original Pose prior to modify()

An empty set – no positions are pre-existing.

C++: protocols::forge::build::SegmentSwap::preexisting_positions() const –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

ready(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → bool

Is the BuildInstruction’s state at READY?

READY indicates the BuildInstruction has been reset

and is ready to modify a Pose.

C++: protocols::forge::build::BuildInstruction::ready() const –> bool

reset_accounting(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → None

reset intervals, positions, etc to initial state and drop

observers. State set to READY.

C++: protocols::forge::build::BuildInstruction::reset_accounting() –> void

residue_type_set(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → pyrosetta.rosetta.core.chemical.ResidueTypeSet

the residue type set being used

C++: protocols::forge::build::BuildInstruction::residue_type_set() const –> const class core::chemical::ResidueTypeSet &

state(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → pyrosetta.rosetta.protocols.forge.build.BuildInstructionState.Enum

return the state of this BuildInstruction

C++: protocols::forge::build::BuildInstruction::state() const –> enum protocols::forge::build::BuildInstructionState::Enum

swap_in(self: pyrosetta.rosetta.protocols.forge.build.SegmentSwap) → pyrosetta.rosetta.core.pose.Pose

the pose to swap in

C++: protocols::forge::build::SegmentSwap::swap_in() const –> const class core::pose::Pose &

swap_in_movemap(self: pyrosetta.rosetta.protocols.forge.build.SegmentSwap) → pyrosetta.rosetta.core.kinematics.MoveMap

fixed backbone residues in this movemap will be used for new jumps

Procedure will attempt to honor this movemap as much as it can.

The caveat is that sequences of calls to some FoldTree routines may shift the jumps internally in a way that is not easily predictable. If the procedure cannot find an allowed residue for a jump, it will make a jump to the (lower) median residue in the disconnected fold tree interval.

C++: protocols::forge::build::SegmentSwap::swap_in_movemap() const –> const class core::kinematics::MoveMap &

undefined_positions(self: pyrosetta.rosetta.protocols.forge.build.SegmentSwap) → pyrosetta.rosetta.std.set_unsigned_long_t

return a copy of the set of positions within the newly modified

region that has an undefined conformation. E.g. newly created residues.

An empty set – no undefined positions.

This set can change wrt length changes in Pose/Conformation being

watched.

C++: protocols::forge::build::SegmentSwap::undefined_positions() const –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

waiting_on_dependencies(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → bool

Is the BuildInstruction’s state at WAITING_ON_DEPENDENCIES?

WAITING_ON_DEPENDENCIES indicates

the BuildInstruction is waiting for its dependencies to be satisfied before allowing modifications to proceed.

C++: protocols::forge::build::BuildInstruction::waiting_on_dependencies() const –> bool