design¶

Bindings for protocols::antibody::design namespace

class pyrosetta.rosetta.protocols.antibody.design.AntibodyDesignMover¶

Bases: pyrosetta.rosetta.protocols.moves.Mover

This class designs antibodies by grafting, using cluster information and constraints to help. It represents the first step in The Rosetta Antibody Designer, but can be used outside of the application. A 2011 Antibody Database is included in the rosetta datase. Up-to-date versions can be downloaded from

To use this class: 1) Use default instruction path, or set one. Loads CDRs from AntibodyDatabase

*See rosetta_database/sampling/antibodies for file format.

Use class interface settings to control sampling. Loads CDRs from AntibodyDatabase.
Use set_cdr_sets to set your own CDRs to graft.

__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.design.AntibodyDesignMover) -> None
__init__(self: pyrosetta.rosetta.protocols.antibody.design.AntibodyDesignMover, ab_info: pyrosetta.rosetta.protocols.antibody.AntibodyInfo) -> None
__init__(self: pyrosetta.rosetta.protocols.antibody.design.AntibodyDesignMover, arg0: pyrosetta.rosetta.protocols.antibody.design.AntibodyDesignMover) -> 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.design.AntibodyDesignMover, pose: pyrosetta.rosetta.core.pose.Pose) → None¶: C++: protocols::antibody::design::AntibodyDesignMover::apply(class core::pose::Pose &) –> void

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

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.design.AntibodyDesignMover) → pyrosetta.rosetta.protocols.moves.Mover¶: C++: protocols::antibody::design::AntibodyDesignMover::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.design.AntibodyDesignMover) → pyrosetta.rosetta.protocols.moves.Mover¶: C++: protocols::antibody::design::AntibodyDesignMover::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.design.AntibodyDesignMover) → str¶: C++: protocols::antibody::design::AntibodyDesignMover::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_top_designs(self: pyrosetta.rosetta.protocols.antibody.design.AntibodyDesignMover) → pyrosetta.rosetta.utility.vector1_std_shared_ptr_core_pose_Pose_t¶

Get the top designs found. You can then use them in other protocols, dump them, etc. They are in order.

This should be refactored to get_additional_output.

C++: protocols::antibody::design::AntibodyDesignMover::get_top_designs() –> class utility::vector1<class std::shared_ptr<class core::pose::Pose>, class std::allocator<class std::shared_ptr<class core::pose::Pose> > >

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::design::AntibodyDesignMover::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::design::AntibodyDesignMover::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_set_options(self: pyrosetta.rosetta.protocols.antibody.design.AntibodyDesignMover, cdr_set_options: pyrosetta.rosetta.utility.vector1_std_shared_ptr_protocols_antibody_CDRSetOptions_t) → None¶

Set the options which will be used for querying the database

C++: protocols::antibody::design::AntibodyDesignMover::set_cdr_set_options(class utility::vector1<class std::shared_ptr<class protocols::antibody::CDRSetOptions>, class std::allocator<class std::shared_ptr<class protocols::antibody::CDRSetOptions> > >) –> 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_defaults(self: pyrosetta.rosetta.protocols.antibody.design.AntibodyDesignMover) → None¶

Reads default CDRGraftInstruction file and creates structs.

C++: protocols::antibody::design::AntibodyDesignMover::set_defaults() –> void

set_design_protocol(self: pyrosetta.rosetta.protocols.antibody.design.AntibodyDesignMover, design_protocol: pyrosetta.rosetta.protocols.antibody.design.AntibodyDesignProtocolEnum) → None¶

Set the design protocol. Default is classic_monte_carlo.: Available options are: generalized_monte_carlo, deterministc_graft.

. Deterministic Protocol only available if GraftDesigning a single CDR.

C++: protocols::antibody::design::AntibodyDesignMover::set_design_protocol(enum protocols::antibody::design::AntibodyDesignProtocolEnum) –> void

set_dock_post_graft(self: pyrosetta.rosetta.protocols.antibody.design.AntibodyDesignMover, dock_post_graft: bool) → None¶

Set the algorithm to run a low-resolution docking step after each graft. Default false.

Uses command-line options for docking. Lower inner or outer cycles if you are grafting many CDRs. Still quicker then relax.

C++: protocols::antibody::design::AntibodyDesignMover::set_dock_post_graft(bool) –> void

set_dock_rounds(self: pyrosetta.rosetta.protocols.antibody.design.AntibodyDesignMover, dock_rounds: int) → None¶: C++: protocols::antibody::design::AntibodyDesignMover::set_dock_rounds(unsigned long) –> void

set_epitope_residues(self: pyrosetta.rosetta.protocols.antibody.design.AntibodyDesignMover, epitope_residues: pyrosetta.rosetta.utility.vector1_protocols_antibody_design_PDBNumbering) → None¶

Set any epitope residues in PDB numbering. If not set, they will be detected automatically via the interface.

C++: protocols::antibody::design::AntibodyDesignMover::set_epitope_residues(class utility::vector1<struct protocols::antibody::design::PDBNumbering, class std::allocator<struct protocols::antibody::design::PDBNumbering> >) –> void

set_graft_design_cdrs(self: pyrosetta.rosetta.protocols.antibody.design.AntibodyDesignMover, graft_design_cdrs: pyrosetta.rosetta.utility.vector1_protocols_antibody_CDRNameEnum) → None¶

Set the CDRs which will undergo Graft-Design

C++: protocols::antibody::design::AntibodyDesignMover::set_graft_design_cdrs(class utility::vector1<enum protocols::antibody::CDRNameEnum, class std::allocator<enum protocols::antibody::CDRNameEnum> >) –> void

set_graft_design_options(self: pyrosetta.rosetta.protocols.antibody.design.AntibodyDesignMover, graft_design_options: pyrosetta.rosetta.utility.vector1_std_shared_ptr_protocols_antibody_design_CDRGraftDesignOptions_t) → None¶

Set CDR-specific GraftDesign options

C++: protocols::antibody::design::AntibodyDesignMover::set_graft_design_options(class utility::vector1<class std::shared_ptr<class protocols::antibody::design::CDRGraftDesignOptions>, class std::allocator<class std::shared_ptr<class protocols::antibody::design::CDRGraftDesignOptions> > >) –> void

set_inner_cycles(self: pyrosetta.rosetta.protocols.antibody.design.AntibodyDesignMover, inner_cycles: int) → None¶

Set the number of inner cycles, which optimizes the structure and sequence of the antibody after any graft.: Essentially min cycles.

C++: protocols::antibody::design::AntibodyDesignMover::set_inner_cycles(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_instruction_file(self: pyrosetta.rosetta.protocols.antibody.design.AntibodyDesignMover, instruction_file: str) → None¶

Set the instruction file path to load options from instead of setting these via associated options functions: Or loading via cmd-line option. Gotta love supporting 3 different Rosetta interfaces.

C++: protocols::antibody::design::AntibodyDesignMover::set_instruction_file(class std::basic_string<char>) –> void

set_interface_dis(self: pyrosetta.rosetta.protocols.antibody.design.AntibodyDesignMover, interface_dis: float) → None¶: C++: protocols::antibody::design::AntibodyDesignMover::set_interface_dis(double) –> void

set_keep_top_designs(self: pyrosetta.rosetta.protocols.antibody.design.AntibodyDesignMover, top_designs: int) → None¶

Sets the protocol to keep a specific number of top designs. Default is 10

C++: protocols::antibody::design::AntibodyDesignMover::set_keep_top_designs(unsigned long) –> 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_neighbor_dis(self: pyrosetta.rosetta.protocols.antibody.design.AntibodyDesignMover, neighbor_dis: float) → None¶: C++: protocols::antibody::design::AntibodyDesignMover::set_neighbor_dis(double) –> void

set_outer_cycles(self: pyrosetta.rosetta.protocols.antibody.design.AntibodyDesignMover, outer_cycles: int) → None¶

Set the number of overall rounds. Each round will choose a CDR and design it and others based on options: Default = 25.

C++: protocols::antibody::design::AntibodyDesignMover::set_outer_cycles(unsigned long) –> void

set_paratope_cdrs(self: pyrosetta.rosetta.protocols.antibody.design.AntibodyDesignMover, cdrs: pyrosetta.rosetta.utility.vector1_bool) → None¶

Set any paratope CDRs. If not set, will use all CDRs as the paratope where needed.: Used mainly for constraints

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

set_primary_cdrs(self: pyrosetta.rosetta.protocols.antibody.design.AntibodyDesignMover, primary_cdrs: pyrosetta.rosetta.utility.vector1_protocols_antibody_CDRNameEnum) → None¶

Manually set the CDRs which can be chosen in the outer cycle.

These should be on for either Sequence-Design or Graft-Design. Normally, the outer cycles are whatever CDRs we are designing, including CDRs which are sequence-design only. Use this if you are primarily interested in specific CDRs

(such as graft-designing H3 and allowing H1 and L3 to sequence design during the inner cycle.

C++: protocols::antibody::design::AntibodyDesignMover::set_primary_cdrs(class utility::vector1<enum protocols::antibody::CDRNameEnum, class std::allocator<enum protocols::antibody::CDRNameEnum> >) –> void

set_scorefunction(self: pyrosetta.rosetta.protocols.antibody.design.AntibodyDesignMover, scorefxn: pyrosetta.rosetta.core.scoring.ScoreFunction) → None¶: C++: protocols::antibody::design::AntibodyDesignMover::set_scorefunction(class std::shared_ptr<class core::scoring::ScoreFunction>) –> void

set_scorefunction_min(self: pyrosetta.rosetta.protocols.antibody.design.AntibodyDesignMover, min_scorefxn: pyrosetta.rosetta.core.scoring.ScoreFunction) → None¶: C++: protocols::antibody::design::AntibodyDesignMover::set_scorefunction_min(class std::shared_ptr<class core::scoring::ScoreFunction>) –> void

set_seq_design_cdrs(self: pyrosetta.rosetta.protocols.antibody.design.AntibodyDesignMover, seq_design_cdrs: pyrosetta.rosetta.utility.vector1_protocols_antibody_CDRNameEnum) → None¶

Set the CDRs which will undergo Sequence-Design

C++: protocols::antibody::design::AntibodyDesignMover::set_seq_design_cdrs(class utility::vector1<enum protocols::antibody::CDRNameEnum, class std::allocator<enum protocols::antibody::CDRNameEnum> >) –> void

set_seq_design_options(self: pyrosetta.rosetta.protocols.antibody.design.AntibodyDesignMover, seq_design_options: pyrosetta.rosetta.utility.vector1_std_shared_ptr_protocols_antibody_design_CDRSeqDesignOptions_t) → None¶

Set CDR-specific SeqDesign options

C++: protocols::antibody::design::AntibodyDesignMover::set_seq_design_options(class utility::vector1<class std::shared_ptr<class protocols::antibody::design::CDRSeqDesignOptions>, class std::allocator<class std::shared_ptr<class protocols::antibody::design::CDRSeqDesignOptions> > >) –> 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_epitope_constraints(self: pyrosetta.rosetta.protocols.antibody.design.AntibodyDesignMover, use_epitope_csts: bool) → None¶

Setting to use epitope constraints. Without this false, will not use any set epitope residues.

C++: protocols::antibody::design::AntibodyDesignMover::set_use_epitope_constraints(bool) –> void

show(*args, **kwargs)¶

Overloaded function.

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

C++: protocols::antibody::design::AntibodyDesignMover::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.design.AntibodyDesignProtocol¶

Bases: pyrosetta.rosetta.protocols.moves.Mover

Main AntibodyDesignProtocol, tieing together individual movers and classes. Main mover for application.

__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.design.AntibodyDesignProtocol) -> None
__init__(self: pyrosetta.rosetta.protocols.antibody.design.AntibodyDesignProtocol, arg0: pyrosetta.rosetta.protocols.antibody.design.AntibodyDesignProtocol) -> 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.design.AntibodyDesignProtocol, pose: pyrosetta.rosetta.core.pose.Pose) → None¶: C++: protocols::antibody::design::AntibodyDesignProtocol::apply(class core::pose::Pose &) –> void

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

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.design.AntibodyDesignProtocol) → pyrosetta.rosetta.protocols.moves.Mover¶: C++: protocols::antibody::design::AntibodyDesignProtocol::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.design.AntibodyDesignProtocol) → pyrosetta.rosetta.protocols.moves.Mover¶: C++: protocols::antibody::design::AntibodyDesignProtocol::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.design.AntibodyDesignProtocol) → str¶: C++: protocols::antibody::design::AntibodyDesignProtocol::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::design::AntibodyDesignProtocol::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::design::AntibodyDesignProtocol::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.antibody.design.AntibodyDesignProtocol) → bool¶: C++: protocols::antibody::design::AntibodyDesignProtocol::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_instruction_file_path(self: pyrosetta.rosetta.protocols.antibody.design.AntibodyDesignProtocol, instruction_file: str) → None¶

