sequence¶

Bindings for core::sequence namespace

class pyrosetta.rosetta.core.sequence.ABEGO¶

Bases: pybind11_builtins.pybind11_object

abego elments

__delattr__¶: Implement delattr(self, name).

__dir__() → list¶: default dir() implementation

__eq__¶: Return self==value.

__format__()¶: default object formatter

__ge__¶: Return self>=value.

__getattribute__¶: Return getattr(self, name).

__gt__¶: Return self>value.

__hash__¶: Return hash(self).

__init__(*args, **kwargs)¶

Overloaded function.

__init__(self: pyrosetta.rosetta.core.sequence.ABEGO) -> None
__init__(self: pyrosetta.rosetta.core.sequence.ABEGO, name: str, phi_min: float, phi_max: float, psi_min: float, psi_max: float, cis_omega: bool) -> 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_line(self: pyrosetta.rosetta.core.sequence.ABEGO, slope: float, intercept: float, region: bool) → None¶: C++: core::sequence::ABEGO::add_line(const double, const double, const bool) –> void

check_rama(self: pyrosetta.rosetta.core.sequence.ABEGO, phi: float, psi: float, omega: float) → bool¶

check input torsion angle are in a given abego region

C++: core::sequence::ABEGO::check_rama(const double &, const double &, const double &) –> bool

check_rama2(self: pyrosetta.rosetta.core.sequence.ABEGO, phi: float, psi: float) → bool¶

check input torsion angle are in a given abego region

C++: core::sequence::ABEGO::check_rama2(const double &, const double &) –> bool

cis_omega(self: pyrosetta.rosetta.core.sequence.ABEGO) → bool¶: C++: core::sequence::ABEGO::cis_omega() –> bool

name(self: pyrosetta.rosetta.core.sequence.ABEGO) → str¶: C++: core::sequence::ABEGO::name() –> char

phi_max(self: pyrosetta.rosetta.core.sequence.ABEGO) → float¶: C++: core::sequence::ABEGO::phi_max() –> double

phi_min(self: pyrosetta.rosetta.core.sequence.ABEGO) → float¶: C++: core::sequence::ABEGO::phi_min() –> double

psi_max(self: pyrosetta.rosetta.core.sequence.ABEGO) → float¶: C++: core::sequence::ABEGO::psi_max() –> double

psi_min(self: pyrosetta.rosetta.core.sequence.ABEGO) → float¶: C++: core::sequence::ABEGO::psi_min() –> double

class pyrosetta.rosetta.core.sequence.ABEGOManager¶

Bases: pybind11_builtins.pybind11_object

manager for abego

__delattr__¶: Implement delattr(self, name).

__dir__() → list¶: default dir() implementation

__eq__¶: Return self==value.

__format__()¶: default object formatter

__ge__¶: Return self>=value.

__getattribute__¶: Return getattr(self, name).

__gt__¶: Return self>value.

__hash__¶: Return hash(self).

__init__(*args, **kwargs)¶

Overloaded function.

__init__(self: pyrosetta.rosetta.core.sequence.ABEGOManager) -> None
__init__(self: pyrosetta.rosetta.core.sequence.ABEGOManager, arg0: pyrosetta.rosetta.core.sequence.ABEGOManager) -> 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).

alllevel(self: pyrosetta.rosetta.core.sequence.ABEGOManager) → int¶

all output level in current setup

C++: core::sequence::ABEGOManager::alllevel() –> unsigned long

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

base5index2symbolString(self: pyrosetta.rosetta.core.sequence.ABEGOManager, base5index: int, length: int) → str¶

transform abego string to abego base5 index

C++: core::sequence::ABEGOManager::base5index2symbolString(unsigned long, unsigned long) –> std::string

check_rama(self: pyrosetta.rosetta.core.sequence.ABEGOManager, symbol: str, phi: float, psi: float, omega: float) → bool¶

check input torsion angle are in a given abego region

C++: core::sequence::ABEGOManager::check_rama(const char &, const double &, const double &, const double &) –> bool

get_abego_string(self: pyrosetta.rosetta.core.sequence.ABEGOManager, abego: pyrosetta.rosetta.utility.vector1_std_string) → str¶

get abego string

C++: core::sequence::ABEGOManager::get_abego_string(class utility::vector1<class std::basic_string<char>, class std::allocator<class std::basic_string<char> > >) –> std::string

get_symbols(*args, **kwargs)¶

Overloaded function.

get_symbols(self: pyrosetta.rosetta.core.sequence.ABEGOManager, pose: pyrosetta.rosetta.core.pose.Pose) -> pyrosetta.rosetta.utility.vector1_std_string
get_symbols(self: pyrosetta.rosetta.core.sequence.ABEGOManager, pose: pyrosetta.rosetta.core.pose.Pose, level: int) -> pyrosetta.rosetta.utility.vector1_std_string

