antibody¶

Bindings for protocols::antibody namespace

class pyrosetta.rosetta.protocols.antibody.Ab_TemplateInfo¶

Bases: pybind11_builtins.pybind11_object

Specifically for AntibodyModeling protocol templates. Not for general use.

__delattr__¶: Implement delattr(self, name).

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

__eq__¶: Return self==value.

__format__()¶: default object formatter

__ge__¶: Return self>=value.

__getattribute__¶: Return getattr(self, name).

__gt__¶: Return self>value.

__hash__¶: Return hash(self).

__init__(*args, **kwargs)¶

Overloaded function.

__init__(self: pyrosetta.rosetta.protocols.antibody.Ab_TemplateInfo) -> None
__init__(self: pyrosetta.rosetta.protocols.antibody.Ab_TemplateInfo, load_L1: bool, load_L2: bool, load_L3: bool, load_H1: bool, load_H2: bool, load_H3: bool) -> None
__init__(self: pyrosetta.rosetta.protocols.antibody.Ab_TemplateInfo, load_L1: bool, load_L2: bool, load_L3: bool, load_H1: bool, load_H2: bool, load_H3: bool, camelid: bool) -> None
__init__(self: pyrosetta.rosetta.protocols.antibody.Ab_TemplateInfo, arg0: pyrosetta.rosetta.protocols.antibody.Ab_TemplateInfo) -> 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.protocols.antibody.Ab_TemplateInfo) → 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).

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

get_one_template_pose(self: pyrosetta.rosetta.protocols.antibody.Ab_TemplateInfo, cdr_name: str) → pyrosetta.rosetta.core.pose.Pose¶: C++: protocols::antibody::Ab_TemplateInfo::get_one_template_pose(class std::basic_string<char>) –> class core::pose::Pose

is_camelid(self: pyrosetta.rosetta.protocols.antibody.Ab_TemplateInfo) → bool¶: C++: protocols::antibody::Ab_TemplateInfo::is_camelid() –> bool

load_templates_from_pdbs(self: pyrosetta.rosetta.protocols.antibody.Ab_TemplateInfo, load_L1: bool, load_L2: bool, load_L3: bool, load_H1: bool, load_H2: bool, load_H3: bool, camelid: bool) → None¶: C++: protocols::antibody::Ab_TemplateInfo::load_templates_from_pdbs(bool, bool, bool, bool, bool, bool, bool) –> void

show(*args, **kwargs)¶

Overloaded function.

show(self: pyrosetta.rosetta.protocols.antibody.Ab_TemplateInfo) -> None
show(self: pyrosetta.rosetta.protocols.antibody.Ab_TemplateInfo, out: pyrosetta.rosetta.std.ostream) -> None

C++: protocols::antibody::Ab_TemplateInfo::show(class std::basic_ostream<char> &) –> void

class pyrosetta.rosetta.protocols.antibody.AntibodyCDRGrafter¶

Bases: pyrosetta.rosetta.protocols.moves.Mover

Class to graft CDR loops from an antibody to a new antibody or from a CDR pose into a different antibody.: Independant of antibody and CDR modeling. Results in 100 percent loop closure if using both graft algorithms.

Recommended to use cluster-based or general dihedral constraints on the CDR with a min or relax to optimize graft. Use optimiize_cdrs option to optimize the CDRs that were grafted and any neighbor CDRs using these dihedral constraints during relax.

By default, uses two residues on N and C terminal of insert CDR and scaffold to close loop. Use getters of primary and secondary graft mover to change this if needed. By default, stops after the graft is closed!

__delattr__¶: Implement delattr(self, name).

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

__eq__¶: Return self==value.

__format__()¶: default object formatter

__ge__¶: Return self>=value.

__getattribute__¶: Return getattr(self, name).

__gt__¶: Return self>value.

__hash__¶: Return hash(self).

__init__(*args, **kwargs)¶

Overloaded function.

__init__(self: pyrosetta.rosetta.protocols.antibody.AntibodyCDRGrafter) -> None
__init__(self: pyrosetta.rosetta.protocols.antibody.AntibodyCDRGrafter, ab_info: protocols::antibody::AntibodyInfo) -> None
__init__(self: pyrosetta.rosetta.protocols.antibody.AntibodyCDRGrafter, arg0: protocols::antibody::AntibodyInfo, arg1: pyrosetta.rosetta.core.pose.Pose, arg2: pyrosetta.rosetta.utility.vector1_bool) -> None

doc

__init__(self: pyrosetta.rosetta.protocols.antibody.AntibodyCDRGrafter, arg0: protocols::antibody::AntibodyInfo, arg1: pyrosetta.rosetta.core.pose.Pose, arg2: pyrosetta.rosetta.utility.vector1_bool, arg3: int) -> None

doc

__init__(self: pyrosetta.rosetta.protocols.antibody.AntibodyCDRGrafter, ab_info: protocols::antibody::AntibodyInfo, donor_structure: pyrosetta.rosetta.core.pose.Pose, cdrs_to_graft: pyrosetta.rosetta.utility.vector1_bool, nter_overhang: int, cter_overhang: int) -> None
__init__(self: pyrosetta.rosetta.protocols.antibody.AntibodyCDRGrafter, arg0: pyrosetta.rosetta.protocols.antibody.AntibodyCDRGrafter) -> None

__init_subclass__()¶

This method is called when a class is subclassed.

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

__le__¶: Return self<=value.

__lt__¶: Return self<value.

__ne__¶: Return self!=value.

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

__reduce__()¶: helper for pickle

__reduce_ex__()¶: helper for pickle

__repr__¶: Return repr(self).

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

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

__str__¶: Return str(self).

__subclasshook__()¶

Abstract classes can override this to customize issubclass().

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

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

apply_to_cdr(self: pyrosetta.rosetta.protocols.antibody.AntibodyCDRGrafter, pose: pyrosetta.rosetta.core.pose.Pose, cdr_region_with_overhang: pyrosetta.rosetta.core.pose.Pose, cdr: pyrosetta.rosetta.protocols.antibody.CDRNameEnum, grafter: pyrosetta.rosetta.protocols.grafting.AnchoredGraftMover) → Tuple[bool, int]¶

Apply graft mover to pose, inserting the cdr_region.

Return success or failure of the graft and the position of the failure. Public in case one wants to use it by itself…

C++: protocols::antibody::AntibodyCDRGrafter::apply_to_cdr(class core::pose::Pose &, class core::pose::Pose &, const enum protocols::antibody::CDRNameEnum, class std::shared_ptr<class protocols::grafting::AnchoredGraftMover>) –> struct std::pair<bool, unsigned long>

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

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

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

clear_info is called by jd2 before calling apply

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

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

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

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

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

fpd

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

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

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

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

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

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

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

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

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

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

get_name(self: pyrosetta.rosetta.protocols.antibody.AntibodyCDRGrafter) → str¶: C++: protocols::antibody::AntibodyCDRGrafter::get_name() const –> std::string

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

get_primary_graft_mover(self: pyrosetta.rosetta.protocols.antibody.AntibodyCDRGrafter) → pyrosetta.rosetta.protocols.grafting.CCDEndsGraftMover¶

Get a reference of the main graft mover to tweak settings.

C++: protocols::antibody::AntibodyCDRGrafter::get_primary_graft_mover() –> class protocols::grafting::CCDEndsGraftMover &

get_secondary_graft_mover(self: pyrosetta.rosetta.protocols.antibody.AntibodyCDRGrafter) → pyrosetta.rosetta.protocols.grafting.AnchoredGraftMover¶

Get a reference of the secondary graft mover to tweak settings.

C++: protocols::antibody::AntibodyCDRGrafter::get_secondary_graft_mover() –> class protocols::grafting::AnchoredGraftMover &

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

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

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

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

non-const accessor

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

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

mover_name() → str¶: C++: protocols::antibody::AntibodyCDRGrafter::mover_name() –> std::string

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

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

register_options() → None¶

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

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

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

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

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

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

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

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

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

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

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

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

set_cdr_only(self: pyrosetta.rosetta.protocols.antibody.AntibodyCDRGrafter, cdr: pyrosetta.rosetta.protocols.antibody.CDRNameEnum) → None¶

Set a single CDR we are going to graft in.

C++: protocols::antibody::AntibodyCDRGrafter::set_cdr_only(enum protocols::antibody::CDRNameEnum) –> void

set_cdrs(self: pyrosetta.rosetta.protocols.antibody.AntibodyCDRGrafter, cdrs: pyrosetta.rosetta.utility.vector1_bool) → None¶

Set the CDRs to graft. Boolean vector of CDRNameEnums (1-8) (includes CDR4/DE loop)

C++: protocols::antibody::AntibodyCDRGrafter::set_cdrs(const class utility::vector1<bool, class std::allocator<bool> > &) –> void

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

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

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

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

set_dihedral_constraint_weight(self: pyrosetta.rosetta.protocols.antibody.AntibodyCDRGrafter, dih_cst_wt: float) → None¶

Set the dihedral constraint weight used if optimization is done and the scorefxn dihedral_constraint: weight is zero. Default = 2.0

C++: protocols::antibody::AntibodyCDRGrafter::set_dihedral_constraint_weight(double) –> void

set_donor_structure(self: pyrosetta.rosetta.protocols.antibody.AntibodyCDRGrafter, pose: pyrosetta.rosetta.core.pose.Pose) → None¶

Set a donor structure. Culd be a single CDR, multiple CDRs or a whole other antibody.

C++: protocols::antibody::AntibodyCDRGrafter::set_donor_structure(const class core::pose::Pose &) –> void

set_idealize_insert(self: pyrosetta.rosetta.protocols.antibody.AntibodyCDRGrafter, idealize_insert: bool) → None¶

Idealize the insert. Default TRUE.

C++: protocols::antibody::AntibodyCDRGrafter::set_idealize_insert(bool) –> void

set_include_cdr4_in_optimization(self: pyrosetta.rosetta.protocols.antibody.AntibodyCDRGrafter, include_cdr4: bool) → None¶

Set to include the DE loop, or CDR4 if it is a neighbor to a grafted CDR and optimization is set to on.: Recommended if optimizing. Default TRUE.

C++: protocols::antibody::AntibodyCDRGrafter::set_include_cdr4_in_optimization(bool) –> void

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

setter for poses contained for rms

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

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

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

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

set_optimize_cdrs(self: pyrosetta.rosetta.protocols.antibody.AntibodyCDRGrafter, optimize_cdrs: bool) → None¶

Set to optimize any grafted and neighbor CDRs using dihdedral constrained relax on them. Default FALSE.: Recommended if using secondary graft mover.

C++: protocols::antibody::AntibodyCDRGrafter::set_optimize_cdrs(bool) –> void

set_overhang(self: pyrosetta.rosetta.protocols.antibody.AntibodyCDRGrafter, nter_overhang: int, cter_overhang: int) → None¶

Set the N and Cterminal overhang used for superposition before the graft.

C++: protocols::antibody::AntibodyCDRGrafter::set_overhang(unsigned long, unsigned long) –> void

set_scorefxn_low(self: pyrosetta.rosetta.protocols.antibody.AntibodyCDRGrafter, scorefxn: pyrosetta.rosetta.core.scoring.ScoreFunction) → None¶

Set the (low-res) scorefunction used by the graft movers to close loop.: Default is to use Frank Dimaio’s smoothed low-res terms.

C++: protocols::antibody::AntibodyCDRGrafter::set_scorefxn_low(class std::shared_ptr<const class core::scoring::ScoreFunction>) –> void

set_scorefxn_pack(self: pyrosetta.rosetta.protocols.antibody.AntibodyCDRGrafter, scorefxn: pyrosetta.rosetta.core.scoring.ScoreFunction) → None¶

Set the (all-atom) scorefunction used by the graft movers for packing: Otherwise use cmd-line default

C++: protocols::antibody::AntibodyCDRGrafter::set_scorefxn_pack(class std::shared_ptr<const class core::scoring::ScoreFunction>) –> void

set_stop_after_closure(self: pyrosetta.rosetta.protocols.antibody.AntibodyCDRGrafter, stop_after_closure: bool) → None¶

Set a boolean for whether to stop after closure or not. Default TRUE.

C++: protocols::antibody::AntibodyCDRGrafter::set_stop_after_closure(bool) –> void

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

set_use_secondary_graft_mover_if_needed(self: pyrosetta.rosetta.protocols.antibody.AntibodyCDRGrafter, use_secondary_graft_mover: bool) → None¶

Set a boolean for whether to use the secondary graft mover is the graft is not closed using the first.

Default FALSE.

Using this results in 100% graft closure, however, in order to fix the structure, a dihedral constrained relax is done on the CDR while repacking neighbor residues. 85% Graft closure without (slight chainbreaks - not as bad as what used to be used for antibody modeling.)

C++: protocols::antibody::AntibodyCDRGrafter::set_use_secondary_graft_mover_if_needed(bool) –> void

show(*args, **kwargs)¶

Overloaded function.

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

Outputs details about the Mover, including current settings.

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

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

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

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

type(*args, **kwargs)¶

Overloaded function.

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

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

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

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

class pyrosetta.rosetta.protocols.antibody.AntibodyDatabaseManager¶

Bases: pybind11_builtins.pybind11_object

Class responsible for loading information from the AntibodyDatabase.

__delattr__¶: Implement delattr(self, name).

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

__eq__¶: Return self==value.

__format__()¶: default object formatter

__ge__¶: Return self>=value.

__getattribute__¶: Return getattr(self, name).

__gt__¶: Return self>value.

__hash__¶: Return hash(self).

__init__(*args, **kwargs)¶

Overloaded function.

__init__(self: pyrosetta.rosetta.protocols.antibody.AntibodyDatabaseManager, arg0: pyrosetta.rosetta.protocols.antibody.AntibodyInfo) -> None

doc

__init__(self: pyrosetta.rosetta.protocols.antibody.AntibodyDatabaseManager, ab_info: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, force_north_paper_db: bool) -> None
__init__(self: pyrosetta.rosetta.protocols.antibody.AntibodyDatabaseManager, arg0: pyrosetta.rosetta.protocols.antibody.AntibodyDatabaseManager) -> 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.antibody.AntibodyDatabaseManager, : pyrosetta.rosetta.protocols.antibody.AntibodyDatabaseManager) → pyrosetta.rosetta.protocols.antibody.AntibodyDatabaseManager¶: C++: protocols::antibody::AntibodyDatabaseManager::operator=(const class protocols::antibody::AntibodyDatabaseManager &) –> class protocols::antibody::AntibodyDatabaseManager &

clone(self: pyrosetta.rosetta.protocols.antibody.AntibodyDatabaseManager) → pyrosetta.rosetta.protocols.antibody.AntibodyDatabaseManager¶: C++: protocols::antibody::AntibodyDatabaseManager::clone() const –> class std::shared_ptr<class protocols::antibody::AntibodyDatabaseManager>

ignore_light_chain(self: pyrosetta.rosetta.protocols.antibody.AntibodyDatabaseManager, ignore_light_chain: bool) → None¶: C++: protocols::antibody::AntibodyDatabaseManager::ignore_light_chain(const bool) –> void

load_cdr_design_data(self: pyrosetta.rosetta.protocols.antibody.AntibodyDatabaseManager, options: pyrosetta.rosetta.utility.vector1_std_shared_ptr_protocols_antibody_design_CDRSeqDesignOptions_t, pose: pyrosetta.rosetta.core.pose.Pose, prob_set: pyrosetta.rosetta.std.map_unsigned_long_std_map_core_chemical_AA_double_std_less_core_chemical_AA_std_allocator_std_pair_const_core_chemical_AA_double_t, cutoff: int) → pyrosetta.rosetta.utility.vector1_bool¶

Load probability data for CDR Design. Returns CDRs where data could not be loaded. Cutoff indicates number of total sequences needed to use the data.

Will attempt to use Pose Datacache for identification of CDR clusters first.

C++: protocols::antibody::AntibodyDatabaseManager::load_cdr_design_data(const class utility::vector1<class std::shared_ptr<class protocols::antibody::design::CDRSeqDesignOptions>, class std::allocator<class std::shared_ptr<class protocols::antibody::design::CDRSeqDesignOptions> > > &, const class core::pose::Pose &, class std::map<unsigned long, class std::map<enum core::chemical::AA, double, struct std::less<enum core::chemical::AA>, class std::allocator<struct std::pair<const enum core::chemical::AA, double> > >, struct std::less<unsigned long>, class std::allocator<struct std::pair<const unsigned long, class std::map<enum core::chemical::AA, double, struct std::less<enum core::chemical::AA>, class std::allocator<struct std::pair<const enum core::chemical::AA, double> > > > > > &, const unsigned long) –> class utility::vector1<bool, class std::allocator<bool> >

load_cdr_design_data_for_cdrs(self: pyrosetta.rosetta.protocols.antibody.AntibodyDatabaseManager, cdrs: pyrosetta.rosetta.utility.vector1_bool, pose: pyrosetta.rosetta.core.pose.Pose, prob_set: pyrosetta.rosetta.std.map_unsigned_long_std_map_core_chemical_AA_double_std_less_core_chemical_AA_std_allocator_std_pair_const_core_chemical_AA_double_t, cutoff: int) → pyrosetta.rosetta.utility.vector1_bool¶: C++: protocols::antibody::AntibodyDatabaseManager::load_cdr_design_data_for_cdrs(const class utility::vector1<bool, class std::allocator<bool> > &, const class core::pose::Pose &, class std::map<unsigned long, class std::map<enum core::chemical::AA, double, struct std::less<enum core::chemical::AA>, class std::allocator<struct std::pair<const enum core::chemical::AA, double> > >, struct std::less<unsigned long>, class std::allocator<struct std::pair<const unsigned long, class std::map<enum core::chemical::AA, double, struct std::less<enum core::chemical::AA>, class std::allocator<struct std::pair<const enum core::chemical::AA, double> > > > > > &, const unsigned long) –> class utility::vector1<bool, class std::allocator<bool> >

load_cdr_pose(self: pyrosetta.rosetta.protocols.antibody.AntibodyDatabaseManager, db_pose: pyrosetta.rosetta.protocols.antibody.CDRDBPose) → pyrosetta.rosetta.core.pose.Pose¶

Load a single pose into the db_pose using the given struct_id. If failure, it is nullptr

C++: protocols::antibody::AntibodyDatabaseManager::load_cdr_pose(struct protocols::antibody::CDRDBPose &) –> class std::shared_ptr<class core::pose::Pose>

set_outlier_use(self: pyrosetta.rosetta.protocols.antibody.AntibodyDatabaseManager, use_outliers: bool) → None¶

Set to parse outliers for both sequence and structural data. Default False.

C++: protocols::antibody::AntibodyDatabaseManager::set_outlier_use(bool) –> void

class pyrosetta.rosetta.protocols.antibody.AntibodyEnumManager¶

Bases: pybind11_builtins.pybind11_object

Interface to this class is in AntibodyInfo.

__delattr__¶: Implement delattr(self, name).

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

__eq__¶: Return self==value.

__format__()¶: default object formatter

__ge__¶: Return self>=value.

__getattribute__¶: Return getattr(self, name).

__gt__¶: Return self>value.

__hash__¶: Return hash(self).

__init__(self: pyrosetta.rosetta.protocols.antibody.AntibodyEnumManager) → 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).

all_cdrs(*args, **kwargs)¶

Overloaded function.

all_cdrs(self: pyrosetta.rosetta.protocols.antibody.AntibodyEnumManager) -> pyrosetta.rosetta.utility.vector1_protocols_antibody_CDRNameEnum
all_cdrs(self: pyrosetta.rosetta.protocols.antibody.AntibodyEnumManager, include_proto_cdr4: bool) -> pyrosetta.rosetta.utility.vector1_protocols_antibody_CDRNameEnum