Set the instruction file path instead of reading it from the cmd-line options.

C++: protocols::antibody::design::AntibodyDesignProtocol::set_instruction_file_path(class std::basic_string<char>) –> 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_run_relax(self: pyrosetta.rosetta.protocols.antibody.design.AntibodyDesignProtocol, setting: bool) → None¶

Run Dualspace Relax after main design runs

C++: protocols::antibody::design::AntibodyDesignProtocol::set_run_relax(bool) –> void

set_run_snugdock(self: pyrosetta.rosetta.protocols.antibody.design.AntibodyDesignProtocol, setting: bool) → None¶

Run SnugDock after main design runs

C++: protocols::antibody::design::AntibodyDesignProtocol::set_run_snugdock(bool) –> void

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

Set the global scorefunction. Used for snugdock/relax/total energy/etc.: Not Used for Docking within the protocol.

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

set_scorefxn_min(self: pyrosetta.rosetta.protocols.antibody.design.AntibodyDesignProtocol, scorefxn: pyrosetta.rosetta.core.scoring.ScoreFunction) → None¶

Set the min scorefunction used by the AntibodyDesignMover during the Minimization step.: Should include dihedral_constraint weights if using default CDR constraints added during the protocol.

C++: protocols::antibody::design::AntibodyDesignProtocol::set_scorefxn_min(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.design.AntibodySeqDesignTFCreator¶

Bases: pybind11_builtins.pybind11_object

Create a TaskFactory or individual TaskOperations based on a set of options These options are mainly for per-CDR and per-framework control of sequence design

__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.design.AntibodySeqDesignTFCreator, arg0: pyrosetta.rosetta.protocols.antibody.AntibodyInfo) -> None

doc

__init__(self: pyrosetta.rosetta.protocols.antibody.design.AntibodySeqDesignTFCreator, ab_info: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, force_north_paper_db: bool) -> None
__init__(self: pyrosetta.rosetta.protocols.antibody.design.AntibodySeqDesignTFCreator, arg0: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, arg1: pyrosetta.rosetta.utility.vector1_std_shared_ptr_protocols_antibody_design_CDRSeqDesignOptions_t) -> None

doc

__init__(self: pyrosetta.rosetta.protocols.antibody.design.AntibodySeqDesignTFCreator, arg0: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, arg1: pyrosetta.rosetta.utility.vector1_std_shared_ptr_protocols_antibody_design_CDRSeqDesignOptions_t, arg2: bool) -> None

doc

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

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

design_antigen(self: pyrosetta.rosetta.protocols.antibody.design.AntibodySeqDesignTFCreator, antigen_design: bool) → None¶

Normally, we do not want to design the antigen residues - but perhaps someday we will.: If False, turn design off for the antigen for any TF creation.

C++: protocols::antibody::design::AntibodySeqDesignTFCreator::design_antigen(bool) –> void

design_framework(self: pyrosetta.rosetta.protocols.antibody.design.AntibodySeqDesignTFCreator, framework_design: bool) → None¶

Design any framework residues included in the task. Default True.: If False, turn design off for the framework for any TF creation.

C++: protocols::antibody::design::AntibodySeqDesignTFCreator::design_framework(bool) –> void

design_proline(self: pyrosetta.rosetta.protocols.antibody.design.AntibodySeqDesignTFCreator, setting: bool) → None¶

Keep proline fixed for design. If using profile design, this should not really come into play.

C++: protocols::antibody::design::AntibodySeqDesignTFCreator::design_proline(const bool) –> void

disable_design_for_non_designing_cdrs(self: pyrosetta.rosetta.protocols.antibody.design.AntibodySeqDesignTFCreator, tf: pyrosetta.rosetta.core.pack.task.TaskFactory, pose: pyrosetta.rosetta.core.pose.Pose) → None¶

Turns off CDRs for design that are set to off.

C++: protocols::antibody::design::AntibodySeqDesignTFCreator::disable_design_for_non_designing_cdrs(class std::shared_ptr<class core::pack::task::TaskFactory>, const class core::pose::Pose &) –> void

disable_disallowed_aa(self: pyrosetta.rosetta.protocols.antibody.design.AntibodySeqDesignTFCreator, tf: pyrosetta.rosetta.core.pack.task.TaskFactory, pose: pyrosetta.rosetta.core.pose.Pose) → None¶: C++: protocols::antibody::design::AntibodySeqDesignTFCreator::disable_disallowed_aa(class std::shared_ptr<class core::pack::task::TaskFactory>, const class core::pose::Pose &) const –> void

disable_proline_design(self: pyrosetta.rosetta.protocols.antibody.design.AntibodySeqDesignTFCreator, tf: pyrosetta.rosetta.core.pack.task.TaskFactory, pose: pyrosetta.rosetta.core.pose.Pose) → None¶: C++: protocols::antibody::design::AntibodySeqDesignTFCreator::disable_proline_design(class std::shared_ptr<class core::pack::task::TaskFactory>, const class core::pose::Pose &) const –> void

generate_task_op_all_cdr_design(*args, **kwargs)¶

Overloaded function.

generate_task_op_all_cdr_design(self: pyrosetta.rosetta.protocols.antibody.design.AntibodySeqDesignTFCreator, pose: pyrosetta.rosetta.core.pose.Pose) -> pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictToLoopsAndNeighbors
generate_task_op_all_cdr_design(self: pyrosetta.rosetta.protocols.antibody.design.AntibodySeqDesignTFCreator, pose: pyrosetta.rosetta.core.pose.Pose, design_neighbors: bool) -> pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictToLoopsAndNeighbors

Create a TaskOp to limit Packing and Design to CDR loops and neighbors.

C++: protocols::antibody::design::AntibodySeqDesignTFCreator::generate_task_op_all_cdr_design(const class core::pose::Pose &, bool) const –> class std::shared_ptr<class protocols::toolbox::task_operations::RestrictToLoopsAndNeighbors>

generate_task_op_cdr_design(*args, **kwargs)¶

Overloaded function.

generate_task_op_cdr_design(self: pyrosetta.rosetta.protocols.antibody.design.AntibodySeqDesignTFCreator, pose: pyrosetta.rosetta.core.pose.Pose) -> pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictToLoopsAndNeighbors
generate_task_op_cdr_design(self: pyrosetta.rosetta.protocols.antibody.design.AntibodySeqDesignTFCreator, pose: pyrosetta.rosetta.core.pose.Pose, design_neighbors: bool) -> pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictToLoopsAndNeighbors

Create a TaskOp to limit Packing and Design to only CDR loops with design on. Use neighbor distance.

C++: protocols::antibody::design::AntibodySeqDesignTFCreator::generate_task_op_cdr_design(const class core::pose::Pose &, bool) const –> class std::shared_ptr<class protocols::toolbox::task_operations::RestrictToLoopsAndNeighbors>

generate_task_op_cdr_design(self: pyrosetta.rosetta.protocols.antibody.design.AntibodySeqDesignTFCreator, pose: pyrosetta.rosetta.core.pose.Pose, cdrs: pyrosetta.rosetta.utility.vector1_bool) -> pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictToLoopsAndNeighbors
generate_task_op_cdr_design(self: pyrosetta.rosetta.protocols.antibody.design.AntibodySeqDesignTFCreator, pose: pyrosetta.rosetta.core.pose.Pose, cdrs: pyrosetta.rosetta.utility.vector1_bool, design_neighbors: bool) -> pyrosetta.rosetta.protocols.toolbox.task_operations.RestrictToLoopsAndNeighbors

Create a TaskOp for only CDR loops set to True in the boolean vector.

C++: protocols::antibody::design::AntibodySeqDesignTFCreator::generate_task_op_cdr_design(const class core::pose::Pose &, class utility::vector1<bool, class std::allocator<bool> >, bool) const –> class std::shared_ptr<class protocols::toolbox::task_operations::RestrictToLoopsAndNeighbors>

generate_task_op_cdr_profiles(self: pyrosetta.rosetta.protocols.antibody.design.AntibodySeqDesignTFCreator, pose: pyrosetta.rosetta.core.pose.Pose) → protocols::antibody::task_operations::AddCDRProfilesOperation¶

Setup the CDRProfilesOperation and conservative/basic design: according to primary and fallback strategies and which CDRs are set to design. Pre-load the data

C++: protocols::antibody::design::AntibodySeqDesignTFCreator::generate_task_op_cdr_profiles(const class core::pose::Pose &) –> class std::shared_ptr<class protocols::antibody::task_operations::AddCDRProfilesOperation>

generate_tf_seq_design(*args, **kwargs)¶

Overloaded function.

generate_tf_seq_design(self: pyrosetta.rosetta.protocols.antibody.design.AntibodySeqDesignTFCreator, pose: pyrosetta.rosetta.core.pose.Pose) -> pyrosetta.rosetta.core.pack.task.TaskFactory
generate_tf_seq_design(self: pyrosetta.rosetta.protocols.antibody.design.AntibodySeqDesignTFCreator, pose: pyrosetta.rosetta.core.pose.Pose, disable_non_designing_cdrs: bool) -> pyrosetta.rosetta.core.pack.task.TaskFactory

Create the FULL TaskFactory for antibody sequence design.: There are no limits to repacking or design - AKA NO RestrictToLoops. Optionally disable framework residues for design Optionally disable antigen residues for design. Optionally disable framework conservative residues -> Combine with other Tasks for general design requirements.

C++: protocols::antibody::design::AntibodySeqDesignTFCreator::generate_tf_seq_design(const class core::pose::Pose &, bool) –> class std::shared_ptr<class core::pack::task::TaskFactory>

generate_tf_seq_design_graft_design(self: pyrosetta.rosetta.protocols.antibody.design.AntibodySeqDesignTFCreator, pose: pyrosetta.rosetta.core.pose.Pose, cdr: pyrosetta.rosetta.protocols.antibody.CDRNameEnum, neighbor_cdr_min: pyrosetta.rosetta.utility.vector1_bool) → pyrosetta.rosetta.core.pack.task.TaskFactory¶