get abego sequence from pose

C++: core::sequence::ABEGOManager::get_symbols(const class core::pose::Pose &, const unsigned long) –> class utility::vector1<std::string, class std::allocator<std::string > >

get_symbols(self: pyrosetta.rosetta.core.sequence.ABEGOManager, pose: pyrosetta.rosetta.core.pose.Pose, begin: int, end: int, level: int) -> pyrosetta.rosetta.utility.vector1_std_string

get abego sequence from pose

C++: core::sequence::ABEGOManager::get_symbols(const class core::pose::Pose &, const unsigned long, const unsigned long, const unsigned long) –> class utility::vector1<std::string, class std::allocator<std::string > >

index2symbol(self: pyrosetta.rosetta.core.sequence.ABEGOManager, idx: int) → str¶

transform abego index to symbol

C++: core::sequence::ABEGOManager::index2symbol(const unsigned long &) –> char

initialize(self: pyrosetta.rosetta.core.sequence.ABEGOManager) → None¶

initialize

C++: core::sequence::ABEGOManager::initialize() –> void

symbol2index(self: pyrosetta.rosetta.core.sequence.ABEGOManager, symbol: str) → int¶

transform abego symbol to index

C++: core::sequence::ABEGOManager::symbol2index(const char &) –> unsigned long

symbolString2base5index(self: pyrosetta.rosetta.core.sequence.ABEGOManager, symbolString: str) → int¶

transform abego symbol string to base5 index

C++: core::sequence::ABEGOManager::symbolString2base5index(class std::basic_string<char>) –> unsigned long

torsion2index(*args, **kwargs)¶

Overloaded function.

torsion2index(self: pyrosetta.rosetta.core.sequence.ABEGOManager, phi: float, psi: float, omega: float) -> int
torsion2index(self: pyrosetta.rosetta.core.sequence.ABEGOManager, phi: float, psi: float, omega: float, level: int) -> int

get abego index from torsion angles

C++: core::sequence::ABEGOManager::torsion2index(const double, const double, const double, const unsigned long) –> unsigned long

torsion2index_level1(self: pyrosetta.rosetta.core.sequence.ABEGOManager, phi: float, psi: float, omega: float) → int¶

get abego index from torsion angles at level 1

C++: core::sequence::ABEGOManager::torsion2index_level1(const double, const double, const double) –> unsigned long

torsion2index_level2(self: pyrosetta.rosetta.core.sequence.ABEGOManager, phi: float, psi: float, omega: float) → int¶

get abego index from torsion angles at level 2

C++: core::sequence::ABEGOManager::torsion2index_level2(const double, const double, const double) –> unsigned long

torsion2index_level3(self: pyrosetta.rosetta.core.sequence.ABEGOManager, phi: float, psi: float, omega: float) → int¶

get abego index from torsion angles at level 3

C++: core::sequence::ABEGOManager::torsion2index_level3(const double, const double, const double) –> unsigned long

torsion2index_level4(self: pyrosetta.rosetta.core.sequence.ABEGOManager, phi: float, psi: float, omega: float) → int¶

get abego index from torsion angles at level 3

C++: core::sequence::ABEGOManager::torsion2index_level4(const double, const double, const double) –> unsigned long

total_number_abego(self: pyrosetta.rosetta.core.sequence.ABEGOManager) → int¶

total number of abego definition

C++: core::sequence::ABEGOManager::total_number_abego() –> unsigned long

class pyrosetta.rosetta.core.sequence.DerivedSequenceMapping¶

Bases: pyrosetta.rosetta.core.id.SequenceMapping

This is quite possibly the laziest form of class naming ever. What does the name of this class tell you about it? It’s a SequenceMapping, and it’s derived from SequenceMapping. Oops, it said it twice. What is different about this sequence mapping from the parent class? Who knows! When should you use it? Who knows!</snark>

__delattr__¶: Implement delattr(self, name).

__dir__() → list¶: default dir() implementation

__eq__(self: pyrosetta.rosetta.core.sequence.DerivedSequenceMapping, rhs: pyrosetta.rosetta.core.id.SequenceMapping) → bool¶: C++: core::sequence::DerivedSequenceMapping::operator==(const class core::id::SequenceMapping &) const –> bool

__format__()¶: default object formatter

__ge__¶: Return self>=value.

__getattribute__¶: Return getattr(self, name).

__getitem__(self: pyrosetta.rosetta.core.id.SequenceMapping, pos1: int) → int¶: C++: core::id::SequenceMapping::operator[](const unsigned long) –> unsigned long &