C++: protocols::antibody::AntibodyEnumManager::all_cdrs(bool) –> const class utility::vector1<enum protocols::antibody::CDRNameEnum, class std::allocator<enum protocols::antibody::CDRNameEnum> > &

antibody_region_enum_to_string(self: pyrosetta.rosetta.protocols.antibody.AntibodyEnumManager, antibody_region: pyrosetta.rosetta.protocols.antibody.AntibodyRegionEnum) → str¶: C++: protocols::antibody::AntibodyEnumManager::antibody_region_enum_to_string(const enum protocols::antibody::AntibodyRegionEnum) const –> std::string

antibody_region_string_to_enum(self: pyrosetta.rosetta.protocols.antibody.AntibodyEnumManager, antibody_region: str) → pyrosetta.rosetta.protocols.antibody.AntibodyRegionEnum¶

////////////// Antibody Region ////////////////////////////////////////////

C++: protocols::antibody::AntibodyEnumManager::antibody_region_string_to_enum(const class std::basic_string<char> &) const –> enum protocols::antibody::AntibodyRegionEnum

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

cdr_definition_enum_to_string(self: pyrosetta.rosetta.protocols.antibody.AntibodyEnumManager, cdr_definition: pyrosetta.rosetta.protocols.antibody.CDRDefinitionEnum) → str¶: C++: protocols::antibody::AntibodyEnumManager::cdr_definition_enum_to_string(const enum protocols::antibody::CDRDefinitionEnum) const –> std::string

cdr_definition_is_present(self: pyrosetta.rosetta.protocols.antibody.AntibodyEnumManager, cdr_definition: str) → bool¶: C++: protocols::antibody::AntibodyEnumManager::cdr_definition_is_present(const class std::basic_string<char> &) const –> bool

cdr_definition_string_to_enum(self: pyrosetta.rosetta.protocols.antibody.AntibodyEnumManager, cdr_definition: str) → pyrosetta.rosetta.protocols.antibody.CDRDefinitionEnum¶

/////////////// CDR Definitions ///////////////////////////////////////

C++: protocols::antibody::AntibodyEnumManager::cdr_definition_string_to_enum(const class std::basic_string<char> &) const –> enum protocols::antibody::CDRDefinitionEnum

cdr_landmark_enum_to_string(self: pyrosetta.rosetta.protocols.antibody.AntibodyEnumManager, landmark: pyrosetta.rosetta.protocols.antibody.CDRLandmarkEnum) → str¶: C++: protocols::antibody::AntibodyEnumManager::cdr_landmark_enum_to_string(const enum protocols::antibody::CDRLandmarkEnum) const –> std::string

cdr_landmark_is_present(self: pyrosetta.rosetta.protocols.antibody.AntibodyEnumManager, landmark: str) → bool¶: C++: protocols::antibody::AntibodyEnumManager::cdr_landmark_is_present(const class std::basic_string<char> &) const –> bool

cdr_landmark_string_to_enum(self: pyrosetta.rosetta.protocols.antibody.AntibodyEnumManager, landmark: str) → pyrosetta.rosetta.protocols.antibody.CDRLandmarkEnum¶

////////////// Antibody Landmarks ////////////////////////////////////////////

C++: protocols::antibody::AntibodyEnumManager::cdr_landmark_string_to_enum(const class std::basic_string<char> &) const –> enum protocols::antibody::CDRLandmarkEnum

cdr_name_enum_to_string(self: pyrosetta.rosetta.protocols.antibody.AntibodyEnumManager, cdr_name: pyrosetta.rosetta.protocols.antibody.CDRNameEnum) → str¶: C++: protocols::antibody::AntibodyEnumManager::cdr_name_enum_to_string(const enum protocols::antibody::CDRNameEnum) const –> std::string

cdr_name_is_present(self: pyrosetta.rosetta.protocols.antibody.AntibodyEnumManager, cdr_name: str) → bool¶: C++: protocols::antibody::AntibodyEnumManager::cdr_name_is_present(const class std::basic_string<char> &) const –> bool

cdr_name_string_to_enum(self: pyrosetta.rosetta.protocols.antibody.AntibodyEnumManager, cdr_name: str) → pyrosetta.rosetta.protocols.antibody.CDRNameEnum¶

/////////////// CDR names ///////////////////////////////////////////////

C++: protocols::antibody::AntibodyEnumManager::cdr_name_string_to_enum(const class std::basic_string<char> &) const –> enum protocols::antibody::CDRNameEnum

get_recognized_cdr_definitions(self: pyrosetta.rosetta.protocols.antibody.AntibodyEnumManager) → pyrosetta.rosetta.utility.vector1_std_string¶: C++: protocols::antibody::AntibodyEnumManager::get_recognized_cdr_definitions() const –> class utility::vector1<std::string, class std::allocator<std::string > >

get_recognized_numbering_schemes(self: pyrosetta.rosetta.protocols.antibody.AntibodyEnumManager) → pyrosetta.rosetta.utility.vector1_std_string¶: C++: protocols::antibody::AntibodyEnumManager::get_recognized_numbering_schemes() const –> class utility::vector1<std::string, class std::allocator<std::string > >

h3_base_type_enum_to_string(self: pyrosetta.rosetta.protocols.antibody.AntibodyEnumManager, base_type: pyrosetta.rosetta.protocols.antibody.H3BaseTypeEnum) → str¶: C++: protocols::antibody::AntibodyEnumManager::h3_base_type_enum_to_string(const enum protocols::antibody::H3BaseTypeEnum) const –> std::string

h3_base_type_string_to_enum(self: pyrosetta.rosetta.protocols.antibody.AntibodyEnumManager, base_type: str) → pyrosetta.rosetta.protocols.antibody.H3BaseTypeEnum¶

/////////////// H3 Base Type ////////////////////////////////////////////

C++: protocols::antibody::AntibodyEnumManager::h3_base_type_string_to_enum(const class std::basic_string<char> &) const –> enum protocols::antibody::H3BaseTypeEnum

light_chain_type_enum_to_string(self: pyrosetta.rosetta.protocols.antibody.AntibodyEnumManager, light_chain: pyrosetta.rosetta.protocols.antibody.LightChainTypeEnum) → str¶: C++: protocols::antibody::AntibodyEnumManager::light_chain_type_enum_to_string(const enum protocols::antibody::LightChainTypeEnum) const –> std::string

light_chain_type_is_present(self: pyrosetta.rosetta.protocols.antibody.AntibodyEnumManager, light_chain: str) → bool¶: C++: protocols::antibody::AntibodyEnumManager::light_chain_type_is_present(const class std::basic_string<char> &) const –> bool

light_chain_type_string_to_enum(self: pyrosetta.rosetta.protocols.antibody.AntibodyEnumManager, light_chain: str) → pyrosetta.rosetta.protocols.antibody.LightChainTypeEnum¶

////////////// LightChain Types ////////////////////////////////////////////

C++: protocols::antibody::AntibodyEnumManager::light_chain_type_string_to_enum(const class std::basic_string<char> &) const –> enum protocols::antibody::LightChainTypeEnum

numbering_scheme_enum_to_string(self: pyrosetta.rosetta.protocols.antibody.AntibodyEnumManager, numbering_scheme: pyrosetta.rosetta.protocols.antibody.AntibodyNumberingSchemeEnum) → str¶: C++: protocols::antibody::AntibodyEnumManager::numbering_scheme_enum_to_string(const enum protocols::antibody::AntibodyNumberingSchemeEnum) const –> std::string

numbering_scheme_is_present(self: pyrosetta.rosetta.protocols.antibody.AntibodyEnumManager, numbering_scheme: str) → bool¶: C++: protocols::antibody::AntibodyEnumManager::numbering_scheme_is_present(const class std::basic_string<char> &) const –> bool

numbering_scheme_string_to_enum(self: pyrosetta.rosetta.protocols.antibody.AntibodyEnumManager, numbering_scheme: str) → pyrosetta.rosetta.protocols.antibody.AntibodyNumberingSchemeEnum¶

/////////////// Numbering Schemes ///////////////////////////////////////

C++: protocols::antibody::AntibodyEnumManager::numbering_scheme_string_to_enum(const class std::basic_string<char> &) const –> enum protocols::antibody::AntibodyNumberingSchemeEnum

packing_angle_enum_to_string(self: pyrosetta.rosetta.protocols.antibody.AntibodyEnumManager, angle_type: pyrosetta.rosetta.protocols.antibody.PackingAngleEnum) → str¶: C++: protocols::antibody::AntibodyEnumManager::packing_angle_enum_to_string(const enum protocols::antibody::PackingAngleEnum) const –> std::string

packing_angle_string_to_enum(self: pyrosetta.rosetta.protocols.antibody.AntibodyEnumManager, angle_type: str) → pyrosetta.rosetta.protocols.antibody.PackingAngleEnum¶

////////////// Packing Angle ////////////////////////////////////////////

C++: protocols::antibody::AntibodyEnumManager::packing_angle_string_to_enum(const class std::basic_string<char> &) const –> enum protocols::antibody::PackingAngleEnum

class pyrosetta.rosetta.protocols.antibody.AntibodyFeatures¶

Bases: pyrosetta.rosetta.protocols.features.InterfaceFeatures

Collects data on an antibody including CDRs, interfaces of L_H, L_A, H_A, and LH_A (this can be set), and other metrics.

Adds …. tables to the database. See also protocols/antibody/clusters/CDRClusterFeatures

__delattr__¶: Implement delattr(self, name).

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

__eq__¶: Return self==value.

__format__()¶: default object formatter

__ge__¶: Return self>=value.

__getattribute__¶: Return getattr(self, name).

__gt__¶: Return self>value.

__hash__¶: Return hash(self).

__init__(*args, **kwargs)¶

Overloaded function.

__init__(self: pyrosetta.rosetta.protocols.antibody.AntibodyFeatures) -> None
__init__(self: pyrosetta.rosetta.protocols.antibody.AntibodyFeatures, ab_info: pyrosetta.rosetta.protocols.antibody.AntibodyInfo) -> None
__init__(self: pyrosetta.rosetta.protocols.antibody.AntibodyFeatures, ab_info: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, scorefxn: pyrosetta.rosetta.core.scoring.ScoreFunction) -> None
__init__(self: pyrosetta.rosetta.protocols.antibody.AntibodyFeatures, arg0: pyrosetta.rosetta.protocols.antibody.AntibodyFeatures) -> 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.antibody.AntibodyFeatures, : pyrosetta.rosetta.protocols.antibody.AntibodyFeatures) → pyrosetta.rosetta.protocols.antibody.AntibodyFeatures¶: C++: protocols::antibody::AntibodyFeatures::operator=(const class protocols::antibody::AntibodyFeatures &) –> class protocols::antibody::AntibodyFeatures &

check_relevant_residues(*args, **kwargs)¶

Overloaded function.

check_relevant_residues(self: pyrosetta.rosetta.protocols.features.FeaturesReporter, relevant_residues: pyrosetta.rosetta.utility.vector1_bool, res1: int) -> bool

C++: protocols::features::FeaturesReporter::check_relevant_residues(const class utility::vector1<bool, class std::allocator<bool> > &, unsigned long) const –> bool

check_relevant_residues(self: pyrosetta.rosetta.protocols.features.FeaturesReporter, relevant_residues: pyrosetta.rosetta.utility.vector1_bool, res1: int, res2: int) -> bool

C++: protocols::features::FeaturesReporter::check_relevant_residues(const class utility::vector1<bool, class std::allocator<bool> > &, unsigned long, unsigned long) const –> bool

check_relevant_residues(self: pyrosetta.rosetta.protocols.features.FeaturesReporter, relevant_residues: pyrosetta.rosetta.utility.vector1_bool, residues: pyrosetta.rosetta.utility.vector1_unsigned_long) -> bool

C++: protocols::features::FeaturesReporter::check_relevant_residues(const class utility::vector1<bool, class std::allocator<bool> > &, const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &) const –> bool

check_relevant_residues_range(self: pyrosetta.rosetta.protocols.features.FeaturesReporter, relevant_residues: pyrosetta.rosetta.utility.vector1_bool, res1: int, res2: int) → bool¶: C++: protocols::features::FeaturesReporter::check_relevant_residues_range(const class utility::vector1<bool, class std::allocator<bool> > &, unsigned long, unsigned long) const –> bool

class_name() → str¶: C++: protocols::antibody::AntibodyFeatures::class_name() –> std::string

delete_record(self: pyrosetta.rosetta.protocols.features.FeaturesReporter, : int, : pyrosetta.rosetta.utility.sql_database.session) → None¶: C++: protocols::features::FeaturesReporter::delete_record(unsigned long, class std::shared_ptr<class utility::sql_database::session>) –> void

features_reporter_dependencies(self: pyrosetta.rosetta.protocols.features.InterfaceFeatures) → pyrosetta.rosetta.utility.vector1_std_string¶

return the set of features reporters that are required to also already be extracted by the time this one is used.

C++: protocols::features::InterfaceFeatures::features_reporter_dependencies() const –> class utility::vector1<std::string, class std::allocator<std::string > >

get_relevant_residues_mode(self: pyrosetta.rosetta.protocols.features.FeaturesReporter) → pyrosetta.rosetta.protocols.features.RelevantResiduesMode.T¶: C++: protocols::features::FeaturesReporter::get_relevant_residues_mode() const –> enum protocols::features::RelevantResiduesMode::T

load_into_pose(self: pyrosetta.rosetta.protocols.features.FeaturesReporter, : pyrosetta.rosetta.utility.sql_database.session, : int, : pyrosetta.rosetta.core.pose.Pose) → None¶: C++: protocols::features::FeaturesReporter::load_into_pose(class std::shared_ptr<class utility::sql_database::session>, unsigned long, class core::pose::Pose &) –> void

make_interface_combos(self: pyrosetta.rosetta.protocols.features.InterfaceFeatures, pose: pyrosetta.rosetta.core.pose.Pose, interfaces: pyrosetta.rosetta.utility.vector1_std_string) → None¶

Gets all possible interface combinations of a given pose.

C++: protocols::features::InterfaceFeatures::make_interface_combos(const class core::pose::Pose &, class utility::vector1<class std::basic_string<char>, class std::allocator<class std::basic_string<char> > > &) –> void

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

report_ab_H3_kink_metrics_features(self: pyrosetta.rosetta.protocols.antibody.AntibodyFeatures, pose: pyrosetta.rosetta.core.pose.Pose, struct_id: int, db_session: pyrosetta.rosetta.utility.sql_database.session) → None¶: C++: protocols::antibody::AntibodyFeatures::report_ab_H3_kink_metrics_features(const class core::pose::Pose &, unsigned long, class std::shared_ptr<class utility::sql_database::session>) –> void

report_ab_metrics_features(self: pyrosetta.rosetta.protocols.antibody.AntibodyFeatures, pose: pyrosetta.rosetta.core.pose.Pose, struct_id: int, db_session: pyrosetta.rosetta.utility.sql_database.session) → None¶: C++: protocols::antibody::AntibodyFeatures::report_ab_metrics_features(const class core::pose::Pose &, unsigned long, class std::shared_ptr<class utility::sql_database::session>) –> void

report_all_interface_features(self: pyrosetta.rosetta.protocols.features.InterfaceFeatures, pose: pyrosetta.rosetta.core.pose.Pose, relevant_residues: pyrosetta.rosetta.utility.vector1_bool, struct_id: int, db_session: pyrosetta.rosetta.utility.sql_database.session, interface: str, db_interface: str) → None¶

Report all features. Called by report_features. Easy interface for subclassing specific interfaces.

interface is the interface analyzed, db_interface is the name that is actually inserted into the database Usually this is the same, but useful when dealing with different chain ids but same interface type. db_interface should have sides as well (L_H))

C++: protocols::features::InterfaceFeatures::report_all_interface_features(const class core::pose::Pose &, const class utility::vector1<bool, class std::allocator<bool> > &, unsigned long, class std::shared_ptr<class utility::sql_database::session>, const class std::basic_string<char> &, const class std::basic_string<char> &) –> void

report_cdr_metrics_features(self: pyrosetta.rosetta.protocols.antibody.AntibodyFeatures, pose: pyrosetta.rosetta.core.pose.Pose, struct_id: int, db_session: pyrosetta.rosetta.utility.sql_database.session, cdr: pyrosetta.rosetta.protocols.antibody.CDRNameEnum) → None¶: C++: protocols::antibody::AntibodyFeatures::report_cdr_metrics_features(const class core::pose::Pose &, unsigned long, class std::shared_ptr<class utility::sql_database::session>, const enum protocols::antibody::CDRNameEnum &) –> void

report_cdr_residue_features(self: pyrosetta.rosetta.protocols.antibody.AntibodyFeatures, pose: pyrosetta.rosetta.core.pose.Pose, struct_id: int, db_session: pyrosetta.rosetta.utility.sql_database.session, cdr: pyrosetta.rosetta.protocols.antibody.CDRNameEnum, relevant_residues: pyrosetta.rosetta.utility.vector1_bool) → None¶: C++: protocols::antibody::AntibodyFeatures::report_cdr_residue_features(const class core::pose::Pose &, unsigned long, class std::shared_ptr<class utility::sql_database::session>, const enum protocols::antibody::CDRNameEnum &, const class utility::vector1<bool, class std::allocator<bool> > &) –> void

report_cdr_residue_features_row(self: pyrosetta.rosetta.protocols.antibody.AntibodyFeatures, pose: pyrosetta.rosetta.core.pose.Pose, struct_id: int, db_session: pyrosetta.rosetta.utility.sql_database.session, cdr: pyrosetta.rosetta.protocols.antibody.CDRNameEnum, resnum: int, position: int) → None¶: C++: protocols::antibody::AntibodyFeatures::report_cdr_residue_features_row(const class core::pose::Pose &, unsigned long, class std::shared_ptr<class utility::sql_database::session>, const enum protocols::antibody::CDRNameEnum &, unsigned long, unsigned long) –> void

report_features(self: pyrosetta.rosetta.protocols.antibody.AntibodyFeatures, pose: pyrosetta.rosetta.core.pose.Pose, relevant_residues: pyrosetta.rosetta.utility.vector1_bool, struct_id: int, db_session: pyrosetta.rosetta.utility.sql_database.session) → int¶

collect all the feature data for the pose

C++: protocols::antibody::AntibodyFeatures::report_features(const class core::pose::Pose &, const class utility::vector1<bool, class std::allocator<bool> > &, unsigned long, class std::shared_ptr<class utility::sql_database::session>) –> unsigned long

report_interface_features(self: pyrosetta.rosetta.protocols.features.InterfaceFeatures, pose: pyrosetta.rosetta.core.pose.Pose, struct_id: int, db_session: pyrosetta.rosetta.utility.sql_database.session, chains_side1: str, chains_side2: str) → None¶

Add interfaces table data to table

C++: protocols::features::InterfaceFeatures::report_interface_features(const class core::pose::Pose &, unsigned long, class std::shared_ptr<class utility::sql_database::session>, const class std::basic_string<char> &, const class std::basic_string<char> &) const –> void

report_interface_residue_features(self: pyrosetta.rosetta.protocols.features.InterfaceFeatures, pose: pyrosetta.rosetta.core.pose.Pose, relevant_residues: pyrosetta.rosetta.utility.vector1_bool, struct_id: int, db_session: pyrosetta.rosetta.utility.sql_database.session, chains_side1: str, chains_side2: str) → None¶

Add interface_residues data to table

C++: protocols::features::InterfaceFeatures::report_interface_residue_features(const class core::pose::Pose &, const class utility::vector1<bool, class std::allocator<bool> > &, unsigned long, class std::shared_ptr<class utility::sql_database::session>, const class std::basic_string<char> &, const class std::basic_string<char> &) const –> void