Create the TaskFactory used for sequence design during the GraftDesign stage.

This limits design to the passed CDR, optionally designing neighbor CDRs specified in options and included in min.

Basically will create a TF including CDRs you are minimizing and any neighbors. It will then use settings in your Options classes and class settings such as framework or antigen design to create the TF, disabling CDRs that are not allowed to design as well as framework or antigen regions.

Optionally design any neighbor framework residues Optionally design any neighbor antigen residues Optionally disable framework conservative residues

C++: protocols::antibody::design::AntibodySeqDesignTFCreator::generate_tf_seq_design_graft_design(const class core::pose::Pose &, enum protocols::antibody::CDRNameEnum, const class utility::vector1<bool, class std::allocator<bool> > &) –> class std::shared_ptr<class core::pack::task::TaskFactory>

get_cdr_design_options(*args, **kwargs)¶

Overloaded function.

get_cdr_design_options(self: pyrosetta.rosetta.protocols.antibody.design.AntibodySeqDesignTFCreator) -> pyrosetta.rosetta.utility.vector1_std_shared_ptr_protocols_antibody_design_CDRSeqDesignOptions_t

Get modifiable options

C++: protocols::antibody::design::AntibodySeqDesignTFCreator::get_cdr_design_options() –> class utility::vector1<class std::shared_ptr<class protocols::antibody::design::CDRSeqDesignOptions>, class std::allocator<class std::shared_ptr<class protocols::antibody::design::CDRSeqDesignOptions> > >

get_cdr_design_options(self: pyrosetta.rosetta.protocols.antibody.design.AntibodySeqDesignTFCreator, cdr: pyrosetta.rosetta.protocols.antibody.CDRNameEnum) -> pyrosetta.rosetta.protocols.antibody.design.CDRSeqDesignOptions

Get modifiable options

C++: protocols::antibody::design::AntibodySeqDesignTFCreator::get_cdr_design_options(enum protocols::antibody::CDRNameEnum) –> class std::shared_ptr<class protocols::antibody::design::CDRSeqDesignOptions>

neighbor_detection_dis(self: pyrosetta.rosetta.protocols.antibody.design.AntibodySeqDesignTFCreator, neighbor_distance: float) → None¶

Repack neighbors of CDR’s being designed within this distance.

C++: protocols::antibody::design::AntibodySeqDesignTFCreator::neighbor_detection_dis(const double) –> void

set_cdr_design_options(*args, **kwargs)¶

Overloaded function.

set_cdr_design_options(self: pyrosetta.rosetta.protocols.antibody.design.AntibodySeqDesignTFCreator, cdr: pyrosetta.rosetta.protocols.antibody.CDRNameEnum, design_options: pyrosetta.rosetta.protocols.antibody.design.CDRSeqDesignOptions) -> None

Set design options for single CDR

C++: protocols::antibody::design::AntibodySeqDesignTFCreator::set_cdr_design_options(enum protocols::antibody::CDRNameEnum, class std::shared_ptr<const class protocols::antibody::design::CDRSeqDesignOptions>) –> void

set_cdr_design_options(self: pyrosetta.rosetta.protocols.antibody.design.AntibodySeqDesignTFCreator, design_options: pyrosetta.rosetta.utility.vector1_std_shared_ptr_protocols_antibody_design_CDRSeqDesignOptions_t) -> None

Set design options for All CDRs

C++: protocols::antibody::design::AntibodySeqDesignTFCreator::set_cdr_design_options(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> > >) –> void

set_design_H3_stem(self: pyrosetta.rosetta.protocols.antibody.design.AntibodySeqDesignTFCreator, design_H3_stem: bool) → None¶

Enable design of the first 2 and last 3 residues of the H3 loop. These are off by default as to help hinder the transition from extended: to kinked and vice versa during sequence design.

C++: protocols::antibody::design::AntibodySeqDesignTFCreator::set_design_H3_stem(bool) –> void

set_design_framework_conservative(self: pyrosetta.rosetta.protocols.antibody.design.AntibodySeqDesignTFCreator, design_framework_conservative: bool) → None¶

Use the Conservative Design TaskOP if designing Framework residues.: Default true. Recommended.

C++: protocols::antibody::design::AntibodySeqDesignTFCreator::set_design_framework_conservative(bool) –> void

set_design_framework_conserved_res(self: pyrosetta.rosetta.protocols.antibody.design.AntibodySeqDesignTFCreator, design_framework_conserved_res: bool) → None¶

Enable design of 100% conserved framework positions during TF generation.: Default false. Will be expanded.

C++: protocols::antibody::design::AntibodySeqDesignTFCreator::set_design_framework_conserved_res(bool) –> void

set_probability_data_cutoff(self: pyrosetta.rosetta.protocols.antibody.design.AntibodySeqDesignTFCreator, cutoff: int) → None¶

Use conservative mutations (or alternative method) instead of using cluster sequence probabilities for design: if the number of sequences in the particular CDR’s cluster probability data is lower than this cutoff. Default is 10. This is why we try and stay in type 1 lengths during graft.

C++: protocols::antibody::design::AntibodySeqDesignTFCreator::set_probability_data_cutoff(const unsigned long) –> void

set_zero_prob_weight_at(self: pyrosetta.rosetta.protocols.antibody.design.AntibodySeqDesignTFCreator, weight: float) → None¶

Use these weights during probabilistic design for data that is normally zero.

C++: protocols::antibody::design::AntibodySeqDesignTFCreator::set_zero_prob_weight_at(const double) –> void

class pyrosetta.rosetta.protocols.antibody.design.CDRGraftDesignOptions¶

Bases: pybind11_builtins.pybind11_object

Class that holds CDRGraftDesign Options. Now that GraftDesign is not a separate ‘thing’, this should be split into CDRGraftOptions and CDRMinOptions eventually.

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

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

design(*args, **kwargs)¶

Overloaded function.

design(self: pyrosetta.rosetta.protocols.antibody.design.CDRGraftDesignOptions, design: bool) -> None

Should this CDR be designed?

C++: protocols::antibody::design::CDRGraftDesignOptions::design(bool) –> void

design(self: pyrosetta.rosetta.protocols.antibody.design.CDRGraftDesignOptions) -> bool

Should this CDR be designed?

C++: protocols::antibody::design::CDRGraftDesignOptions::design() const –> bool

min_neighbor_sc(*args, **kwargs)¶

Overloaded function.

min_neighbor_sc(self: pyrosetta.rosetta.protocols.antibody.design.CDRGraftDesignOptions, min_neighbor_sc: bool) -> None

Minimize neighbor sidechains?

C++: protocols::antibody::design::CDRGraftDesignOptions::min_neighbor_sc(bool) –> void

min_neighbor_sc(self: pyrosetta.rosetta.protocols.antibody.design.CDRGraftDesignOptions) -> bool

C++: protocols::antibody::design::CDRGraftDesignOptions::min_neighbor_sc() const –> bool

min_rb(*args, **kwargs)¶

Overloaded function.

min_rb(self: pyrosetta.rosetta.protocols.antibody.design.CDRGraftDesignOptions, min_rb: bool) -> None

Use rigid body optimization during minimization of the CDR (Minimize jump bt antigen and antibody)?

Does nothing if repacking the cdr. Default False.

C++: protocols::antibody::design::CDRGraftDesignOptions::min_rb(bool) –> void

min_rb(self: pyrosetta.rosetta.protocols.antibody.design.CDRGraftDesignOptions) -> bool

C++: protocols::antibody::design::CDRGraftDesignOptions::min_rb() const –> bool

min_sc(*args, **kwargs)¶

Overloaded function.

min_sc(self: pyrosetta.rosetta.protocols.antibody.design.CDRGraftDesignOptions, min_sc: bool) -> None

Minimize sidechains during minimization (relax/min/etc) (default True?

C++: protocols::antibody::design::CDRGraftDesignOptions::min_sc(bool) –> void

min_sc(self: pyrosetta.rosetta.protocols.antibody.design.CDRGraftDesignOptions) -> bool

C++: protocols::antibody::design::CDRGraftDesignOptions::min_sc() const –> bool

mintype(*args, **kwargs)¶

Overloaded function.

mintype(self: pyrosetta.rosetta.protocols.antibody.design.CDRGraftDesignOptions, mintype: pyrosetta.rosetta.protocols.antibody.design.MinTypeEnum) -> None

Options are: relax, minimize, repack, dualspace. Default is repack for time, but relax is the best

C++: protocols::antibody::design::CDRGraftDesignOptions::mintype(enum protocols::antibody::design::MinTypeEnum) –> void

mintype(self: pyrosetta.rosetta.protocols.antibody.design.CDRGraftDesignOptions) -> pyrosetta.rosetta.protocols.antibody.design.MinTypeEnum

C++: protocols::antibody::design::CDRGraftDesignOptions::mintype() const –> enum protocols::antibody::design::MinTypeEnum

neighbor_min(*args, **kwargs)¶

Overloaded function.

neighbor_min(self: pyrosetta.rosetta.protocols.antibody.design.CDRGraftDesignOptions, neighbor_min: pyrosetta.rosetta.utility.vector1_protocols_antibody_CDRNameEnum) -> None

Set other CDRs to minimize when this CDR is minimized

C++: protocols::antibody::design::CDRGraftDesignOptions::neighbor_min(class utility::vector1<enum protocols::antibody::CDRNameEnum, class std::allocator<enum protocols::antibody::CDRNameEnum> >) –> void

neighbor_min(self: pyrosetta.rosetta.protocols.antibody.design.CDRGraftDesignOptions) -> pyrosetta.rosetta.utility.vector1_protocols_antibody_CDRNameEnum

C++: protocols::antibody::design::CDRGraftDesignOptions::neighbor_min() const –> class utility::vector1<enum protocols::antibody::CDRNameEnum, class std::allocator<enum protocols::antibody::CDRNameEnum> >

neighbor_min_add(self: pyrosetta.rosetta.protocols.antibody.design.CDRGraftDesignOptions, cdr: pyrosetta.rosetta.protocols.antibody.CDRNameEnum) → None¶: C++: protocols::antibody::design::CDRGraftDesignOptions::neighbor_min_add(enum protocols::antibody::CDRNameEnum) –> void

neighbor_min_clear(self: pyrosetta.rosetta.protocols.antibody.design.CDRGraftDesignOptions) → None¶: C++: protocols::antibody::design::CDRGraftDesignOptions::neighbor_min_clear() –> void

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

Set the CDR type for this instance of options.

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

set_defaults(self: pyrosetta.rosetta.protocols.antibody.design.CDRGraftDesignOptions) → None¶

Set defaults - !!! these are not the defaults from the database default instruction file.: Use the parser to parse those instructions if you wish.

C++: protocols::antibody::design::CDRGraftDesignOptions::set_defaults() –> void

weight(*args, **kwargs)¶

Overloaded function.

weight(self: pyrosetta.rosetta.protocols.antibody.design.CDRGraftDesignOptions, weight: float) -> None

Set the weight we will use for choosing this particular CDR for design.

C++: protocols::antibody::design::CDRGraftDesignOptions::weight(double) –> void

weight(self: pyrosetta.rosetta.protocols.antibody.design.CDRGraftDesignOptions) -> float

Return the weight we will use for choosing this particular CDR for design.

C++: protocols::antibody::design::CDRGraftDesignOptions::weight() const –> double

class pyrosetta.rosetta.protocols.antibody.design.GeneralAntibodyModeler¶

Bases: pybind11_builtins.pybind11_object

Basic Class that can run modeling for various protocols. Does not do any design. Setup design TF via AntibodySeqDesignTFCreator.

__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.design.GeneralAntibodyModeler, ab_info: pyrosetta.rosetta.protocols.antibody.AntibodyInfo) -> None
__init__(self: pyrosetta.rosetta.protocols.antibody.design.GeneralAntibodyModeler, arg0: pyrosetta.rosetta.protocols.antibody.design.GeneralAntibodyModeler) -> 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).