__gt__¶: Return self>value.

__hash__¶: Return hash(self).

__init__(*args, **kwargs)¶

Overloaded function.

__init__(self: pyrosetta.rosetta.core.sequence.DerivedSequenceMapping) -> None
__init__(self: pyrosetta.rosetta.core.sequence.DerivedSequenceMapping, s1: int, s2: int) -> None
__init__(self: pyrosetta.rosetta.core.sequence.DerivedSequenceMapping, arg0: pyrosetta.rosetta.core.sequence.DerivedSequenceMapping) -> None

__init_subclass__()¶

This method is called when a class is subclassed.

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

__le__¶: Return self<=value.

__lt__¶: Return self<value.

__ne__¶: Return self!=value.

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

__reduce__()¶: helper for pickle

__reduce_ex__()¶: helper for pickle

__repr__¶: Return repr(self).

__setattr__¶: Implement setattr(self, name, value).

__sizeof__() → int¶: size of object in memory, in bytes

__str__(self: pyrosetta.rosetta.core.id.SequenceMapping) → str¶

__subclasshook__()¶

Abstract classes can override this to customize issubclass().

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

all_aligned(self: pyrosetta.rosetta.core.id.SequenceMapping) → bool¶: C++: core::id::SequenceMapping::all_aligned() const –> bool

assign(self: pyrosetta.rosetta.core.sequence.DerivedSequenceMapping, src: pyrosetta.rosetta.core.sequence.DerivedSequenceMapping) → pyrosetta.rosetta.core.sequence.DerivedSequenceMapping¶: C++: core::sequence::DerivedSequenceMapping::operator=(const class core::sequence::DerivedSequenceMapping &) –> class core::sequence::DerivedSequenceMapping &

clear(self: pyrosetta.rosetta.core.id.SequenceMapping) → None¶: C++: core::id::SequenceMapping::clear() –> void

delete_source_residue(self: pyrosetta.rosetta.core.id.SequenceMapping, pos1: int) → None¶: C++: core::id::SequenceMapping::delete_source_residue(const unsigned long) –> void

delete_target_residue(self: pyrosetta.rosetta.core.id.SequenceMapping, pos: int) → None¶: C++: core::id::SequenceMapping::delete_target_residue(const unsigned long) –> void

downstream_combine(self: pyrosetta.rosetta.core.id.SequenceMapping, smap_to_add: pyrosetta.rosetta.core.id.SequenceMapping) → None¶

Apply a B->C mapping to the current A->B mapping to get an A->C mapping: i.e. smap[j] becomes smap_to_add[ smap[j] ]

C++: core::id::SequenceMapping::downstream_combine(const class core::id::SequenceMapping &) –> void

get_corresponding_residue_in_current(self: pyrosetta.rosetta.core.id.SequenceMapping, original_resnum: int) → int¶

A->B; Get the corresponding (new) resnum (B) from the old (A).

C++: core::id::SequenceMapping::get_corresponding_residue_in_current(unsigned long) const –> unsigned long

identity(size: int) → pyrosetta.rosetta.core.id.SequenceMapping¶

Construct an identity mapping, which means that for all positions,: i in seq1 maps to i in seq2.

C++: core::id::SequenceMapping::identity(const unsigned long) –> class core::id::SequenceMapping

insert_aligned_residue(self: pyrosetta.rosetta.core.id.SequenceMapping, pos1: int, pos2: int) → None¶: C++: core::id::SequenceMapping::insert_aligned_residue(const unsigned long, const unsigned long) –> void

insert_aligned_residue_safe(self: pyrosetta.rosetta.core.id.SequenceMapping, pos1: int, pos2: int) → None¶

same as insert_aligned_residue, but a couple of extra checks on size1 and size2.

C++: core::id::SequenceMapping::insert_aligned_residue_safe(const unsigned long, const unsigned long) –> void

insert_source_residue(self: pyrosetta.rosetta.core.id.SequenceMapping, pos1: int) → None¶: C++: core::id::SequenceMapping::insert_source_residue(const unsigned long) –> void

insert_target_residue(self: pyrosetta.rosetta.core.id.SequenceMapping, pos: int) → None¶: C++: core::id::SequenceMapping::insert_target_residue(const unsigned long) –> void

is_identity(self: pyrosetta.rosetta.core.id.SequenceMapping) → bool¶: C++: core::id::SequenceMapping::is_identity() const –> bool

is_identity_ignore_gaps(self: pyrosetta.rosetta.core.id.SequenceMapping) → bool¶: C++: core::id::SequenceMapping::is_identity_ignore_gaps() const –> bool

mapping(*args, **kwargs)¶

Overloaded function.