report_interface_side_features(self: pyrosetta.rosetta.protocols.features.InterfaceFeatures, pose: pyrosetta.rosetta.core.pose.Pose, struct_id: int, db_session: pyrosetta.rosetta.utility.sql_database.session, chains_side1: str, chains_side2: str, region: pyrosetta.rosetta.protocols.analysis.InterfaceRegion, region_string: str) → None¶

Add interface_sides table data to table

C++: protocols::features::InterfaceFeatures::report_interface_side_features(const class core::pose::Pose &, unsigned long, class std::shared_ptr<class utility::sql_database::session>, const class std::basic_string<char> &, const class std::basic_string<char> &, enum protocols::analysis::InterfaceRegion, const class std::basic_string<char> &) const –> void

schema(self: pyrosetta.rosetta.protocols.features.FeaturesReporter) → str¶

return sql statements that sets up the appropriate tables to contain the features. This should be removed once everything has been moved to the schema generator

C++: protocols::features::FeaturesReporter::schema() const –> std::string

set_ab_info(self: pyrosetta.rosetta.protocols.antibody.AntibodyFeatures, ab_info: pyrosetta.rosetta.protocols.antibody.AntibodyInfo) → None¶: C++: protocols::antibody::AntibodyFeatures::set_ab_info(class std::shared_ptr<class protocols::antibody::AntibodyInfo>) –> void

set_compute_packstat(self: pyrosetta.rosetta.protocols.features.InterfaceFeatures, compute_packstat: bool) → None¶

Compute the packstat score? Default true

C++: protocols::features::InterfaceFeatures::set_compute_packstat(const bool) –> void

set_dSASA_cutoff(self: pyrosetta.rosetta.protocols.features.InterfaceFeatures, dSASA_cutoff: float) → None¶

Set the reporter to only include interfaces >dSASA_cutoff.

C++: protocols::features::InterfaceFeatures::set_dSASA_cutoff(double) –> void

set_defaults(self: pyrosetta.rosetta.protocols.features.InterfaceFeatures) → None¶: C++: protocols::features::InterfaceFeatures::set_defaults() –> void

set_interface_chains(self: pyrosetta.rosetta.protocols.antibody.AntibodyFeatures, intermediate_interfaces: pyrosetta.rosetta.utility.vector1_std_string) → None¶

Set intermediate interface chains: Example: L_A, H_A, L_H, LH_A (A stands for antigen)

Any other chains, use InterfaceFeatures.

C++: protocols::antibody::AntibodyFeatures::set_interface_chains(const class utility::vector1<class std::basic_string<char>, class std::allocator<class std::basic_string<char> > > &) –> void

set_pack_separated(self: pyrosetta.rosetta.protocols.features.InterfaceFeatures, pack_separated: bool) → None¶

Pack the interface before separation? Default is false.

C++: protocols::features::InterfaceFeatures::set_pack_separated(const bool) –> void

set_pack_together(self: pyrosetta.rosetta.protocols.features.InterfaceFeatures, pack_together: bool) → None¶

Pack the interface after separation? Default is true.

C++: protocols::features::InterfaceFeatures::set_pack_together(const bool) –> void

set_relevant_residues_mode(self: pyrosetta.rosetta.protocols.features.FeaturesReporter, setting: pyrosetta.rosetta.protocols.features.RelevantResiduesMode.T) → None¶: C++: protocols::features::FeaturesReporter::set_relevant_residues_mode(enum protocols::features::RelevantResiduesMode::T) –> void

set_scorefxn(self: pyrosetta.rosetta.protocols.features.InterfaceFeatures, scorefxn: pyrosetta.rosetta.core.scoring.ScoreFunction) → None¶: C++: protocols::features::InterfaceFeatures::set_scorefxn(class std::shared_ptr<class core::scoring::ScoreFunction>) –> void

type_name(self: pyrosetta.rosetta.protocols.antibody.AntibodyFeatures) → str¶: C++: protocols::antibody::AntibodyFeatures::type_name() const –> std::string

write_ab_H3_kink_metrics_schema_to_db(self: pyrosetta.rosetta.protocols.antibody.AntibodyFeatures, db_session: pyrosetta.rosetta.utility.sql_database.session) → None¶

Write kink metrics schema. Please add or modify as needed.

C++: protocols::antibody::AntibodyFeatures::write_ab_H3_kink_metrics_schema_to_db(class std::shared_ptr<class utility::sql_database::session>) const –> void

write_ab_metrics_schema_to_db(self: pyrosetta.rosetta.protocols.antibody.AntibodyFeatures, db_session: pyrosetta.rosetta.utility.sql_database.session) → None¶: C++: protocols::antibody::AntibodyFeatures::write_ab_metrics_schema_to_db(class std::shared_ptr<class utility::sql_database::session>) const –> void

write_cdr_metrics_schema_to_db(self: pyrosetta.rosetta.protocols.antibody.AntibodyFeatures, db_session: pyrosetta.rosetta.utility.sql_database.session) → None¶: C++: protocols::antibody::AntibodyFeatures::write_cdr_metrics_schema_to_db(class std::shared_ptr<class utility::sql_database::session>) const –> void

write_cdr_residue_schema_to_db(self: pyrosetta.rosetta.protocols.antibody.AntibodyFeatures, db_session: pyrosetta.rosetta.utility.sql_database.session) → None¶: C++: protocols::antibody::AntibodyFeatures::write_cdr_residue_schema_to_db(class std::shared_ptr<class utility::sql_database::session>) const –> void

write_interface_residues_schema_to_db(self: pyrosetta.rosetta.protocols.features.InterfaceFeatures, db_session: pyrosetta.rosetta.utility.sql_database.session) → None¶: C++: protocols::features::InterfaceFeatures::write_interface_residues_schema_to_db(class std::shared_ptr<class utility::sql_database::session>) const –> void

write_interface_schema_to_db(self: pyrosetta.rosetta.protocols.features.InterfaceFeatures, db_session: pyrosetta.rosetta.utility.sql_database.session) → None¶: C++: protocols::features::InterfaceFeatures::write_interface_schema_to_db(class std::shared_ptr<class utility::sql_database::session>) const –> void

write_interface_side_schema_to_db(self: pyrosetta.rosetta.protocols.features.InterfaceFeatures, db_session: pyrosetta.rosetta.utility.sql_database.session) → None¶: C++: protocols::features::InterfaceFeatures::write_interface_side_schema_to_db(class std::shared_ptr<class utility::sql_database::session>) const –> void

write_schema_to_db(self: pyrosetta.rosetta.protocols.antibody.AntibodyFeatures, db_session: pyrosetta.rosetta.utility.sql_database.session) → None¶

return string with class name

C++: protocols::antibody::AntibodyFeatures::write_schema_to_db(class std::shared_ptr<class utility::sql_database::session>) const –> void

class pyrosetta.rosetta.protocols.antibody.AntibodyFeaturesCreator¶

Bases: pyrosetta.rosetta.protocols.features.FeaturesReporterCreator

creator for the HBondParameterFeatures 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.protocols.antibody.AntibodyFeaturesCreator) → 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.antibody.AntibodyFeaturesCreator, : pyrosetta.rosetta.protocols.antibody.AntibodyFeaturesCreator) → pyrosetta.rosetta.protocols.antibody.AntibodyFeaturesCreator¶: C++: protocols::antibody::AntibodyFeaturesCreator::operator=(const class protocols::antibody::AntibodyFeaturesCreator &) –> class protocols::antibody::AntibodyFeaturesCreator &

create_features_reporter(self: pyrosetta.rosetta.protocols.antibody.AntibodyFeaturesCreator) → pyrosetta.rosetta.protocols.features.FeaturesReporter¶: C++: protocols::antibody::AntibodyFeaturesCreator::create_features_reporter() const –> class std::shared_ptr<class protocols::features::FeaturesReporter>

provide_xml_schema(self: pyrosetta.rosetta.protocols.antibody.AntibodyFeaturesCreator, xsd: pyrosetta.rosetta.utility.tag.XMLSchemaDefinition) → None¶: C++: protocols::antibody::AntibodyFeaturesCreator::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) const –> void

type_name(self: pyrosetta.rosetta.protocols.antibody.AntibodyFeaturesCreator) → str¶: C++: protocols::antibody::AntibodyFeaturesCreator::type_name() const –> std::string

class pyrosetta.rosetta.protocols.antibody.AntibodyInfo¶

Bases: pybind11_builtins.pybind11_object

This class is used to get all relevant information you would need when dealing with an antibody.

It mainly holds numbering information, but passes out a variety of Rosetta specific objects like movemaps, Loops, taskfactories, etc.: as well as other information such as CDR cluster type, camelid, H3 types, etc.

__delattr__¶: Implement delattr(self, name).

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

__eq__¶: Return self==value.

__format__()¶: default object formatter

__ge__¶: Return self>=value.

__getattribute__¶: Return getattr(self, name).

__gt__¶: Return self>value.

__hash__¶: Return hash(self).

__init__(*args, **kwargs)¶

Overloaded function.

__init__(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, arg0: pyrosetta.rosetta.core.pose.Pose) -> None

doc

__init__(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, pose: pyrosetta.rosetta.core.pose.Pose, cdr_pdb_numbered: bool) -> None
__init__(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, arg0: pyrosetta.rosetta.core.pose.Pose, arg1: pyrosetta.rosetta.protocols.antibody.AntibodyNumberingSchemeEnum, arg2: pyrosetta.rosetta.protocols.antibody.CDRDefinitionEnum) -> None

doc

__init__(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, pose: pyrosetta.rosetta.core.pose.Pose, numbering_scheme: pyrosetta.rosetta.protocols.antibody.AntibodyNumberingSchemeEnum, cdr_definition: pyrosetta.rosetta.protocols.antibody.CDRDefinitionEnum, cdr_pdb_numbered: bool) -> None
__init__(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, arg0: pyrosetta.rosetta.core.pose.Pose, arg1: pyrosetta.rosetta.protocols.antibody.CDRDefinitionEnum) -> None

doc

__init__(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, pose: pyrosetta.rosetta.core.pose.Pose, cdr_definition: pyrosetta.rosetta.protocols.antibody.CDRDefinitionEnum, cdr_pdb_numbered: bool) -> None
__init__(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, arg0: pyrosetta.rosetta.protocols.antibody.AntibodyInfo) -> 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.protocols.antibody.AntibodyInfo) → str¶

__subclasshook__()¶

Abstract classes can override this to customize issubclass().

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

add_CDR_to_MoveMap(*args, **kwargs)¶

Overloaded function.

add_CDR_to_MoveMap(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, pose: pyrosetta.rosetta.core.pose.Pose, movemap: pyrosetta.rosetta.core.kinematics.MoveMap, cdr_name: pyrosetta.rosetta.protocols.antibody.CDRNameEnum) -> None
add_CDR_to_MoveMap(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, pose: pyrosetta.rosetta.core.pose.Pose, movemap: pyrosetta.rosetta.core.kinematics.MoveMap, cdr_name: pyrosetta.rosetta.protocols.antibody.CDRNameEnum, bb_only: bool) -> None
add_CDR_to_MoveMap(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, pose: pyrosetta.rosetta.core.pose.Pose, movemap: pyrosetta.rosetta.core.kinematics.MoveMap, cdr_name: pyrosetta.rosetta.protocols.antibody.CDRNameEnum, bb_only: bool, include_nb_sc: bool) -> None
add_CDR_to_MoveMap(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, pose: pyrosetta.rosetta.core.pose.Pose, movemap: pyrosetta.rosetta.core.kinematics.MoveMap, cdr_name: pyrosetta.rosetta.protocols.antibody.CDRNameEnum, bb_only: bool, include_nb_sc: bool, nb_dist: float) -> None

Add CDR flexibility to a movemap. Uses pose for numbering.

C++: protocols::antibody::AntibodyInfo::add_CDR_to_MoveMap(const class core::pose::Pose &, class std::shared_ptr<class core::kinematics::MoveMap>, const enum protocols::antibody::CDRNameEnum, const bool &, const bool &, const double &) const –> void

antigen_present(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo) → bool¶

return whether this pose has antigen or not

C++: protocols::antibody::AntibodyInfo::antigen_present() const –> bool

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

clone(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo) → pyrosetta.rosetta.protocols.antibody.AntibodyInfo¶

Clone the pointer.

C++: protocols::antibody::AntibodyInfo::clone() const –> class std::shared_ptr<class protocols::antibody::AntibodyInfo>

get_AllCDRs_in_loopsop(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo) → pyrosetta.rosetta.protocols.loops.Loops¶

return a LoopsOP object, initialized upon class construction.

C++: protocols::antibody::AntibodyInfo::get_AllCDRs_in_loopsop() const –> class std::shared_ptr<class protocols::loops::Loops>

get_CDR_chain(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, cdr_name: pyrosetta.rosetta.protocols.antibody.CDRNameEnum) → str¶: C++: protocols::antibody::AntibodyInfo::get_CDR_chain(const enum protocols::antibody::CDRNameEnum) const –> char

get_CDR_cluster(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, cdr_name: pyrosetta.rosetta.protocols.antibody.CDRNameEnum) → pyrosetta.rosetta.protocols.antibody.clusters.CDRCluster¶

get the cdr’s cluster identity and distance to cluster using it’s structure as a CDRCluster object.

See North, B., A. Lehmann, et al. (2011). JMB 406(2): 228-256.

Must use setup_CDR_clusters first.

If this AbInfo does not have all 6 chains, CDRClusterOP may be NULL if the CDR is not present to begin with.

C++: protocols::antibody::AntibodyInfo::get_CDR_cluster(const enum protocols::antibody::CDRNameEnum) const –> class std::shared_ptr<const class protocols::antibody::clusters::CDRCluster>

get_CDR_cluster_set(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo) → pyrosetta.rosetta.protocols.antibody.clusters.CDRClusterSet¶: C++: protocols::antibody::AntibodyInfo::get_CDR_cluster_set() const –> class std::shared_ptr<class protocols::antibody::clusters::CDRClusterSet>

get_CDR_end(*args, **kwargs)¶

Overloaded function.

get_CDR_end(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, cdr_name: pyrosetta.rosetta.protocols.antibody.CDRNameEnum, pose: pyrosetta.rosetta.core.pose.Pose) -> int

Return pose number of CDR end residue in the definition of the numbering scheme of transform.

C++: protocols::antibody::AntibodyInfo::get_CDR_end(const enum protocols::antibody::CDRNameEnum, const class core::pose::Pose &) const –> unsigned long

get_CDR_end(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, cdr_name: pyrosetta.rosetta.protocols.antibody.CDRNameEnum, pose: pyrosetta.rosetta.core.pose.Pose, transform: pyrosetta.rosetta.protocols.antibody.CDRDefinitionEnum) -> int

C++: protocols::antibody::AntibodyInfo::get_CDR_end(const enum protocols::antibody::CDRNameEnum, const class core::pose::Pose &, const enum protocols::antibody::CDRDefinitionEnum &) const –> unsigned long

get_CDR_end_PDB_num(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, cdr_name: pyrosetta.rosetta.protocols.antibody.CDRNameEnum) → int¶

Return PDB residue number of CDR end residue

C++: protocols::antibody::AntibodyInfo::get_CDR_end_PDB_num(const enum protocols::antibody::CDRNameEnum) const –> unsigned long

get_CDR_in_loopsop(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, cdr_name: pyrosetta.rosetta.protocols.antibody.CDRNameEnum) → pyrosetta.rosetta.protocols.loops.Loops¶

return the loop of a certain loop type

C++: protocols::antibody::AntibodyInfo::get_CDR_in_loopsop(const enum protocols::antibody::CDRNameEnum) const –> class std::shared_ptr<class protocols::loops::Loops>

get_CDR_length(*args, **kwargs)¶

Overloaded function.

get_CDR_length(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, cdr_name: pyrosetta.rosetta.protocols.antibody.CDRNameEnum) -> int

get the length of the cdr upon construction of AntibodyInfo

Does not work for proto CDR4 (DE loop)

C++: protocols::antibody::AntibodyInfo::get_CDR_length(const enum protocols::antibody::CDRNameEnum) const –> unsigned long

get_CDR_length(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, cdr_name: pyrosetta.rosetta.protocols.antibody.CDRNameEnum, pose: pyrosetta.rosetta.core.pose.Pose) -> int

On-the-fly CDR length.

C++: protocols::antibody::AntibodyInfo::get_CDR_length(const enum protocols::antibody::CDRNameEnum, const class core::pose::Pose &) const –> unsigned long

get_CDR_length(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, cdr_name: pyrosetta.rosetta.protocols.antibody.CDRNameEnum, pose: pyrosetta.rosetta.core.pose.Pose, transform: pyrosetta.rosetta.protocols.antibody.CDRDefinitionEnum) -> int

C++: protocols::antibody::AntibodyInfo::get_CDR_length(const enum protocols::antibody::CDRNameEnum, const class core::pose::Pose &, const enum protocols::antibody::CDRDefinitionEnum) const –> unsigned long

get_CDR_loop(*args, **kwargs)¶

Overloaded function.

get_CDR_loop(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, cdr_name: pyrosetta.rosetta.protocols.antibody.CDRNameEnum) -> pyrosetta.rosetta.protocols.loops.Loop

return the loop of a certain loop type

C++: protocols::antibody::AntibodyInfo::get_CDR_loop(const enum protocols::antibody::CDRNameEnum) const –> class protocols::loops::Loop

get_CDR_loop(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, cdr_name: pyrosetta.rosetta.protocols.antibody.CDRNameEnum, pose: pyrosetta.rosetta.core.pose.Pose) -> pyrosetta.rosetta.protocols.loops.Loop
get_CDR_loop(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, cdr_name: pyrosetta.rosetta.protocols.antibody.CDRNameEnum, pose: pyrosetta.rosetta.core.pose.Pose, overhang: int) -> pyrosetta.rosetta.protocols.loops.Loop

return the loop of a certain loop type on the fly

C++: protocols::antibody::AntibodyInfo::get_CDR_loop(const enum protocols::antibody::CDRNameEnum, const class core::pose::Pose &, unsigned long) const –> class protocols::loops::Loop

get_CDR_loop(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, cdr_name: pyrosetta.rosetta.protocols.antibody.CDRNameEnum, pose: pyrosetta.rosetta.core.pose.Pose, transform: pyrosetta.rosetta.protocols.antibody.CDRDefinitionEnum) -> pyrosetta.rosetta.protocols.loops.Loop
get_CDR_loop(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, cdr_name: pyrosetta.rosetta.protocols.antibody.CDRNameEnum, pose: pyrosetta.rosetta.core.pose.Pose, transform: pyrosetta.rosetta.protocols.antibody.CDRDefinitionEnum, overhang: int) -> pyrosetta.rosetta.protocols.loops.Loop

return the loop of a certain loop type in definitions of the numbering scheme transform.

C++: protocols::antibody::AntibodyInfo::get_CDR_loop(const enum protocols::antibody::CDRNameEnum, const class core::pose::Pose &, const enum protocols::antibody::CDRDefinitionEnum, unsigned long) const –> class protocols::loops::Loop

get_CDR_loops(*args, **kwargs)¶

Overloaded function.

get_CDR_loops(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, pose: pyrosetta.rosetta.core.pose.Pose) -> pyrosetta.rosetta.protocols.loops.Loops
get_CDR_loops(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, pose: pyrosetta.rosetta.core.pose.Pose, overhang: int) -> pyrosetta.rosetta.protocols.loops.Loops

On-the-fly CDR LoopsOP

C++: protocols::antibody::AntibodyInfo::get_CDR_loops(const class core::pose::Pose &, unsigned long) const –> class std::shared_ptr<class protocols::loops::Loops>

get_CDR_loops(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, pose: pyrosetta.rosetta.core.pose.Pose, cdrs: pyrosetta.rosetta.utility.vector1_bool) -> pyrosetta.rosetta.protocols.loops.Loops
get_CDR_loops(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, pose: pyrosetta.rosetta.core.pose.Pose, cdrs: pyrosetta.rosetta.utility.vector1_bool, overhang: int) -> pyrosetta.rosetta.protocols.loops.Loops