ab_dock_chains(self: pyrosetta.rosetta.protocols.antibody.design.GeneralAntibodyModeler, ab_dock_chains: str) → None¶

Set the ab_dock chains, which will be used for any docking or minimization on the jump. (LH_A, L_H, etc. - A for antigen)

C++: protocols::antibody::design::GeneralAntibodyModeler::ab_dock_chains(class std::basic_string<char>) –> void

apply_A_LH_foldtree(self: pyrosetta.rosetta.protocols.antibody.design.GeneralAntibodyModeler, pose: pyrosetta.rosetta.core.pose.Pose) → None¶

Applies a docking foldtree.. Forked from AbInfo - Its version uses hardcoded order of the PDB. However, this calls docking FT, which is hard coded as well for now.: Fix Me.

C++: protocols::antibody::design::GeneralAntibodyModeler::apply_A_LH_foldtree(class core::pose::Pose &) const –> void

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

backrub_cdrs(*args, **kwargs)¶

Overloaded function.

backrub_cdrs(self: pyrosetta.rosetta.protocols.antibody.design.GeneralAntibodyModeler, pose: pyrosetta.rosetta.core.pose.Pose) -> None
backrub_cdrs(self: pyrosetta.rosetta.protocols.antibody.design.GeneralAntibodyModeler, pose: pyrosetta.rosetta.core.pose.Pose, min_sc: bool) -> None
backrub_cdrs(self: pyrosetta.rosetta.protocols.antibody.design.GeneralAntibodyModeler, pose: pyrosetta.rosetta.core.pose.Pose, min_sc: bool, include_neighbor_sc: bool) -> None

Run the BackrubProtocol on the CDRs. Control backrub through cmd-line.

C++: protocols::antibody::design::GeneralAntibodyModeler::backrub_cdrs(class core::pose::Pose &, bool, bool) const –> void

cdr_overhang(self: pyrosetta.rosetta.protocols.antibody.design.GeneralAntibodyModeler, cdr: pyrosetta.rosetta.protocols.antibody.CDRNameEnum, overhang: int) → None¶

How many residues on either side of the CDR to include in CDR - modeling? (Default is 0)

C++: protocols::antibody::design::GeneralAntibodyModeler::cdr_overhang(const enum protocols::antibody::CDRNameEnum, const unsigned long) –> void

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

dock_high_res(*args, **kwargs)¶

Overloaded function.

dock_high_res(self: pyrosetta.rosetta.protocols.antibody.design.GeneralAntibodyModeler, pose: pyrosetta.rosetta.core.pose.Pose) -> None
dock_high_res(self: pyrosetta.rosetta.protocols.antibody.design.GeneralAntibodyModeler, pose: pyrosetta.rosetta.core.pose.Pose, first_cycle: int) -> None
dock_high_res(self: pyrosetta.rosetta.protocols.antibody.design.GeneralAntibodyModeler, pose: pyrosetta.rosetta.core.pose.Pose, first_cycle: int, second_cycle: int) -> None

C++: protocols::antibody::design::GeneralAntibodyModeler::dock_high_res(class core::pose::Pose &, unsigned long, unsigned long) const –> void

dock_low_res(*args, **kwargs)¶

Overloaded function.

dock_low_res(self: pyrosetta.rosetta.protocols.antibody.design.GeneralAntibodyModeler, pose: pyrosetta.rosetta.core.pose.Pose) -> None
dock_low_res(self: pyrosetta.rosetta.protocols.antibody.design.GeneralAntibodyModeler, pose: pyrosetta.rosetta.core.pose.Pose, pack_interface: bool) -> None

Dock the antibody. Using A for designation of Antigen chains. Not full antigen chains. (L_A, LH_A, L_H, etc.)

C++: protocols::antibody::design::GeneralAntibodyModeler::dock_low_res(class core::pose::Pose &, bool) const –> void

extend_CDR(self: pyrosetta.rosetta.protocols.antibody.design.GeneralAntibodyModeler, pose: pyrosetta.rosetta.core.pose.Pose, cdr: pyrosetta.rosetta.protocols.antibody.CDRNameEnum) → None¶

Randomizes the dihedrals of the CDR.

C++: protocols::antibody::design::GeneralAntibodyModeler::extend_CDR(class core::pose::Pose &, enum protocols::antibody::CDRNameEnum) const –> void

get_cdr_loop_with_overhang(self: pyrosetta.rosetta.protocols.antibody.design.GeneralAntibodyModeler, pose: pyrosetta.rosetta.core.pose.Pose, cdr: pyrosetta.rosetta.protocols.antibody.CDRNameEnum) → pyrosetta.rosetta.protocols.loops.Loop¶: C++: protocols::antibody::design::GeneralAntibodyModeler::get_cdr_loop_with_overhang(const class core::pose::Pose &, enum protocols::antibody::CDRNameEnum) const –> class protocols::loops::Loop

get_cdr_loops(self: pyrosetta.rosetta.protocols.antibody.design.GeneralAntibodyModeler, pose: pyrosetta.rosetta.core.pose.Pose) → pyrosetta.rosetta.protocols.loops.Loops¶

Get CDR loops with cutpoint in the middle.

C++: protocols::antibody::design::GeneralAntibodyModeler::get_cdr_loops(const class core::pose::Pose &) const –> class std::shared_ptr<class protocols::loops::Loops>

get_cdr_loops_with_overhang(self: pyrosetta.rosetta.protocols.antibody.design.GeneralAntibodyModeler, pose: pyrosetta.rosetta.core.pose.Pose) → pyrosetta.rosetta.protocols.loops.Loops¶

Get CDR loops with set overhang with cutpoint at the stop position +1.

C++: protocols::antibody::design::GeneralAntibodyModeler::get_cdr_loops_with_overhang(const class core::pose::Pose &) const –> class std::shared_ptr<class protocols::loops::Loops>

get_cdrs_movemap_with_overhang(*args, **kwargs)¶

Overloaded function.

get_cdrs_movemap_with_overhang(self: pyrosetta.rosetta.protocols.antibody.design.GeneralAntibodyModeler, pose: pyrosetta.rosetta.core.pose.Pose) -> pyrosetta.rosetta.core.kinematics.MoveMap
get_cdrs_movemap_with_overhang(self: pyrosetta.rosetta.protocols.antibody.design.GeneralAntibodyModeler, pose: pyrosetta.rosetta.core.pose.Pose, min_bb: bool) -> pyrosetta.rosetta.core.kinematics.MoveMap
get_cdrs_movemap_with_overhang(self: pyrosetta.rosetta.protocols.antibody.design.GeneralAntibodyModeler, pose: pyrosetta.rosetta.core.pose.Pose, min_bb: bool, min_sc: bool) -> pyrosetta.rosetta.core.kinematics.MoveMap
get_cdrs_movemap_with_overhang(self: pyrosetta.rosetta.protocols.antibody.design.GeneralAntibodyModeler, pose: pyrosetta.rosetta.core.pose.Pose, min_bb: bool, min_sc: bool, include_neighbor_sc: bool) -> pyrosetta.rosetta.core.kinematics.MoveMap
get_cdrs_movemap_with_overhang(self: pyrosetta.rosetta.protocols.antibody.design.GeneralAntibodyModeler, pose: pyrosetta.rosetta.core.pose.Pose, min_bb: bool, min_sc: bool, include_neighbor_sc: bool, include_neighbor_bb: bool) -> pyrosetta.rosetta.core.kinematics.MoveMap

C++: protocols::antibody::design::GeneralAntibodyModeler::get_cdrs_movemap_with_overhang(class core::pose::Pose &, bool, bool, bool, bool) const –> class std::shared_ptr<class core::kinematics::MoveMap>

get_movemap_from_task(self: pyrosetta.rosetta.protocols.antibody.design.GeneralAntibodyModeler, pose: pyrosetta.rosetta.core.pose.Pose, task: pyrosetta.rosetta.core.pack.task.PackerTask) → pyrosetta.rosetta.core.kinematics.MoveMap¶: C++: protocols::antibody::design::GeneralAntibodyModeler::get_movemap_from_task(const class core::pose::Pose &, class std::shared_ptr<const class core::pack::task::PackerTask>) const –> class std::shared_ptr<class core::kinematics::MoveMap>

interface_detection_dis(*args, **kwargs)¶

Overloaded function.

interface_detection_dis(self: pyrosetta.rosetta.protocols.antibody.design.GeneralAntibodyModeler, interface_distance: float) -> None

Set a value for interface detection across the class.

C++: protocols::antibody::design::GeneralAntibodyModeler::interface_detection_dis(double) –> void

interface_detection_dis(self: pyrosetta.rosetta.protocols.antibody.design.GeneralAntibodyModeler) -> float

C++: protocols::antibody::design::GeneralAntibodyModeler::interface_detection_dis() const –> double

minimize_cdrs(*args, **kwargs)¶

Overloaded function.

minimize_cdrs(self: pyrosetta.rosetta.protocols.antibody.design.GeneralAntibodyModeler, pose: pyrosetta.rosetta.core.pose.Pose) -> None
minimize_cdrs(self: pyrosetta.rosetta.protocols.antibody.design.GeneralAntibodyModeler, pose: pyrosetta.rosetta.core.pose.Pose, min_sc: bool) -> None
minimize_cdrs(self: pyrosetta.rosetta.protocols.antibody.design.GeneralAntibodyModeler, pose: pyrosetta.rosetta.core.pose.Pose, min_sc: bool, include_neighbor_sc: bool) -> None
minimize_cdrs(self: pyrosetta.rosetta.protocols.antibody.design.GeneralAntibodyModeler, pose: pyrosetta.rosetta.core.pose.Pose, min_sc: bool, include_neighbor_sc: bool, min_interface: bool) -> None
minimize_cdrs(self: pyrosetta.rosetta.protocols.antibody.design.GeneralAntibodyModeler, pose: pyrosetta.rosetta.core.pose.Pose, min_sc: bool, include_neighbor_sc: bool, min_interface: bool, cartmin: bool) -> None
minimize_cdrs(self: pyrosetta.rosetta.protocols.antibody.design.GeneralAntibodyModeler, pose: pyrosetta.rosetta.core.pose.Pose, min_sc: bool, include_neighbor_sc: bool, min_interface: bool, cartmin: bool, use_talaris_cartmin: bool) -> None

Vanilla minimizer using dfpmin_armijo_nonmonotone at .001 tolerance (or lfbgs for cartmin).

C++: protocols::antibody::design::GeneralAntibodyModeler::minimize_cdrs(class core::pose::Pose &, bool, bool, bool, bool, bool) const –> void

minimize_interface(*args, **kwargs)¶

Overloaded function.

minimize_interface(self: pyrosetta.rosetta.protocols.antibody.design.GeneralAntibodyModeler, pose: pyrosetta.rosetta.core.pose.Pose) -> None
minimize_interface(self: pyrosetta.rosetta.protocols.antibody.design.GeneralAntibodyModeler, pose: pyrosetta.rosetta.core.pose.Pose, min_interface_sc: bool) -> None