mapping(self: pyrosetta.rosetta.core.id.SequenceMapping) -> pyrosetta.rosetta.utility.vector1_unsigned_long

C++: core::id::SequenceMapping::mapping() const –> const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &

mapping(self: pyrosetta.rosetta.core.id.SequenceMapping, mapping: pyrosetta.rosetta.utility.vector1_unsigned_long) -> None

C++: core::id::SequenceMapping::mapping(const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &) –> void

push_back(self: pyrosetta.rosetta.core.id.SequenceMapping, al: int) → None¶: C++: core::id::SequenceMapping::push_back(const unsigned long) –> void

resize(self: pyrosetta.rosetta.core.id.SequenceMapping, s1: int, s2: int) → None¶

resize

C++: core::id::SequenceMapping::resize(const unsigned long, const unsigned long) –> void

reverse(self: pyrosetta.rosetta.core.id.SequenceMapping) → None¶

go from an A->B mapping to a B->A mapping

C++: core::id::SequenceMapping::reverse() –> void

same_type_as_me(self: pyrosetta.rosetta.core.sequence.DerivedSequenceMapping, other: pyrosetta.rosetta.core.id.SequenceMapping) → bool¶: C++: core::sequence::DerivedSequenceMapping::same_type_as_me(const class core::id::SequenceMapping &) const –> bool

seq1(*args, **kwargs)¶

Overloaded function.

seq1(self: pyrosetta.rosetta.core.sequence.DerivedSequenceMapping) -> str

C++: core::sequence::DerivedSequenceMapping::seq1() –> std::string &

seq1(self: pyrosetta.rosetta.core.sequence.DerivedSequenceMapping, s: str) -> None

C++: core::sequence::DerivedSequenceMapping::seq1(const class std::basic_string<char> &) –> void

seq2(*args, **kwargs)¶

Overloaded function.

seq2(self: pyrosetta.rosetta.core.sequence.DerivedSequenceMapping) -> str

C++: core::sequence::DerivedSequenceMapping::seq2() –> std::string &

seq2(self: pyrosetta.rosetta.core.sequence.DerivedSequenceMapping, s: str) -> None

C++: core::sequence::DerivedSequenceMapping::seq2(const class std::basic_string<char> &) –> void

set_offset(self: pyrosetta.rosetta.core.id.SequenceMapping, setting: int) → None¶: C++: core::id::SequenceMapping::set_offset(int) –> void

show(*args, **kwargs)¶

Overloaded function.

show(self: pyrosetta.rosetta.core.id.SequenceMapping) -> None

C++: core::id::SequenceMapping::show() const –> void

show(self: pyrosetta.rosetta.core.id.SequenceMapping, output: pyrosetta.rosetta.std.ostream) -> None

C++: core::id::SequenceMapping::show(class std::basic_ostream<char> &) const –> void

size1(self: pyrosetta.rosetta.core.id.SequenceMapping) → int¶

size of target sequence

C++: core::id::SequenceMapping::size1() const –> unsigned long

size2(*args, **kwargs)¶

Overloaded function.

size2(self: pyrosetta.rosetta.core.id.SequenceMapping) -> int

size of aligned sequence ???

C++: core::id::SequenceMapping::size2() const –> unsigned long

size2(self: pyrosetta.rosetta.core.id.SequenceMapping, s2: int) -> None

C++: core::id::SequenceMapping::size2(const unsigned long) –> void

start_seq2(*args, **kwargs)¶

Overloaded function.

start_seq2(self: pyrosetta.rosetta.core.sequence.DerivedSequenceMapping) -> int

C++: core::sequence::DerivedSequenceMapping::start_seq2() const –> const unsigned long &

start_seq2(self: pyrosetta.rosetta.core.sequence.DerivedSequenceMapping, s: int) -> None

C++: core::sequence::DerivedSequenceMapping::start_seq2(unsigned long) –> void

to_string(self: pyrosetta.rosetta.core.id.SequenceMapping) → str¶: C++: core::id::SequenceMapping::to_string() const –> std::string

upstream_combine(self: pyrosetta.rosetta.core.id.SequenceMapping, smap_to_add: pyrosetta.rosetta.core.id.SequenceMapping) → None¶

Apply a C->A mapping to the current A->B mapping to get a C->B mapping: i.e. smap[j] becomes smap[ smap_to_add[ j ] ]

C++: core::id::SequenceMapping::upstream_combine(const class core::id::SequenceMapping &) –> void

class pyrosetta.rosetta.core.sequence.Line¶

Bases: pybind11_builtins.pybind11_object

struct

__delattr__¶: Implement delattr(self, name).

__dir__() → list¶: default dir() implementation