C++: protocols::antibody::AntibodyInfo::get_CDR_loops(const class core::pose::Pose &, const class utility::vector1<bool, class std::allocator<bool> > &, unsigned long) const –> class std::shared_ptr<class protocols::loops::Loops>

get_CDR_name(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, cdr_name: pyrosetta.rosetta.protocols.antibody.CDRNameEnum) → str¶: C++: protocols::antibody::AntibodyInfo::get_CDR_name(const enum protocols::antibody::CDRNameEnum) const –> std::string

get_CDR_name_enum(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, cdr_name: str) → pyrosetta.rosetta.protocols.antibody.CDRNameEnum¶: C++: protocols::antibody::AntibodyInfo::get_CDR_name_enum(const class std::basic_string<char> &) const –> enum protocols::antibody::CDRNameEnum

get_CDR_sequence_with_stem(*args, **kwargs)¶

Overloaded function.

get_CDR_sequence_with_stem(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, cdr_name: pyrosetta.rosetta.protocols.antibody.CDRNameEnum) -> str
get_CDR_sequence_with_stem(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, cdr_name: pyrosetta.rosetta.protocols.antibody.CDRNameEnum, left_stem: int) -> str
get_CDR_sequence_with_stem(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, cdr_name: pyrosetta.rosetta.protocols.antibody.CDRNameEnum, left_stem: int, right_stem: int) -> str

return the sequence of a particular CDR loop: Deprecated in favor of on the fly sequence.

C++: protocols::antibody::AntibodyInfo::get_CDR_sequence_with_stem(const enum protocols::antibody::CDRNameEnum, unsigned long, unsigned long) const –> std::string

get_CDR_sequence_with_stem(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, cdr_name: pyrosetta.rosetta.protocols.antibody.CDRNameEnum, pose: pyrosetta.rosetta.core.pose.Pose) -> str
get_CDR_sequence_with_stem(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, cdr_name: pyrosetta.rosetta.protocols.antibody.CDRNameEnum, pose: pyrosetta.rosetta.core.pose.Pose, left_stem: int) -> str
get_CDR_sequence_with_stem(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, cdr_name: pyrosetta.rosetta.protocols.antibody.CDRNameEnum, pose: pyrosetta.rosetta.core.pose.Pose, left_stem: int, right_stem: int) -> str

On-The-Fly CDR sequence

C++: protocols::antibody::AntibodyInfo::get_CDR_sequence_with_stem(const enum protocols::antibody::CDRNameEnum, const class core::pose::Pose &, unsigned long, unsigned long) const –> std::string

get_CDR_sequence_with_stem(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, cdr_name: pyrosetta.rosetta.protocols.antibody.CDRNameEnum, pose: pyrosetta.rosetta.core.pose.Pose, left_stem: int, right_stem: int, transform: pyrosetta.rosetta.protocols.antibody.CDRDefinitionEnum) -> str

On-The-Fly CDR sequence

C++: protocols::antibody::AntibodyInfo::get_CDR_sequence_with_stem(const enum protocols::antibody::CDRNameEnum, const class core::pose::Pose &, unsigned long, unsigned long, const enum protocols::antibody::CDRDefinitionEnum &) const –> std::string

get_CDR_start(*args, **kwargs)¶

Overloaded function.

get_CDR_start(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, cdr_name: pyrosetta.rosetta.protocols.antibody.CDRNameEnum, pose: pyrosetta.rosetta.core.pose.Pose) -> int

Return pose number of CDR start residue

C++: protocols::antibody::AntibodyInfo::get_CDR_start(const enum protocols::antibody::CDRNameEnum, const class core::pose::Pose &) const –> unsigned long

get_CDR_start(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, cdr_name: pyrosetta.rosetta.protocols.antibody.CDRNameEnum, pose: pyrosetta.rosetta.core.pose.Pose, transform: pyrosetta.rosetta.protocols.antibody.CDRDefinitionEnum) -> int

C++: protocols::antibody::AntibodyInfo::get_CDR_start(const enum protocols::antibody::CDRNameEnum, const class core::pose::Pose &, const enum protocols::antibody::CDRDefinitionEnum &) const –> unsigned long

get_CDR_start_PDB_num(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, cdr_name: pyrosetta.rosetta.protocols.antibody.CDRNameEnum) → int¶

Return PDB residue number of CDR start residue

C++: protocols::antibody::AntibodyInfo::get_CDR_start_PDB_num(const enum protocols::antibody::CDRNameEnum) const –> unsigned long

get_FoldTree_AllCDRs(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, pose: pyrosetta.rosetta.core.pose.Pose) → pyrosetta.rosetta.core.kinematics.FoldTree¶: C++: protocols::antibody::AntibodyInfo::get_FoldTree_AllCDRs(const class core::pose::Pose &) const –> class std::shared_ptr<const class core::kinematics::FoldTree>

get_FoldTree_AllCDRs_LHDock(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, pose: pyrosetta.rosetta.core.pose.Pose) → pyrosetta.rosetta.core.kinematics.FoldTree¶: C++: protocols::antibody::AntibodyInfo::get_FoldTree_AllCDRs_LHDock(const class core::pose::Pose &) const –> class std::shared_ptr<const class core::kinematics::FoldTree>

get_FoldTree_LA_H(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, pose: pyrosetta.rosetta.core.pose.Pose) → pyrosetta.rosetta.core.kinematics.FoldTree¶: C++: protocols::antibody::AntibodyInfo::get_FoldTree_LA_H(const class core::pose::Pose &) const –> class core::kinematics::FoldTree

get_FoldTree_LH_A(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, pose: pyrosetta.rosetta.core.pose.Pose) → pyrosetta.rosetta.core.kinematics.FoldTree¶

SnugDock foldtrees

C++: protocols::antibody::AntibodyInfo::get_FoldTree_LH_A(const class core::pose::Pose &) const –> class core::kinematics::FoldTree

get_FoldTree_L_HA(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, pose: pyrosetta.rosetta.core.pose.Pose) → pyrosetta.rosetta.core.kinematics.FoldTree¶: C++: protocols::antibody::AntibodyInfo::get_FoldTree_L_HA(const class core::pose::Pose &) const –> class core::kinematics::FoldTree

get_H3_kink_type(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo) → pyrosetta.rosetta.protocols.antibody.H3BaseTypeEnum¶

get H3 cterminal kink/extended conformation (predicted by constructor)

C++: protocols::antibody::AntibodyInfo::get_H3_kink_type() const –> enum protocols::antibody::H3BaseTypeEnum

get_H3_kink_type_name(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo) → str¶: C++: protocols::antibody::AntibodyInfo::get_H3_kink_type_name() const –> std::string

get_MoveMap_for_AllCDRsSideChains_and_H3backbone(*args, **kwargs)¶

Overloaded function.

get_MoveMap_for_AllCDRsSideChains_and_H3backbone(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, pose: pyrosetta.rosetta.core.pose.Pose) -> pyrosetta.rosetta.core.kinematics.MoveMap
get_MoveMap_for_AllCDRsSideChains_and_H3backbone(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, pose: pyrosetta.rosetta.core.pose.Pose, include_nb_sc: bool) -> pyrosetta.rosetta.core.kinematics.MoveMap
get_MoveMap_for_AllCDRsSideChains_and_H3backbone(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, pose: pyrosetta.rosetta.core.pose.Pose, include_nb_sc: bool, nb_dist: float) -> pyrosetta.rosetta.core.kinematics.MoveMap

C++: protocols::antibody::AntibodyInfo::get_MoveMap_for_AllCDRsSideChains_and_H3backbone(const class core::pose::Pose &, const bool &, const double &) const –> class core::kinematics::MoveMap

get_MoveMap_for_Loops(*args, **kwargs)¶

Overloaded function.

get_MoveMap_for_Loops(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, pose: pyrosetta.rosetta.core.pose.Pose, the_loops: pyrosetta.rosetta.protocols.loops.Loops) -> pyrosetta.rosetta.core.kinematics.MoveMap
get_MoveMap_for_Loops(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, pose: pyrosetta.rosetta.core.pose.Pose, the_loops: pyrosetta.rosetta.protocols.loops.Loops, bb_only: bool) -> pyrosetta.rosetta.core.kinematics.MoveMap
get_MoveMap_for_Loops(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, pose: pyrosetta.rosetta.core.pose.Pose, the_loops: pyrosetta.rosetta.protocols.loops.Loops, bb_only: bool, include_nb_sc: bool) -> pyrosetta.rosetta.core.kinematics.MoveMap
get_MoveMap_for_Loops(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, pose: pyrosetta.rosetta.core.pose.Pose, the_loops: pyrosetta.rosetta.protocols.loops.Loops, bb_only: bool, include_nb_sc: bool, nb_dist: float) -> pyrosetta.rosetta.core.kinematics.MoveMap

TODO: this should be a standard utility for loops?

get a movemap for loops.

C++: protocols::antibody::AntibodyInfo::get_MoveMap_for_Loops(const class core::pose::Pose &, const class protocols::loops::Loops &, const bool &, const bool &, const double &) const –> class core::kinematics::MoveMap

get_MoveMap_for_LoopsandDock(*args, **kwargs)¶

Overloaded function.

get_MoveMap_for_LoopsandDock(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, pose: pyrosetta.rosetta.core.pose.Pose, the_loops: pyrosetta.rosetta.protocols.loops.Loops) -> pyrosetta.rosetta.core.kinematics.MoveMap
get_MoveMap_for_LoopsandDock(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, pose: pyrosetta.rosetta.core.pose.Pose, the_loops: pyrosetta.rosetta.protocols.loops.Loops, bb_only: bool) -> pyrosetta.rosetta.core.kinematics.MoveMap
get_MoveMap_for_LoopsandDock(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, pose: pyrosetta.rosetta.core.pose.Pose, the_loops: pyrosetta.rosetta.protocols.loops.Loops, bb_only: bool, include_nb_sc: bool) -> pyrosetta.rosetta.core.kinematics.MoveMap
get_MoveMap_for_LoopsandDock(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, pose: pyrosetta.rosetta.core.pose.Pose, the_loops: pyrosetta.rosetta.protocols.loops.Loops, bb_only: bool, include_nb_sc: bool, nb_dist: float) -> pyrosetta.rosetta.core.kinematics.MoveMap

get a movemap for loops and set the first jump be true

C++: protocols::antibody::AntibodyInfo::get_MoveMap_for_LoopsandDock(const class core::pose::Pose &, const class protocols::loops::Loops &, const bool &, const bool &, const double &) const –> class core::kinematics::MoveMap

get_PackingAngleResidues(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo) → pyrosetta.rosetta.utility.vector1_unsigned_long¶

get residues used to calculate VL/VH packing angle

C++: protocols::antibody::AntibodyInfo::get_PackingAngleResidues() const –> class utility::vector1<unsigned long, class std::allocator<unsigned long> >

get_TaskFactory_AllCDRs(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, pose: pyrosetta.rosetta.core.pose.Pose) → pyrosetta.rosetta.core.pack.task.TaskFactory¶

TaskFactory

C++: protocols::antibody::AntibodyInfo::get_TaskFactory_AllCDRs(class core::pose::Pose &) const –> class std::shared_ptr<class core::pack::task::TaskFactory>

get_TaskFactory_OneCDR(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, pose: pyrosetta.rosetta.core.pose.Pose, cdr_name: pyrosetta.rosetta.protocols.antibody.CDRNameEnum) → pyrosetta.rosetta.core.pack.task.TaskFactory¶: C++: protocols::antibody::AntibodyInfo::get_TaskFactory_OneCDR(class core::pose::Pose &, const enum protocols::antibody::CDRNameEnum) const –> class std::shared_ptr<class core::pack::task::TaskFactory>

get_all_cdrs(*args, **kwargs)¶

Overloaded function.

get_all_cdrs(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo) -> pyrosetta.rosetta.utility.vector1_protocols_antibody_CDRNameEnum
get_all_cdrs(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, include_proto_cdr4: bool) -> pyrosetta.rosetta.utility.vector1_protocols_antibody_CDRNameEnum

Get a vector of all CDRs. Easy to iterate on.

C++: protocols::antibody::AntibodyInfo::get_all_cdrs(bool) const –> const class utility::vector1<enum protocols::antibody::CDRNameEnum, class std::allocator<enum protocols::antibody::CDRNameEnum> > &

get_all_cdrs_present(*args, **kwargs)¶

Overloaded function.

get_all_cdrs_present(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo) -> pyrosetta.rosetta.utility.vector1_protocols_antibody_CDRNameEnum
get_all_cdrs_present(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, include_proto_cdr4: bool) -> pyrosetta.rosetta.utility.vector1_protocols_antibody_CDRNameEnum

Get a vector of all the CDRs in this antibody. Easy to iterate on.

C++: protocols::antibody::AntibodyInfo::get_all_cdrs_present(bool) const –> const class utility::vector1<enum protocols::antibody::CDRNameEnum, class std::allocator<enum protocols::antibody::CDRNameEnum> > &

get_antibody_chain_ids(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, pose: pyrosetta.rosetta.core.pose.Pose) → pyrosetta.rosetta.utility.vector1_unsigned_long¶: C++: protocols::antibody::AntibodyInfo::get_antibody_chain_ids(const class core::pose::Pose &) const –> class utility::vector1<unsigned long, class std::allocator<unsigned long> >

get_antibody_chain_string(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo) → str¶

Returns H or LH depeding on camelid.

C++: protocols::antibody::AntibodyInfo::get_antibody_chain_string() const –> std::string

get_antibody_chains(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo) → pyrosetta.rosetta.utility.vector1_char¶: C++: protocols::antibody::AntibodyInfo::get_antibody_chains() const –> class utility::vector1<char, class std::allocator<char> >

get_antibody_enum_manager(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo) → pyrosetta.rosetta.protocols.antibody.AntibodyEnumManager¶: C++: protocols::antibody::AntibodyInfo::get_antibody_enum_manager() const –> class std::shared_ptr<const class protocols::antibody::AntibodyEnumManager>

get_antibody_numbering_info(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo) → pyrosetta.rosetta.protocols.antibody.AntibodyNumbering¶

Get the full antibody numbering struct for use in anything.

C++: protocols::antibody::AntibodyInfo::get_antibody_numbering_info() const –> const struct protocols::antibody::AntibodyNumbering &

get_antibody_sequence(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo) → str¶

return the antibody sequence of LH or just H for camelid

C++: protocols::antibody::AntibodyInfo::get_antibody_sequence() const –> std::string

get_antigen_chain_ids(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, pose: pyrosetta.rosetta.core.pose.Pose) → pyrosetta.rosetta.utility.vector1_unsigned_long¶: C++: protocols::antibody::AntibodyInfo::get_antigen_chain_ids(const class core::pose::Pose &) const –> class utility::vector1<unsigned long, class std::allocator<unsigned long> >

get_antigen_chain_string(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo) → str¶

Return the antigen chains as a string

C++: protocols::antibody::AntibodyInfo::get_antigen_chain_string() const –> std::string

get_antigen_chains(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo) → pyrosetta.rosetta.utility.vector1_char¶

gets all non-LH chains. Empty vector if no antigen present.

C++: protocols::antibody::AntibodyInfo::get_antigen_chains() const –> class utility::vector1<char, class std::allocator<char> >

get_cdr_cluster_enum_manager(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo) → pyrosetta.rosetta.protocols.antibody.clusters.CDRClusterEnumManager¶: C++: protocols::antibody::AntibodyInfo::get_cdr_cluster_enum_manager() const –> class std::shared_ptr<const class protocols::antibody::clusters::CDRClusterEnumManager>

get_cdr_enum_for_cluster(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, cluster: pyrosetta.rosetta.protocols.antibody.clusters.CDRClusterEnum) → pyrosetta.rosetta.protocols.antibody.CDRNameEnum¶: C++: protocols::antibody::AntibodyInfo::get_cdr_enum_for_cluster(const enum protocols::antibody::clusters::CDRClusterEnum) const –> enum protocols::antibody::CDRNameEnum

get_cluster_enum(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, cluster: str) → pyrosetta.rosetta.protocols.antibody.clusters.CDRClusterEnum¶: C++: protocols::antibody::AntibodyInfo::get_cluster_enum(const class std::basic_string<char> &) const –> enum protocols::antibody::clusters::CDRClusterEnum

get_cluster_length(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, cluster: pyrosetta.rosetta.protocols.antibody.clusters.CDRClusterEnum) → int¶: C++: protocols::antibody::AntibodyInfo::get_cluster_length(const enum protocols::antibody::clusters::CDRClusterEnum) const –> unsigned long

get_cluster_name(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, cluster: pyrosetta.rosetta.protocols.antibody.clusters.CDRClusterEnum) → str¶: C++: protocols::antibody::AntibodyInfo::get_cluster_name(const enum protocols::antibody::clusters::CDRClusterEnum) const –> std::string

get_current_AntibodyNumberingScheme(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo) → str¶

: get the current numbering scheme being used

C++: protocols::antibody::AntibodyInfo::get_current_AntibodyNumberingScheme() const –> std::string

get_current_CDRDefinition(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo) → str¶: C++: protocols::antibody::AntibodyInfo::get_current_CDRDefinition() const –> std::string

get_landmark_resnum(*args, **kwargs)¶

Overloaded function.

get_landmark_resnum(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, pose: pyrosetta.rosetta.core.pose.Pose, scheme: pyrosetta.rosetta.protocols.antibody.AntibodyNumberingSchemeEnum, chain: str, pdb_resnum: int) -> int
get_landmark_resnum(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, pose: pyrosetta.rosetta.core.pose.Pose, scheme: pyrosetta.rosetta.protocols.antibody.AntibodyNumberingSchemeEnum, chain: str, pdb_resnum: int, insertion_code: str) -> int
get_landmark_resnum(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, pose: pyrosetta.rosetta.core.pose.Pose, scheme: pyrosetta.rosetta.protocols.antibody.AntibodyNumberingSchemeEnum, chain: str, pdb_resnum: int, insertion_code: str, fail_on_missing_resnum: bool) -> int

Used to get a residue number of a particular place in the framework or conserved residue in the CDR.

Use this instead of PDBInfo!!

If the current numbering scheme is not ‘scheme’, will return the equivalent position of the current numbering scheme using the transform scheme file in the database. Should not be used for residues within CDRs since numbering schemes vary greatly in their within cdr alignments and numbering. Use get_CDR_start/end/loop functions with relative positions for this purpose. Returns 0 if residue is not found in pose

C++: protocols::antibody::AntibodyInfo::get_landmark_resnum(const class core::pose::Pose &, const enum protocols::antibody::AntibodyNumberingSchemeEnum, const char, const unsigned long, const char, bool) const –> unsigned long

get_light_chain_type(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo) → str¶

Return if antibody is lambda, kappa or unknown. Type set via cmd-line option for now

C++: protocols::antibody::AntibodyInfo::get_light_chain_type() const –> std::string

get_light_chain_type_enum(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo) → pyrosetta.rosetta.protocols.antibody.LightChainTypeEnum¶

Return if antibody is lambda, kappa or unknown. Type set via cmd-line option for now

C++: protocols::antibody::AntibodyInfo::get_light_chain_type_enum() const –> enum protocols::antibody::LightChainTypeEnum

get_region_of_residue(*args, **kwargs)¶

Overloaded function.

get_region_of_residue(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, pose: pyrosetta.rosetta.core.pose.Pose, resnum: int) -> pyrosetta.rosetta.protocols.antibody.AntibodyRegionEnum
get_region_of_residue(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, pose: pyrosetta.rosetta.core.pose.Pose, resnum: int, de_as_framework: bool) -> pyrosetta.rosetta.protocols.antibody.AntibodyRegionEnum