C++: protocols::antibody::design::GeneralAntibodyModeler::minimize_interface(class core::pose::Pose &, bool) const –> void

neighbor_detection_dis(*args, **kwargs)¶

Overloaded function.

neighbor_detection_dis(self: pyrosetta.rosetta.protocols.antibody.design.GeneralAntibodyModeler, neighbor_distance: float) -> None

C++: protocols::antibody::design::GeneralAntibodyModeler::neighbor_detection_dis(double) –> void

neighbor_detection_dis(self: pyrosetta.rosetta.protocols.antibody.design.GeneralAntibodyModeler) -> float

C++: protocols::antibody::design::GeneralAntibodyModeler::neighbor_detection_dis() const –> double

relax_cdrs(*args, **kwargs)¶

Overloaded function.

relax_cdrs(self: pyrosetta.rosetta.protocols.antibody.design.GeneralAntibodyModeler, pose: pyrosetta.rosetta.core.pose.Pose) -> None
relax_cdrs(self: pyrosetta.rosetta.protocols.antibody.design.GeneralAntibodyModeler, pose: pyrosetta.rosetta.core.pose.Pose, include_neighbor_sc: bool) -> None
relax_cdrs(self: pyrosetta.rosetta.protocols.antibody.design.GeneralAntibodyModeler, pose: pyrosetta.rosetta.core.pose.Pose, include_neighbor_sc: bool, starting_coordinate_constraints: bool) -> None
relax_cdrs(self: pyrosetta.rosetta.protocols.antibody.design.GeneralAntibodyModeler, pose: pyrosetta.rosetta.core.pose.Pose, include_neighbor_sc: bool, starting_coordinate_constraints: bool, min_interface: bool) -> None
relax_cdrs(self: pyrosetta.rosetta.protocols.antibody.design.GeneralAntibodyModeler, pose: pyrosetta.rosetta.core.pose.Pose, include_neighbor_sc: bool, starting_coordinate_constraints: bool, min_interface: bool, dualspace: bool) -> None

Relax CDRs using FastRelax. CentroidRelax unfortunately does not work well. Perhaps with centroid rotamers..

Cluster Constraints should already be set. Optionally use start_coordinate constraints. All coordinate constraints on the pose will then be removed.

C++: protocols::antibody::design::GeneralAntibodyModeler::relax_cdrs(class core::pose::Pose &, bool, bool, bool, bool) const –> void

relax_interface(*args, **kwargs)¶

Overloaded function.

relax_interface(self: pyrosetta.rosetta.protocols.antibody.design.GeneralAntibodyModeler, pose: pyrosetta.rosetta.core.pose.Pose) -> None
relax_interface(self: pyrosetta.rosetta.protocols.antibody.design.GeneralAntibodyModeler, pose: pyrosetta.rosetta.core.pose.Pose, min_interface_sc: bool) -> None

C++: protocols::antibody::design::GeneralAntibodyModeler::relax_interface(class core::pose::Pose &, bool) const –> void

repack_antibody_interface(self: pyrosetta.rosetta.protocols.antibody.design.GeneralAntibodyModeler, pose: pyrosetta.rosetta.core.pose.Pose) → None¶

Repack the interface between antibody and antigen, but only pack antibody.

C++: protocols::antibody::design::GeneralAntibodyModeler::repack_antibody_interface(class core::pose::Pose &) const –> void

repack_antigen_ab_interface(self: pyrosetta.rosetta.protocols.antibody.design.GeneralAntibodyModeler, pose: pyrosetta.rosetta.core.pose.Pose) → None¶

Repack the interface between Antibody and Antigen.

C++: protocols::antibody::design::GeneralAntibodyModeler::repack_antigen_ab_interface(class core::pose::Pose &) const –> void

repack_antigen_interface(self: pyrosetta.rosetta.protocols.antibody.design.GeneralAntibodyModeler, pose: pyrosetta.rosetta.core.pose.Pose) → None¶

Repack the interface between antibody and antigen, but only pack antigen.

C++: protocols::antibody::design::GeneralAntibodyModeler::repack_antigen_interface(class core::pose::Pose &) const –> void

repack_cdrs(*args, **kwargs)¶

Overloaded function.

repack_cdrs(self: pyrosetta.rosetta.protocols.antibody.design.GeneralAntibodyModeler, pose: pyrosetta.rosetta.core.pose.Pose) -> None
repack_cdrs(self: pyrosetta.rosetta.protocols.antibody.design.GeneralAntibodyModeler, pose: pyrosetta.rosetta.core.pose.Pose, include_neighbor_sc: bool) -> None

Repack the CDRs given. Nothing special.

C++: protocols::antibody::design::GeneralAntibodyModeler::repack_cdrs(class core::pose::Pose &, bool) –> void

reset_task_factory(self: pyrosetta.rosetta.protocols.antibody.design.GeneralAntibodyModeler) → None¶: C++: protocols::antibody::design::GeneralAntibodyModeler::reset_task_factory() –> void

set_cdr(self: pyrosetta.rosetta.protocols.antibody.design.GeneralAntibodyModeler, cdr: pyrosetta.rosetta.protocols.antibody.CDRNameEnum, setting: bool) → None¶

Set to model CDRs. Default is all of them false.

C++: protocols::antibody::design::GeneralAntibodyModeler::set_cdr(const enum protocols::antibody::CDRNameEnum, bool) –> void

set_cdr_only(self: pyrosetta.rosetta.protocols.antibody.design.GeneralAntibodyModeler, cdr: pyrosetta.rosetta.protocols.antibody.CDRNameEnum, setting: bool) → None¶

Set to model only one cdr, or all others but one.

C++: protocols::antibody::design::GeneralAntibodyModeler::set_cdr_only(const enum protocols::antibody::CDRNameEnum, bool) –> void

set_cdr_range(self: pyrosetta.rosetta.protocols.antibody.design.GeneralAntibodyModeler, cdr_start: pyrosetta.rosetta.protocols.antibody.CDRNameEnum, cdr_end: pyrosetta.rosetta.protocols.antibody.CDRNameEnum, setting: bool) → None¶

Set a range of CDRs.

C++: protocols::antibody::design::GeneralAntibodyModeler::set_cdr_range(const enum protocols::antibody::CDRNameEnum, const enum protocols::antibody::CDRNameEnum, bool) –> void

set_cdrs(self: pyrosetta.rosetta.protocols.antibody.design.GeneralAntibodyModeler, cdrs: pyrosetta.rosetta.utility.vector1_bool) → None¶: C++: protocols::antibody::design::GeneralAntibodyModeler::set_cdrs(class utility::vector1<bool, class std::allocator<bool> >) –> void

set_dock_high_res_scorefunction(self: pyrosetta.rosetta.protocols.antibody.design.GeneralAntibodyModeler, scorefxn: pyrosetta.rosetta.core.scoring.ScoreFunction) → None¶: C++: protocols::antibody::design::GeneralAntibodyModeler::set_dock_high_res_scorefunction(class std::shared_ptr<const class core::scoring::ScoreFunction>) –> void

set_dock_low_res_scorefunction(self: pyrosetta.rosetta.protocols.antibody.design.GeneralAntibodyModeler, scorefxn: pyrosetta.rosetta.core.scoring.ScoreFunction) → None¶: C++: protocols::antibody::design::GeneralAntibodyModeler::set_dock_low_res_scorefunction(class std::shared_ptr<const class core::scoring::ScoreFunction>) –> void

set_overhang(self: pyrosetta.rosetta.protocols.antibody.design.GeneralAntibodyModeler, overhang: int) → None¶

Set the overhang for all cdrs. (Default is 0)

C++: protocols::antibody::design::GeneralAntibodyModeler::set_overhang(const unsigned long) –> void

set_scorefunction(self: pyrosetta.rosetta.protocols.antibody.design.GeneralAntibodyModeler, scorefxn: pyrosetta.rosetta.core.scoring.ScoreFunction) → None¶: C++: protocols::antibody::design::GeneralAntibodyModeler::set_scorefunction(class std::shared_ptr<const class core::scoring::ScoreFunction>) –> void

set_scorefunction_min(self: pyrosetta.rosetta.protocols.antibody.design.GeneralAntibodyModeler, scorefxn: pyrosetta.rosetta.core.scoring.ScoreFunction) → None¶

Set scorefunction used for bb minimization.

C++: protocols::antibody::design::GeneralAntibodyModeler::set_scorefunction_min(class std::shared_ptr<const class core::scoring::ScoreFunction>) –> void

set_task_factory(self: pyrosetta.rosetta.protocols.antibody.design.GeneralAntibodyModeler, tf: pyrosetta.rosetta.core.pack.task.TaskFactory) → None¶: C++: protocols::antibody::design::GeneralAntibodyModeler::set_task_factory(class std::shared_ptr<class core::pack::task::TaskFactory>) –> void

class pyrosetta.rosetta.protocols.antibody.design.MutateFrameworkForCluster¶

Bases: pyrosetta.rosetta.protocols.moves.Mover

Mutates framework positions to what is needed for a particular cluster if that cluster has needed mutations.

Will use clusters from pose data cache if there, otherwise, will use clusters set from AntibodyInfo.

Use set_cdr or set_cdrs to limit to a particular CDR or set of CDRs.

__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.design.MutateFrameworkForCluster) -> None
__init__(self: pyrosetta.rosetta.protocols.antibody.design.MutateFrameworkForCluster, ab_info: pyrosetta.rosetta.protocols.antibody.AntibodyInfo) -> None
__init__(self: pyrosetta.rosetta.protocols.antibody.design.MutateFrameworkForCluster, arg0: pyrosetta.rosetta.protocols.antibody.design.MutateFrameworkForCluster) -> 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.design.MutateFrameworkForCluster, pose: pyrosetta.rosetta.core.pose.Pose) → None¶: C++: protocols::antibody::design::MutateFrameworkForCluster::apply(class core::pose::Pose &) –> void

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

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>

framework_dependant_clusters(self: pyrosetta.rosetta.protocols.antibody.design.MutateFrameworkForCluster) → pyrosetta.rosetta.utility.vector1_protocols_antibody_clusters_CDRClusterEnum¶

Get all framework dependant clusters in list

C++: protocols::antibody::design::MutateFrameworkForCluster::framework_dependant_clusters() –> class utility::vector1<enum protocols::antibody::clusters::CDRClusterEnum, class std::allocator<enum protocols::antibody::clusters::CDRClusterEnum> >

framework_dependant_mutations(self: pyrosetta.rosetta.protocols.antibody.design.MutateFrameworkForCluster, pose: pyrosetta.rosetta.core.pose.Pose, cluster: pyrosetta.rosetta.protocols.antibody.clusters.CDRClusterEnum, resnum: int) → pyrosetta.rosetta.utility.vector1_bool¶

Get all framework mutations for a particular framework dependent position, regardless of whether that cluster is in the pose.

C++: protocols::antibody::design::MutateFrameworkForCluster::framework_dependant_mutations(const class core::pose::Pose &, const enum protocols::antibody::clusters::CDRClusterEnum, const unsigned long) –> class utility::vector1<bool, class std::allocator<bool> >

framework_dependant_positions(*args, **kwargs)¶

Overloaded function.

framework_dependant_positions(self: pyrosetta.rosetta.protocols.antibody.design.MutateFrameworkForCluster, pose: pyrosetta.rosetta.core.pose.Pose) -> pyrosetta.rosetta.utility.vector1_bool

Get all framework positions that would be required by clusters regardless of whether that cluster is in the pose.