__eq__¶: Return self==value.

__format__()¶: default object formatter

__ge__¶: Return self>=value.

__getattribute__¶: Return getattr(self, name).

__gt__¶: Return self>value.

__hash__¶: Return hash(self).

__init__(*args, **kwargs)¶

Overloaded function.

__init__(self: pyrosetta.rosetta.core.sequence.Line) -> None
__init__(self: pyrosetta.rosetta.core.sequence.Line, r1: float, r2: float, b: bool) -> None
__init__(self: pyrosetta.rosetta.core.sequence.Line, arg0: pyrosetta.rosetta.core.sequence.Line) -> None

__init_subclass__()¶

This method is called when a class is subclassed.

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

__le__¶: Return self<=value.

__lt__¶: Return self<value.

__ne__¶: Return self!=value.

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

__reduce__()¶: helper for pickle

__reduce_ex__()¶: helper for pickle

__repr__¶: Return repr(self).

__setattr__¶: Implement setattr(self, name, value).

__sizeof__() → int¶: size of object in memory, in bytes

__str__¶: Return str(self).

__subclasshook__()¶

Abstract classes can override this to customize issubclass().

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

assign(self: pyrosetta.rosetta.core.sequence.Line, rval: pyrosetta.rosetta.core.sequence.Line) → pyrosetta.rosetta.core.sequence.Line¶

copy assignment

C++: core::sequence::Line::operator=(const struct core::sequence::Line &) –> struct core::sequence::Line &

class pyrosetta.rosetta.core.sequence.SSManager¶

Bases: pybind11_builtins.pybind11_object

manager for abego

__delattr__¶: Implement delattr(self, name).

__dir__() → list¶: default dir() implementation

__eq__¶: Return self==value.

__format__()¶: default object formatter

__ge__¶: Return self>=value.

__getattribute__¶: Return getattr(self, name).

__gt__¶: Return self>value.

__hash__¶: Return hash(self).

__init__(self: pyrosetta.rosetta.core.sequence.SSManager) → None¶

__init_subclass__()¶

This method is called when a class is subclassed.

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

__le__¶: Return self<=value.

__lt__¶: Return self<value.

__ne__¶: Return self!=value.

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

__reduce__()¶: helper for pickle

__reduce_ex__()¶: helper for pickle

__repr__¶: Return repr(self).

__setattr__¶: Implement setattr(self, name, value).

__sizeof__() → int¶: size of object in memory, in bytes

__str__¶: Return str(self).

__subclasshook__()¶

Abstract classes can override this to customize issubclass().

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

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

index2symbol(self: pyrosetta.rosetta.core.sequence.SSManager, idx: int) → str¶

transform abego index to symbol

C++: core::sequence::SSManager::index2symbol(const unsigned long &) –> char

index2symbolString(self: pyrosetta.rosetta.core.sequence.SSManager, base5index: int, length: int) → str¶

transform abego string to abego base5 index

C++: core::sequence::SSManager::index2symbolString(unsigned long, unsigned long) –> std::string

symbol2index(self: pyrosetta.rosetta.core.sequence.SSManager, symbol: str) → int¶

transform abego symbol to index

C++: core::sequence::SSManager::symbol2index(const char &) –> unsigned long

symbolString2index(self: pyrosetta.rosetta.core.sequence.SSManager, symbolString: str) → int¶

transform abego symbol string to base5 index

C++: core::sequence::SSManager::symbolString2index(class std::basic_string<char>) –> unsigned long

class pyrosetta.rosetta.core.sequence.SequenceAlignmentHasher¶

Bases: pyrosetta.rosetta.std.unary_function_core_sequence_SequenceAlignment_unsigned_long_t

Allows SequenceAlignment’s to be used as keys in unordered_{set|map}.

__call__(self: pyrosetta.rosetta.core.sequence.SequenceAlignmentHasher, alignment: pyrosetta.rosetta.core.sequence.SequenceAlignment) → int¶: C++: core::sequence::SequenceAlignmentHasher::operator()(const class core::sequence::SequenceAlignment &) 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__(self: pyrosetta.rosetta.core.sequence.SequenceAlignmentHasher) → 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).

class pyrosetta.rosetta.core.sequence.SequenceCreator¶

Bases: pybind11_builtins.pybind11_object

Abstract base class for a Mover factory; the Creator class is responsible for creating a particular mover class.

__delattr__¶: Implement delattr(self, name).

__dir__() → list¶: default dir() implementation

__eq__¶: Return self==value.

__format__()¶: default object formatter

__ge__¶: Return self>=value.

__getattribute__¶: Return getattr(self, name).

__gt__¶: Return self>value.

__hash__¶: Return hash(self).