Get the region of the resnum - aka - antigen_region, cdr_region, or framework_region: By default, count the DE region (CDR4) as framework.

C++: protocols::antibody::AntibodyInfo::get_region_of_residue(const class core::pose::Pose &, unsigned long, bool) const –> enum protocols::antibody::AntibodyRegionEnum

get_total_num_CDRs(*args, **kwargs)¶

Overloaded function.

get_total_num_CDRs(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo) -> pyrosetta.rosetta.protocols.antibody.CDRNameEnum
get_total_num_CDRs(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, include_proto_cdr4: bool) -> pyrosetta.rosetta.protocols.antibody.CDRNameEnum

return num of cdr loops, 3 (nanobody) or 6 (regular antibody)

C++: protocols::antibody::AntibodyInfo::get_total_num_CDRs(bool) const –> enum protocols::antibody::CDRNameEnum

has_CDR(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, cdr_name: pyrosetta.rosetta.protocols.antibody.CDRNameEnum) → bool¶

Does the antibody have this CDR?

See also:: is_camelid()) get_total_num_CDRs())

C++: protocols::antibody::AntibodyInfo::has_CDR(const enum protocols::antibody::CDRNameEnum) const –> bool

has_cluster_for_cdr(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, cdr_name: pyrosetta.rosetta.protocols.antibody.CDRNameEnum) → bool¶

Check to make sure AbInfo has a cluster object for this CDR. In that all 6 CDRs not nessessarily present for each antibody.

C++: protocols::antibody::AntibodyInfo::has_cluster_for_cdr(const enum protocols::antibody::CDRNameEnum) const –> bool

is_camelid(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo) → bool¶

return this antibody is camelid or not

C++: protocols::antibody::AntibodyInfo::is_camelid() const –> bool

kink_anion_atoms(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, pose: pyrosetta.rosetta.core.pose.Pose) → pyrosetta.rosetta.std.vector_numeric_xyzVector_double_t¶

return side chain anion atoms (typically Asp/Glu oxygens) in the kink bulge HBond

C++: protocols::antibody::AntibodyInfo::kink_anion_atoms(const class core::pose::Pose &) const –> class std::vector<class numeric::xyzVector<double>, class std::allocator<class numeric::xyzVector<double> > >

kink_anion_residue(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, pose: pyrosetta.rosetta.core.pose.Pose) → int¶

return pose residue number of the kink ‘anion’ (typically Asp/Glu) residue in the kink bulge HBond

C++: protocols::antibody::AntibodyInfo::kink_anion_residue(const class core::pose::Pose &) const –> unsigned long

kink_begin(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, pose: pyrosetta.rosetta.core.pose.Pose) → int¶

return pose residue number of the first residue of the H3 kink

C++: protocols::antibody::AntibodyInfo::kink_begin(const class core::pose::Pose &) const –> unsigned long

kink_cation_atoms(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, pose: pyrosetta.rosetta.core.pose.Pose) → pyrosetta.rosetta.std.vector_numeric_xyzVector_double_t¶

return side chain cation atoms (typically Lys/His nitrogens) in the kink bulge HBond

C++: protocols::antibody::AntibodyInfo::kink_cation_atoms(const class core::pose::Pose &) const –> class std::vector<class numeric::xyzVector<double>, class std::allocator<class numeric::xyzVector<double> > >

kink_cation_residue(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, pose: pyrosetta.rosetta.core.pose.Pose) → int¶

return pose residue number of the kink ‘cation’ (typically Arg/Lys) residue in the kink bulge HBond

C++: protocols::antibody::AntibodyInfo::kink_cation_residue(const class core::pose::Pose &) const –> unsigned long

kink_end(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, pose: pyrosetta.rosetta.core.pose.Pose) → int¶

return pose residue number of the last residue of the H3 kink

C++: protocols::antibody::AntibodyInfo::kink_end(const class core::pose::Pose &) const –> unsigned long

kink_trp(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, pose: pyrosetta.rosetta.core.pose.Pose) → int¶

return pose residue number of the last residue of the H3 kink

C++: protocols::antibody::AntibodyInfo::kink_trp(const class core::pose::Pose &) const –> unsigned long

set_CDR_cluster(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, cdr: pyrosetta.rosetta.protocols.antibody.CDRNameEnum, cluster: pyrosetta.rosetta.protocols.antibody.clusters.CDRCluster) → None¶

Manually set the CDR cluster for a particular CDR

C++: protocols::antibody::AntibodyInfo::set_CDR_cluster(enum protocols::antibody::CDRNameEnum, class std::shared_ptr<const class protocols::antibody::clusters::CDRCluster>) –> void

setup_CDR_cluster(*args, **kwargs)¶

Overloaded function.

setup_CDR_cluster(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, pose: pyrosetta.rosetta.core.pose.Pose, cdr: pyrosetta.rosetta.protocols.antibody.CDRNameEnum) -> None
setup_CDR_cluster(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, pose: pyrosetta.rosetta.core.pose.Pose, cdr: pyrosetta.rosetta.protocols.antibody.CDRNameEnum, attempt_set_from_pose: bool) -> None

setup the clustering information for a particular CDR.: Optionally, attempt to set the CDR cluster from the Pose data cache if any data is there.

C++: protocols::antibody::AntibodyInfo::setup_CDR_cluster(const class core::pose::Pose &, enum protocols::antibody::CDRNameEnum, bool) –> void

setup_CDR_clusters(*args, **kwargs)¶

Overloaded function.

setup_CDR_clusters(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, pose: pyrosetta.rosetta.core.pose.Pose) -> None
setup_CDR_clusters(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, pose: pyrosetta.rosetta.core.pose.Pose, attempt_set_from_pose: bool) -> None

setup the clustering information for each CDR to totalCDRLoops: Optionally, attempt to set the CDR cluster from the Pose data cache if any data is there.

C++: protocols::antibody::AntibodyInfo::setup_CDR_clusters(const class core::pose::Pose &, bool) –> void

setup_CDR_clusters(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, pose: pyrosetta.rosetta.core.pose.Pose, cdrs: pyrosetta.rosetta.utility.vector1_bool) -> None
setup_CDR_clusters(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, pose: pyrosetta.rosetta.core.pose.Pose, cdrs: pyrosetta.rosetta.utility.vector1_bool, attempt_set_from_pose: bool) -> None

setup the clustering information for each CDR according to boolean vector.: Optionally, attempt to set the CDR cluster from the Pose data cache if any data is there.

C++: protocols::antibody::AntibodyInfo::setup_CDR_clusters(const class core::pose::Pose &, const class utility::vector1<bool, class std::allocator<bool> > &, bool) –> void

setup_simple_fold_tree(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, jumppoint1: int, cutpoint: int, jumppoint2: int, pose: pyrosetta.rosetta.core.pose.Pose) → pyrosetta.rosetta.core.kinematics.FoldTree¶: C++: protocols::antibody::AntibodyInfo::setup_simple_fold_tree(const unsigned long &, const unsigned long &, const unsigned long &, const class core::pose::Pose &) const –> class std::shared_ptr<const class core::kinematics::FoldTree>

show(*args, **kwargs)¶

Overloaded function.

show(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo) -> None
show(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, out: pyrosetta.rosetta.std.ostream) -> None

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

class pyrosetta.rosetta.protocols.antibody.AntibodyNumberingConverterMover¶

Bases: pyrosetta.rosetta.protocols.moves.Mover

Converts numbering schemes of an antibody, independant of AntibodyInfo.: By default, works on a SINGLE antibody FAB with chains L and H, as in the rest of Rosetta.

Usable Numbering Schemes:

Chothia_Scheme Enhanced_Chothia_Scheme AHO_Scheme Kabat_Scheme IMGT_Scheme

__delattr__¶: Implement delattr(self, name).

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

__eq__¶: Return self==value.

__format__()¶: default object formatter

__ge__¶: Return self>=value.

__getattribute__¶: Return getattr(self, name).

__gt__¶: Return self>value.

__hash__¶: Return hash(self).

__init__(*args, **kwargs)¶

Overloaded function.

__init__(self: pyrosetta.rosetta.protocols.antibody.AntibodyNumberingConverterMover) -> None
__init__(self: pyrosetta.rosetta.protocols.antibody.AntibodyNumberingConverterMover, from: pyrosetta.rosetta.protocols.antibody.AntibodyNumberingSchemeEnum, to: pyrosetta.rosetta.protocols.antibody.AntibodyNumberingSchemeEnum) -> None
__init__(self: pyrosetta.rosetta.protocols.antibody.AntibodyNumberingConverterMover, arg0: pyrosetta.rosetta.protocols.antibody.AntibodyNumberingConverterMover) -> 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.protocols.antibody.AntibodyNumberingConverterMover) → 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).

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

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

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

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

clear_info is called by jd2 before calling apply

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

clone(self: pyrosetta.rosetta.protocols.antibody.AntibodyNumberingConverterMover) → pyrosetta.rosetta.protocols.moves.Mover¶

required in the context of the parser/scripting scheme

C++: protocols::antibody::AntibodyNumberingConverterMover::clone() const –> class std::shared_ptr<class protocols::moves::Mover>

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

fresh_instance(self: pyrosetta.rosetta.protocols.antibody.AntibodyNumberingConverterMover) → pyrosetta.rosetta.protocols.moves.Mover¶

required in the context of the parser/scripting scheme

C++: protocols::antibody::AntibodyNumberingConverterMover::fresh_instance() const –> class std::shared_ptr<class protocols::moves::Mover>

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

fpd

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

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

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

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

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

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

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

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

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

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

get_name(self: pyrosetta.rosetta.protocols.antibody.AntibodyNumberingConverterMover) → str¶: C++: protocols::antibody::AntibodyNumberingConverterMover::get_name() const –> std::string

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

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

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

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

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

non-const accessor

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

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

mover_name() → str¶: C++: protocols::antibody::AntibodyNumberingConverterMover::mover_name() –> std::string

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

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

register_options() → None¶

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

setter for poses contained for rms

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

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

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

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

set_scheme_conversion(self: pyrosetta.rosetta.protocols.antibody.AntibodyNumberingConverterMover, from: pyrosetta.rosetta.protocols.antibody.AntibodyNumberingSchemeEnum, to: pyrosetta.rosetta.protocols.antibody.AntibodyNumberingSchemeEnum) → None¶

Set the scheme to convert the pose into.

C++: protocols::antibody::AntibodyNumberingConverterMover::set_scheme_conversion(const enum protocols::antibody::AntibodyNumberingSchemeEnum, const enum protocols::antibody::AntibodyNumberingSchemeEnum) –> void

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

show(*args, **kwargs)¶

Overloaded function.

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

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

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

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

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

type(*args, **kwargs)¶

Overloaded function.

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

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

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

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

class pyrosetta.rosetta.protocols.antibody.AntibodyNumberingParser¶

Bases: pybind11_builtins.pybind11_object

Class responsible for reading database Numbering Scheme definitions and their transforms from the database.

__delattr__¶: Implement delattr(self, name).

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

__eq__¶: Return self==value.

__format__()¶: default object formatter

__ge__¶: Return self>=value.

__getattribute__¶: Return getattr(self, name).

__gt__¶: Return self>value.

__hash__¶: Return hash(self).

__init__(*args, **kwargs)¶

Overloaded function.

__init__(self: pyrosetta.rosetta.protocols.antibody.AntibodyNumberingParser, enum_manager: pyrosetta.rosetta.protocols.antibody.AntibodyEnumManager) -> None
__init__(self: pyrosetta.rosetta.protocols.antibody.AntibodyNumberingParser, arg0: pyrosetta.rosetta.protocols.antibody.AntibodyNumberingParser) -> 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.antibody.AntibodyNumberingParser, : pyrosetta.rosetta.protocols.antibody.AntibodyNumberingParser) → pyrosetta.rosetta.protocols.antibody.AntibodyNumberingParser¶: C++: protocols::antibody::AntibodyNumberingParser::operator=(const class protocols::antibody::AntibodyNumberingParser &) –> class protocols::antibody::AntibodyNumberingParser &

get_antibody_numbering(self: pyrosetta.rosetta.protocols.antibody.AntibodyNumberingParser, numbering_scheme: pyrosetta.rosetta.protocols.antibody.AntibodyNumberingSchemeEnum, cdr_definition: pyrosetta.rosetta.protocols.antibody.CDRDefinitionEnum) → pyrosetta.rosetta.protocols.antibody.AntibodyNumbering¶

Read numbering file and return AntibodyNumbering structure

C++: protocols::antibody::AntibodyNumberingParser::get_antibody_numbering(const enum protocols::antibody::AntibodyNumberingSchemeEnum, const enum protocols::antibody::CDRDefinitionEnum) –> struct protocols::antibody::AntibodyNumbering

class pyrosetta.rosetta.protocols.antibody.CDRLandmarkEnum¶

Bases: pybind11_builtins.pybind11_object

Main enumerator for AntibodyNumbering.

__delattr__¶: Implement delattr(self, name).

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

__eq__(*args, **kwargs)¶

Overloaded function.

__eq__(self: pyrosetta.rosetta.protocols.antibody.CDRLandmarkEnum, arg0: pyrosetta.rosetta.protocols.antibody.CDRLandmarkEnum) -> bool
__eq__(self: pyrosetta.rosetta.protocols.antibody.CDRLandmarkEnum, arg0: int) -> bool

__format__()¶: default object formatter

__ge__¶: Return self>=value.

__getattribute__¶: Return getattr(self, name).

__getstate__(self: pyrosetta.rosetta.protocols.antibody.CDRLandmarkEnum) → tuple¶

__gt__¶: Return self>value.

__hash__(self: pyrosetta.rosetta.protocols.antibody.CDRLandmarkEnum) → int¶

__init__(self: pyrosetta.rosetta.protocols.antibody.CDRLandmarkEnum, arg0: int) → None¶

__init_subclass__()¶

This method is called when a class is subclassed.

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

__int__(self: pyrosetta.rosetta.protocols.antibody.CDRLandmarkEnum) → int¶

__le__¶: Return self<=value.

__lt__¶: Return self<value.

__ne__(*args, **kwargs)¶

Overloaded function.

__ne__(self: pyrosetta.rosetta.protocols.antibody.CDRLandmarkEnum, arg0: pyrosetta.rosetta.protocols.antibody.CDRLandmarkEnum) -> bool
__ne__(self: pyrosetta.rosetta.protocols.antibody.CDRLandmarkEnum, arg0: int) -> bool

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

__reduce__()¶: helper for pickle

__reduce_ex__()¶: helper for pickle

__repr__(self: pyrosetta.rosetta.protocols.antibody.CDRLandmarkEnum) → str¶

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

__setstate__(self: pyrosetta.rosetta.protocols.antibody.CDRLandmarkEnum, arg0: tuple) → None¶

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

__str__¶: Return str(self).

__subclasshook__()¶

Abstract classes can override this to customize issubclass().

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

class pyrosetta.rosetta.protocols.antibody.CDRSetOptions¶

Bases: pybind11_builtins.pybind11_object

Class that holds instructions for a single CDR for loading from the antibody database. Default is instructions to load all CDRs from the database

__delattr__¶: Implement delattr(self, name).

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

__eq__¶: Return self==value.

__format__()¶: default object formatter

__ge__¶: Return self>=value.

__getattribute__¶: Return getattr(self, name).

__gt__¶: Return self>value.

__hash__¶: Return hash(self).

__init__(*args, **kwargs)¶

Overloaded function.

__init__(self: pyrosetta.rosetta.protocols.antibody.CDRSetOptions) -> None

doc

__init__(self: pyrosetta.rosetta.protocols.antibody.CDRSetOptions, load: bool) -> None
__init__(self: pyrosetta.rosetta.protocols.antibody.CDRSetOptions, arg0: pyrosetta.rosetta.protocols.antibody.CDRNameEnum) -> None

doc

__init__(self: pyrosetta.rosetta.protocols.antibody.CDRSetOptions, cdr: pyrosetta.rosetta.protocols.antibody.CDRNameEnum, load: bool) -> None
__init__(self: pyrosetta.rosetta.protocols.antibody.CDRSetOptions, arg0: pyrosetta.rosetta.protocols.antibody.CDRSetOptions) -> 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.antibody.CDRSetOptions, : pyrosetta.rosetta.protocols.antibody.CDRSetOptions) → pyrosetta.rosetta.protocols.antibody.CDRSetOptions¶: C++: protocols::antibody::CDRSetOptions::operator=(const class protocols::antibody::CDRSetOptions &) –> class protocols::antibody::CDRSetOptions &

cdr(self: pyrosetta.rosetta.protocols.antibody.CDRSetOptions) → pyrosetta.rosetta.protocols.antibody.CDRNameEnum¶: C++: protocols::antibody::CDRSetOptions::cdr() const –> enum protocols::antibody::CDRNameEnum

clone(self: pyrosetta.rosetta.protocols.antibody.CDRSetOptions) → pyrosetta.rosetta.protocols.antibody.CDRSetOptions¶: C++: protocols::antibody::CDRSetOptions::clone() const –> class std::shared_ptr<class protocols::antibody::CDRSetOptions>

cluster_sampling_cutoff(*args, **kwargs)¶

Overloaded function.

cluster_sampling_cutoff(self: pyrosetta.rosetta.protocols.antibody.CDRSetOptions, cutoff: int) -> None

Set a sampling cutoff. Use zero for no cutoff as default.

C++: protocols::antibody::CDRSetOptions::cluster_sampling_cutoff(unsigned long) –> void

cluster_sampling_cutoff(self: pyrosetta.rosetta.protocols.antibody.CDRSetOptions) -> int

C++: protocols::antibody::CDRSetOptions::cluster_sampling_cutoff() const –> unsigned long

exclude_clusters(*args, **kwargs)¶

Overloaded function.

exclude_clusters(self: pyrosetta.rosetta.protocols.antibody.CDRSetOptions, exclude: pyrosetta.rosetta.utility.vector1_protocols_antibody_clusters_CDRClusterEnum) -> None

/////////// Clusters /////////////////

C++: protocols::antibody::CDRSetOptions::exclude_clusters(class utility::vector1<enum protocols::antibody::clusters::CDRClusterEnum, class std::allocator<enum protocols::antibody::clusters::CDRClusterEnum> >) –> void

exclude_clusters(self: pyrosetta.rosetta.protocols.antibody.CDRSetOptions) -> pyrosetta.rosetta.utility.vector1_protocols_antibody_clusters_CDRClusterEnum

C++: protocols::antibody::CDRSetOptions::exclude_clusters() const –> class utility::vector1<enum protocols::antibody::clusters::CDRClusterEnum, class std::allocator<enum protocols::antibody::clusters::CDRClusterEnum> >

exclude_clusters_add(self: pyrosetta.rosetta.protocols.antibody.CDRSetOptions, exclude: pyrosetta.rosetta.protocols.antibody.clusters.CDRClusterEnum) → None¶: C++: protocols::antibody::CDRSetOptions::exclude_clusters_add(enum protocols::antibody::clusters::CDRClusterEnum) –> void

exclude_clusters_clear(self: pyrosetta.rosetta.protocols.antibody.CDRSetOptions) → None¶: C++: protocols::antibody::CDRSetOptions::exclude_clusters_clear() –> void

exclude_germlines(*args, **kwargs)¶

Overloaded function.

exclude_germlines(self: pyrosetta.rosetta.protocols.antibody.CDRSetOptions, exclude: pyrosetta.rosetta.utility.vector1_std_string) -> None

//////// Germlines ////////////////////

C++: protocols::antibody::CDRSetOptions::exclude_germlines(class utility::vector1<class std::basic_string<char>, class std::allocator<class std::basic_string<char> > >) –> void

exclude_germlines(self: pyrosetta.rosetta.protocols.antibody.CDRSetOptions) -> pyrosetta.rosetta.utility.vector1_std_string