C++: protocols::antibody::design::MutateFrameworkForCluster::framework_dependant_positions(const class core::pose::Pose &) –> class utility::vector1<bool, class std::allocator<bool> >

framework_dependant_positions(self: pyrosetta.rosetta.protocols.antibody.design.MutateFrameworkForCluster, pose: pyrosetta.rosetta.core.pose.Pose, cluster: pyrosetta.rosetta.protocols.antibody.clusters.CDRClusterEnum) -> pyrosetta.rosetta.utility.vector1_bool

Get all framework positions that would be required by a cluster regardless of whether that cluster is in the pose.

C++: protocols::antibody::design::MutateFrameworkForCluster::framework_dependant_positions(const class core::pose::Pose &, const enum protocols::antibody::clusters::CDRClusterEnum) –> class utility::vector1<bool, class std::allocator<bool> >

fresh_instance(self: pyrosetta.rosetta.protocols.antibody.design.MutateFrameworkForCluster) → pyrosetta.rosetta.protocols.moves.Mover¶: C++: protocols::antibody::design::MutateFrameworkForCluster::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.design.MutateFrameworkForCluster) → str¶: C++: protocols::antibody::design::MutateFrameworkForCluster::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

has_framework_dependant_cluster(self: pyrosetta.rosetta.protocols.antibody.design.MutateFrameworkForCluster, pose: pyrosetta.rosetta.core.pose.Pose, cdr: pyrosetta.rosetta.protocols.antibody.CDRNameEnum) → bool¶: C++: protocols::antibody::design::MutateFrameworkForCluster::has_framework_dependant_cluster(const class core::pose::Pose &, const enum protocols::antibody::CDRNameEnum) –> bool

has_framework_dependant_clusters(self: pyrosetta.rosetta.protocols.antibody.design.MutateFrameworkForCluster, pose: pyrosetta.rosetta.core.pose.Pose) → bool¶

//////// Helper functions //////////////

C++: protocols::antibody::design::MutateFrameworkForCluster::has_framework_dependant_clusters(const class core::pose::Pose &) –> bool

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

keep_current(self: pyrosetta.rosetta.protocols.antibody.design.MutateFrameworkForCluster, keep_current: bool) → None¶

Set to keep the current amino acid(s) for the position in the mutation set.: Each position is not 100 percent a particular mutant for a cluster, so we allow this by default and hope Rosetta can choose properly.

C++: protocols::antibody::design::MutateFrameworkForCluster::keep_current(bool) –> void

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_cdr_only(self: pyrosetta.rosetta.protocols.antibody.design.MutateFrameworkForCluster, cdr: pyrosetta.rosetta.protocols.antibody.CDRNameEnum) → None¶: C++: protocols::antibody::design::MutateFrameworkForCluster::set_cdr_only(const enum protocols::antibody::CDRNameEnum &) –> void

set_cdrs(self: pyrosetta.rosetta.protocols.antibody.design.MutateFrameworkForCluster, cdrs: pyrosetta.rosetta.utility.vector1_bool) → None¶: C++: protocols::antibody::design::MutateFrameworkForCluster::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_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_pack_shell(self: pyrosetta.rosetta.protocols.antibody.design.MutateFrameworkForCluster, pack_shell: float) → None¶

Set the distance for the packing shell.

C++: protocols::antibody::design::MutateFrameworkForCluster::set_pack_shell(const double) –> void