__init__(self: pyrosetta.rosetta.core.sequence.SequenceCreator) → None¶

__init_subclass__()¶

This method is called when a class is subclassed.

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

__le__¶: Return self<=value.

__lt__¶: Return self<value.

__ne__¶: Return self!=value.

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

__reduce__()¶: helper for pickle

__reduce_ex__()¶: helper for pickle

__repr__¶: Return repr(self).

__setattr__¶: Implement setattr(self, name, value).

__sizeof__() → int¶: size of object in memory, in bytes

__str__¶: Return str(self).

__subclasshook__()¶

Abstract classes can override this to customize issubclass().

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

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

create_sequence(self: pyrosetta.rosetta.core.sequence.SequenceCreator) → pyrosetta.rosetta.core.sequence.Sequence¶: C++: core::sequence::SequenceCreator::create_sequence() const –> class std::shared_ptr<class core::sequence::Sequence>

keyname(self: pyrosetta.rosetta.core.sequence.SequenceCreator) → str¶: C++: core::sequence::SequenceCreator::keyname() const –> std::string

pyrosetta.rosetta.core.sequence.align_naive(seq1: pyrosetta.rosetta.core.sequence.Sequence, seq2: pyrosetta.rosetta.core.sequence.Sequence) → pyrosetta.rosetta.core.sequence.SequenceAlignment¶

Generate a naive sequence alignment between two sequences.

C++: core::sequence::align_naive(class std::shared_ptr<class core::sequence::Sequence>, class std::shared_ptr<class core::sequence::Sequence>) –> class core::sequence::SequenceAlignment

pyrosetta.rosetta.core.sequence.align_poses_naive(pose1: pyrosetta.rosetta.core.pose.Pose, pose2: pyrosetta.rosetta.core.pose.Pose) → pyrosetta.rosetta.core.sequence.SequenceAlignment¶: C++: core::sequence::align_poses_naive(class core::pose::Pose &, class core::pose::Pose &) –> class core::sequence::SequenceAlignment

pyrosetta.rosetta.core.sequence.alignment_from_pose(pose: pyrosetta.rosetta.core.pose.Pose) → pyrosetta.rosetta.core.sequence.SequenceAlignment¶: C++: core::sequence::alignment_from_pose(class core::pose::Pose &) –> class core::sequence::SequenceAlignment

pyrosetta.rosetta.core.sequence.alignment_into_pose(aln: pyrosetta.rosetta.core.sequence.SequenceAlignment, pose: pyrosetta.rosetta.core.pose.Pose) → None¶: C++: core::sequence::alignment_into_pose(const class core::sequence::SequenceAlignment &, class core::pose::Pose &) –> void

pyrosetta.rosetta.core.sequence.calpha_superimpose_with_mapping(mod_pose: pyrosetta.rosetta.core.pose.Pose, ref_pose: pyrosetta.rosetta.core.pose.Pose, mapping: pyrosetta.rosetta.core.id.SequenceMapping) → float¶: C++: core::sequence::calpha_superimpose_with_mapping(class core::pose::Pose &, const class core::pose::Pose &, const class core::id::SequenceMapping &) –> double

pyrosetta.rosetta.core.sequence.get_abego(*args, **kwargs)¶

Overloaded function.

get_abego(pose: pyrosetta.rosetta.core.pose.Pose) -> pyrosetta.rosetta.utility.vector1_std_string
get_abego(pose: pyrosetta.rosetta.core.pose.Pose, level: int) -> pyrosetta.rosetta.utility.vector1_std_string

utility for getting abego

C++: core::sequence::get_abego(const class core::pose::Pose &, const unsigned long) –> class utility::vector1<std::string, class std::allocator<std::string > >

pyrosetta.rosetta.core.sequence.get_maximum_scores(ss: pyrosetta.rosetta.core.sequence.ScoringScheme, seq: pyrosetta.rosetta.core.sequence.Sequence) → pyrosetta.rosetta.utility.vector1_double¶: C++: core::sequence::get_maximum_scores(class std::shared_ptr<class core::sequence::ScoringScheme>, class std::shared_ptr<class core::sequence::Sequence>) –> class utility::vector1<double, class std::allocator<double> >

pyrosetta.rosetta.core.sequence.map_seq1_seq2(seq1: pyrosetta.rosetta.core.sequence.Sequence, seq2: pyrosetta.rosetta.core.sequence.Sequence) → pyrosetta.rosetta.core.id.SequenceMapping¶

Generates a mapping of sequence 1 onto sequence 2 using dynamic: programming with a simple scoring framework.

C++: core::sequence::map_seq1_seq2(class std::shared_ptr<class core::sequence::Sequence>, class std::shared_ptr<class core::sequence::Sequence>) –> class core::id::SequenceMapping