C++: protocols::antibody::CDRSetOptions::exclude_germlines() const –> class utility::vector1<std::string, class std::allocator<std::string > >

exclude_germlines_add(self: pyrosetta.rosetta.protocols.antibody.CDRSetOptions, exclude: str) → None¶: C++: protocols::antibody::CDRSetOptions::exclude_germlines_add(class std::basic_string<char>) –> void

exclude_germlines_clear(self: pyrosetta.rosetta.protocols.antibody.CDRSetOptions) → None¶: C++: protocols::antibody::CDRSetOptions::exclude_germlines_clear() –> void

exclude_pdbs(*args, **kwargs)¶

Overloaded function.

exclude_pdbs(self: pyrosetta.rosetta.protocols.antibody.CDRSetOptions, exclude_pdbids: pyrosetta.rosetta.utility.vector1_std_string) -> None

/////////// PDBIds ///////////////////

C++: protocols::antibody::CDRSetOptions::exclude_pdbs(class utility::vector1<class std::basic_string<char>, class std::allocator<class std::basic_string<char> > >) –> void

exclude_pdbs(self: pyrosetta.rosetta.protocols.antibody.CDRSetOptions) -> pyrosetta.rosetta.utility.vector1_std_string

C++: protocols::antibody::CDRSetOptions::exclude_pdbs() const –> class utility::vector1<std::string, class std::allocator<std::string > >

exclude_pdbs_add(self: pyrosetta.rosetta.protocols.antibody.CDRSetOptions, pdbid: str) → None¶: C++: protocols::antibody::CDRSetOptions::exclude_pdbs_add(class std::basic_string<char>) –> void

exclude_pdbs_clear(self: pyrosetta.rosetta.protocols.antibody.CDRSetOptions) → None¶: C++: protocols::antibody::CDRSetOptions::exclude_pdbs_clear() –> void

exclude_species(*args, **kwargs)¶

Overloaded function.

exclude_species(self: pyrosetta.rosetta.protocols.antibody.CDRSetOptions, exclude: pyrosetta.rosetta.utility.vector1_std_string) -> None

////////// Species ////////////////////

C++: protocols::antibody::CDRSetOptions::exclude_species(class utility::vector1<class std::basic_string<char>, class std::allocator<class std::basic_string<char> > >) –> void

exclude_species(self: pyrosetta.rosetta.protocols.antibody.CDRSetOptions) -> pyrosetta.rosetta.utility.vector1_std_string

C++: protocols::antibody::CDRSetOptions::exclude_species() const –> class utility::vector1<std::string, class std::allocator<std::string > >

exclude_species_add(self: pyrosetta.rosetta.protocols.antibody.CDRSetOptions, exclude: str) → None¶: C++: protocols::antibody::CDRSetOptions::exclude_species_add(class std::basic_string<char>) –> void

exclude_species_clear(self: pyrosetta.rosetta.protocols.antibody.CDRSetOptions) → None¶: C++: protocols::antibody::CDRSetOptions::exclude_species_clear() –> void

include_only_center_clusters(*args, **kwargs)¶

Overloaded function.

include_only_center_clusters(self: pyrosetta.rosetta.protocols.antibody.CDRSetOptions, centers_only: bool) -> None

Do we only include the center members of the clusters in the CDRSet?

C++: protocols::antibody::CDRSetOptions::include_only_center_clusters(bool) –> void

include_only_center_clusters(self: pyrosetta.rosetta.protocols.antibody.CDRSetOptions) -> bool

C++: protocols::antibody::CDRSetOptions::include_only_center_clusters() const –> bool

include_only_clusters(*args, **kwargs)¶

Overloaded function.

include_only_clusters(self: pyrosetta.rosetta.protocols.antibody.CDRSetOptions, include_only: pyrosetta.rosetta.utility.vector1_protocols_antibody_clusters_CDRClusterEnum) -> None

C++: protocols::antibody::CDRSetOptions::include_only_clusters(class utility::vector1<enum protocols::antibody::clusters::CDRClusterEnum, class std::allocator<enum protocols::antibody::clusters::CDRClusterEnum> >) –> void

include_only_clusters(self: pyrosetta.rosetta.protocols.antibody.CDRSetOptions) -> pyrosetta.rosetta.utility.vector1_protocols_antibody_clusters_CDRClusterEnum

C++: protocols::antibody::CDRSetOptions::include_only_clusters() const –> class utility::vector1<enum protocols::antibody::clusters::CDRClusterEnum, class std::allocator<enum protocols::antibody::clusters::CDRClusterEnum> >

include_only_clusters_add(self: pyrosetta.rosetta.protocols.antibody.CDRSetOptions, include_only: pyrosetta.rosetta.protocols.antibody.clusters.CDRClusterEnum) → None¶: C++: protocols::antibody::CDRSetOptions::include_only_clusters_add(enum protocols::antibody::clusters::CDRClusterEnum) –> void

include_only_clusters_clear(self: pyrosetta.rosetta.protocols.antibody.CDRSetOptions) → None¶: C++: protocols::antibody::CDRSetOptions::include_only_clusters_clear() –> void

include_only_current_cluster(*args, **kwargs)¶

Overloaded function.

include_only_current_cluster(self: pyrosetta.rosetta.protocols.antibody.CDRSetOptions, only_current_cluster: bool) -> None

If antibody CDRs are loaded in relation to the current PDB in whatever algorithm or app is using this,: Should we only pull clusters of the same type as this PDB?

May or may not be used. In AntibodyGraftDesign, this is used.

C++: protocols::antibody::CDRSetOptions::include_only_current_cluster(bool) –> void

include_only_current_cluster(self: pyrosetta.rosetta.protocols.antibody.CDRSetOptions) -> bool

C++: protocols::antibody::CDRSetOptions::include_only_current_cluster() const –> bool

include_only_germlines(*args, **kwargs)¶

Overloaded function.

include_only_germlines(self: pyrosetta.rosetta.protocols.antibody.CDRSetOptions, include_only: pyrosetta.rosetta.utility.vector1_std_string) -> None

C++: protocols::antibody::CDRSetOptions::include_only_germlines(class utility::vector1<class std::basic_string<char>, class std::allocator<class std::basic_string<char> > >) –> void

include_only_germlines(self: pyrosetta.rosetta.protocols.antibody.CDRSetOptions) -> pyrosetta.rosetta.utility.vector1_std_string

C++: protocols::antibody::CDRSetOptions::include_only_germlines() const –> class utility::vector1<std::string, class std::allocator<std::string > >

include_only_germlines_add(self: pyrosetta.rosetta.protocols.antibody.CDRSetOptions, include_only: str) → None¶: C++: protocols::antibody::CDRSetOptions::include_only_germlines_add(class std::basic_string<char>) –> void

include_only_germlines_clear(self: pyrosetta.rosetta.protocols.antibody.CDRSetOptions) → None¶: C++: protocols::antibody::CDRSetOptions::include_only_germlines_clear() –> void

include_only_pdbs(*args, **kwargs)¶

Overloaded function.

include_only_pdbs(self: pyrosetta.rosetta.protocols.antibody.CDRSetOptions, include_pdbids: pyrosetta.rosetta.utility.vector1_std_string) -> None

C++: protocols::antibody::CDRSetOptions::include_only_pdbs(class utility::vector1<class std::basic_string<char>, class std::allocator<class std::basic_string<char> > >) –> void

include_only_pdbs(self: pyrosetta.rosetta.protocols.antibody.CDRSetOptions) -> pyrosetta.rosetta.utility.vector1_std_string

C++: protocols::antibody::CDRSetOptions::include_only_pdbs() const –> class utility::vector1<std::string, class std::allocator<std::string > >

include_only_pdbs_add(self: pyrosetta.rosetta.protocols.antibody.CDRSetOptions, pdbid: str) → None¶: C++: protocols::antibody::CDRSetOptions::include_only_pdbs_add(class std::basic_string<char>) –> void

include_only_pdbs_clear(self: pyrosetta.rosetta.protocols.antibody.CDRSetOptions) → None¶: C++: protocols::antibody::CDRSetOptions::include_only_pdbs_clear() –> void

include_only_species(*args, **kwargs)¶

Overloaded function.

include_only_species(self: pyrosetta.rosetta.protocols.antibody.CDRSetOptions, include_only: pyrosetta.rosetta.utility.vector1_std_string) -> None

C++: protocols::antibody::CDRSetOptions::include_only_species(class utility::vector1<class std::basic_string<char>, class std::allocator<class std::basic_string<char> > >) –> void

include_only_species(self: pyrosetta.rosetta.protocols.antibody.CDRSetOptions) -> pyrosetta.rosetta.utility.vector1_std_string

C++: protocols::antibody::CDRSetOptions::include_only_species() const –> class utility::vector1<std::string, class std::allocator<std::string > >

include_only_species_add(self: pyrosetta.rosetta.protocols.antibody.CDRSetOptions, include_only: str) → None¶: C++: protocols::antibody::CDRSetOptions::include_only_species_add(class std::basic_string<char>) –> void

include_only_species_clear(self: pyrosetta.rosetta.protocols.antibody.CDRSetOptions) → None¶: C++: protocols::antibody::CDRSetOptions::include_only_species_clear() –> void

length_type(*args, **kwargs)¶

Overloaded function.

length_type(self: pyrosetta.rosetta.protocols.antibody.CDRSetOptions, type: int, setting: bool) -> None

Set to only sample with clusters of the given type for this CDR.

C++: protocols::antibody::CDRSetOptions::length_type(const unsigned long, const bool) –> void

length_type(self: pyrosetta.rosetta.protocols.antibody.CDRSetOptions) -> pyrosetta.rosetta.utility.vector1_bool

C++: protocols::antibody::CDRSetOptions::length_type() const –> class utility::vector1<bool, class std::allocator<bool> >

load(*args, **kwargs)¶

Overloaded function.

load(self: pyrosetta.rosetta.protocols.antibody.CDRSetOptions, load: bool) -> None

C++: protocols::antibody::CDRSetOptions::load(bool) –> void

load(self: pyrosetta.rosetta.protocols.antibody.CDRSetOptions) -> bool

C++: protocols::antibody::CDRSetOptions::load() const –> bool

max_length(*args, **kwargs)¶

Overloaded function.

max_length(self: pyrosetta.rosetta.protocols.antibody.CDRSetOptions, length: int) -> None

set the maximum cdr length to sample. Nothing longer then this will be used. Useful for H3.

C++: protocols::antibody::CDRSetOptions::max_length(unsigned long) –> void

max_length(self: pyrosetta.rosetta.protocols.antibody.CDRSetOptions) -> int

C++: protocols::antibody::CDRSetOptions::max_length() const –> unsigned long

min_length(*args, **kwargs)¶

Overloaded function.

min_length(self: pyrosetta.rosetta.protocols.antibody.CDRSetOptions, length: int) -> None

set the minimum cdr length to sample. Nothing shorter then this will be used during graft.

C++: protocols::antibody::CDRSetOptions::min_length(unsigned long) –> void

min_length(self: pyrosetta.rosetta.protocols.antibody.CDRSetOptions) -> int

C++: protocols::antibody::CDRSetOptions::min_length() const –> unsigned long

set_cdr(self: pyrosetta.rosetta.protocols.antibody.CDRSetOptions, cdr: pyrosetta.rosetta.protocols.antibody.CDRNameEnum) → None¶

/// General settings //////////////

C++: protocols::antibody::CDRSetOptions::set_cdr(enum protocols::antibody::CDRNameEnum) –> void

set_defaults(self: pyrosetta.rosetta.protocols.antibody.CDRSetOptions) → None¶: C++: protocols::antibody::CDRSetOptions::set_defaults() –> void

class pyrosetta.rosetta.protocols.antibody.CDRSetOptionsParser¶

Bases: pybind11_builtins.pybind11_object

Parses CDRSetOptions for a single CDR at a time from a simple instruction file

__delattr__¶: Implement delattr(self, name).

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

__eq__¶: Return self==value.

__format__()¶: default object formatter

__ge__¶: Return self>=value.

__getattribute__¶: Return getattr(self, name).

__gt__¶: Return self>value.

__hash__¶: Return hash(self).

__init__(*args, **kwargs)¶

Overloaded function.

__init__(self: pyrosetta.rosetta.protocols.antibody.CDRSetOptionsParser) -> None
__init__(self: pyrosetta.rosetta.protocols.antibody.CDRSetOptionsParser, arg0: pyrosetta.rosetta.protocols.antibody.CDRSetOptionsParser) -> 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.antibody.CDRSetOptionsParser, : pyrosetta.rosetta.protocols.antibody.CDRSetOptionsParser) → pyrosetta.rosetta.protocols.antibody.CDRSetOptionsParser¶: C++: protocols::antibody::CDRSetOptionsParser::operator=(const class protocols::antibody::CDRSetOptionsParser &) –> class protocols::antibody::CDRSetOptionsParser &

clone(self: pyrosetta.rosetta.protocols.antibody.CDRSetOptionsParser) → pyrosetta.rosetta.protocols.antibody.CDRSetOptionsParser¶: C++: protocols::antibody::CDRSetOptionsParser::clone() const –> class std::shared_ptr<class protocols::antibody::CDRSetOptionsParser>

parse_default_and_user_options(*args, **kwargs)¶

Overloaded function.

parse_default_and_user_options(self: pyrosetta.rosetta.protocols.antibody.CDRSetOptionsParser, cdr: pyrosetta.rosetta.protocols.antibody.CDRNameEnum, filename: str) -> pyrosetta.rosetta.protocols.antibody.CDRSetOptions

Parse default instructions (mainly used for AbDesign) then parse user file

C++: protocols::antibody::CDRSetOptionsParser::parse_default_and_user_options(enum protocols::antibody::CDRNameEnum, const class std::basic_string<char> &) –> class std::shared_ptr<class protocols::antibody::CDRSetOptions>

parse_default_and_user_options(self: pyrosetta.rosetta.protocols.antibody.CDRSetOptionsParser, filename: str) -> pyrosetta.rosetta.utility.vector1_std_shared_ptr_protocols_antibody_CDRSetOptions_t

C++: protocols::antibody::CDRSetOptionsParser::parse_default_and_user_options(const class std::basic_string<char> &) –> class utility::vector1<class std::shared_ptr<class protocols::antibody::CDRSetOptions>, class std::allocator<class std::shared_ptr<class protocols::antibody::CDRSetOptions> > >

parse_options(*args, **kwargs)¶

Overloaded function.

parse_options(self: pyrosetta.rosetta.protocols.antibody.CDRSetOptionsParser, cdr: pyrosetta.rosetta.protocols.antibody.CDRNameEnum, filename: str) -> pyrosetta.rosetta.protocols.antibody.CDRSetOptions

C++: protocols::antibody::CDRSetOptionsParser::parse_options(enum protocols::antibody::CDRNameEnum, const class std::basic_string<char> &) –> class std::shared_ptr<class protocols::antibody::CDRSetOptions>

parse_options(self: pyrosetta.rosetta.protocols.antibody.CDRSetOptionsParser, filename: str) -> pyrosetta.rosetta.utility.vector1_std_shared_ptr_protocols_antibody_CDRSetOptions_t

//////////Parse Options for all CDRs////////////////

C++: protocols::antibody::CDRSetOptionsParser::parse_options(const class std::basic_string<char> &) –> class utility::vector1<class std::shared_ptr<class protocols::antibody::CDRSetOptions>, class std::allocator<class std::shared_ptr<class protocols::antibody::CDRSetOptions> > >

pyrosetta.rosetta.protocols.antibody.CDR_H3_cter_filter(pose_in: pyrosetta.rosetta.core.pose.Pose, ab_info: pyrosetta.rosetta.protocols.antibody.AntibodyInfo) → bool¶: C++: protocols::antibody::CDR_H3_cter_filter(const class core::pose::Pose &, class std::shared_ptr<class protocols::antibody::AntibodyInfo>) –> bool

pyrosetta.rosetta.protocols.antibody.CDR_H3_filter_legacy_code_with_old_rule(pose_in: pyrosetta.rosetta.core.pose.Pose, input_loop: pyrosetta.rosetta.protocols.loops.Loop, is_camelid: bool) → bool¶: C++: protocols::antibody::CDR_H3_filter_legacy_code_with_old_rule(const class core::pose::Pose &, class protocols::loops::Loop &, bool) –> bool

class pyrosetta.rosetta.protocols.antibody.CloseOneCDRLoop¶

Bases: pyrosetta.rosetta.protocols.moves.Mover

Closes only one CDR onto a framework

__delattr__¶: Implement delattr(self, name).

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

__eq__¶: Return self==value.

__format__()¶: default object formatter

__ge__¶: Return self>=value.

__getattribute__¶: Return getattr(self, name).

__gt__¶: Return self>value.

__hash__¶: Return hash(self).

__init__(*args, **kwargs)¶

Overloaded function.

__init__(self: pyrosetta.rosetta.protocols.antibody.CloseOneCDRLoop) -> None
__init__(self: pyrosetta.rosetta.protocols.antibody.CloseOneCDRLoop, query_start: int, query_end: int) -> None
__init__(self: pyrosetta.rosetta.protocols.antibody.CloseOneCDRLoop, arg0: pyrosetta.rosetta.protocols.antibody.CloseOneCDRLoop) -> None

__init_subclass__()¶

This method is called when a class is subclassed.

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

__le__¶: Return self<=value.

__lt__¶: Return self<value.

__ne__¶: Return self!=value.

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

__reduce__()¶: helper for pickle

__reduce_ex__()¶: helper for pickle

__repr__¶: Return repr(self).

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

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

__str__¶: Return str(self).

__subclasshook__()¶

Abstract classes can override this to customize issubclass().

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

apply(self: pyrosetta.rosetta.protocols.antibody.CloseOneCDRLoop, pose_in: pyrosetta.rosetta.core.pose.Pose) → None¶: C++: protocols::antibody::CloseOneCDRLoop::apply(class core::pose::Pose &) –> void

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

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

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

clear_info is called by jd2 before calling apply

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

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

Return a clone of the Mover object.

C++: protocols::moves::Mover::clone() const –> class std::shared_ptr<class protocols::moves::Mover>

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

enable_benchmark_mode(self: pyrosetta.rosetta.protocols.antibody.CloseOneCDRLoop, setting: bool) → None¶

enable benchmark mode

C++: protocols::antibody::CloseOneCDRLoop::enable_benchmark_mode(bool) –> void

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

Generates a new Mover object freshly created with the default ctor.

C++: protocols::moves::Mover::fresh_instance() const –> class std::shared_ptr<class protocols::moves::Mover>

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

fpd

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

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

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

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

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

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

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

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

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

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

get_name(self: pyrosetta.rosetta.protocols.antibody.CloseOneCDRLoop) → str¶: C++: protocols::antibody::CloseOneCDRLoop::get_name() const –> std::string

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

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

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

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

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

non-const accessor

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

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

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

register_options() → None¶

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

set_default(self: pyrosetta.rosetta.protocols.antibody.CloseOneCDRLoop) → None¶: C++: protocols::antibody::CloseOneCDRLoop::set_default() –> void

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

setter for poses contained for rms

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

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

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

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

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

show(*args, **kwargs)¶

Overloaded function.

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

Outputs details about the Mover, including current settings.

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

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

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

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

type(*args, **kwargs)¶

Overloaded function.

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

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

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

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

class pyrosetta.rosetta.protocols.antibody.GraftOneCDRLoop¶

Bases: pyrosetta.rosetta.protocols.moves.Mover

Grafts only one CDR onto a framework

__delattr__¶: Implement delattr(self, name).

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

__eq__¶: Return self==value.

__format__()¶: default object formatter

__ge__¶: Return self>=value.

__getattribute__¶: Return getattr(self, name).

__gt__¶: Return self>value.

__hash__¶: Return hash(self).

__init__(*args, **kwargs)¶

Overloaded function.