set_scorefxn(self: pyrosetta.rosetta.protocols.antibody.design.MutateFrameworkForCluster, scorefxn: pyrosetta.rosetta.core.scoring.ScoreFunction) → None¶: C++: protocols::antibody::design::MutateFrameworkForCluster::set_scorefxn(class std::shared_ptr<const 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.design.NativeAntibodySeq¶

Bases: pyrosetta.rosetta.basic.datacache.CacheableData

Class that keeps track of the ‘native’ sequence during design. Native means that no design has occured. Used for conservative base design to keep it from hopping around residue types.

__delattr__¶: Implement delattr(self, name).

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

__eq__¶: Return self==value.

__format__()¶: default object formatter

__ge__¶: Return self>=value.

__getattribute__¶: Return getattr(self, name).

__gt__¶: Return self>value.

__hash__¶: Return hash(self).

__init__(*args, **kwargs)¶

Overloaded function.

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

clone(self: pyrosetta.rosetta.protocols.antibody.design.NativeAntibodySeq) → pyrosetta.rosetta.basic.datacache.CacheableData¶: C++: protocols::antibody::design::NativeAntibodySeq::clone() const –> class std::shared_ptr<class basic::datacache::CacheableData>

get_self_ptr(self: pyrosetta.rosetta.basic.datacache.CacheableData) → pyrosetta.rosetta.basic.datacache.CacheableData¶: C++: basic::datacache::CacheableData::get_self_ptr() –> class std::shared_ptr<class basic::datacache::CacheableData>

get_self_weak_ptr(self: pyrosetta.rosetta.basic.datacache.CacheableData) → pyrosetta.rosetta.std.weak_ptr_basic_datacache_CacheableData_t¶: C++: basic::datacache::CacheableData::get_self_weak_ptr() –> class std::weak_ptr<class basic::datacache::CacheableData>

get_sequence(self: pyrosetta.rosetta.protocols.antibody.design.NativeAntibodySeq, pose: pyrosetta.rosetta.core.pose.Pose) → str¶

Get the full pose sequence.

C++: protocols::antibody::design::NativeAntibodySeq::get_sequence(const class core::pose::Pose &) const –> std::string

set_from_cdr(self: pyrosetta.rosetta.protocols.antibody.design.NativeAntibodySeq, pose: pyrosetta.rosetta.core.pose.Pose, cdr: pyrosetta.rosetta.protocols.antibody.CDRNameEnum) → None¶

Sets the sequence from the CDR of the PDB into this class and into the pose.

C++: protocols::antibody::design::NativeAntibodySeq::set_from_cdr(const class core::pose::Pose &, enum protocols::antibody::CDRNameEnum) –> void

set_sequence(self: pyrosetta.rosetta.protocols.antibody.design.NativeAntibodySeq, pose: pyrosetta.rosetta.core.pose.Pose) → None¶

Sets the sequence from the PDB into this class and into the pose.

C++: protocols::antibody::design::NativeAntibodySeq::set_sequence(const class core::pose::Pose &) –> void

set_to_pose(self: pyrosetta.rosetta.protocols.antibody.design.NativeAntibodySeq, pose: pyrosetta.rosetta.core.pose.Pose) → None¶

Set this class to the pose datacache.

C++: protocols::antibody::design::NativeAntibodySeq::set_to_pose(class core::pose::Pose &) –> void

class pyrosetta.rosetta.protocols.antibody.design.PDBNumbering¶

Bases: pybind11_builtins.pybind11_object

Move this somewhere in pose or pose_selection. PDBInfo’s ResidueKey should be public and passed around in the first place.

Super-basic numbering struct.

__delattr__¶: Implement delattr(self, name).

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

__eq__¶: Return self==value.

__format__()¶: default object formatter

__ge__¶: Return self>=value.

__getattribute__¶: Return getattr(self, name).

__gt__¶: Return self>value.

__hash__¶: Return hash(self).

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

pyrosetta.rosetta.protocols.antibody.design.add_loops_from_bool_vector(*args, **kwargs)¶

Overloaded function.

add_loops_from_bool_vector(loops: pyrosetta.rosetta.protocols.loops.Loops, residues: pyrosetta.rosetta.utility.vector1_bool) -> None
add_loops_from_bool_vector(loops: pyrosetta.rosetta.protocols.loops.Loops, residues: pyrosetta.rosetta.utility.vector1_bool, add_cutpoints: bool) -> None

C++: protocols::antibody::design::add_loops_from_bool_vector(class protocols::loops::Loops &, class utility::vector1<bool, class std::allocator<bool> >, bool) –> void

pyrosetta.rosetta.protocols.antibody.design.attributes_for_get_ab_design_global_scorefxn(attlist: pyrosetta.rosetta.std.list_utility_tag_XMLSchemaAttribute_t) → None¶

adds the required attribute to the AttributeList for XMLSchema generation

C++: protocols::antibody::design::attributes_for_get_ab_design_global_scorefxn(class std::list<class utility::tag::XMLSchemaAttribute, class std::allocator<class utility::tag::XMLSchemaAttribute> > &) –> void

pyrosetta.rosetta.protocols.antibody.design.attributes_for_get_ab_design_min_scorefxn(attlist: pyrosetta.rosetta.std.list_utility_tag_XMLSchemaAttribute_t) → None¶

adds the required attribute to the AttributeList for XMLSchema generation

C++: protocols::antibody::design::attributes_for_get_ab_design_min_scorefxn(class std::list<class utility::tag::XMLSchemaAttribute, class std::allocator<class utility::tag::XMLSchemaAttribute> > &) –> void

pyrosetta.rosetta.protocols.antibody.design.check_cb(*args, **kwargs)¶

Overloaded function.

check_cb(pose: pyrosetta.rosetta.core.pose.Pose, residues: pyrosetta.rosetta.utility.vector1_bool) -> Tuple[bool, int]

Check for severe peptide bond issues. Return pair of chainbreak, and position of wonky peptide bond

C++: protocols::antibody::design::check_cb(const class core::pose::Pose &, const class utility::vector1<bool, class std::allocator<bool> > &) –> struct std::pair<bool, unsigned long>

check_cb(pose: pyrosetta.rosetta.core.pose.Pose, loops: pyrosetta.rosetta.protocols.loops.Loops) -> Tuple[bool, int]

Check for severe peptide bond issues. Return pair of chainbreak, and position of wonky peptide bond

C++: protocols::antibody::design::check_cb(const class core::pose::Pose &, const class protocols::loops::Loops &) –> struct std::pair<bool, unsigned long>

pyrosetta.rosetta.protocols.antibody.design.design_protocol_to_enum(design_type: str) → pyrosetta.rosetta.protocols.antibody.design.AntibodyDesignProtocolEnum¶: C++: protocols::antibody::design::design_protocol_to_enum(const class std::basic_string<char> &) –> enum protocols::antibody::design::AntibodyDesignProtocolEnum

pyrosetta.rosetta.protocols.antibody.design.design_protocol_to_string(design_type: pyrosetta.rosetta.protocols.antibody.design.AntibodyDesignProtocolEnum) → str¶: C++: protocols::antibody::design::design_protocol_to_string(const enum protocols::antibody::design::AntibodyDesignProtocolEnum) –> std::string

pyrosetta.rosetta.protocols.antibody.design.disable_conserved_framework_positions(ab_info: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, pose: pyrosetta.rosetta.core.pose.Pose) → pyrosetta.rosetta.core.pack.task.operation.RestrictResidueToRepacking¶

Disable design for conserved framework positions.: TODO: Needs to be expanded to read positions from database.

C++: protocols::antibody::design::disable_conserved_framework_positions(class std::shared_ptr<const class protocols::antibody::AntibodyInfo>, const class core::pose::Pose &) –> class std::shared_ptr<class core::pack::task::operation::RestrictResidueToRepacking>

pyrosetta.rosetta.protocols.antibody.design.disable_design_antigen(ab_info: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, pose: pyrosetta.rosetta.core.pose.Pose) → pyrosetta.rosetta.core.pack.task.operation.RestrictResidueToRepacking¶

Disable design of the antigen residues

C++: protocols::antibody::design::disable_design_antigen(class std::shared_ptr<const class protocols::antibody::AntibodyInfo>, const class core::pose::Pose &) –> class std::shared_ptr<class core::pack::task::operation::RestrictResidueToRepacking>

pyrosetta.rosetta.protocols.antibody.design.disable_design_cdr(ab_info: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, cdr: pyrosetta.rosetta.protocols.antibody.CDRNameEnum, pose: pyrosetta.rosetta.core.pose.Pose) → pyrosetta.rosetta.core.pack.task.operation.RestrictResidueToRepacking¶

Get a Restrict operation to turn OFF design for particular CDRs.

C++: protocols::antibody::design::disable_design_cdr(class std::shared_ptr<const class protocols::antibody::AntibodyInfo>, enum protocols::antibody::CDRNameEnum, const class core::pose::Pose &) –> class std::shared_ptr<class core::pack::task::operation::RestrictResidueToRepacking>

pyrosetta.rosetta.protocols.antibody.design.disable_design_cdrs(ab_info: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, pose: pyrosetta.rosetta.core.pose.Pose) → pyrosetta.rosetta.core.pack.task.operation.RestrictResidueToRepacking¶

Get a Restrict operation to turn OFF design for all CDRs.

C++: protocols::antibody::design::disable_design_cdrs(class std::shared_ptr<const class protocols::antibody::AntibodyInfo>, const class core::pose::Pose &) –> class std::shared_ptr<class core::pack::task::operation::RestrictResidueToRepacking>

pyrosetta.rosetta.protocols.antibody.design.disable_design_framework(*args, **kwargs)¶

Overloaded function.

disable_design_framework(ab_info: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, pose: pyrosetta.rosetta.core.pose.Pose) -> pyrosetta.rosetta.core.pack.task.operation.RestrictResidueToRepacking
disable_design_framework(ab_info: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, pose: pyrosetta.rosetta.core.pose.Pose, cdr4_as_framework: bool) -> pyrosetta.rosetta.core.pack.task.operation.RestrictResidueToRepacking

Disable design of the framework residues

C++: protocols::antibody::design::disable_design_framework(class std::shared_ptr<const class protocols::antibody::AntibodyInfo>, const class core::pose::Pose &, bool) –> class std::shared_ptr<class core::pack::task::operation::RestrictResidueToRepacking>

pyrosetta.rosetta.protocols.antibody.design.disable_design_region(*args, **kwargs)¶

Overloaded function.

disable_design_region(ab_info: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, pose: pyrosetta.rosetta.core.pose.Pose, region: pyrosetta.rosetta.protocols.antibody.AntibodyRegionEnum) -> pyrosetta.rosetta.core.pack.task.operation.RestrictResidueToRepacking
disable_design_region(ab_info: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, pose: pyrosetta.rosetta.core.pose.Pose, region: pyrosetta.rosetta.protocols.antibody.AntibodyRegionEnum, cdr4_as_framework: bool) -> pyrosetta.rosetta.core.pack.task.operation.RestrictResidueToRepacking

Disable design of any particular region of the antibody complex.

C++: protocols::antibody::design::disable_design_region(class std::shared_ptr<const class protocols::antibody::AntibodyInfo>, const class core::pose::Pose &, enum protocols::antibody::AntibodyRegionEnum, bool) –> class std::shared_ptr<class core::pack::task::operation::RestrictResidueToRepacking>

pyrosetta.rosetta.protocols.antibody.design.disable_h3_stem_positions(*args, **kwargs)¶

Overloaded function.

disable_h3_stem_positions(ab_info: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, pose: pyrosetta.rosetta.core.pose.Pose) -> pyrosetta.rosetta.core.pack.task.operation.RestrictResidueToRepacking
disable_h3_stem_positions(ab_info: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, pose: pyrosetta.rosetta.core.pose.Pose, nter_stem: int) -> pyrosetta.rosetta.core.pack.task.operation.RestrictResidueToRepacking
disable_h3_stem_positions(ab_info: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, pose: pyrosetta.rosetta.core.pose.Pose, nter_stem: int, cter_stem: int) -> pyrosetta.rosetta.core.pack.task.operation.RestrictResidueToRepacking

Disable design of the first 2 and last 3 residues of the H3 CDR (North CDR definitions - kink determinants)

C++: protocols::antibody::design::disable_h3_stem_positions(class std::shared_ptr<const class protocols::antibody::AntibodyInfo>, const class core::pose::Pose &, unsigned long, unsigned long) –> class std::shared_ptr<class core::pack::task::operation::RestrictResidueToRepacking>

pyrosetta.rosetta.protocols.antibody.design.get_ab_design_dock_high_scorefxn() → pyrosetta.rosetta.core.scoring.ScoreFunction¶: C++: protocols::antibody::design::get_ab_design_dock_high_scorefxn() –> class std::shared_ptr<class core::scoring::ScoreFunction>

pyrosetta.rosetta.protocols.antibody.design.get_ab_design_dock_low_scorefxn() → pyrosetta.rosetta.core.scoring.ScoreFunction¶: C++: protocols::antibody::design::get_ab_design_dock_low_scorefxn() –> class std::shared_ptr<class core::scoring::ScoreFunction>

pyrosetta.rosetta.protocols.antibody.design.get_ab_design_global_scorefxn(*args, **kwargs)¶

Overloaded function.

get_ab_design_global_scorefxn() -> pyrosetta.rosetta.core.scoring.ScoreFunction

C++: protocols::antibody::design::get_ab_design_global_scorefxn() –> class std::shared_ptr<class core::scoring::ScoreFunction>

get_ab_design_global_scorefxn(tag: pyrosetta.rosetta.utility.tag.Tag, data: pyrosetta.rosetta.basic.datacache.DataMap) -> pyrosetta.rosetta.core.scoring.ScoreFunction

Get Global Scorefxn from RS; XSD companion function: attributes_for_get_ab_design_global_scorefxn

C++: protocols::antibody::design::get_ab_design_global_scorefxn(class std::shared_ptr<const class utility::tag::Tag>, class basic::datacache::DataMap &) –> class std::shared_ptr<class core::scoring::ScoreFunction>

pyrosetta.rosetta.protocols.antibody.design.get_ab_design_min_scorefxn(*args, **kwargs)¶

Overloaded function.

get_ab_design_min_scorefxn() -> pyrosetta.rosetta.core.scoring.ScoreFunction

XSD companion function: attributes_for_get_ab_design_min_scorefxn

C++: protocols::antibody::design::get_ab_design_min_scorefxn() –> class std::shared_ptr<class core::scoring::ScoreFunction>

get_ab_design_min_scorefxn(tag: pyrosetta.rosetta.utility.tag.Tag, data: pyrosetta.rosetta.basic.datacache.DataMap) -> pyrosetta.rosetta.core.scoring.ScoreFunction

C++: protocols::antibody::design::get_ab_design_min_scorefxn(class std::shared_ptr<const class utility::tag::Tag>, class basic::datacache::DataMap &) –> class std::shared_ptr<class core::scoring::ScoreFunction>

pyrosetta.rosetta.protocols.antibody.design.get_all_graft_permutations(permutations: pyrosetta.rosetta.utility.vector1_utility_vector1_unsigned_long_std_allocator_unsigned_long_t, totals: pyrosetta.rosetta.utility.vector1_unsigned_long, n: int) → pyrosetta.rosetta.utility.vector1_utility_vector1_unsigned_long_std_allocator_unsigned_long_t¶

Gets all possible graft permutations.

all_permutations is a list of vectors corresponding to cdrs_to_design vector. Essentially, each inner index describes a position in the cdr_set. Indexes correspond to CDRNameEnum, and whose values correspond to the cdr_set index. If the value is 0, it means no cdr in set. Example: <1, 0, 1, 1, 1, 1>. This is a possible combination to try graft, the second CDR, H2 is not part of the combination.

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

pyrosetta.rosetta.protocols.antibody.design.get_cdr_set_options(*args, **kwargs)¶

Overloaded function.

get_cdr_set_options() -> pyrosetta.rosetta.utility.vector1_std_shared_ptr_protocols_antibody_CDRSetOptions_t

Get default options

C++: protocols::antibody::design::get_cdr_set_options() –> class utility::vector1<class std::shared_ptr<class protocols::antibody::CDRSetOptions>, class std::allocator<class std::shared_ptr<class protocols::antibody::CDRSetOptions> > >

get_cdr_set_options(instruction_file: str) -> pyrosetta.rosetta.utility.vector1_std_shared_ptr_protocols_antibody_CDRSetOptions_t

Get options from an instruction file

C++: protocols::antibody::design::get_cdr_set_options(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.design.get_cluster_profile_probability_data(*args, **kwargs)¶

Overloaded function.

get_cluster_profile_probability_data(ab_info: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, pose: pyrosetta.rosetta.core.pose.Pose, cdrs: pyrosetta.rosetta.utility.vector1_bool, no_data_cdrs: pyrosetta.rosetta.utility.vector1_bool) -> 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
get_cluster_profile_probability_data(ab_info: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, pose: pyrosetta.rosetta.core.pose.Pose, cdrs: pyrosetta.rosetta.utility.vector1_bool, no_data_cdrs: pyrosetta.rosetta.utility.vector1_bool, prob_cutoff: int) -> 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
get_cluster_profile_probability_data(ab_info: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, pose: pyrosetta.rosetta.core.pose.Pose, cdrs: pyrosetta.rosetta.utility.vector1_bool, no_data_cdrs: pyrosetta.rosetta.utility.vector1_bool, prob_cutoff: int, use_outliers: bool) -> 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
get_cluster_profile_probability_data(ab_info: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, pose: pyrosetta.rosetta.core.pose.Pose, cdrs: pyrosetta.rosetta.utility.vector1_bool, no_data_cdrs: pyrosetta.rosetta.utility.vector1_bool, prob_cutoff: int, use_outliers: bool, force_north_db: bool) -> 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
get_cluster_profile_probability_data(ab_info: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, pose: pyrosetta.rosetta.core.pose.Pose, cdrs: pyrosetta.rosetta.utility.vector1_bool, no_data_cdrs: pyrosetta.rosetta.utility.vector1_bool, prob_cutoff: int, use_outliers: bool, force_north_db: bool, ignore_light_chain_: bool) -> 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

Get probability data for a given set of CDRs. Will fill in the no_data_cdrs;

C++: protocols::antibody::design::get_cluster_profile_probability_data(class std::shared_ptr<const class protocols::antibody::AntibodyInfo>, const class core::pose::Pose &, const class utility::vector1<bool, class std::allocator<bool> > &, class utility::vector1<bool, class std::allocator<bool> > &, const unsigned long, const bool, const bool, const bool) –> 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> > > > > >

get_cluster_profile_probability_data(ab_info: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, pose: pyrosetta.rosetta.core.pose.Pose, seq_design_options: pyrosetta.rosetta.utility.vector1_std_shared_ptr_protocols_antibody_design_CDRSeqDesignOptions_t, no_data_cdrs: pyrosetta.rosetta.utility.vector1_bool) -> 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
get_cluster_profile_probability_data(ab_info: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, pose: pyrosetta.rosetta.core.pose.Pose, seq_design_options: pyrosetta.rosetta.utility.vector1_std_shared_ptr_protocols_antibody_design_CDRSeqDesignOptions_t, no_data_cdrs: pyrosetta.rosetta.utility.vector1_bool, prob_cutoff: int) -> 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
get_cluster_profile_probability_data(ab_info: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, pose: pyrosetta.rosetta.core.pose.Pose, seq_design_options: pyrosetta.rosetta.utility.vector1_std_shared_ptr_protocols_antibody_design_CDRSeqDesignOptions_t, no_data_cdrs: pyrosetta.rosetta.utility.vector1_bool, prob_cutoff: int, use_outliers: bool) -> 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
get_cluster_profile_probability_data(ab_info: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, pose: pyrosetta.rosetta.core.pose.Pose, seq_design_options: pyrosetta.rosetta.utility.vector1_std_shared_ptr_protocols_antibody_design_CDRSeqDesignOptions_t, no_data_cdrs: pyrosetta.rosetta.utility.vector1_bool, prob_cutoff: int, use_outliers: bool, force_north_db: bool) -> 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
get_cluster_profile_probability_data(ab_info: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, pose: pyrosetta.rosetta.core.pose.Pose, seq_design_options: pyrosetta.rosetta.utility.vector1_std_shared_ptr_protocols_antibody_design_CDRSeqDesignOptions_t, no_data_cdrs: pyrosetta.rosetta.utility.vector1_bool, prob_cutoff: int, use_outliers: bool, force_north_db: bool, ignore_light_chain_: bool) -> 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

C++: protocols::antibody::design::get_cluster_profile_probability_data(class std::shared_ptr<const class protocols::antibody::AntibodyInfo>, const class core::pose::Pose &, 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> > > &, class utility::vector1<bool, class std::allocator<bool> > &, const unsigned long, const bool, const bool, const bool) –> 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> > > > > >

pyrosetta.rosetta.protocols.antibody.design.get_dock_chains_from_ab_dock_chains(ab_info: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, ab_dock_chains: str) → str¶

Convert an ab_dock_chain (L_H/ LH_A, etc. to the full dock chain string)

C++: protocols::antibody::design::get_dock_chains_from_ab_dock_chains(class std::shared_ptr<const class protocols::antibody::AntibodyInfo>, class std::basic_string<char>) –> std::string

pyrosetta.rosetta.protocols.antibody.design.get_graft_design_options(*args, **kwargs)¶

Overloaded function.

get_graft_design_options() -> pyrosetta.rosetta.utility.vector1_std_shared_ptr_protocols_antibody_design_CDRGraftDesignOptions_t

Get default options

C++: protocols::antibody::design::get_graft_design_options() –> class utility::vector1<class std::shared_ptr<class protocols::antibody::design::CDRGraftDesignOptions>, class std::allocator<class std::shared_ptr<class protocols::antibody::design::CDRGraftDesignOptions> > >

get_graft_design_options(instruction_file: str) -> pyrosetta.rosetta.utility.vector1_std_shared_ptr_protocols_antibody_design_CDRGraftDesignOptions_t

Get options from an instruction file

C++: protocols::antibody::design::get_graft_design_options(class std::basic_string<char>) –> class utility::vector1<class std::shared_ptr<class protocols::antibody::design::CDRGraftDesignOptions>, class std::allocator<class std::shared_ptr<class protocols::antibody::design::CDRGraftDesignOptions> > >

pyrosetta.rosetta.protocols.antibody.design.get_native_sequence(pose: pyrosetta.rosetta.core.pose.Pose) → str¶: C++: protocols::antibody::design::get_native_sequence(const class core::pose::Pose &) –> std::string

pyrosetta.rosetta.protocols.antibody.design.get_pdb_numbering_from_single_string(pdb_residue: str) → pyrosetta.rosetta.protocols.antibody.design.PDBNumbering¶

Get the PDBNumbering from strings such as: 1A, 1A:I, 1:A:~, 1:A:I with A being chain A and I being an insertion code.

C++: protocols::antibody::design::get_pdb_numbering_from_single_string(const class std::basic_string<char> &) –> struct protocols::antibody::design::PDBNumbering

pyrosetta.rosetta.protocols.antibody.design.get_pdb_numbering_from_strings(pdb_residues: pyrosetta.rosetta.utility.vector1_std_string) → pyrosetta.rosetta.utility.vector1_protocols_antibody_design_PDBNumbering¶

Get PDBNumbering from a vector of strings:: Example: 1A, 1A:I, 1:A:~, 1:A:I with A being chain A and I being an insertion code.

C++: protocols::antibody::design::get_pdb_numbering_from_strings(const class utility::vector1<class std::basic_string<char>, class std::allocator<class std::basic_string<char> > > &) –> class utility::vector1<struct protocols::antibody::design::PDBNumbering, class std::allocator<struct protocols::antibody::design::PDBNumbering> >

pyrosetta.rosetta.protocols.antibody.design.get_resnum_from_pdb_numbering(pose: pyrosetta.rosetta.core.pose.Pose, pdb_residues: pyrosetta.rosetta.utility.vector1_protocols_antibody_design_PDBNumbering) → pyrosetta.rosetta.utility.vector1_bool¶

Get a boolean vector from a string of PDBNumbering. No error checking. Use with caution.

C++: protocols::antibody::design::get_resnum_from_pdb_numbering(const class core::pose::Pose &, const class utility::vector1<struct protocols::antibody::design::PDBNumbering, class std::allocator<struct protocols::antibody::design::PDBNumbering> > &) –> class utility::vector1<bool, class std::allocator<bool> >

pyrosetta.rosetta.protocols.antibody.design.get_resnum_from_single_string(pose: pyrosetta.rosetta.core.pose.Pose, pdb_residue: str) → int¶

Get a resnum from strings such as: 1A, 1A:I, 1:A:~, 1:A:I with A being chain A and I being an insertion code.

C++: protocols::antibody::design::get_resnum_from_single_string(const class core::pose::Pose &, const class std::basic_string<char> &) –> unsigned long

pyrosetta.rosetta.protocols.antibody.design.get_resnum_from_single_string_w_landmark(ab_info: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, pose: pyrosetta.rosetta.core.pose.Pose, pdb_residue: str, scheme: pyrosetta.rosetta.protocols.antibody.AntibodyNumberingSchemeEnum) → int¶

Get a resnum using the PDBLandmark from strings such as: 1A, 1A:I, 1:A:~, 1:A:I with A being chain A and I being an insertion code.

C++: protocols::antibody::design::get_resnum_from_single_string_w_landmark(class std::shared_ptr<const class protocols::antibody::AntibodyInfo>, const class core::pose::Pose &, const class std::basic_string<char> &, const enum protocols::antibody::AntibodyNumberingSchemeEnum &) –> unsigned long

pyrosetta.rosetta.protocols.antibody.design.get_resnum_from_strings(pose: pyrosetta.rosetta.core.pose.Pose, pdb_residues: pyrosetta.rosetta.utility.vector1_std_string) → pyrosetta.rosetta.utility.vector1_bool¶

get a boolean vector from a vector of strings:: Example: 1A, 1A:I, 1:A:~, 1:A:I with A being chain A and I being an insertion code.

C++: protocols::antibody::design::get_resnum_from_strings(const class core::pose::Pose &, const class utility::vector1<class std::basic_string<char>, class std::allocator<class std::basic_string<char> > > &) –> class utility::vector1<bool, class std::allocator<bool> >

pyrosetta.rosetta.protocols.antibody.design.get_resnums_from_strings_with_ranges(pose: pyrosetta.rosetta.core.pose.Pose, pdb_residues: pyrosetta.rosetta.utility.vector1_std_string) → pyrosetta.rosetta.utility.vector1_bool¶

Get a boolean vector of resnums with ranges, where a - indicates range.: Parses strings for PDB resnums such as 1A, 1A:I, 1:A:~, 1:A:I with A being chain A and I being an insertion code. Example: 1A-10A or 1A-10A:I

C++: protocols::antibody::design::get_resnums_from_strings_with_ranges(const class core::pose::Pose &, const class utility::vector1<class std::basic_string<char>, class std::allocator<class std::basic_string<char> > > &) –> class utility::vector1<bool, class std::allocator<bool> >

pyrosetta.rosetta.protocols.antibody.design.get_seq_design_options(*args, **kwargs)¶

Overloaded function.

get_seq_design_options() -> pyrosetta.rosetta.utility.vector1_std_shared_ptr_protocols_antibody_design_CDRSeqDesignOptions_t

Get default options

C++: protocols::antibody::design::get_seq_design_options() –> class utility::vector1<class std::shared_ptr<class protocols::antibody::design::CDRSeqDesignOptions>, class std::allocator<class std::shared_ptr<class protocols::antibody::design::CDRSeqDesignOptions> > >

get_seq_design_options(instruction_file: str) -> pyrosetta.rosetta.utility.vector1_std_shared_ptr_protocols_antibody_design_CDRSeqDesignOptions_t

Get options from an instruction file

C++: protocols::antibody::design::get_seq_design_options(class std::basic_string<char>) –> class utility::vector1<class std::shared_ptr<class protocols::antibody::design::CDRSeqDesignOptions>, class std::allocator<class std::shared_ptr<class protocols::antibody::design::CDRSeqDesignOptions> > >

pyrosetta.rosetta.protocols.antibody.design.has_native_sequence(pose: pyrosetta.rosetta.core.pose.Pose) → bool¶: C++: protocols::antibody::design::has_native_sequence(const class core::pose::Pose &) –> bool

pyrosetta.rosetta.protocols.antibody.design.insert_cdr_into_antibody(*args, **kwargs)¶

Overloaded function.

insert_cdr_into_antibody(ab_info: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, cdr: pyrosetta.rosetta.protocols.antibody.CDRNameEnum, pose: pyrosetta.rosetta.core.pose.Pose, cdr_piece: pyrosetta.rosetta.core.pose.Pose) -> None
insert_cdr_into_antibody(ab_info: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, cdr: pyrosetta.rosetta.protocols.antibody.CDRNameEnum, pose: pyrosetta.rosetta.core.pose.Pose, cdr_piece: pyrosetta.rosetta.core.pose.Pose, overhang: int) -> None

Use insert_pose_into_pose to replace the cdr_piece with the current antibody’s CDR. No modeling or superposition. For that, use protocols/grafting

C++: protocols::antibody::design::insert_cdr_into_antibody(class std::shared_ptr<const class protocols::antibody::AntibodyInfo>, const enum protocols::antibody::CDRNameEnum, class core::pose::Pose &, class core::pose::Pose &, unsigned long) –> void

pyrosetta.rosetta.protocols.antibody.design.seq_design_strategy_to_enum(strategy: str) → pyrosetta.rosetta.protocols.antibody.design.SeqDesignStrategyEnum¶: C++: protocols::antibody::design::seq_design_strategy_to_enum(const class std::basic_string<char>) –> enum protocols::antibody::design::SeqDesignStrategyEnum

pyrosetta.rosetta.protocols.antibody.design.seq_design_strategy_to_string(strategy: pyrosetta.rosetta.protocols.antibody.design.SeqDesignStrategyEnum) → str¶: C++: protocols::antibody::design::seq_design_strategy_to_string(enum protocols::antibody::design::SeqDesignStrategyEnum) –> std::string

pyrosetta.rosetta.protocols.antibody.design.set_native_cdr_sequence(ab_info: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, cdr: pyrosetta.rosetta.protocols.antibody.CDRNameEnum, pose: pyrosetta.rosetta.core.pose.Pose) → None¶

Set the native CDR sequence into the pose datacache: If none is set in the pose, will add it.

C++: protocols::antibody::design::set_native_cdr_sequence(class std::shared_ptr<const class protocols::antibody::AntibodyInfo>, enum protocols::antibody::CDRNameEnum, class core::pose::Pose &) –> void