pyrosetta.rosetta.core.sequence.mapping_to_alignment(mapping: pyrosetta.rosetta.core.id.SequenceMapping, seq1: pyrosetta.rosetta.core.sequence.Sequence, seq2: pyrosetta.rosetta.core.sequence.Sequence) → pyrosetta.rosetta.core.sequence.SequenceAlignment¶

Constructs a SequenceAlignment from the given SequenceMapping and: the two sequences.

C++: core::sequence::mapping_to_alignment(const class core::id::SequenceMapping &, class std::shared_ptr<class core::sequence::Sequence>, class std::shared_ptr<class core::sequence::Sequence>) –> class core::sequence::SequenceAlignment

pyrosetta.rosetta.core.sequence.n_correctly_aligned_positions(candidate_aln: pyrosetta.rosetta.core.sequence.SequenceAlignment, true_aln: pyrosetta.rosetta.core.sequence.SequenceAlignment) → int¶: C++: core::sequence::n_correctly_aligned_positions(class core::sequence::SequenceAlignment &, class core::sequence::SequenceAlignment &) –> unsigned long

pyrosetta.rosetta.core.sequence.parse_out_non_standard_residues(*args, **kwargs)¶

Overloaded function.

parse_out_non_standard_residues(fasta_sequences: pyrosetta.rosetta.utility.vector1_std_shared_ptr_core_sequence_Sequence_t) -> pyrosetta.rosetta.std.map_unsigned_long_std_string

C++: core::sequence::parse_out_non_standard_residues(class utility::vector1<class std::shared_ptr<class core::sequence::Sequence>, class std::allocator<class std::shared_ptr<class core::sequence::Sequence> > > &) –> class std::map<unsigned long, std::string, struct std::less<unsigned long>, class std::allocator<struct std::pair<const unsigned long, std::string > > >

parse_out_non_standard_residues(sequence: str) -> pyrosetta.rosetta.std.map_unsigned_long_std_string

C++: core::sequence::parse_out_non_standard_residues(class std::basic_string<char> &) –> class std::map<unsigned long, std::string, struct std::less<unsigned long>, class std::allocator<struct std::pair<const unsigned long, std::string > > >

pyrosetta.rosetta.core.sequence.read_alignment_file(filename: str, seq1: str, seq2: str, mapping: pyrosetta.rosetta.core.sequence.DerivedSequenceMapping) → None¶

helper function for reading a SequenceMapping from an alignment: file.

C++: core::sequence::read_alignment_file(const class std::basic_string<char> &, class std::basic_string<char> &, class std::basic_string<char> &, class core::sequence::DerivedSequenceMapping &) –> void

pyrosetta.rosetta.core.sequence.read_all_alignments(format: str, files: pyrosetta.rosetta.utility.vector1_std_string, alignments: pyrosetta.rosetta.utility.vector1_core_sequence_SequenceAlignment) → None¶

Populates the non-null vector <alignments> with all of the sequence: alignments found in <files>. Each alignment is required to have format <format>.

C++: core::sequence::read_all_alignments(const class std::basic_string<char> &, const class utility::vector1<class std::basic_string<char>, class std::allocator<class std::basic_string<char> > > &, class utility::vector1<class core::sequence::SequenceAlignment, class std::allocator<class core::sequence::SequenceAlignment> > &) –> void

pyrosetta.rosetta.core.sequence.read_aln(format: str, filename: str) → pyrosetta.rosetta.utility.vector1_core_sequence_SequenceAlignment¶: C++: core::sequence::read_aln(const class std::basic_string<char> &, const class std::basic_string<char> &) –> class utility::vector1<class core::sequence::SequenceAlignment, class std::allocator<class core::sequence::SequenceAlignment> >

pyrosetta.rosetta.core.sequence.read_fasta_file(filename: str) → pyrosetta.rosetta.utility.vector1_std_shared_ptr_core_sequence_Sequence_t¶

Read in sequences from a fasta-formatted file.

C++: core::sequence::read_fasta_file(const class std::basic_string<char> &) –> class utility::vector1<class std::shared_ptr<class core::sequence::Sequence>, class std::allocator<class std::shared_ptr<class core::sequence::Sequence> > >

pyrosetta.rosetta.core.sequence.read_fasta_file_and_concatenate(filename: str) → str¶

Read fasta file and concatenate sequences

C++: core::sequence::read_fasta_file_and_concatenate(const class std::basic_string<char> &) –> std::string

pyrosetta.rosetta.core.sequence.read_fasta_file_return_str(filename: str) → str¶: C++: core::sequence::read_fasta_file_return_str(const class std::basic_string<char> &) –> std::string