__init__(self: pyrosetta.rosetta.protocols.antibody.GraftOneCDRLoop) -> None
__init__(self: pyrosetta.rosetta.protocols.antibody.GraftOneCDRLoop, cdr_name: pyrosetta.rosetta.protocols.antibody.CDRNameEnum, antibody_info: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, ab_t_info: pyrosetta.rosetta.protocols.antibody.Ab_TemplateInfo) -> None
__init__(self: pyrosetta.rosetta.protocols.antibody.GraftOneCDRLoop, arg0: pyrosetta.rosetta.protocols.antibody.GraftOneCDRLoop) -> None

__init_subclass__()¶

This method is called when a class is subclassed.

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

__le__¶: Return self<=value.

__lt__¶: Return self<value.

__ne__¶: Return self!=value.

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

__reduce__()¶: helper for pickle

__reduce_ex__()¶: helper for pickle

__repr__¶: Return repr(self).

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

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

__str__¶: Return str(self).

__subclasshook__()¶

Abstract classes can override this to customize issubclass().

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

apply(self: pyrosetta.rosetta.protocols.antibody.GraftOneCDRLoop, pose_in: pyrosetta.rosetta.core.pose.Pose) → None¶: C++: protocols::antibody::GraftOneCDRLoop::apply(class core::pose::Pose &) –> void

assign(self: pyrosetta.rosetta.protocols.antibody.GraftOneCDRLoop, rhs: pyrosetta.rosetta.protocols.antibody.GraftOneCDRLoop) → pyrosetta.rosetta.protocols.antibody.GraftOneCDRLoop¶

assignment operator

C++: protocols::antibody::GraftOneCDRLoop::operator=(const class protocols::antibody::GraftOneCDRLoop &) –> class protocols::antibody::GraftOneCDRLoop &

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

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

clear_info is called by jd2 before calling apply

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

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

Return a clone of the Mover object.

C++: protocols::moves::Mover::clone() const –> class std::shared_ptr<class protocols::moves::Mover>

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

enable_benchmark_mode(self: pyrosetta.rosetta.protocols.antibody.GraftOneCDRLoop, setting: bool) → None¶

enable benchmark mode

C++: protocols::antibody::GraftOneCDRLoop::enable_benchmark_mode(bool) –> void

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

Generates a new Mover object freshly created with the default ctor.

C++: protocols::moves::Mover::fresh_instance() const –> class std::shared_ptr<class protocols::moves::Mover>

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

fpd

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

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

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

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

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

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

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

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

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

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

get_name(self: pyrosetta.rosetta.protocols.antibody.GraftOneCDRLoop) → str¶: C++: protocols::antibody::GraftOneCDRLoop::get_name() const –> std::string

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

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

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

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

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

non-const accessor

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

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

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

register_options() → None¶

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

set_flank_size(self: pyrosetta.rosetta.protocols.antibody.GraftOneCDRLoop, setting: int) → None¶: C++: protocols::antibody::GraftOneCDRLoop::set_flank_size(unsigned long) –> void

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

setter for poses contained for rms

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

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

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

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

set_no_stem_copy(self: pyrosetta.rosetta.protocols.antibody.GraftOneCDRLoop, setting: bool) → None¶

R2 just graft R2 by copying some stem residues, and remove H3 to do: H3 loop modeling later. But the terminal has been changed by this grafting. Therefore, in R3, an option for not copying h3 stem is provided.

C++: protocols::antibody::GraftOneCDRLoop::set_no_stem_copy(const bool &) –> void

set_scorefxn(self: pyrosetta.rosetta.protocols.antibody.GraftOneCDRLoop, scorefxn: pyrosetta.rosetta.core.scoring.ScoreFunction) → None¶

users can pass their own scorefunction for packing after grafting

C++: protocols::antibody::GraftOneCDRLoop::set_scorefxn(class std::shared_ptr<class core::scoring::ScoreFunction>) –> void

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

show(*args, **kwargs)¶

Overloaded function.

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

Outputs details about the Mover, including current settings.

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

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

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

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

type(*args, **kwargs)¶

Overloaded function.

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

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

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

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

class pyrosetta.rosetta.protocols.antibody.GraftedStemOptimizer¶

Bases: pyrosetta.rosetta.protocols.moves.Mover

Grafts only one CDR onto a framework

__delattr__¶: Implement delattr(self, name).

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

__eq__¶: Return self==value.

__format__()¶: default object formatter

__ge__¶: Return self>=value.

__getattribute__¶: Return getattr(self, name).

__gt__¶: Return self>value.

__hash__¶: Return hash(self).

__init__(*args, **kwargs)¶

Overloaded function.

__init__(self: pyrosetta.rosetta.protocols.antibody.GraftedStemOptimizer, cdr_name: pyrosetta.rosetta.protocols.antibody.CDRNameEnum, antibody_info: pyrosetta.rosetta.protocols.antibody.AntibodyInfo) -> None
__init__(self: pyrosetta.rosetta.protocols.antibody.GraftedStemOptimizer, arg0: pyrosetta.rosetta.protocols.antibody.GraftedStemOptimizer) -> None

__init_subclass__()¶

This method is called when a class is subclassed.

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

__le__¶: Return self<=value.

__lt__¶: Return self<value.

__ne__¶: Return self!=value.

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

__reduce__()¶: helper for pickle

__reduce_ex__()¶: helper for pickle

__repr__¶: Return repr(self).

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

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

__str__¶: Return str(self).

__subclasshook__()¶

Abstract classes can override this to customize issubclass().

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

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

assign(self: pyrosetta.rosetta.protocols.antibody.GraftedStemOptimizer, rhs: pyrosetta.rosetta.protocols.antibody.GraftedStemOptimizer) → pyrosetta.rosetta.protocols.antibody.GraftedStemOptimizer¶

assignment operator

C++: protocols::antibody::GraftedStemOptimizer::operator=(const class protocols::antibody::GraftedStemOptimizer &) –> class protocols::antibody::GraftedStemOptimizer &

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

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

clear_info is called by jd2 before calling apply

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

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

Return a clone of the Mover object.

C++: protocols::moves::Mover::clone() const –> class std::shared_ptr<class protocols::moves::Mover>

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

enable_benchmark_mode(self: pyrosetta.rosetta.protocols.antibody.GraftedStemOptimizer, setting: bool) → None¶

enable benchmark mode

C++: protocols::antibody::GraftedStemOptimizer::enable_benchmark_mode(const bool &) –> void

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

Generates a new Mover object freshly created with the default ctor.

C++: protocols::moves::Mover::fresh_instance() const –> class std::shared_ptr<class protocols::moves::Mover>

get_Cstem_foldtree(self: pyrosetta.rosetta.protocols.antibody.GraftedStemOptimizer, pose: pyrosetta.rosetta.core.pose.Pose) → pyrosetta.rosetta.core.kinematics.FoldTree¶: C++: protocols::antibody::GraftedStemOptimizer::get_Cstem_foldtree(const class core::pose::Pose &) const –> class std::shared_ptr<class core::kinematics::FoldTree>

get_N_C_stems_foldtree(self: pyrosetta.rosetta.protocols.antibody.GraftedStemOptimizer, pose: pyrosetta.rosetta.core.pose.Pose) → pyrosetta.rosetta.core.kinematics.FoldTree¶: C++: protocols::antibody::GraftedStemOptimizer::get_N_C_stems_foldtree(const class core::pose::Pose &) const –> class std::shared_ptr<class core::kinematics::FoldTree>

get_Nstem_foldtree(self: pyrosetta.rosetta.protocols.antibody.GraftedStemOptimizer, pose: pyrosetta.rosetta.core.pose.Pose) → pyrosetta.rosetta.core.kinematics.FoldTree¶: C++: protocols::antibody::GraftedStemOptimizer::get_Nstem_foldtree(const class core::pose::Pose &) const –> class std::shared_ptr<class core::kinematics::FoldTree>

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

fpd

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

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

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

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

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

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

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

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

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

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

get_name(self: pyrosetta.rosetta.protocols.antibody.GraftedStemOptimizer) → str¶: C++: protocols::antibody::GraftedStemOptimizer::get_name() const –> std::string

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

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

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

get_stem_movemap(*args, **kwargs)¶

Overloaded function.

get_stem_movemap(self: pyrosetta.rosetta.protocols.antibody.GraftedStemOptimizer, pose: pyrosetta.rosetta.core.pose.Pose, type: str) -> pyrosetta.rosetta.core.kinematics.MoveMap
get_stem_movemap(self: pyrosetta.rosetta.protocols.antibody.GraftedStemOptimizer, pose: pyrosetta.rosetta.core.pose.Pose, type: str, include_nb_sc: bool) -> pyrosetta.rosetta.core.kinematics.MoveMap

C++: protocols::antibody::GraftedStemOptimizer::get_stem_movemap(const class core::pose::Pose &, const class std::basic_string<char> &, const bool &) const –> class std::shared_ptr<class core::kinematics::MoveMap>

get_stem_taskfactory(*args, **kwargs)¶

Overloaded function.

get_stem_taskfactory(self: pyrosetta.rosetta.protocols.antibody.GraftedStemOptimizer, pose: pyrosetta.rosetta.core.pose.Pose, type: str) -> pyrosetta.rosetta.core.pack.task.TaskFactory
get_stem_taskfactory(self: pyrosetta.rosetta.protocols.antibody.GraftedStemOptimizer, pose: pyrosetta.rosetta.core.pose.Pose, type: str, include_nb_sc: bool) -> pyrosetta.rosetta.core.pack.task.TaskFactory

C++: protocols::antibody::GraftedStemOptimizer::get_stem_taskfactory(class core::pose::Pose &, const class std::basic_string<char> &, const bool &) const –> class std::shared_ptr<class core::pack::task::TaskFactory>

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

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

non-const accessor

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

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

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

register_options() → None¶

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

set_deep_optimization(self: pyrosetta.rosetta.protocols.antibody.GraftedStemOptimizer, setting: bool) → None¶

deep optimization will do small_share_ccd

C++: protocols::antibody::GraftedStemOptimizer::set_deep_optimization(const bool &) –> void

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

setter for poses contained for rms

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

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

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

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

set_scorefxn(self: pyrosetta.rosetta.protocols.antibody.GraftedStemOptimizer, setting: pyrosetta.rosetta.core.scoring.ScoreFunction) → None¶

users can pass their own scorefunction, foldtree, movemap, and taskfactory

C++: protocols::antibody::GraftedStemOptimizer::set_scorefxn(class std::shared_ptr<class core::scoring::ScoreFunction>) –> void

set_stem_size(self: pyrosetta.rosetta.protocols.antibody.GraftedStemOptimizer, setting: int) → None¶

stem that was replaced by the extra reesidues at the end of the: loop terminus. Default is “2”

C++: protocols::antibody::GraftedStemOptimizer::set_stem_size(const unsigned long &) –> void

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

show(*args, **kwargs)¶

Overloaded function.

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

Outputs details about the Mover, including current settings.

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

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

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

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

type(*args, **kwargs)¶

Overloaded function.

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

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

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

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

class pyrosetta.rosetta.protocols.antibody.H3CterInsert¶

Bases: pyrosetta.rosetta.protocols.moves.Mover

H3 CDR, Fragment Insertion and CCD

__delattr__¶: Implement delattr(self, name).

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

__eq__¶: Return self==value.

__format__()¶: default object formatter

__ge__¶: Return self>=value.

__getattribute__¶: Return getattr(self, name).

__gt__¶: Return self>value.

__hash__¶: Return hash(self).

__init__(*args, **kwargs)¶

Overloaded function.

__init__(self: pyrosetta.rosetta.protocols.antibody.H3CterInsert) -> None
__init__(self: pyrosetta.rosetta.protocols.antibody.H3CterInsert, antibody_info: pyrosetta.rosetta.protocols.antibody.AntibodyInfo) -> None
__init__(self: pyrosetta.rosetta.protocols.antibody.H3CterInsert, arg0: pyrosetta.rosetta.protocols.antibody.H3CterInsert) -> None

__init_subclass__()¶

This method is called when a class is subclassed.

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

__le__¶: Return self<=value.

__lt__¶: Return self<value.

__ne__¶: Return self!=value.

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

__reduce__()¶: helper for pickle

__reduce_ex__()¶: helper for pickle

__repr__¶: Return repr(self).

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

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

__str__¶: Return str(self).

__subclasshook__()¶

Abstract classes can override this to customize issubclass().

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

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

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

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

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

clear_info is called by jd2 before calling apply

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

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

Return a clone of the Mover object.

C++: protocols::moves::Mover::clone() const –> class std::shared_ptr<class protocols::moves::Mover>

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

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

Generates a new Mover object freshly created with the default ctor.

C++: protocols::moves::Mover::fresh_instance() const –> class std::shared_ptr<class protocols::moves::Mover>

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

fpd

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

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

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

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

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

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

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

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

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

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

get_name(self: pyrosetta.rosetta.protocols.antibody.H3CterInsert) → str¶: C++: protocols::antibody::H3CterInsert::get_name() const –> std::string

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

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

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

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

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

non-const accessor

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

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

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

read_H3_cter_fragment(self: pyrosetta.rosetta.protocols.antibody.H3CterInsert, pose: pyrosetta.rosetta.core.pose.Pose) → None¶: C++: protocols::antibody::H3CterInsert::read_H3_cter_fragment(const class core::pose::Pose &) –> void

register_options() → None¶

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

set_default(self: pyrosetta.rosetta.protocols.antibody.H3CterInsert) → None¶: C++: protocols::antibody::H3CterInsert::set_default() –> void

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

setter for poses contained for rms

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

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

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

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

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

show(*args, **kwargs)¶

Overloaded function.

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

Outputs details about the Mover, including current settings.

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

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

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

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

type(*args, **kwargs)¶

Overloaded function.

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

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

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

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

class pyrosetta.rosetta.protocols.antibody.ModelCDRH3¶

Bases: pyrosetta.rosetta.protocols.moves.Mover

Ab initio modeling of CDR H3 loop

__delattr__¶: Implement delattr(self, name).

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

__eq__¶: Return self==value.

__format__()¶: default object formatter

__ge__¶: Return self>=value.

__getattribute__¶: Return getattr(self, name).

__gt__¶: Return self>value.

__hash__¶: Return hash(self).

__init__(*args, **kwargs)¶

Overloaded function.

__init__(self: pyrosetta.rosetta.protocols.antibody.ModelCDRH3) -> None
__init__(self: pyrosetta.rosetta.protocols.antibody.ModelCDRH3, antibody_info: pyrosetta.rosetta.protocols.antibody.AntibodyInfo) -> None
__init__(self: pyrosetta.rosetta.protocols.antibody.ModelCDRH3, antibody_info: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, lowres_scorefxn: pyrosetta.rosetta.core.scoring.ScoreFunction) -> None
__init__(self: pyrosetta.rosetta.protocols.antibody.ModelCDRH3, arg0: pyrosetta.rosetta.protocols.antibody.ModelCDRH3) -> None

__init_subclass__()¶

This method is called when a class is subclassed.

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

__le__¶: Return self<=value.

__lt__¶: Return self<value.

__ne__¶: Return self!=value.

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

__reduce__()¶: helper for pickle

__reduce_ex__()¶: helper for pickle

__repr__¶: Return repr(self).

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

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

__str__¶: Return str(self).

__subclasshook__()¶

Abstract classes can override this to customize issubclass().

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

apply(self: pyrosetta.rosetta.protocols.antibody.ModelCDRH3, pose_in: pyrosetta.rosetta.core.pose.Pose) → None¶: C++: protocols::antibody::ModelCDRH3::apply(class core::pose::Pose &) –> void

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

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

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

clear_info is called by jd2 before calling apply

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

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

Return a clone of the Mover object.

C++: protocols::moves::Mover::clone() const –> class std::shared_ptr<class protocols::moves::Mover>

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

enable_benchmark_mode(self: pyrosetta.rosetta.protocols.antibody.ModelCDRH3, setting: bool) → None¶

enable benchmark mode

C++: protocols::antibody::ModelCDRH3::enable_benchmark_mode(bool) –> void

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

Generates a new Mover object freshly created with the default ctor.

C++: protocols::moves::Mover::fresh_instance() const –> class std::shared_ptr<class protocols::moves::Mover>

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

fpd

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

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

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

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

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

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

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

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

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

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

get_name(self: pyrosetta.rosetta.protocols.antibody.ModelCDRH3) → str¶: C++: protocols::antibody::ModelCDRH3::get_name() const –> std::string

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

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

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

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

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

non-const accessor

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

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

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

register_options() → None¶

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

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

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

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

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

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

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

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

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

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

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

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

set_bad_nter(self: pyrosetta.rosetta.protocols.antibody.ModelCDRH3, setting: bool) → None¶: C++: protocols::antibody::ModelCDRH3::set_bad_nter(bool) –> void

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

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

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

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

set_default(self: pyrosetta.rosetta.protocols.antibody.ModelCDRH3) → None¶: C++: protocols::antibody::ModelCDRH3::set_default() –> void

set_extend_h3(self: pyrosetta.rosetta.protocols.antibody.ModelCDRH3, setting: bool) → None¶: C++: protocols::antibody::ModelCDRH3::set_extend_h3(bool) –> void

set_idealize_h3_stems(self: pyrosetta.rosetta.protocols.antibody.ModelCDRH3, setting: bool) → None¶: C++: protocols::antibody::ModelCDRH3::set_idealize_h3_stems(bool) –> void

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

setter for poses contained for rms

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

set_lowres_score_func(self: pyrosetta.rosetta.protocols.antibody.ModelCDRH3, lowres_scorefxn: pyrosetta.rosetta.core.scoring.ScoreFunction) → None¶

set scorefunction for low resolution of CDR H3 modeling

C++: protocols::antibody::ModelCDRH3::set_lowres_score_func(class std::shared_ptr<const class core::scoring::ScoreFunction>) –> void

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

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

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

set_perturb_type(self: pyrosetta.rosetta.protocols.antibody.ModelCDRH3, setting: str) → None¶: C++: protocols::antibody::ModelCDRH3::set_perturb_type(class std::basic_string<char>) –> void

set_task_factory(self: pyrosetta.rosetta.protocols.antibody.ModelCDRH3, tf: pyrosetta.rosetta.core.pack.task.TaskFactory) → None¶

set task factory

C++: protocols::antibody::ModelCDRH3::set_task_factory(class std::shared_ptr<const class core::pack::task::TaskFactory>) –> void

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

show(*args, **kwargs)¶

Overloaded function.

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

Outputs details about the Mover, including current settings.

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

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

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

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

turn_off_H3_filter(self: pyrosetta.rosetta.protocols.antibody.ModelCDRH3) → None¶: C++: protocols::antibody::ModelCDRH3::turn_off_H3_filter() –> void

turn_off_cter_insert(self: pyrosetta.rosetta.protocols.antibody.ModelCDRH3) → None¶: C++: protocols::antibody::ModelCDRH3::turn_off_cter_insert() –> void

type(*args, **kwargs)¶

Overloaded function.

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

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

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

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

class pyrosetta.rosetta.protocols.antibody.PDBLandmark¶

Bases: pybind11_builtins.pybind11_object

Class that was once a struct; Used for matching pdb information between numbering schemes and cdr definitions.

__delattr__¶: Implement delattr(self, name).

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

__eq__(self: pyrosetta.rosetta.protocols.antibody.PDBLandmark, compare: pyrosetta.rosetta.protocols.antibody.PDBLandmark) → bool¶: C++: protocols::antibody::PDBLandmark::operator==(const class protocols::antibody::PDBLandmark &) 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.