pyrosetta.rosetta.core.sequence.read_fasta_file_section(filename: str, section: str) → str¶

read sequence from particular section of fasta file (comment starting with ‘> section’), terminate with failure if section not found: Note: section detection string is case insensitive

C++: core::sequence::read_fasta_file_section(const class std::basic_string<char> &, const class std::basic_string<char> &) –> std::string

pyrosetta.rosetta.core.sequence.read_fasta_file_str(filename: str) → pyrosetta.rosetta.utility.vector1_std_string¶: C++: core::sequence::read_fasta_file_str(const class std::basic_string<char> &) –> class utility::vector1<std::string, class std::allocator<std::string > >

pyrosetta.rosetta.core.sequence.read_general_aln(input: pyrosetta.rosetta.std.istream) → pyrosetta.rosetta.utility.vector1_core_sequence_SequenceAlignment¶

read generalized alignment format.

C++: core::sequence::read_general_aln(class std::basic_istream<char> &) –> class utility::vector1<class core::sequence::SequenceAlignment, class std::allocator<class core::sequence::SequenceAlignment> >

pyrosetta.rosetta.core.sequence.read_general_aln_file(filename: str) → pyrosetta.rosetta.utility.vector1_core_sequence_SequenceAlignment¶: C++: core::sequence::read_general_aln_file(const class std::basic_string<char> &) –> class utility::vector1<class core::sequence::SequenceAlignment, class std::allocator<class core::sequence::SequenceAlignment> >

pyrosetta.rosetta.core.sequence.read_grishin_aln_file(filename: str) → pyrosetta.rosetta.utility.vector1_core_sequence_SequenceAlignment¶: C++: core::sequence::read_grishin_aln_file(const class std::basic_string<char> &) –> class utility::vector1<class core::sequence::SequenceAlignment, class std::allocator<class core::sequence::SequenceAlignment> >

pyrosetta.rosetta.core.sequence.seqs_from_cmd_lines() → pyrosetta.rosetta.utility.vector1_std_shared_ptr_core_sequence_Sequence_t¶: C++: core::sequence::seqs_from_cmd_lines() –> class utility::vector1<class std::shared_ptr<class core::sequence::Sequence>, class std::allocator<class std::shared_ptr<class core::sequence::Sequence> > >

pyrosetta.rosetta.core.sequence.simple_mapping_from_file(filename: str) → pyrosetta.rosetta.core.sequence.DerivedSequenceMapping¶

Read in a SequenceMapping from a file. File: format is super-simple, it just contains single lines like this that claim that residue resi and resj are aligned: resi resj

C++: core::sequence::simple_mapping_from_file(const class std::basic_string<char> &) –> class core::sequence::DerivedSequenceMapping

pyrosetta.rosetta.core.sequence.steal_alignment(aln_to_steal: pyrosetta.rosetta.core.sequence.SequenceAlignment, seqs: pyrosetta.rosetta.utility.vector1_std_shared_ptr_core_sequence_Sequence_t) → pyrosetta.rosetta.core.sequence.SequenceAlignment¶

takes the sequences in the provided vector1 and makes them match: the alignment in aln_to_steal by matching gaps. This assumes that the ungapped sequences at index j in the vector1< SequenceOP > match the ungapped sequences at index j in aln_to_steal.

C++: core::sequence::steal_alignment(class core::sequence::SequenceAlignment, class utility::vector1<class std::shared_ptr<class core::sequence::Sequence>, class std::allocator<class std::shared_ptr<class core::sequence::Sequence> > >) –> class core::sequence::SequenceAlignment

pyrosetta.rosetta.core.sequence.strip_spacers(*args, **kwargs)¶

Overloaded function.

strip_spacers(sequence: str) -> pyrosetta.rosetta.utility.vector1_unsigned_long
strip_spacers(sequence: str, annotations_in_brackets: bool) -> pyrosetta.rosetta.utility.vector1_unsigned_long

C++: core::sequence::strip_spacers(class std::basic_string<char> &, const bool) –> class utility::vector1<unsigned long, class std::allocator<unsigned long> >

pyrosetta.rosetta.core.sequence.transitive_map(map1: pyrosetta.rosetta.core.id.SequenceMapping, map2: pyrosetta.rosetta.core.id.SequenceMapping) → pyrosetta.rosetta.core.id.SequenceMapping¶

Assuming that map1 maps sequence A to sequence B, and map2 maps: sequence B to sequence C, this function returns the SequenceMapping representing the direct map of sequence A to sequence C.

C++: core::sequence::transitive_map(const class core::id::SequenceMapping &, const class core::id::SequenceMapping &) –> class core::id::SequenceMapping