__init__(self: pyrosetta.rosetta.protocols.antibody.PDBLandmark, chain: str, resnum: int, insertion_code: str) -> None
__init__(self: pyrosetta.rosetta.protocols.antibody.PDBLandmark, chain: str, resnum: int, insertion_code: str, scheme: pyrosetta.rosetta.protocols.antibody.AntibodyNumberingSchemeEnum) -> 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__(self: pyrosetta.rosetta.protocols.antibody.PDBLandmark, compare: pyrosetta.rosetta.protocols.antibody.PDBLandmark) → bool¶: C++: protocols::antibody::PDBLandmark::operator!=(const class protocols::antibody::PDBLandmark &) const –> bool

__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.antibody.PDBLandmark, src: pyrosetta.rosetta.protocols.antibody.PDBLandmark) → pyrosetta.rosetta.protocols.antibody.PDBLandmark¶: C++: protocols::antibody::PDBLandmark::operator=(const class protocols::antibody::PDBLandmark &) –> class protocols::antibody::PDBLandmark &

chain(self: pyrosetta.rosetta.protocols.antibody.PDBLandmark) → str¶: C++: protocols::antibody::PDBLandmark::chain() const –> char

get_string(self: pyrosetta.rosetta.protocols.antibody.PDBLandmark) → str¶: C++: protocols::antibody::PDBLandmark::get_string() const –> std::string

insertion_code(self: pyrosetta.rosetta.protocols.antibody.PDBLandmark) → str¶: C++: protocols::antibody::PDBLandmark::insertion_code() const –> char

numbering_scheme(self: pyrosetta.rosetta.protocols.antibody.PDBLandmark) → pyrosetta.rosetta.protocols.antibody.AntibodyNumberingSchemeEnum¶: C++: protocols::antibody::PDBLandmark::numbering_scheme() const –> enum protocols::antibody::AntibodyNumberingSchemeEnum

resnum(self: pyrosetta.rosetta.protocols.antibody.PDBLandmark) → int¶: C++: protocols::antibody::PDBLandmark::resnum() const –> unsigned long

class pyrosetta.rosetta.protocols.antibody.PackingAngleEnum¶

Bases: pybind11_builtins.pybind11_object

These are used to determine the VL_VH packing angle.

__delattr__¶: Implement delattr(self, name).

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

__eq__(*args, **kwargs)¶

Overloaded function.

__eq__(self: pyrosetta.rosetta.protocols.antibody.PackingAngleEnum, arg0: pyrosetta.rosetta.protocols.antibody.PackingAngleEnum) -> bool
__eq__(self: pyrosetta.rosetta.protocols.antibody.PackingAngleEnum, arg0: int) -> bool

__format__()¶: default object formatter

__ge__¶: Return self>=value.

__getattribute__¶: Return getattr(self, name).

__getstate__(self: pyrosetta.rosetta.protocols.antibody.PackingAngleEnum) → tuple¶

__gt__¶: Return self>value.

__hash__(self: pyrosetta.rosetta.protocols.antibody.PackingAngleEnum) → int¶

__init__(self: pyrosetta.rosetta.protocols.antibody.PackingAngleEnum, arg0: int) → None¶

__init_subclass__()¶

This method is called when a class is subclassed.

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

__int__(self: pyrosetta.rosetta.protocols.antibody.PackingAngleEnum) → int¶

__le__¶: Return self<=value.

__lt__¶: Return self<value.

__ne__(*args, **kwargs)¶

Overloaded function.

__ne__(self: pyrosetta.rosetta.protocols.antibody.PackingAngleEnum, arg0: pyrosetta.rosetta.protocols.antibody.PackingAngleEnum) -> bool
__ne__(self: pyrosetta.rosetta.protocols.antibody.PackingAngleEnum, arg0: int) -> bool

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

__reduce__()¶: helper for pickle

__reduce_ex__()¶: helper for pickle

__repr__(self: pyrosetta.rosetta.protocols.antibody.PackingAngleEnum) → str¶

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

__setstate__(self: pyrosetta.rosetta.protocols.antibody.PackingAngleEnum, arg0: tuple) → None¶

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

__str__¶: Return str(self).

__subclasshook__()¶

Abstract classes can override this to customize issubclass().

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

pyrosetta.rosetta.protocols.antibody.align_to_native(*args, **kwargs)¶

Overloaded function.

align_to_native(pose: pyrosetta.rosetta.core.pose.Pose, native_pose: pyrosetta.rosetta.core.pose.Pose, ab_info: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, native_ab_info: pyrosetta.rosetta.protocols.antibody.AntibodyInfo) -> None
align_to_native(pose: pyrosetta.rosetta.core.pose.Pose, native_pose: pyrosetta.rosetta.core.pose.Pose, ab_info: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, native_ab_info: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, request_chain: str) -> None

align current Fv to native.Fv

C++: protocols::antibody::align_to_native(class core::pose::Pose &, const class core::pose::Pose &, const class std::shared_ptr<class protocols::antibody::AntibodyInfo>, const class std::shared_ptr<class protocols::antibody::AntibodyInfo>, const class std::basic_string<char> &) –> void

pyrosetta.rosetta.protocols.antibody.attributes_for_get_cdr_bool_from_tag(*args, **kwargs)¶

Overloaded function.

attributes_for_get_cdr_bool_from_tag(attlist: pyrosetta.rosetta.std.list_utility_tag_XMLSchemaAttribute_t, tagname: str) -> None
attributes_for_get_cdr_bool_from_tag(attlist: pyrosetta.rosetta.std.list_utility_tag_XMLSchemaAttribute_t, tagname: str, Description: str) -> None

C++: protocols::antibody::attributes_for_get_cdr_bool_from_tag(class std::list<class utility::tag::XMLSchemaAttribute, class std::allocator<class utility::tag::XMLSchemaAttribute> > &, const class std::basic_string<char> &, const class std::basic_string<char> &) –> void

pyrosetta.rosetta.protocols.antibody.cdr_CN_anchor_distance(pose: pyrosetta.rosetta.core.pose.Pose, ab_info: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, cdr: pyrosetta.rosetta.protocols.antibody.CDRNameEnum) → float¶

Calculate the distance between the carbon and nitrogen of each residue before and after the CDR respectively

C++: protocols::antibody::cdr_CN_anchor_distance(const class core::pose::Pose &, class std::shared_ptr<const class protocols::antibody::AntibodyInfo>, const enum protocols::antibody::CDRNameEnum &) –> double

pyrosetta.rosetta.protocols.antibody.cdr_energy(pose: pyrosetta.rosetta.core.pose.Pose, ab_info: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, scorefxn: pyrosetta.rosetta.core.scoring.ScoreFunction, cdr: pyrosetta.rosetta.protocols.antibody.CDRNameEnum) → float¶

Calculates energy of cdr by decomposing scorefxn into pair and then summing. This means it includes hbonding components, etc.

C++: protocols::antibody::cdr_energy(const class core::pose::Pose &, class std::shared_ptr<const class protocols::antibody::AntibodyInfo>, class std::shared_ptr<const class core::scoring::ScoreFunction>, const enum protocols::antibody::CDRNameEnum &) –> double

pyrosetta.rosetta.protocols.antibody.check_fix_aho_cdr_numbering(*args, **kwargs)¶

Overloaded function.

check_fix_aho_cdr_numbering(ab_info: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, cdr: pyrosetta.rosetta.protocols.antibody.CDRNameEnum, pose: pyrosetta.rosetta.core.pose.Pose) -> None

Checks the length of the CDR, fixes AHO numbering for longer CDR loops that don’t: fit within the numbering scheme

C++: protocols::antibody::check_fix_aho_cdr_numbering(class std::shared_ptr<const class protocols::antibody::AntibodyInfo>, enum protocols::antibody::CDRNameEnum, class core::pose::Pose &) –> void

check_fix_aho_cdr_numbering(ab_info: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, pose: pyrosetta.rosetta.core.pose.Pose) -> None

C++: protocols::antibody::check_fix_aho_cdr_numbering(class std::shared_ptr<const class protocols::antibody::AntibodyInfo>, class core::pose::Pose &) –> void

pyrosetta.rosetta.protocols.antibody.cutpoint_separation(pose_in: pyrosetta.rosetta.core.pose.Pose, cutpoint: int) → float¶

Compute the separation at the cutpoint. The N-C distance of the: peptide bond which should be formed at the cutpoint. A closed loop is assumed to have a gap < 1.9 Ang

C++: protocols::antibody::cutpoint_separation(class core::pose::Pose &, unsigned long) –> double

pyrosetta.rosetta.protocols.antibody.cutpoints_separation(pose: pyrosetta.rosetta.core.pose.Pose, antibody_info: pyrosetta.rosetta.protocols.antibody.AntibodyInfo) → bool¶

return false if any cdr cutpoint is broken

C++: protocols::antibody::cutpoints_separation(class core::pose::Pose &, class std::shared_ptr<class protocols::antibody::AntibodyInfo> &) –> bool

pyrosetta.rosetta.protocols.antibody.get_cdr_bool_from_tag(*args, **kwargs)¶

Overloaded function.

get_cdr_bool_from_tag(tag: pyrosetta.rosetta.utility.tag.Tag, name: str) -> pyrosetta.rosetta.utility.vector1_bool
get_cdr_bool_from_tag(tag: pyrosetta.rosetta.utility.tag.Tag, name: str, include_cdr4: bool) -> pyrosetta.rosetta.utility.vector1_bool

Geta boolean vector of CDRs from a RosettaScripts tag. Companion function for XSD generation: attributes_for_get_cdr_bool_from_tag

C++: protocols::antibody::get_cdr_bool_from_tag(class std::shared_ptr<const class utility::tag::Tag>, const class std::basic_string<char> &, bool) –> class utility::vector1<bool, class std::allocator<bool> >

pyrosetta.rosetta.protocols.antibody.get_cdr_loops(*args, **kwargs)¶

Overloaded function.

get_cdr_loops(ab_info: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, pose: pyrosetta.rosetta.core.pose.Pose, cdrs: pyrosetta.rosetta.utility.vector1_bool) -> pyrosetta.rosetta.protocols.loops.Loops
get_cdr_loops(ab_info: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, pose: pyrosetta.rosetta.core.pose.Pose, cdrs: pyrosetta.rosetta.utility.vector1_bool, stem_size: int) -> pyrosetta.rosetta.protocols.loops.Loops

Get a set of loops for a boolean vector of CDRNameEnums including any stem residues.

C++: protocols::antibody::get_cdr_loops(class std::shared_ptr<const class protocols::antibody::AntibodyInfo>, const class core::pose::Pose &, const class utility::vector1<bool, class std::allocator<bool> > &, unsigned long) –> class std::shared_ptr<class protocols::loops::Loops>

pyrosetta.rosetta.protocols.antibody.get_matching_landmark(numbering: pyrosetta.rosetta.protocols.antibody.AntibodyNumbering, landmark: pyrosetta.rosetta.protocols.antibody.PDBLandmark, from_scheme: pyrosetta.rosetta.protocols.antibody.AntibodyNumberingSchemeEnum, to_scheme: pyrosetta.rosetta.protocols.antibody.AntibodyNumberingSchemeEnum) → pyrosetta.rosetta.protocols.antibody.PDBLandmark¶

get the equivalent landmark in a numbering scheme. Set the resnum to zero if not found.

C++: protocols::antibody::get_matching_landmark(const struct protocols::antibody::AntibodyNumbering &, const class protocols::antibody::PDBLandmark &, const enum protocols::antibody::AntibodyNumberingSchemeEnum, const enum protocols::antibody::AntibodyNumberingSchemeEnum) –> class std::shared_ptr<const class protocols::antibody::PDBLandmark>

pyrosetta.rosetta.protocols.antibody.global_loop_rmsd(pose_in: pyrosetta.rosetta.core.pose.Pose, native_pose: pyrosetta.rosetta.core.pose.Pose, current_loop: pyrosetta.rosetta.protocols.loops.Loops) → float¶

/////////////////////////////////////// things to compare to native //////////////////////////////////////////

C++: protocols::antibody::global_loop_rmsd(const class core::pose::Pose &, const class core::pose::Pose &, class std::shared_ptr<class protocols::loops::Loops>) –> double

pyrosetta.rosetta.protocols.antibody.is_H3_rama_kinked(rama: str) → bool¶

Very basic kink function based on rama groups. Kink is defined as having AB + DB at the C-terminal stem.: This is in the North/Dunbrack CDR definition. Avoid this definition if you can and talk to brain. This is currently used for a quick filtering for design.

C++: protocols::antibody::is_H3_rama_kinked(const class std::basic_string<char> &) –> bool

pyrosetta.rosetta.protocols.antibody.kink_RD_Hbond(pose: pyrosetta.rosetta.core.pose.Pose, abinfo: pyrosetta.rosetta.protocols.antibody.AntibodyInfo) → float¶: C++: protocols::antibody::kink_RD_Hbond(const class core::pose::Pose &, const class protocols::antibody::AntibodyInfo &) –> double

pyrosetta.rosetta.protocols.antibody.kink_Trp_Hbond(pose: pyrosetta.rosetta.core.pose.Pose, abinfo: pyrosetta.rosetta.protocols.antibody.AntibodyInfo) → float¶: C++: protocols::antibody::kink_Trp_Hbond(const class core::pose::Pose &, const class protocols::antibody::AntibodyInfo &) –> double

pyrosetta.rosetta.protocols.antibody.kink_bb_Hbond(pose: pyrosetta.rosetta.core.pose.Pose, abinfo: pyrosetta.rosetta.protocols.antibody.AntibodyInfo) → float¶: C++: protocols::antibody::kink_bb_Hbond(const class core::pose::Pose &, const class protocols::antibody::AntibodyInfo &) –> double

pyrosetta.rosetta.protocols.antibody.kink_constrain_antibody_H3(pose: pyrosetta.rosetta.core.pose.Pose, antibody_info: pyrosetta.rosetta.protocols.antibody.AntibodyInfo) → None¶

Apply auto-generated kink constraint

C++: protocols::antibody::kink_constrain_antibody_H3(class core::pose::Pose &, const class std::shared_ptr<class protocols::antibody::AntibodyInfo>) –> void

pyrosetta.rosetta.protocols.antibody.kink_dihedral(*args, **kwargs)¶

Overloaded function.

kink_dihedral(pose: pyrosetta.rosetta.core.pose.Pose, abinfo: pyrosetta.rosetta.protocols.antibody.AntibodyInfo) -> Tuple[float, float]
kink_dihedral(pose: pyrosetta.rosetta.core.pose.Pose, abinfo: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, debug: bool) -> Tuple[float, float]

C++: protocols::antibody::kink_dihedral(const class core::pose::Pose &, const class protocols::antibody::AntibodyInfo &, bool) –> struct std::pair<double, double>

pyrosetta.rosetta.protocols.antibody.paratope_charge(*args, **kwargs)¶

Overloaded function.

paratope_charge(pose: pyrosetta.rosetta.core.pose.Pose, abinfo: pyrosetta.rosetta.protocols.antibody.AntibodyInfo) -> pyrosetta.rosetta.protocols.antibody.ParatopeMetric_long_t
paratope_charge(pose: pyrosetta.rosetta.core.pose.Pose, abinfo: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, include_de_loop: bool) -> pyrosetta.rosetta.protocols.antibody.ParatopeMetric_long_t

calculate the net charge of the paratope

C++: protocols::antibody::paratope_charge(const class core::pose::Pose &, const class protocols::antibody::AntibodyInfo &, bool) –> struct protocols::antibody::ParatopeMetric<long>

pyrosetta.rosetta.protocols.antibody.paratope_sasa(*args, **kwargs)¶

Overloaded function.

paratope_sasa(pose: pyrosetta.rosetta.core.pose.Pose, ab_info: pyrosetta.rosetta.protocols.antibody.AntibodyInfo) -> Tuple[protocols::antibody::ParatopeMetric<double>, protocols::antibody::ParatopeMetric<double>]
paratope_sasa(pose: pyrosetta.rosetta.core.pose.Pose, ab_info: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, include_de_loop: bool) -> Tuple[protocols::antibody::ParatopeMetric<double>, protocols::antibody::ParatopeMetric<double>]

calculate the SASA of the antibody paratope. Returns all and hydrophobic components.

C++: protocols::antibody::paratope_sasa(const class core::pose::Pose &, const class protocols::antibody::AntibodyInfo &, bool) –> struct std::pair<struct protocols::antibody::ParatopeMetric<double>, struct protocols::antibody::ParatopeMetric<double> >

pyrosetta.rosetta.protocols.antibody.pose_charge(pose: pyrosetta.rosetta.core.pose.Pose) → int¶

calculate the net charge of the antibody

C++: protocols::antibody::pose_charge(const class core::pose::Pose &) –> long

pyrosetta.rosetta.protocols.antibody.select_epitope_residues(*args, **kwargs)¶

Overloaded function.

select_epitope_residues(ab_info: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, pose: pyrosetta.rosetta.core.pose.Pose) -> pyrosetta.rosetta.utility.vector1_bool
select_epitope_residues(ab_info: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, pose: pyrosetta.rosetta.core.pose.Pose, interface_distance: int) -> pyrosetta.rosetta.utility.vector1_bool

Get the epitope residues using the InterGroupNeighborsCalculator.

C++: protocols::antibody::select_epitope_residues(class std::shared_ptr<const class protocols::antibody::AntibodyInfo>, const class core::pose::Pose &, const unsigned long) –> class utility::vector1<bool, class std::allocator<bool> >

pyrosetta.rosetta.protocols.antibody.setup_A_LH_foldtree(ab_info: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, pose: pyrosetta.rosetta.core.pose.Pose) → str¶

Setup A_LH foldtree via docking. Return dock_chains string.

C++: protocols::antibody::setup_A_LH_foldtree(class std::shared_ptr<const class protocols::antibody::AntibodyInfo>, class core::pose::Pose &) –> std::string

pyrosetta.rosetta.protocols.antibody.setup_LH_A_foldtree(ab_info: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, pose: pyrosetta.rosetta.core.pose.Pose) → str¶

Setup LH_A foldtree via docking. Return dock_chains string.

C++: protocols::antibody::setup_LH_A_foldtree(class std::shared_ptr<const class protocols::antibody::AntibodyInfo>, class core::pose::Pose &) –> std::string

pyrosetta.rosetta.protocols.antibody.setup_packer_task(pose_in: pyrosetta.rosetta.core.pose.Pose) → pyrosetta.rosetta.core.pack.task.TaskFactory¶

Very specific packertask,

Ubound rotamer options, repack only, protein only, no disulfides.

C++: protocols::antibody::setup_packer_task(class core::pose::Pose &) –> class std::shared_ptr<class core::pack::task::TaskFactory>

pyrosetta.rosetta.protocols.antibody.simple_fold_tree(pose_in: pyrosetta.rosetta.core.pose.Pose, jumppoint1: int, cutpoint: int, jumppoint2: int) → None¶: C++: protocols::antibody::simple_fold_tree(class core::pose::Pose &, unsigned long, unsigned long, unsigned long) –> void

pyrosetta.rosetta.protocols.antibody.simple_one_loop_fold_tree(pose: pyrosetta.rosetta.core.pose.Pose, loop: pyrosetta.rosetta.protocols.loops.Loop) → None¶

////////////////////////////// Etc. /////////////////////////////////////

C++: protocols::antibody::simple_one_loop_fold_tree(class core::pose::Pose &, const class protocols::loops::Loop &) –> void

pyrosetta.rosetta.protocols.antibody.vl_vh_orientation_coords(pose_in: pyrosetta.rosetta.core.pose.Pose, ab_info: pyrosetta.rosetta.protocols.antibody.AntibodyInfo) → pyrosetta.rosetta.utility.vector1_double¶

calculate the VH_VL packing angle from 2 sheet definitions on each antibody chain

vector is made up of:

vl_vh_distance opening_angle opposite_angle packing_angle

C++: protocols::antibody::vl_vh_orientation_coords(const class core::pose::Pose &, const class protocols::antibody::AntibodyInfo &) –> class utility::vector1<double, class std::allocator<double> >