jd2

• JobInputterInputSource
• archive

Bindings for protocols::jd2 namespace

class pyrosetta.rosetta.protocols.jd2.AtomTreeDiffJobInputter

Bases: pyrosetta.rosetta.protocols.jd2.JobInputter

This is the simplest implementation of JobInputter, which reads from -s/-l and AtomTree files.

__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.jd2.AtomTreeDiffJobInputter) → None

__init_subclass__()

This method is called when a class is subclassed.

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

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

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

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

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

all_ref_poses(self: pyrosetta.rosetta.protocols.jd2.AtomTreeDiffJobInputter) → pyrosetta.rosetta.utility.vector1_std_shared_ptr_core_pose_Pose_t

Utility function to allow mutatable (!) access to the reference

poses of the undelying AtomTreeDiff object. Use with caution.

This exists to allow setup on stored reference poses for properties that don’t get saved/restored in PDB format, like covalent constraints for enzyme design.

C++: protocols::jd2::AtomTreeDiffJobInputter::all_ref_poses() const –> const class utility::vector1<class std::shared_ptr<class core::pose::Pose>, class std::allocator<class std::shared_ptr<class core::pose::Pose> > > &

assign(self: pyrosetta.rosetta.protocols.jd2.JobInputter, : pyrosetta.rosetta.protocols.jd2.JobInputter) → pyrosetta.rosetta.protocols.jd2.JobInputter

C++: protocols::jd2::JobInputter::operator=(const class protocols::jd2::JobInputter &) –> class protocols::jd2::JobInputter &

fill_jobs(self: pyrosetta.rosetta.protocols.jd2.AtomTreeDiffJobInputter, jobs: pyrosetta.rosetta.protocols.jd2.JobsContainer) → None

this function determines what jobs exist from -in::file::silent and

-in::file::tags.

C++: protocols::jd2::AtomTreeDiffJobInputter::fill_jobs(class protocols::jd2::JobsContainer &) –> void

get_self_ptr(self: pyrosetta.rosetta.protocols.jd2.JobInputter) → pyrosetta.rosetta.protocols.jd2.JobInputter

Get self owning pointers.

C++: protocols::jd2::JobInputter::get_self_ptr() –> class std::shared_ptr<class protocols::jd2::JobInputter>

get_self_weak_ptr(self: pyrosetta.rosetta.protocols.jd2.JobInputter) → pyrosetta.rosetta.std.weak_ptr_protocols_jd2_JobInputter_t

Get self weak pointers.

C++: protocols::jd2::JobInputter::get_self_weak_ptr() –> class std::weak_ptr<class protocols::jd2::JobInputter>

input_source(self: pyrosetta.rosetta.protocols.jd2.AtomTreeDiffJobInputter) → pyrosetta.rosetta.protocols.jd2.JobInputterInputSource.Enum

Return the type of input source that the AtomTreeDiffJobInputter is currently

using.

Always ATOM_TREE_FILE.

C++: protocols::jd2::AtomTreeDiffJobInputter::input_source() const –> enum protocols::jd2::JobInputterInputSource::Enum

job_inputter_input_source_to_string(source: pyrosetta.rosetta.protocols.jd2.JobInputterInputSource.Enum) → str

call this with input_source() to get the input source of a

particular job inputter

C++: protocols::jd2::JobInputter::job_inputter_input_source_to_string(enum protocols::jd2::JobInputterInputSource::Enum) –> std::string

pose_from_job(self: pyrosetta.rosetta.protocols.jd2.AtomTreeDiffJobInputter, pose: pyrosetta.rosetta.core.pose.Pose, job: protocols::jd2::Job) → None

this function is responsible for filling the pose reference with

the pose indicated by the job. The Job object (within its InnerJob) contains a PoseCOP. This function needs to either fill the pose reference from the InnerJob or, on first demand of a pose from that InnerJob, instantiate the pose, hand off a COP to the InnerJob, and fill the reference. This implementation uses pose_from_pdb

C++: protocols::jd2::AtomTreeDiffJobInputter::pose_from_job(class core::pose::Pose &, class std::shared_ptr<class protocols::jd2::Job>) –> void

update_jobs_list(self: pyrosetta.rosetta.protocols.jd2.JobInputter, jobs: protocols::jd2::JobsContainer) → None

This function is only called by certain JobInputters to update the jobs list after it has already been created.

An example case would be the LargeNstructJobInputter, which uses this function to load additional jobs after the first N have started to come back.

C++: protocols::jd2::JobInputter::update_jobs_list(class std::shared_ptr<class protocols::jd2::JobsContainer>) –> void

updates_jobs_list(self: pyrosetta.rosetta.protocols.jd2.JobInputter) → bool

Does this type of JobInputter update the jobs list?

False by default. Override this function in derived classes to make it true.

C++: protocols::jd2::JobInputter::updates_jobs_list() const –> bool

class pyrosetta.rosetta.protocols.jd2.AtomTreeDiffJobOutputter

Bases: pyrosetta.rosetta.protocols.jd2.FileJobOutputter

this is a middle-layer implementation of JobOutputter for file-based output. It handles scorefile output, as scorefiles are common to file-outputting methods.

__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.jd2.AtomTreeDiffJobOutputter) → None

__init_subclass__()

This method is called when a class is subclassed.

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

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

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

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

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

add_evaluation(self: pyrosetta.rosetta.protocols.jd2.JobOutputter, : pyrosetta.rosetta.protocols.evaluation.PoseEvaluator) → None

////////////////////////////// evaluator interface ////////////////////////////////////////////

C++: protocols::jd2::JobOutputter::add_evaluation(class std::shared_ptr<class protocols::evaluation::PoseEvaluator>) –> void

call_output_observers(self: pyrosetta.rosetta.protocols.jd2.JobOutputter, pose: pyrosetta.rosetta.core.pose.Pose, job: protocols::jd2::Job) → None

call all output_observers

C++: protocols::jd2::JobOutputter::call_output_observers(const class core::pose::Pose &, class std::shared_ptr<class protocols::jd2::Job>) const –> void

clear_evaluators(self: pyrosetta.rosetta.protocols.jd2.JobOutputter) → None

C++: protocols::jd2::JobOutputter::clear_evaluators() –> void

evaluate(self: pyrosetta.rosetta.protocols.jd2.JobOutputter, pose: pyrosetta.rosetta.core.pose.Pose, tag: str, pss: pyrosetta.rosetta.core.io.silent.SilentStruct) → None

C++: protocols::jd2::JobOutputter::evaluate(class core::pose::Pose &, class std::basic_string<char>, class core::io::silent::SilentStruct &) const –> void

evaluators(self: pyrosetta.rosetta.protocols.jd2.JobOutputter) → pyrosetta.rosetta.protocols.evaluation.MetaPoseEvaluator

C++: protocols::jd2::JobOutputter::evaluators() const –> class std::shared_ptr<const class protocols::evaluation::MetaPoseEvaluator>

file(self: pyrosetta.rosetta.protocols.jd2.FileJobOutputter, job: protocols::jd2::Job, data: str) → None

this function takes a string and writes it to disk (separately from Tracer output).

C++: protocols::jd2::FileJobOutputter::file(class std::shared_ptr<const class protocols::jd2::Job>, const class std::basic_string<char> &) –> void

filename(self: pyrosetta.rosetta.protocols.jd2.JobOutputter, : protocols::jd2::Job) → str

C++: protocols::jd2::JobOutputter::filename(class std::shared_ptr<const class protocols::jd2::Job>) const –> std::string

final_pose(self: pyrosetta.rosetta.protocols.jd2.AtomTreeDiffJobOutputter, job: protocols::jd2::Job, pose: pyrosetta.rosetta.core.pose.Pose, tag: str) → None

this function outputs the final result of a job.

C++: protocols::jd2::AtomTreeDiffJobOutputter::final_pose(class std::shared_ptr<class protocols::jd2::Job>, const class core::pose::Pose &, const class std::basic_string<char> &) –> void

flush(self: pyrosetta.rosetta.protocols.jd2.JobOutputter) → None

this function is meant to be redefined in child classes to allow for flushing of memory buffers.

Here’s the long version: The SilentFileJobOutputter wanted to buffer output, but needed to guaruntee that the output would be flushed at end of runtime. The original implementation was to A) bend over backward to ensure that the destructor was run (JobOutputter lives inside static JobDistributor, which was previously not destructed because it’s static) and B) flush the buffers in the destructor. This caused a problem because the buffer-flushing tried to use the Tracers, which had already been destructed…boom crash.

New solution: re-forbid use of destructors within the static JobDistributor system, and create a flush function to force this stuff out. So here it is:

C++: protocols::jd2::JobOutputter::flush() –> void

job_has_completed(self: pyrosetta.rosetta.protocols.jd2.AtomTreeDiffJobOutputter, job: protocols::jd2::Job) → bool

this function is not used for output, but it belongs here since it needs to check the same output locations as the class normally writes to. This class checks wherever output goes to see if the job’s expected output already exists (on disk or whatever). This is the most basic form of checkpointing. The base implementation looks for a pdb with the job’s name already in existence.

C++: protocols::jd2::AtomTreeDiffJobOutputter::job_has_completed(class std::shared_ptr<const class protocols::jd2::Job>) –> bool

other_pose(*args, **kwargs)

Overloaded function.

1. other_pose(self: pyrosetta.rosetta.protocols.jd2.AtomTreeDiffJobOutputter, job: protocols::jd2::Job, pose: pyrosetta.rosetta.core.pose.Pose, tag: str) -> None
2. other_pose(self: pyrosetta.rosetta.protocols.jd2.AtomTreeDiffJobOutputter, job: protocols::jd2::Job, pose: pyrosetta.rosetta.core.pose.Pose, tag: str, copy_count: int) -> None
3. other_pose(self: pyrosetta.rosetta.protocols.jd2.AtomTreeDiffJobOutputter, job: protocols::jd2::Job, pose: pyrosetta.rosetta.core.pose.Pose, tag: str, copy_count: int, score_only: bool) -> None

this function is intended for saving mid-protocol poses; for example the final centroid structure in a combined centroid/fullatom protocol.

C++: protocols::jd2::AtomTreeDiffJobOutputter::other_pose(class std::shared_ptr<class protocols::jd2::Job>, const class core::pose::Pose &, const class std::basic_string<char> &, int, bool) –> void

output_name(self: pyrosetta.rosetta.protocols.jd2.AtomTreeDiffJobOutputter, job: protocols::jd2::Job) → str

this is the master function for determining the unique output identifier for a job

C++: protocols::jd2::AtomTreeDiffJobOutputter::output_name(class std::shared_ptr<const class protocols::jd2::Job>) –> std::string

scorefile_name(self: pyrosetta.rosetta.protocols.jd2.FileJobOutputter) → pyrosetta.rosetta.utility.file.FileName

C++: protocols::jd2::FileJobOutputter::scorefile_name() –> const class utility::file::FileName &

set_defaults(self: pyrosetta.rosetta.protocols.jd2.FileJobOutputter) → None

C++: protocols::jd2::FileJobOutputter::set_defaults() –> void

set_evaluators(self: pyrosetta.rosetta.protocols.jd2.JobOutputter, : pyrosetta.rosetta.protocols.evaluation.MetaPoseEvaluator) → None

C++: protocols::jd2::JobOutputter::set_evaluators(const class protocols::evaluation::MetaPoseEvaluator &) –> void

set_precision(self: pyrosetta.rosetta.protocols.jd2.AtomTreeDiffJobOutputter, bb_precision: int, sc_precision: int, bondlen_precision: int) → None

what precision should the atom_tree_diff be ouput at?

C++: protocols::jd2::AtomTreeDiffJobOutputter::set_precision(int, int, int) –> void

starting_pose(self: pyrosetta.rosetta.protocols.jd2.JobOutputter, : pyrosetta.rosetta.core.pose.Pose) → None

optionally pass a starting (reference) pose to a JobOutputter for later comparison

purposes and/or as interface for initializing evaluators

C++: protocols::jd2::JobOutputter::starting_pose(const class core::pose::Pose &) –> void

use_input_for_ref(*args, **kwargs)

Overloaded function.

1. use_input_for_ref(self: pyrosetta.rosetta.protocols.jd2.AtomTreeDiffJobOutputter) -> None
2. use_input_for_ref(self: pyrosetta.rosetta.protocols.jd2.AtomTreeDiffJobOutputter, use_input: bool) -> None

use input as reference pose?

C++: protocols::jd2::AtomTreeDiffJobOutputter::use_input_for_ref(bool) –> void

write_scorefile(self: pyrosetta.rosetta.protocols.jd2.FileJobOutputter) → bool

C++: protocols::jd2::FileJobOutputter::write_scorefile() const –> bool

class pyrosetta.rosetta.protocols.jd2.BatchJobInputter

Bases: pyrosetta.rosetta.protocols.jd2.JobInputter

This is the simplest implementation of JobInputter, which reads from -s/-l and Batch files.

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: pyrosetta.rosetta.protocols.jd2.BatchJobInputter, batch: str) -> None
2. __init__(self: pyrosetta.rosetta.protocols.jd2.BatchJobInputter, arg0: pyrosetta.rosetta.protocols.jd2.BatchJobInputter) -> 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.jd2.JobInputter, : pyrosetta.rosetta.protocols.jd2.JobInputter) → pyrosetta.rosetta.protocols.jd2.JobInputter

C++: protocols::jd2::JobInputter::operator=(const class protocols::jd2::JobInputter &) –> class protocols::jd2::JobInputter &

fill_jobs(self: pyrosetta.rosetta.protocols.jd2.BatchJobInputter, jobs: pyrosetta.rosetta.protocols.jd2.JobsContainer) → None

this function determines what jobs exist from -in::file::silent and

-in::file::tags.

C++: protocols::jd2::BatchJobInputter::fill_jobs(class protocols::jd2::JobsContainer &) –> void

get_self_ptr(self: pyrosetta.rosetta.protocols.jd2.JobInputter) → pyrosetta.rosetta.protocols.jd2.JobInputter

Get self owning pointers.

C++: protocols::jd2::JobInputter::get_self_ptr() –> class std::shared_ptr<class protocols::jd2::JobInputter>

get_self_weak_ptr(self: pyrosetta.rosetta.protocols.jd2.JobInputter) → pyrosetta.rosetta.std.weak_ptr_protocols_jd2_JobInputter_t

Get self weak pointers.

C++: protocols::jd2::JobInputter::get_self_weak_ptr() –> class std::weak_ptr<class protocols::jd2::JobInputter>

input_source(self: pyrosetta.rosetta.protocols.jd2.BatchJobInputter) → pyrosetta.rosetta.protocols.jd2.JobInputterInputSource.Enum

Return the type of input source that the BatchJobInputter is currently

using.

The input source for the current batch.

C++: protocols::jd2::BatchJobInputter::input_source() const –> enum protocols::jd2::JobInputterInputSource::Enum

job_inputter_input_source_to_string(source: pyrosetta.rosetta.protocols.jd2.JobInputterInputSource.Enum) → str

call this with input_source() to get the input source of a

particular job inputter

C++: protocols::jd2::JobInputter::job_inputter_input_source_to_string(enum protocols::jd2::JobInputterInputSource::Enum) –> std::string

pose_from_job(self: pyrosetta.rosetta.protocols.jd2.BatchJobInputter, pose: pyrosetta.rosetta.core.pose.Pose, job: pyrosetta.rosetta.protocols.jd2.Job) → None

this function is responsible for filling the pose reference with

the pose indicated by the job. The Job object (within its InnerJob) contains a PoseCOP. This function needs to either fill the pose reference from the InnerJob or, on first demand of a pose from that InnerJob, instantiate the pose, hand off a COP to the InnerJob, and fill the reference. This implementation uses pose_from_pdb

C++: protocols::jd2::BatchJobInputter::pose_from_job(class core::pose::Pose &, class std::shared_ptr<class protocols::jd2::Job>) –> void

update_jobs_list(self: pyrosetta.rosetta.protocols.jd2.JobInputter, jobs: protocols::jd2::JobsContainer) → None

This function is only called by certain JobInputters to update the jobs list after it has already been created.

An example case would be the LargeNstructJobInputter, which uses this function to load additional jobs after the first N have started to come back.

C++: protocols::jd2::JobInputter::update_jobs_list(class std::shared_ptr<class protocols::jd2::JobsContainer>) –> void

updates_jobs_list(self: pyrosetta.rosetta.protocols.jd2.JobInputter) → bool

Does this type of JobInputter update the jobs list?

False by default. Override this function in derived classes to make it true.

C++: protocols::jd2::JobInputter::updates_jobs_list() const –> bool

class pyrosetta.rosetta.protocols.jd2.EnsembleJobInputter

Bases: pyrosetta.rosetta.protocols.jd2.PDBJobInputter

A Job Inputter for distributing a job based on a set of input structures that make up an ensemble

Two modes. Seed Ensemble and Grid Ensemble.

Randomly choose the starting files using the list of structures given by -s and -l

-jd2:seed_ensemble_weights (RealVector)

• Will give weights to the input PDBs and trigger seed_ensemble mode and the JI. We then use the weighted sampler to choose the input pdb for

each nstruct. The weights could be the size of the cluster, the energy, that you like some structure better, etc. Must match number of inputs.

-jd2:seed_ensemble_weight_file (File)

• A file specifying weights to use for each input structure. Enables seed_ensemble mode and the JI. Two columns. basename with extension (or

relative path or full path), weight. Any not given in file will be set to 0 by default. Can give a line that is [ALL weight] to set all input pdbs to a given weight. Used for example, to upweight a specific structure:

Example:

#name weight ALL 1 awesome_model.pdb 3

-jd2:seed_ensemble (Bool)

• Enable seed ensemble mode, but simply randomly choose the input pdb for each nstruct. For seed ensemble mode, the number of input pdbs can

be larger than nstruct.

Use the input files given in -s and -l and nstruct to cover a grid.

-in:jd2:grid_ensemble (Bool)

• Will enable the basic component of the JI. Here, instead of sampling nstruct for every input pdb, we only sample nstruct no matter the number

of input PDBs (with nstruct split as evenly as possible over the input PDBs).

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: pyrosetta.rosetta.protocols.jd2.EnsembleJobInputter) -> None
2. __init__(self: pyrosetta.rosetta.protocols.jd2.EnsembleJobInputter, arg0: pyrosetta.rosetta.protocols.jd2.EnsembleJobInputter) -> 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.jd2.EnsembleJobInputter, : pyrosetta.rosetta.protocols.jd2.EnsembleJobInputter) → pyrosetta.rosetta.protocols.jd2.EnsembleJobInputter

C++: protocols::jd2::EnsembleJobInputter::operator=(const class protocols::jd2::EnsembleJobInputter &) –> class protocols::jd2::EnsembleJobInputter &

fill_jobs(self: pyrosetta.rosetta.protocols.jd2.EnsembleJobInputter, jobs: pyrosetta.rosetta.protocols.jd2.JobsContainer) → None

this function determines what jobs exist from -s/-l

C++: protocols::jd2::EnsembleJobInputter::fill_jobs(class protocols::jd2::JobsContainer &) –> void

get_self_ptr(self: pyrosetta.rosetta.protocols.jd2.JobInputter) → pyrosetta.rosetta.protocols.jd2.JobInputter

Get self owning pointers.

C++: protocols::jd2::JobInputter::get_self_ptr() –> class std::shared_ptr<class protocols::jd2::JobInputter>

get_self_weak_ptr(self: pyrosetta.rosetta.protocols.jd2.JobInputter) → pyrosetta.rosetta.std.weak_ptr_protocols_jd2_JobInputter_t

Get self weak pointers.

C++: protocols::jd2::JobInputter::get_self_weak_ptr() –> class std::weak_ptr<class protocols::jd2::JobInputter>

input_source(self: pyrosetta.rosetta.protocols.jd2.PDBJobInputter) → pyrosetta.rosetta.protocols.jd2.JobInputterInputSource.Enum

Return the type of input source that the PDBJobInputter is currently

using.

Always PDB_FILE.

C++: protocols::jd2::PDBJobInputter::input_source() const –> enum protocols::jd2::JobInputterInputSource::Enum

job_inputter_input_source_to_string(source: pyrosetta.rosetta.protocols.jd2.JobInputterInputSource.Enum) → str

call this with input_source() to get the input source of a

particular job inputter

C++: protocols::jd2::JobInputter::job_inputter_input_source_to_string(enum protocols::jd2::JobInputterInputSource::Enum) –> std::string

pose_from_job(self: pyrosetta.rosetta.protocols.jd2.PDBJobInputter, pose: pyrosetta.rosetta.core.pose.Pose, job: protocols::jd2::Job) → None

this function is responsible for filling the pose reference with the pose indicated by the job. The Job object (within its InnerJob) contains a PoseCOP. This function needs to either fill the pose reference from the InnerJob or, on first demand of a pose from that InnerJob, instantiate the pose, hand off a COP to the InnerJob, and fill the reference. This implementation uses pose_from_pdb

C++: protocols::jd2::PDBJobInputter::pose_from_job(class core::pose::Pose &, class std::shared_ptr<class protocols::jd2::Job>) –> void

update_jobs_list(self: pyrosetta.rosetta.protocols.jd2.JobInputter, jobs: protocols::jd2::JobsContainer) → None

This function is only called by certain JobInputters to update the jobs list after it has already been created.

An example case would be the LargeNstructJobInputter, which uses this function to load additional jobs after the first N have started to come back.

C++: protocols::jd2::JobInputter::update_jobs_list(class std::shared_ptr<class protocols::jd2::JobsContainer>) –> void

updates_jobs_list(self: pyrosetta.rosetta.protocols.jd2.JobInputter) → bool

Does this type of JobInputter update the jobs list?

False by default. Override this function in derived classes to make it true.

C++: protocols::jd2::JobInputter::updates_jobs_list() const –> bool

class pyrosetta.rosetta.protocols.jd2.FileJobOutputter

Bases: pyrosetta.rosetta.protocols.jd2.JobOutputter

this is a middle-layer implementation of JobOutputter for file-based output. It handles scorefile output, as scorefiles are common to file-outputting methods.

__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.jd2.FileJobOutputter) → None

__init_subclass__()

This method is called when a class is subclassed.

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

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

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

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

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

add_evaluation(self: pyrosetta.rosetta.protocols.jd2.JobOutputter, : pyrosetta.rosetta.protocols.evaluation.PoseEvaluator) → None

////////////////////////////// evaluator interface ////////////////////////////////////////////

C++: protocols::jd2::JobOutputter::add_evaluation(class std::shared_ptr<class protocols::evaluation::PoseEvaluator>) –> void

call_output_observers(self: pyrosetta.rosetta.protocols.jd2.JobOutputter, pose: pyrosetta.rosetta.core.pose.Pose, job: protocols::jd2::Job) → None

call all output_observers

C++: protocols::jd2::JobOutputter::call_output_observers(const class core::pose::Pose &, class std::shared_ptr<class protocols::jd2::Job>) const –> void

clear_evaluators(self: pyrosetta.rosetta.protocols.jd2.JobOutputter) → None

C++: protocols::jd2::JobOutputter::clear_evaluators() –> void

evaluate(self: pyrosetta.rosetta.protocols.jd2.JobOutputter, pose: pyrosetta.rosetta.core.pose.Pose, tag: str, pss: pyrosetta.rosetta.core.io.silent.SilentStruct) → None

C++: protocols::jd2::JobOutputter::evaluate(class core::pose::Pose &, class std::basic_string<char>, class core::io::silent::SilentStruct &) const –> void

evaluators(self: pyrosetta.rosetta.protocols.jd2.JobOutputter) → pyrosetta.rosetta.protocols.evaluation.MetaPoseEvaluator

C++: protocols::jd2::JobOutputter::evaluators() const –> class std::shared_ptr<const class protocols::evaluation::MetaPoseEvaluator>

file(self: pyrosetta.rosetta.protocols.jd2.FileJobOutputter, job: protocols::jd2::Job, data: str) → None

this function takes a string and writes it to disk (separately from Tracer output).

C++: protocols::jd2::FileJobOutputter::file(class std::shared_ptr<const class protocols::jd2::Job>, const class std::basic_string<char> &) –> void

filename(self: pyrosetta.rosetta.protocols.jd2.JobOutputter, : protocols::jd2::Job) → str

C++: protocols::jd2::JobOutputter::filename(class std::shared_ptr<const class protocols::jd2::Job>) const –> std::string

final_pose(self: pyrosetta.rosetta.protocols.jd2.FileJobOutputter, job: protocols::jd2::Job, pose: pyrosetta.rosetta.core.pose.Pose, tag: str) → None

this function outputs the final result of a job.

C++: protocols::jd2::FileJobOutputter::final_pose(class std::shared_ptr<class protocols::jd2::Job>, const class core::pose::Pose &, const class std::basic_string<char> &) –> void

flush(self: pyrosetta.rosetta.protocols.jd2.JobOutputter) → None

this function is meant to be redefined in child classes to allow for flushing of memory buffers.

Here’s the long version: The SilentFileJobOutputter wanted to buffer output, but needed to guaruntee that the output would be flushed at end of runtime. The original implementation was to A) bend over backward to ensure that the destructor was run (JobOutputter lives inside static JobDistributor, which was previously not destructed because it’s static) and B) flush the buffers in the destructor. This caused a problem because the buffer-flushing tried to use the Tracers, which had already been destructed…boom crash.

New solution: re-forbid use of destructors within the static JobDistributor system, and create a flush function to force this stuff out. So here it is:

C++: protocols::jd2::JobOutputter::flush() –> void

job_has_completed(self: pyrosetta.rosetta.protocols.jd2.FileJobOutputter, job: protocols::jd2::Job) → bool

this function is not used for output, but it belongs here since it needs to check the same output locations as the class normally writes to. This class checks wherever output goes to see if the job’s expected output already exists (on disk or whatever). This is the most basic form of checkpointing. The base implementation looks for a pdb with the job’s name already in existence.

C++: protocols::jd2::FileJobOutputter::job_has_completed(class std::shared_ptr<const class protocols::jd2::Job>) –> bool

other_pose(*args, **kwargs)

Overloaded function.

1. other_pose(self: pyrosetta.rosetta.protocols.jd2.FileJobOutputter, job: protocols::jd2::Job, pose: pyrosetta.rosetta.core.pose.Pose, tag: str) -> None
2. other_pose(self: pyrosetta.rosetta.protocols.jd2.FileJobOutputter, job: protocols::jd2::Job, pose: pyrosetta.rosetta.core.pose.Pose, tag: str, copy_count: int) -> None
3. other_pose(self: pyrosetta.rosetta.protocols.jd2.FileJobOutputter, job: protocols::jd2::Job, pose: pyrosetta.rosetta.core.pose.Pose, tag: str, copy_count: int, score_only: bool) -> None

this function is intended for saving mid-protocol poses; for example the final centroid structure in a combined centroid/fullatom protocol.

C++: protocols::jd2::FileJobOutputter::other_pose(class std::shared_ptr<class protocols::jd2::Job>, const class core::pose::Pose &, const class std::basic_string<char> &, int, bool) –> void

output_name(self: pyrosetta.rosetta.protocols.jd2.FileJobOutputter, job: protocols::jd2::Job) → str

this is the master function for determining the unique output identifier for a job

C++: protocols::jd2::FileJobOutputter::output_name(class std::shared_ptr<const class protocols::jd2::Job>) –> std::string

scorefile_name(self: pyrosetta.rosetta.protocols.jd2.FileJobOutputter) → pyrosetta.rosetta.utility.file.FileName

C++: protocols::jd2::FileJobOutputter::scorefile_name() –> const class utility::file::FileName &

set_defaults(self: pyrosetta.rosetta.protocols.jd2.FileJobOutputter) → None

C++: protocols::jd2::FileJobOutputter::set_defaults() –> void

set_evaluators(self: pyrosetta.rosetta.protocols.jd2.JobOutputter, : pyrosetta.rosetta.protocols.evaluation.MetaPoseEvaluator) → None

C++: protocols::jd2::JobOutputter::set_evaluators(const class protocols::evaluation::MetaPoseEvaluator &) –> void

starting_pose(self: pyrosetta.rosetta.protocols.jd2.JobOutputter, : pyrosetta.rosetta.core.pose.Pose) → None

optionally pass a starting (reference) pose to a JobOutputter for later comparison

purposes and/or as interface for initializing evaluators

C++: protocols::jd2::JobOutputter::starting_pose(const class core::pose::Pose &) –> void

write_scorefile(self: pyrosetta.rosetta.protocols.jd2.FileJobOutputter) → bool

C++: protocols::jd2::FileJobOutputter::write_scorefile() const –> bool

class pyrosetta.rosetta.protocols.jd2.InnerJob

Bases: pybind11_builtins.pybind11_object

The InnerJob class is responsible for knowing input requirements for a given job - how many nstruct, and what the input is. InnerJobs are relatively heavy; there is no need to duplicate a series of InnerJobs for each index into nstruct. The companion Job class handles the nstruct index and has a pointer to an InnerJob (which is shared across many Jobs). InnerJob also holds a PoseOP to maintain the unmodified input pose for that job.

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__(self: pyrosetta.rosetta.protocols.jd2.InnerJob, other: pyrosetta.rosetta.protocols.jd2.InnerJob) → bool

Mutual comparison of this inner job to the other inner job

so that if either one thinks it’s not the same as the other, then it returns false. Invokes the same() function on both this and other

Note: only compare if the pointers to the poses are to the same location

C++: protocols::jd2::InnerJob::operator==(const class protocols::jd2::InnerJob &) const –> bool

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: pyrosetta.rosetta.protocols.jd2.InnerJob, input_tag: str, nstruct_max: int) -> None
2. __init__(self: pyrosetta.rosetta.protocols.jd2.InnerJob, : pyrosetta.rosetta.core.pose.Pose, input_tag: str, nstruct_max: int) -> None
3. __init__(self: pyrosetta.rosetta.protocols.jd2.InnerJob, arg0: pyrosetta.rosetta.protocols.jd2.InnerJob) -> None

__init_subclass__()

This method is called when a class is subclassed.

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

__le__

Return self<=value.

__lt__

Return self<value.

__ne__(self: pyrosetta.rosetta.protocols.jd2.InnerJob, other: pyrosetta.rosetta.protocols.jd2.InnerJob) → bool

C++: protocols::jd2::InnerJob::operator!=(const class protocols::jd2::InnerJob &) const –> bool

__new__()

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

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__(self: pyrosetta.rosetta.protocols.jd2.InnerJob) → str

__subclasshook__()

Abstract classes can override this to customize issubclass().

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

bad(self: pyrosetta.rosetta.protocols.jd2.InnerJob) → bool

C++: protocols::jd2::InnerJob::bad() const –> bool

clone(self: pyrosetta.rosetta.protocols.jd2.InnerJob) → pyrosetta.rosetta.protocols.jd2.InnerJob

Return an owning pointer to a copy of this object.

C++: protocols::jd2::InnerJob::clone() const –> class std::shared_ptr<class protocols::jd2::InnerJob>

get_pose(self: pyrosetta.rosetta.protocols.jd2.InnerJob) → pyrosetta.rosetta.core.pose.Pose

return a COP to the input pose

DO NOT USE OUTSIDE OF JD2 NAMESPACE

C++: protocols::jd2::InnerJob::get_pose() const –> class std::shared_ptr<const class core::pose::Pose>

input_tag(self: pyrosetta.rosetta.protocols.jd2.InnerJob) → str

return the input tag (a string of space separated PDB filenames)

C++: protocols::jd2::InnerJob::input_tag() const –> const std::string &

nstruct_max(self: pyrosetta.rosetta.protocols.jd2.InnerJob) → int

C++: protocols::jd2::InnerJob::nstruct_max() const –> unsigned long

same(self: pyrosetta.rosetta.protocols.jd2.InnerJob, other: pyrosetta.rosetta.protocols.jd2.InnerJob) → bool

returns true if this is the same as other;

does not call other.same()

C++: protocols::jd2::InnerJob::same(const class protocols::jd2::InnerJob &) const –> bool

set_bad(*args, **kwargs)

Overloaded function.

1. set_bad(self: pyrosetta.rosetta.protocols.jd2.InnerJob) -> None
2. set_bad(self: pyrosetta.rosetta.protocols.jd2.InnerJob, value: bool) -> None

C++: protocols::jd2::InnerJob::set_bad(bool) –> void

show(self: pyrosetta.rosetta.protocols.jd2.InnerJob, out: pyrosetta.rosetta.std.ostream) → None

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

class pyrosetta.rosetta.protocols.jd2.JD2ResourceManager

Bases: pyrosetta.rosetta.basic.resource_manager.LazyResourceManager

The %JD2ResourceManager is the ResourceManager that should be used when running protocols under the jd2 JobDistributor.

The purpose of the ResourceManager is to disentangle the process of feeding protocols with Resources they need from the job distribution system in which they run. When protocols request a resource under the ResourceManager, they do so without knowing what kind of ResourceManager they are communicating with. Protocols that are designed to run under JD2 could conceivably be run under any other job management scheme (e.g. a complicated MPI protocol). It’s the job of the %JD2ResourceManager to determine the right resource to deliver to a protocol, and the context that the %JD2ResourceManager uses to make that decision is the job. E.g., when a protocol asks for the “native” (the Pose of the native structure), the %JD2ResourceManager looks up what job is currently running and then delivers the (single) native Pose for that job.

The %JD2ResourceManager is meant to work with the JD2ResourceManagerJobInputter. Jobs are defined in an input XML file and for each of the jobs that are defined, resources can be mapped to them. Resources are also declared in an XML file and may be declared in the same XML file as the Jobs or in a different XML file. The format of this XML file is specified in full between the documentation in the JD2ResourceManagerJobInputter class and three functions that are documented and implemented in this class.

The %JD2ResourceManager keeps track of which resources are used by which jobs and keeps track of what jobs have completed. It allocates a Resource the first time that resource is requested by a protoocol, and it deallocates that Resource when all jobs that require that resource have finished. Thus a protocol that needs an expensive-to-create resource (e.g. a set of 9-mers) can load that resource once and then have that resource shared between all of the jobs that require that resource (e.g. 10K abinitio trajectories) without having to do any legwork itself. If you have 100K abinitio trajectories for 10 different targets, they could all be run in a single job. (Note: as of 9/2013, abinitio does not work with the jd2 or the ResourceManager but it should!)

The main consequence of relying on the ResourceManager to hand resources to jobs is that jobs which require different resources (usually specified on the command line, and therefore requiring that each job run in a separate process) now can be run together in a single process. For MPI jobs, this is a major improvement, especially in constructing benchmarks, where many separate, (possibly short) jobs need to be run.

(Because Resources are not constructed until they are requested, resources can be declared and never used; you can give a resource file that describes every resource you use in every job, and a job declaration file that only uses one of those resources.)

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

Initialize self. See help(type(self)) for accurate signature.

__init_subclass__()

This method is called when a class is subclassed.

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

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

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

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__(self: pyrosetta.rosetta.basic.resource_manager.LazyResourceManager) → str

__subclasshook__()

Abstract classes can override this to customize issubclass().

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

add_job_options(self: pyrosetta.rosetta.basic.resource_manager.LazyResourceManager, job_tag: str, job_options: pyrosetta.rosetta.basic.resource_manager.JobOptions) → None

C++: basic::resource_manager::LazyResourceManager::add_job_options(const class std::basic_string<char> &, class std::shared_ptr<class basic::resource_manager::JobOptions>) –> void

add_resource_configuration(self: pyrosetta.rosetta.basic.resource_manager.LazyResourceManager, resource_tag: str, resource_configuration: pyrosetta.rosetta.basic.resource_manager.ResourceConfiguration) → None

C++: basic::resource_manager::LazyResourceManager::add_resource_configuration(const class std::basic_string<char> &, const struct basic::resource_manager::ResourceConfiguration &) –> void

add_resource_locator(self: pyrosetta.rosetta.basic.resource_manager.LazyResourceManager, locator_tag: str, resource_locator: basic::resource_manager::ResourceLocator) → None

C++: basic::resource_manager::LazyResourceManager::add_resource_locator(const class std::basic_string<char> &, class std::shared_ptr<class basic::resource_manager::ResourceLocator>) –> void

add_resource_options(self: pyrosetta.rosetta.basic.resource_manager.LazyResourceManager, resource_options_tag: str, resource_options: pyrosetta.rosetta.basic.resource_manager.ResourceOptions) → None

C++: basic::resource_manager::LazyResourceManager::add_resource_options(const class std::basic_string<char> &, class std::shared_ptr<class basic::resource_manager::ResourceOptions>) –> void

add_resource_tag_by_job_tag(self: pyrosetta.rosetta.basic.resource_manager.LazyResourceManager, resource_description: str, job_tag: str, resource_tag: str) → None

C++: basic::resource_manager::LazyResourceManager::add_resource_tag_by_job_tag(const class std::basic_string<char> &, const class std::basic_string<char> &, const class std::basic_string<char> &) –> void

assign(self: pyrosetta.rosetta.protocols.jd2.JD2ResourceManager, : pyrosetta.rosetta.protocols.jd2.JD2ResourceManager) → pyrosetta.rosetta.protocols.jd2.JD2ResourceManager

C++: protocols::jd2::JD2ResourceManager::operator=(const class protocols::jd2::JD2ResourceManager &) –> class protocols::jd2::JD2ResourceManager &

clear(self: pyrosetta.rosetta.protocols.jd2.JD2ResourceManager) → None

C++: protocols::jd2::JD2ResourceManager::clear() –> void

create_resources(self: pyrosetta.rosetta.basic.resource_manager.LazyResourceManager, : str) → None

Create all the resources for a particular job; this should be implemented by the derived

class. The implementation in this class calls utility::exit

C++: basic::resource_manager::LazyResourceManager::create_resources(const class std::basic_string<char> &) –> void

find_resource_configuration(self: pyrosetta.rosetta.basic.resource_manager.LazyResourceManager, resource_tag: str) → pyrosetta.rosetta.basic.resource_manager.ResourceConfiguration

C++: basic::resource_manager::LazyResourceManager::find_resource_configuration(const class std::basic_string<char> &) const –> const struct basic::resource_manager::ResourceConfiguration &

find_resource_locator(self: pyrosetta.rosetta.basic.resource_manager.LazyResourceManager, locator_tag: str) → basic::resource_manager::ResourceLocator

C++: basic::resource_manager::LazyResourceManager::find_resource_locator(const class std::basic_string<char> &) const –> class std::shared_ptr<class basic::resource_manager::ResourceLocator>

find_resource_options(self: pyrosetta.rosetta.basic.resource_manager.LazyResourceManager, resource_options_tag: str) → pyrosetta.rosetta.basic.resource_manager.ResourceOptions

C++: basic::resource_manager::LazyResourceManager::find_resource_options(const class std::basic_string<char> &) const –> class std::shared_ptr<class basic::resource_manager::ResourceOptions>

find_resource_tag_by_job_tag(self: pyrosetta.rosetta.basic.resource_manager.LazyResourceManager, resource_description: str, job_tag: str) → str

C++: basic::resource_manager::LazyResourceManager::find_resource_tag_by_job_tag(const class std::basic_string<char> &, const class std::basic_string<char> &) const –> std::string

free_resource_by_job_tag(self: pyrosetta.rosetta.basic.resource_manager.LazyResourceManager, resource_description: str, job_tag: str) → None

C++: basic::resource_manager::LazyResourceManager::free_resource_by_job_tag(const class std::basic_string<char> &, const class std::basic_string<char> &) –> void

free_resource_by_tag(self: pyrosetta.rosetta.basic.resource_manager.LazyResourceManager, resource_tag: str) → None

C++: basic::resource_manager::LazyResourceManager::free_resource_by_tag(const class std::basic_string<char> &) –> void

get_count_of_jobs_associated_with_resource_tag(self: pyrosetta.rosetta.basic.resource_manager.LazyResourceManager, resource_tag: str) → int

C++: basic::resource_manager::LazyResourceManager::get_count_of_jobs_associated_with_resource_tag(const class std::basic_string<char> &) const –> unsigned long

get_instance() → pyrosetta.rosetta.basic.resource_manager.ResourceManager

Deprecated access to a global (not-quite singleton) ResourceManager instance that

should be removed

C++: basic::resource_manager::ResourceManager::get_instance() –> class basic::resource_manager::ResourceManager *

get_jd2_resource_manager_instance() → pyrosetta.rosetta.protocols.jd2.JD2ResourceManager

C++: protocols::jd2::JD2ResourceManager::get_jd2_resource_manager_instance() –> class protocols::jd2::JD2ResourceManager *

get_job_options(self: pyrosetta.rosetta.basic.resource_manager.LazyResourceManager, job_tag: str) → pyrosetta.rosetta.basic.resource_manager.JobOptions

C++: basic::resource_manager::LazyResourceManager::get_job_options(const class std::basic_string<char> &) const –> class std::shared_ptr<class basic::resource_manager::JobOptions>

get_option(*args, **kwargs)

Overloaded function.

1. get_option(self: pyrosetta.rosetta.protocols.jd2.JD2ResourceManager, key: pyrosetta.rosetta.utility.options.BooleanOptionKey) -> bool

C++: protocols::jd2::JD2ResourceManager::get_option(class utility::options::BooleanOptionKey) const –> bool

2. get_option(self: pyrosetta.rosetta.protocols.jd2.JD2ResourceManager, key: pyrosetta.rosetta.utility.options.BooleanVectorOptionKey) -> pyrosetta.rosetta.utility.vector1_bool

C++: protocols::jd2::JD2ResourceManager::get_option(class utility::options::BooleanVectorOptionKey) const –> const class utility::vector1<bool, class std::allocator<bool> > &

3. get_option(self: pyrosetta.rosetta.protocols.jd2.JD2ResourceManager, key: pyrosetta.rosetta.utility.options.FileOptionKey) -> pyrosetta.rosetta.utility.file.FileName

C++: protocols::jd2::JD2ResourceManager::get_option(class utility::options::FileOptionKey) const –> const class utility::file::FileName &

4. get_option(self: pyrosetta.rosetta.protocols.jd2.JD2ResourceManager, key: pyrosetta.rosetta.utility.options.FileVectorOptionKey) -> pyrosetta.rosetta.utility.vector1_utility_file_FileName

C++: protocols::jd2::JD2ResourceManager::get_option(class utility::options::FileVectorOptionKey) const –> const class utility::vector1<class utility::file::FileName, class std::allocator<class utility::file::FileName> > &

5. get_option(self: pyrosetta.rosetta.protocols.jd2.JD2ResourceManager, key: pyrosetta.rosetta.utility.options.IntegerOptionKey) -> int

C++: protocols::jd2::JD2ResourceManager::get_option(class utility::options::IntegerOptionKey) const –> int

6. get_option(self: pyrosetta.rosetta.protocols.jd2.JD2ResourceManager, key: pyrosetta.rosetta.utility.options.IntegerVectorOptionKey) -> pyrosetta.rosetta.utility.vector1_int

C++: protocols::jd2::JD2ResourceManager::get_option(class utility::options::IntegerVectorOptionKey) const –> const class utility::vector1<int, class std::allocator<int> > &

7. get_option(self: pyrosetta.rosetta.protocols.jd2.JD2ResourceManager, key: pyrosetta.rosetta.utility.options.PathOptionKey) -> pyrosetta.rosetta.utility.file.PathName

C++: protocols::jd2::JD2ResourceManager::get_option(class utility::options::PathOptionKey) const –> const class utility::file::PathName &

8. get_option(self: pyrosetta.rosetta.protocols.jd2.JD2ResourceManager, key: pyrosetta.rosetta.utility.options.PathVectorOptionKey) -> pyrosetta.rosetta.utility.vector1_utility_file_PathName

C++: protocols::jd2::JD2ResourceManager::get_option(class utility::options::PathVectorOptionKey) const –> const class utility::vector1<class utility::file::PathName, class std::allocator<class utility::file::PathName> > &

9. get_option(self: pyrosetta.rosetta.protocols.jd2.JD2ResourceManager, key: pyrosetta.rosetta.utility.options.RealOptionKey) -> float

C++: protocols::jd2::JD2ResourceManager::get_option(class utility::options::RealOptionKey) const –> double

10. get_option(self: pyrosetta.rosetta.protocols.jd2.JD2ResourceManager, key: pyrosetta.rosetta.utility.options.RealVectorOptionKey) -> pyrosetta.rosetta.utility.vector1_double

C++: protocols::jd2::JD2ResourceManager::get_option(class utility::options::RealVectorOptionKey) const –> const class utility::vector1<double, class std::allocator<double> > &

11. get_option(self: pyrosetta.rosetta.protocols.jd2.JD2ResourceManager, key: pyrosetta.rosetta.utility.options.StringOptionKey) -> str

C++: protocols::jd2::JD2ResourceManager::get_option(class utility::options::StringOptionKey) const –> const std::string &

12. get_option(self: pyrosetta.rosetta.protocols.jd2.JD2ResourceManager, key: pyrosetta.rosetta.utility.options.StringVectorOptionKey) -> pyrosetta.rosetta.utility.vector1_std_string

C++: protocols::jd2::JD2ResourceManager::get_option(class utility::options::StringVectorOptionKey) const –> const class utility::vector1<std::string, class std::allocator<std::string > > &

get_resource_tags_for_job_tag(self: pyrosetta.rosetta.basic.resource_manager.LazyResourceManager, job_tag: str) → pyrosetta.rosetta.std.list_std_string_std_allocator_std_string_t

C++: basic::resource_manager::LazyResourceManager::get_resource_tags_for_job_tag(const class std::basic_string<char> &) const –> class std::list<std::string, class std::allocator<std::string > >

has_job_options(self: pyrosetta.rosetta.basic.resource_manager.LazyResourceManager, job_tag: str) → bool

C++: basic::resource_manager::LazyResourceManager::has_job_options(const class std::basic_string<char> &) const –> bool

has_option(*args, **kwargs)

Overloaded function.

1. has_option(self: pyrosetta.rosetta.protocols.jd2.JD2ResourceManager, key: pyrosetta.rosetta.utility.options.BooleanOptionKey) -> bool

C++: protocols::jd2::JD2ResourceManager::has_option(class utility::options::BooleanOptionKey) const –> bool

2. has_option(self: pyrosetta.rosetta.protocols.jd2.JD2ResourceManager, key: pyrosetta.rosetta.utility.options.BooleanVectorOptionKey) -> bool

C++: protocols::jd2::JD2ResourceManager::has_option(class utility::options::BooleanVectorOptionKey) const –> bool

3. has_option(self: pyrosetta.rosetta.protocols.jd2.JD2ResourceManager, key: pyrosetta.rosetta.utility.options.FileOptionKey) -> bool

C++: protocols::jd2::JD2ResourceManager::has_option(class utility::options::FileOptionKey) const –> bool

4. has_option(self: pyrosetta.rosetta.protocols.jd2.JD2ResourceManager, key: pyrosetta.rosetta.utility.options.FileVectorOptionKey) -> bool

C++: protocols::jd2::JD2ResourceManager::has_option(class utility::options::FileVectorOptionKey) const –> bool

5. has_option(self: pyrosetta.rosetta.protocols.jd2.JD2ResourceManager, key: pyrosetta.rosetta.utility.options.IntegerOptionKey) -> bool

C++: protocols::jd2::JD2ResourceManager::has_option(class utility::options::IntegerOptionKey) const –> bool

6. has_option(self: pyrosetta.rosetta.protocols.jd2.JD2ResourceManager, key: pyrosetta.rosetta.utility.options.IntegerVectorOptionKey) -> bool

C++: protocols::jd2::JD2ResourceManager::has_option(class utility::options::IntegerVectorOptionKey) const –> bool

7. has_option(self: pyrosetta.rosetta.protocols.jd2.JD2ResourceManager, key: pyrosetta.rosetta.utility.options.PathOptionKey) -> bool

C++: protocols::jd2::JD2ResourceManager::has_option(class utility::options::PathOptionKey) const –> bool

8. has_option(self: pyrosetta.rosetta.protocols.jd2.JD2ResourceManager, key: pyrosetta.rosetta.utility.options.PathVectorOptionKey) -> bool

C++: protocols::jd2::JD2ResourceManager::has_option(class utility::options::PathVectorOptionKey) const –> bool

9. has_option(self: pyrosetta.rosetta.protocols.jd2.JD2ResourceManager, key: pyrosetta.rosetta.utility.options.RealOptionKey) -> bool

C++: protocols::jd2::JD2ResourceManager::has_option(class utility::options::RealOptionKey) const –> bool

10. has_option(self: pyrosetta.rosetta.protocols.jd2.JD2ResourceManager, key: pyrosetta.rosetta.utility.options.RealVectorOptionKey) -> bool

C++: protocols::jd2::JD2ResourceManager::has_option(class utility::options::RealVectorOptionKey) const –> bool

11. has_option(self: pyrosetta.rosetta.protocols.jd2.JD2ResourceManager, key: pyrosetta.rosetta.utility.options.StringOptionKey) -> bool

C++: protocols::jd2::JD2ResourceManager::has_option(class utility::options::StringOptionKey) const –> bool

12. has_option(self: pyrosetta.rosetta.protocols.jd2.JD2ResourceManager, key: pyrosetta.rosetta.utility.options.StringVectorOptionKey) -> bool

C++: protocols::jd2::JD2ResourceManager::has_option(class utility::options::StringVectorOptionKey) const –> bool

has_resource(self: pyrosetta.rosetta.basic.resource_manager.LazyResourceManager, resource_tag: str) → bool

Does a resource with a given name exist?

C++: basic::resource_manager::LazyResourceManager::has_resource(const class std::basic_string<char> &) const –> bool

has_resource_configuration(self: pyrosetta.rosetta.basic.resource_manager.LazyResourceManager, resource_tag: str) → bool

has a ResourceConfiguration been provided to the LazyResourceManager for a Resource with a particular ResourceTag?

C++: basic::resource_manager::LazyResourceManager::has_resource_configuration(const class std::basic_string<char> &) const –> bool

has_resource_locator(self: pyrosetta.rosetta.basic.resource_manager.LazyResourceManager, locator_tag: str) → bool

has a ResourceLocator object been provided to the LazyResourceManager which has a particular LocatorTag?

C++: basic::resource_manager::LazyResourceManager::has_resource_locator(const class std::basic_string<char> &) const –> bool

has_resource_options(self: pyrosetta.rosetta.basic.resource_manager.LazyResourceManager, resource_options_tag: str) → bool

has a ResourceOptions object been provided to the LazyResourceManager which has a particular ResourceOptionsTag?

C++: basic::resource_manager::LazyResourceManager::has_resource_options(const class std::basic_string<char> &) const –> bool

has_resource_tag_by_job_tag(self: pyrosetta.rosetta.basic.resource_manager.LazyResourceManager, resource_description: str, job_tag: str) → bool

C++: basic::resource_manager::LazyResourceManager::has_resource_tag_by_job_tag(const class std::basic_string<char> &, const class std::basic_string<char> &) const –> bool

has_resource_with_description(self: pyrosetta.rosetta.protocols.jd2.JD2ResourceManager, resource_description: str) → bool

C++: protocols::jd2::JD2ResourceManager::has_resource_with_description(const class std::basic_string<char> &) –> bool

mark_job_tag_as_complete(self: pyrosetta.rosetta.basic.resource_manager.LazyResourceManager, job_tag: str) → None

remove the Job tag from incomplete_job_sets_ for each resource

C++: basic::resource_manager::LazyResourceManager::mark_job_tag_as_complete(const class std::basic_string<char> &) –> void

read_resource_locators_tags(self: pyrosetta.rosetta.protocols.jd2.JD2ResourceManager, tags: pyrosetta.rosetta.utility.tag.Tag) → None

Read the portion of an XML file that declares ResourceLocator objects

C++: protocols::jd2::JD2ResourceManager::read_resource_locators_tags(class std::shared_ptr<const class utility::tag::Tag>) –> void

read_resource_options_tags(self: pyrosetta.rosetta.protocols.jd2.JD2ResourceManager, tags: pyrosetta.rosetta.utility.tag.Tag) → None

C++: protocols::jd2::JD2ResourceManager::read_resource_options_tags(class std::shared_ptr<const class utility::tag::Tag>) –> void

read_resources_tags(self: pyrosetta.rosetta.protocols.jd2.JD2ResourceManager, tags: pyrosetta.rosetta.utility.tag.Tag) → None

C++: protocols::jd2::JD2ResourceManager::read_resources_tags(class std::shared_ptr<const class utility::tag::Tag>) –> void

show(self: pyrosetta.rosetta.basic.resource_manager.LazyResourceManager, out: pyrosetta.rosetta.std.ostream) → None

C++: basic::resource_manager::LazyResourceManager::show(class std::basic_ostream<char> &) const –> void

class pyrosetta.rosetta.protocols.jd2.JD2ResourceManagerCreator

Bases: pyrosetta.rosetta.basic.resource_manager.ResourceManagerCreator

The %JD2ResourceManagerCreator is responsible for instantiating the JD2ResourceManager for the ResourceManagerFactory

__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.jd2.JD2ResourceManagerCreator) → 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.jd2.JD2ResourceManagerCreator, : pyrosetta.rosetta.protocols.jd2.JD2ResourceManagerCreator) → pyrosetta.rosetta.protocols.jd2.JD2ResourceManagerCreator

C++: protocols::jd2::JD2ResourceManagerCreator::operator=(const class protocols::jd2::JD2ResourceManagerCreator &) –> class protocols::jd2::JD2ResourceManagerCreator &

create_resource_manager(self: pyrosetta.rosetta.protocols.jd2.JD2ResourceManagerCreator) → pyrosetta.rosetta.basic.resource_manager.ResourceManager

C++: protocols::jd2::JD2ResourceManagerCreator::create_resource_manager() const –> class basic::resource_manager::ResourceManager *

manager_type(self: pyrosetta.rosetta.protocols.jd2.JD2ResourceManagerCreator) → str

C++: protocols::jd2::JD2ResourceManagerCreator::manager_type() const –> std::string

class pyrosetta.rosetta.protocols.jd2.JD2ResourceManagerJobInputter

Bases: pyrosetta.rosetta.protocols.jd2.JobInputter

See the documentation in the JD2ResourceManager for a description of the file format for the ResourceLocators block (JD2ResourceManager::read_resource_locators_tags), the ResourceOptions block (JD2ResourceManager::read_resource_options_tags) and the Resources block (JD2ResourceManager::read_resources_tags).

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: pyrosetta.rosetta.protocols.jd2.JD2ResourceManagerJobInputter) -> None
2. __init__(self: pyrosetta.rosetta.protocols.jd2.JD2ResourceManagerJobInputter, arg0: pyrosetta.rosetta.protocols.jd2.JD2ResourceManagerJobInputter) -> 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.jd2.JD2ResourceManagerJobInputter, : pyrosetta.rosetta.protocols.jd2.JD2ResourceManagerJobInputter) → pyrosetta.rosetta.protocols.jd2.JD2ResourceManagerJobInputter

C++: protocols::jd2::JD2ResourceManagerJobInputter::operator=(const class protocols::jd2::JD2ResourceManagerJobInputter &) –> class protocols::jd2::JD2ResourceManagerJobInputter &

fill_jobs(self: pyrosetta.rosetta.protocols.jd2.JD2ResourceManagerJobInputter, jobs: pyrosetta.rosetta.protocols.jd2.JobsContainer) → None

this function determines what jobs exist. This function neither knows nor cares what jobs are already complete on disk/memory - it just figures out what ones should exist given the input. NOTE: your JobInputter should order Job objects in the Jobs vector to have as few “transitions” between inputs as possible (group all Jobs of the same input next to each other). This improves efficiency of the “FAIL_BAD_INPUT” functionality. Note I said “should”, not “must”.

C++: protocols::jd2::JD2ResourceManagerJobInputter::fill_jobs(class protocols::jd2::JobsContainer &) –> void

get_self_ptr(self: pyrosetta.rosetta.protocols.jd2.JobInputter) → pyrosetta.rosetta.protocols.jd2.JobInputter

Get self owning pointers.

C++: protocols::jd2::JobInputter::get_self_ptr() –> class std::shared_ptr<class protocols::jd2::JobInputter>

get_self_weak_ptr(self: pyrosetta.rosetta.protocols.jd2.JobInputter) → pyrosetta.rosetta.std.weak_ptr_protocols_jd2_JobInputter_t

Get self weak pointers.

C++: protocols::jd2::JobInputter::get_self_weak_ptr() –> class std::weak_ptr<class protocols::jd2::JobInputter>

input_source(self: pyrosetta.rosetta.protocols.jd2.JD2ResourceManagerJobInputter) → pyrosetta.rosetta.protocols.jd2.JobInputterInputSource.Enum

return the type of input source that the JobInputter is currently

using

C++: protocols::jd2::JD2ResourceManagerJobInputter::input_source() const –> enum protocols::jd2::JobInputterInputSource::Enum

job_inputter_input_source_to_string(source: pyrosetta.rosetta.protocols.jd2.JobInputterInputSource.Enum) → str

call this with input_source() to get the input source of a

particular job inputter

C++: protocols::jd2::JobInputter::job_inputter_input_source_to_string(enum protocols::jd2::JobInputterInputSource::Enum) –> std::string

pose_from_job(self: pyrosetta.rosetta.protocols.jd2.JD2ResourceManagerJobInputter, pose: pyrosetta.rosetta.core.pose.Pose, job: pyrosetta.rosetta.protocols.jd2.Job) → None

this function is responsible for filling the pose reference with the pose indicated by the job. The Job object (within its InnerJob) contains a PoseCOP. This function needs to either fill the pose reference from the InnerJob or, on first demand of a pose from that InnerJob, instantiate the pose, hand off a COP to the InnerJob, and fill the reference.

C++: protocols::jd2::JD2ResourceManagerJobInputter::pose_from_job(class core::pose::Pose &, class std::shared_ptr<class protocols::jd2::Job>) –> void

update_jobs_list(self: pyrosetta.rosetta.protocols.jd2.JobInputter, jobs: protocols::jd2::JobsContainer) → None

This function is only called by certain JobInputters to update the jobs list after it has already been created.

An example case would be the LargeNstructJobInputter, which uses this function to load additional jobs after the first N have started to come back.

C++: protocols::jd2::JobInputter::update_jobs_list(class std::shared_ptr<class protocols::jd2::JobsContainer>) –> void

updates_jobs_list(self: pyrosetta.rosetta.protocols.jd2.JobInputter) → bool

Does this type of JobInputter update the jobs list?

False by default. Override this function in derived classes to make it true.

C++: protocols::jd2::JobInputter::updates_jobs_list() const –> bool

class pyrosetta.rosetta.protocols.jd2.JD2ResourceManagerJobInputterCreator

Bases: pyrosetta.rosetta.protocols.jd2.JobInputterCreator

the %JD2ResourceManagerJobInputterCreator is responsible for instantiating the JD2ResourceManagerJobInputter for the JobDistributorFactory

__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.jd2.JD2ResourceManagerJobInputterCreator) → 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.jd2.JD2ResourceManagerJobInputterCreator, : pyrosetta.rosetta.protocols.jd2.JD2ResourceManagerJobInputterCreator) → pyrosetta.rosetta.protocols.jd2.JD2ResourceManagerJobInputterCreator

C++: protocols::jd2::JD2ResourceManagerJobInputterCreator::operator=(const class protocols::jd2::JD2ResourceManagerJobInputterCreator &) –> class protocols::jd2::JD2ResourceManagerJobInputterCreator &

create_JobInputter(self: pyrosetta.rosetta.protocols.jd2.JD2ResourceManagerJobInputterCreator) → pyrosetta.rosetta.protocols.jd2.JobInputter

Create the JD2ResourceManagerJobInputter

C++: protocols::jd2::JD2ResourceManagerJobInputterCreator::create_JobInputter() const –> class std::shared_ptr<class protocols::jd2::JobInputter>

keyname(self: pyrosetta.rosetta.protocols.jd2.JD2ResourceManagerJobInputterCreator) → str

Return the name of the JobInputter this class instantiates:

“JD2ResourceManagerJobInputter”

C++: protocols::jd2::JD2ResourceManagerJobInputterCreator::keyname() const –> std::string

class pyrosetta.rosetta.protocols.jd2.Job

Bases: pybind11_builtins.pybind11_object

The Job class is directly used by the job distributor. It contains an index into nstruct and a lightweight pointer to an InnerJob (to share those heavier classes). It also directly contains job-associated output data. The idea here is that your scores, etc are associated with the job, not with a particular pose within that running job. Thus, the Job object is a better place to store them than the pose.

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: pyrosetta.rosetta.protocols.jd2.Job, inner_job: pyrosetta.rosetta.protocols.jd2.InnerJob, nstruct_index: int) -> None
2. __init__(self: pyrosetta.rosetta.protocols.jd2.Job, arg0: pyrosetta.rosetta.protocols.jd2.Job) -> None

__init_subclass__()

This method is called when a class is subclassed.

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

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

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

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__(self: pyrosetta.rosetta.protocols.jd2.Job) → str

__subclasshook__()

Abstract classes can override this to customize issubclass().

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

add_string(self: pyrosetta.rosetta.protocols.jd2.Job, string_in: str) → None

add an output string

C++: protocols::jd2::Job::add_string(const class std::basic_string<char> &) –> void

add_string_real_pair(self: pyrosetta.rosetta.protocols.jd2.Job, string_in: str, real_in: float) → None

add a string/real pair

C++: protocols::jd2::Job::add_string_real_pair(const class std::basic_string<char> &, const double) –> void

add_string_string_pair(self: pyrosetta.rosetta.protocols.jd2.Job, string1: str, string2: str) → None

add a string/string pair

C++: protocols::jd2::Job::add_string_string_pair(const class std::basic_string<char> &, const class std::basic_string<char> &) –> void

add_strings(self: pyrosetta.rosetta.protocols.jd2.Job, : pyrosetta.rosetta.std.list_std_string_std_allocator_std_string_t) → None

add output strings

C++: protocols::jd2::Job::add_strings(const class std::list<class std::basic_string<char>, class std::allocator<class std::basic_string<char> > > &) –> void

bad(self: pyrosetta.rosetta.protocols.jd2.Job) → bool

C++: protocols::jd2::Job::bad() const –> bool

call_output_observers(self: pyrosetta.rosetta.protocols.jd2.Job, pose: pyrosetta.rosetta.core.pose.Pose) → None

C++: protocols::jd2::Job::call_output_observers(const class core::pose::Pose &) –> void

can_be_deleted(self: pyrosetta.rosetta.protocols.jd2.Job) → bool

Returns true iff this job can be deleted to free up memory.

Should only be true if the job has completed, is bad, or has failed.

C++: protocols::jd2::Job::can_be_deleted() const –> bool

clear_output(self: pyrosetta.rosetta.protocols.jd2.Job) → None

Delete the output strings, string/string pairs, and string/real pairs.

C++: protocols::jd2::Job::clear_output() –> void

clone(self: pyrosetta.rosetta.protocols.jd2.Job) → pyrosetta.rosetta.protocols.jd2.Job

Return an owning pointer to a copy of this object.

C++: protocols::jd2::Job::clone() const –> class std::shared_ptr<class protocols::jd2::Job>

completed(self: pyrosetta.rosetta.protocols.jd2.Job) → bool

C++: protocols::jd2::Job::completed() const –> bool

copy_without_output(self: pyrosetta.rosetta.protocols.jd2.Job) → pyrosetta.rosetta.protocols.jd2.Job

returns a copy of this object whose “output fields” are zeroed

out. Used by the JobDistributor in cases where the job fails and must be retried to prevent accumulation of Job state after a failure. This implementation was chosen over a clear_all_output function to prevent mover A from deleting mover B’s hard work! You probably should not be trying to call this function. The exception: If you want an intermediate-output pose (not the final pose) to not have the aggregated accessory data in the “real” Job object.

C++: protocols::jd2::Job::copy_without_output() const –> class std::shared_ptr<class protocols::jd2::Job>

elapsed_time(self: pyrosetta.rosetta.protocols.jd2.Job) → int

C++: protocols::jd2::Job::elapsed_time() const –> unsigned long

end_time(self: pyrosetta.rosetta.protocols.jd2.Job) → int

C++: protocols::jd2::Job::end_time() const –> unsigned long

end_timing(self: pyrosetta.rosetta.protocols.jd2.Job) → None

C++: protocols::jd2::Job::end_timing() –> void

get_pose(*args, **kwargs)

Overloaded function.

1. get_pose(self: pyrosetta.rosetta.protocols.jd2.Job) -> pyrosetta.rosetta.core.pose.Pose

return a COP to the input pose

C++: protocols::jd2::Job::get_pose() const –> class std::shared_ptr<const class core::pose::Pose>

2. get_pose(self: pyrosetta.rosetta.protocols.jd2.Job, : pyrosetta.rosetta.core.pose.Pose) -> None

in-place copy of input pose

C++: protocols::jd2::Job::get_pose(class core::pose::Pose &) const –> void

get_string_real_pairs(self: pyrosetta.rosetta.protocols.jd2.Job) → pyrosetta.rosetta.std.map_std_string_double

C++: protocols::jd2::Job::get_string_real_pairs() const –> class std::map<std::string, double, struct std::less<std::string >, class std::allocator<struct std::pair<const std::string, double> > >

get_string_string_pairs(self: pyrosetta.rosetta.protocols.jd2.Job) → pyrosetta.rosetta.std.map_std_string_std_string

C++: protocols::jd2::Job::get_string_string_pairs() const –> class std::map<std::string, std::string, struct std::less<std::string >, class std::allocator<struct std::pair<const std::string, std::string > > >

get_strings(self: pyrosetta.rosetta.protocols.jd2.Job) → pyrosetta.rosetta.std.list_std_string_std_allocator_std_string_t

/////////////////////END SECTION//////////////////////////////////////////////////////////////////

C++: protocols::jd2::Job::get_strings() const –> class std::list<std::string, class std::allocator<std::string > >

inner_job(self: pyrosetta.rosetta.protocols.jd2.Job) → pyrosetta.rosetta.protocols.jd2.InnerJob

access to inner-job … use is discouraged - use sparingly!

— DO NOT use my_job->inner_job()->get_pose() INSTEAD use my_job->get_pose()

C++: protocols::jd2::Job::inner_job() const –> class std::shared_ptr<const class protocols::jd2::InnerJob>

inner_job_nonconst(self: pyrosetta.rosetta.protocols.jd2.Job) → pyrosetta.rosetta.protocols.jd2.InnerJob

nonconst access is intended only for the JobInputter to load poses into the InnerJob, and the Parser to add constraints, and the JobDistributor to delete completed inputs (recycle memory)

C++: protocols::jd2::Job::inner_job_nonconst() –> class std::shared_ptr<class protocols::jd2::InnerJob>

input_tag(self: pyrosetta.rosetta.protocols.jd2.Job) → str

return the input tag (a short string, generally)

C++: protocols::jd2::Job::input_tag() const –> const std::string &

nstruct_index(self: pyrosetta.rosetta.protocols.jd2.Job) → int

C++: protocols::jd2::Job::nstruct_index() const –> unsigned long

nstruct_max(self: pyrosetta.rosetta.protocols.jd2.Job) → int

C++: protocols::jd2::Job::nstruct_max() const –> unsigned long

output_string_real_pairs_begin(self: pyrosetta.rosetta.protocols.jd2.Job) → std::_Rb_tree_const_iterator<std::pair<std::string const, double> >

C++: protocols::jd2::Job::output_string_real_pairs_begin() const –> struct std::_Rb_tree_const_iterator<struct std::pair<const std::string, double> >

output_string_real_pairs_end(self: pyrosetta.rosetta.protocols.jd2.Job) → std::_Rb_tree_const_iterator<std::pair<std::string const, double> >

C++: protocols::jd2::Job::output_string_real_pairs_end() const –> struct std::_Rb_tree_const_iterator<struct std::pair<const std::string, double> >

output_string_string_pairs_begin(self: pyrosetta.rosetta.protocols.jd2.Job) → std::_Rb_tree_const_iterator<std::pair<std::string const, std::string> >

C++: protocols::jd2::Job::output_string_string_pairs_begin() const –> struct std::_Rb_tree_const_iterator<struct std::pair<const std::string, std::string > >

output_string_string_pairs_end(self: pyrosetta.rosetta.protocols.jd2.Job) → std::_Rb_tree_const_iterator<std::pair<std::string const, std::string> >

C++: protocols::jd2::Job::output_string_string_pairs_end() const –> struct std::_Rb_tree_const_iterator<struct std::pair<const std::string, std::string > >

output_strings_begin(self: pyrosetta.rosetta.protocols.jd2.Job) → std::_List_const_iterator<std::string>

/////////////////THIS SECTION OF FUNCTIONS IS FORBIDDEN FOR USE BY MOVERS//////////////////////////////////

C++: protocols::jd2::Job::output_strings_begin() const –> struct std::_List_const_iterator<std::string >

output_strings_end(self: pyrosetta.rosetta.protocols.jd2.Job) → std::_List_const_iterator<std::string>

C++: protocols::jd2::Job::output_strings_end() const –> struct std::_List_const_iterator<std::string >

set_bad(*args, **kwargs)

Overloaded function.

1. set_bad(self: pyrosetta.rosetta.protocols.jd2.Job) -> None
2. set_bad(self: pyrosetta.rosetta.protocols.jd2.Job, value: bool) -> None

C++: protocols::jd2::Job::set_bad(bool) –> void

set_can_be_deleted(*args, **kwargs)

Overloaded function.

1. set_can_be_deleted(self: pyrosetta.rosetta.protocols.jd2.Job) -> None
2. set_can_be_deleted(self: pyrosetta.rosetta.protocols.jd2.Job, value: bool) -> None

Set whether this job can be deleted to free up memory.

C++: protocols::jd2::Job::set_can_be_deleted(bool) –> void

set_completed(*args, **kwargs)

Overloaded function.

1. set_completed(self: pyrosetta.rosetta.protocols.jd2.Job) -> None
2. set_completed(self: pyrosetta.rosetta.protocols.jd2.Job, value: bool) -> None

C++: protocols::jd2::Job::set_completed(bool) –> void

set_status_prefix(self: pyrosetta.rosetta.protocols.jd2.Job, prefix: str) → None

C++: protocols::jd2::Job::set_status_prefix(class std::basic_string<char>) –> void

show(self: pyrosetta.rosetta.protocols.jd2.Job, out: pyrosetta.rosetta.std.ostream) → None

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

start_time(self: pyrosetta.rosetta.protocols.jd2.Job) → int

C++: protocols::jd2::Job::start_time() const –> unsigned long

start_timing(self: pyrosetta.rosetta.protocols.jd2.Job) → None

C++: protocols::jd2::Job::start_timing() –> void

status_prefix(self: pyrosetta.rosetta.protocols.jd2.Job) → str

C++: protocols::jd2::Job::status_prefix() const –> const std::string &

timestamp(self: pyrosetta.rosetta.protocols.jd2.Job) → str

C++: protocols::jd2::Job::timestamp() const –> std::string

to_do(self: pyrosetta.rosetta.protocols.jd2.Job) → bool

C++: protocols::jd2::Job::to_do() const –> bool

class pyrosetta.rosetta.protocols.jd2.JobInputter

Bases: pybind11_builtins.pybind11_object

The %JobInputter class is responsible for - determining what jobs exist, and - taking a job object and returning the starting pose associated with that job.

NOTE: your JobInputter should order Job objects in the Jobs vector to have as few “transitions” between inputs as possible (group all Jobs of the same input next to each other). This improves efficiency of the “FAIL_BAD_INPUT” functionality. I said “should”, not “must” on purpose.

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: pyrosetta.rosetta.protocols.jd2.JobInputter) -> None
2. __init__(self: pyrosetta.rosetta.protocols.jd2.JobInputter, arg0: pyrosetta.rosetta.protocols.jd2.JobInputter) -> 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.jd2.JobInputter, : pyrosetta.rosetta.protocols.jd2.JobInputter) → pyrosetta.rosetta.protocols.jd2.JobInputter

C++: protocols::jd2::JobInputter::operator=(const class protocols::jd2::JobInputter &) –> class protocols::jd2::JobInputter &

fill_jobs(self: pyrosetta.rosetta.protocols.jd2.JobInputter, jobs: protocols::jd2::JobsContainer) → None

this function determines what jobs exist. This function neither knows nor

cares what jobs are already complete on disk/memory - it just figures out what ones should exist given the input. NOTE: your JobInputter should order Job objects in the Jobs vector to have as few “transitions” between inputs as possible (group all Jobs of the same input next to each other). This improves efficiency of the “FAIL_BAD_INPUT” functionality. Note I (Brave Sir Steven) said “should”, not “must”.

C++: protocols::jd2::JobInputter::fill_jobs(class protocols::jd2::JobsContainer &) –> void

get_self_ptr(self: pyrosetta.rosetta.protocols.jd2.JobInputter) → pyrosetta.rosetta.protocols.jd2.JobInputter

Get self owning pointers.

C++: protocols::jd2::JobInputter::get_self_ptr() –> class std::shared_ptr<class protocols::jd2::JobInputter>

get_self_weak_ptr(self: pyrosetta.rosetta.protocols.jd2.JobInputter) → pyrosetta.rosetta.std.weak_ptr_protocols_jd2_JobInputter_t

Get self weak pointers.

C++: protocols::jd2::JobInputter::get_self_weak_ptr() –> class std::weak_ptr<class protocols::jd2::JobInputter>

input_source(self: pyrosetta.rosetta.protocols.jd2.JobInputter) → pyrosetta.rosetta.protocols.jd2.JobInputterInputSource.Enum

return the type of input source that the JobInputter is currently

using

C++: protocols::jd2::JobInputter::input_source() const –> enum protocols::jd2::JobInputterInputSource::Enum

job_inputter_input_source_to_string(source: pyrosetta.rosetta.protocols.jd2.JobInputterInputSource.Enum) → str

call this with input_source() to get the input source of a

particular job inputter

C++: protocols::jd2::JobInputter::job_inputter_input_source_to_string(enum protocols::jd2::JobInputterInputSource::Enum) –> std::string

pose_from_job(self: pyrosetta.rosetta.protocols.jd2.JobInputter, pose: pyrosetta.rosetta.core.pose.Pose, job: protocols::jd2::Job) → None

this function is responsible for returning the starting pose to use for

the input job. The Job object (within its InnerJob) contains a PoseCOP. This function needs to either create a new Pose from the InnerJob Pose or, on first demand of a pose from that InnerJob, instantiate the pose, hand off a COP to the InnerJob, and fill the reference.

C++: protocols::jd2::JobInputter::pose_from_job(class core::pose::Pose &, class std::shared_ptr<class protocols::jd2::Job>) –> void

update_jobs_list(self: pyrosetta.rosetta.protocols.jd2.JobInputter, jobs: protocols::jd2::JobsContainer) → None

This function is only called by certain JobInputters to update the jobs list after it has already been created.

An example case would be the LargeNstructJobInputter, which uses this function to load additional jobs after the first N have started to come back.

C++: protocols::jd2::JobInputter::update_jobs_list(class std::shared_ptr<class protocols::jd2::JobsContainer>) –> void

updates_jobs_list(self: pyrosetta.rosetta.protocols.jd2.JobInputter) → bool

Does this type of JobInputter update the jobs list?

False by default. Override this function in derived classes to make it true.

C++: protocols::jd2::JobInputter::updates_jobs_list() const –> bool

class pyrosetta.rosetta.protocols.jd2.JobInputterCreator

Bases: pybind11_builtins.pybind11_object

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

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: pyrosetta.rosetta.protocols.jd2.JobInputterCreator) -> None
2. __init__(self: pyrosetta.rosetta.protocols.jd2.JobInputterCreator, arg0: pyrosetta.rosetta.protocols.jd2.JobInputterCreator) -> 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.jd2.JobInputterCreator, : pyrosetta.rosetta.protocols.jd2.JobInputterCreator) → pyrosetta.rosetta.protocols.jd2.JobInputterCreator

C++: protocols::jd2::JobInputterCreator::operator=(const class protocols::jd2::JobInputterCreator &) –> class protocols::jd2::JobInputterCreator &

create_JobInputter(self: pyrosetta.rosetta.protocols.jd2.JobInputterCreator) → pyrosetta.rosetta.protocols.jd2.JobInputter

C++: protocols::jd2::JobInputterCreator::create_JobInputter() const –> class std::shared_ptr<class protocols::jd2::JobInputter>

keyname(self: pyrosetta.rosetta.protocols.jd2.JobInputterCreator) → str

C++: protocols::jd2::JobInputterCreator::keyname() const –> std::string

class pyrosetta.rosetta.protocols.jd2.JobOutputter

Bases: pybind11_builtins.pybind11_object

the JobOutputter class is responsible for dealing with output, as well as determining what jobs have already been output and what sort of name is associated with a job. Derived classes will be responsible for output such as PDBS, PDBS.tar.gz and silent files.

__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.jd2.JobOutputter) → None

__init_subclass__()

This method is called when a class is subclassed.

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

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

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

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

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

add_evaluation(self: pyrosetta.rosetta.protocols.jd2.JobOutputter, : pyrosetta.rosetta.protocols.evaluation.PoseEvaluator) → None

////////////////////////////// evaluator interface ////////////////////////////////////////////

C++: protocols::jd2::JobOutputter::add_evaluation(class std::shared_ptr<class protocols::evaluation::PoseEvaluator>) –> void

call_output_observers(self: pyrosetta.rosetta.protocols.jd2.JobOutputter, pose: pyrosetta.rosetta.core.pose.Pose, job: protocols::jd2::Job) → None

call all output_observers

C++: protocols::jd2::JobOutputter::call_output_observers(const class core::pose::Pose &, class std::shared_ptr<class protocols::jd2::Job>) const –> void

clear_evaluators(self: pyrosetta.rosetta.protocols.jd2.JobOutputter) → None

C++: protocols::jd2::JobOutputter::clear_evaluators() –> void

evaluate(self: pyrosetta.rosetta.protocols.jd2.JobOutputter, pose: pyrosetta.rosetta.core.pose.Pose, tag: str, pss: pyrosetta.rosetta.core.io.silent.SilentStruct) → None

C++: protocols::jd2::JobOutputter::evaluate(class core::pose::Pose &, class std::basic_string<char>, class core::io::silent::SilentStruct &) const –> void

evaluators(self: pyrosetta.rosetta.protocols.jd2.JobOutputter) → pyrosetta.rosetta.protocols.evaluation.MetaPoseEvaluator

C++: protocols::jd2::JobOutputter::evaluators() const –> class std::shared_ptr<const class protocols::evaluation::MetaPoseEvaluator>

file(self: pyrosetta.rosetta.protocols.jd2.JobOutputter, job: protocols::jd2::Job, data: str) → None

this function takes a string and writes it to disk (separately from Tracer output).

use some sort of extention option system - default .dat? .data?

C++: protocols::jd2::JobOutputter::file(class std::shared_ptr<const class protocols::jd2::Job>, const class std::basic_string<char> &) –> void

filename(self: pyrosetta.rosetta.protocols.jd2.JobOutputter, : protocols::jd2::Job) → str

C++: protocols::jd2::JobOutputter::filename(class std::shared_ptr<const class protocols::jd2::Job>) const –> std::string

final_pose(*args, **kwargs)

Overloaded function.

1. final_pose(self: pyrosetta.rosetta.protocols.jd2.JobOutputter, job: protocols::jd2::Job, pose: pyrosetta.rosetta.core.pose.Pose) -> None
2. final_pose(self: pyrosetta.rosetta.protocols.jd2.JobOutputter, job: protocols::jd2::Job, pose: pyrosetta.rosetta.core.pose.Pose, tag: str) -> None

this function outputs the final result of a job.

C++: protocols::jd2::JobOutputter::final_pose(class std::shared_ptr<class protocols::jd2::Job>, const class core::pose::Pose &, const class std::basic_string<char> &) –> void

flush(self: pyrosetta.rosetta.protocols.jd2.JobOutputter) → None

this function is meant to be redefined in child classes to allow for flushing of memory buffers.

Here’s the long version: The SilentFileJobOutputter wanted to buffer output, but needed to guaruntee that the output would be flushed at end of runtime. The original implementation was to A) bend over backward to ensure that the destructor was run (JobOutputter lives inside static JobDistributor, which was previously not destructed because it’s static) and B) flush the buffers in the destructor. This caused a problem because the buffer-flushing tried to use the Tracers, which had already been destructed…boom crash.

New solution: re-forbid use of destructors within the static JobDistributor system, and create a flush function to force this stuff out. So here it is:

C++: protocols::jd2::JobOutputter::flush() –> void

job_has_completed(self: pyrosetta.rosetta.protocols.jd2.JobOutputter, job: protocols::jd2::Job) → bool

this function is not used for output, but it belongs here since it needs to check

the same output locations as the class normally writes to. This class checks wherever output goes to see if the job’s expected output already exists (on disk or whatever). This is the most basic form of checkpointing.

C++: protocols::jd2::JobOutputter::job_has_completed(class std::shared_ptr<const class protocols::jd2::Job>) –> bool

other_pose(*args, **kwargs)

Overloaded function.

1. other_pose(self: pyrosetta.rosetta.protocols.jd2.JobOutputter, job: protocols::jd2::Job, pose: pyrosetta.rosetta.core.pose.Pose, tag: str) -> None
2. other_pose(self: pyrosetta.rosetta.protocols.jd2.JobOutputter, job: protocols::jd2::Job, pose: pyrosetta.rosetta.core.pose.Pose, tag: str, copy_count: int) -> None
3. other_pose(self: pyrosetta.rosetta.protocols.jd2.JobOutputter, job: protocols::jd2::Job, pose: pyrosetta.rosetta.core.pose.Pose, tag: str, copy_count: int, score_only: bool) -> None

this function is intended for saving mid-protocol poses; for example the final

centroid structure before the fullatom stage begins in a combined centroid / fullatom protocol.

C++: protocols::jd2::JobOutputter::other_pose(class std::shared_ptr<class protocols::jd2::Job>, const class core::pose::Pose &, const class std::basic_string<char> &, int, bool) –> void

output_name(self: pyrosetta.rosetta.protocols.jd2.JobOutputter, job: protocols::jd2::Job) → str

this is the master function for determining the unique output identifier for a

job - should this be defined in the base class?

C++: protocols::jd2::JobOutputter::output_name(class std::shared_ptr<const class protocols::jd2::Job>) –> std::string

set_defaults(self: pyrosetta.rosetta.protocols.jd2.JobOutputter) → None

C++: protocols::jd2::JobOutputter::set_defaults() –> void

set_evaluators(self: pyrosetta.rosetta.protocols.jd2.JobOutputter, : pyrosetta.rosetta.protocols.evaluation.MetaPoseEvaluator) → None

C++: protocols::jd2::JobOutputter::set_evaluators(const class protocols::evaluation::MetaPoseEvaluator &) –> void

starting_pose(self: pyrosetta.rosetta.protocols.jd2.JobOutputter, : pyrosetta.rosetta.core.pose.Pose) → None

optionally pass a starting (reference) pose to a JobOutputter for later comparison

purposes and/or as interface for initializing evaluators

C++: protocols::jd2::JobOutputter::starting_pose(const class core::pose::Pose &) –> void

class pyrosetta.rosetta.protocols.jd2.JobOutputterCreator

Bases: pybind11_builtins.pybind11_object

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

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: pyrosetta.rosetta.protocols.jd2.JobOutputterCreator) -> None
2. __init__(self: pyrosetta.rosetta.protocols.jd2.JobOutputterCreator, arg0: pyrosetta.rosetta.protocols.jd2.JobOutputterCreator) -> 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.jd2.JobOutputterCreator, : pyrosetta.rosetta.protocols.jd2.JobOutputterCreator) → pyrosetta.rosetta.protocols.jd2.JobOutputterCreator

C++: protocols::jd2::JobOutputterCreator::operator=(const class protocols::jd2::JobOutputterCreator &) –> class protocols::jd2::JobOutputterCreator &

create_JobOutputter(self: pyrosetta.rosetta.protocols.jd2.JobOutputterCreator) → pyrosetta.rosetta.protocols.jd2.JobOutputter

C++: protocols::jd2::JobOutputterCreator::create_JobOutputter() const –> class std::shared_ptr<class protocols::jd2::JobOutputter>

keyname(self: pyrosetta.rosetta.protocols.jd2.JobOutputterCreator) → str

C++: protocols::jd2::JobOutputterCreator::keyname() const –> std::string

class pyrosetta.rosetta.protocols.jd2.JobsContainer

Bases: pybind11_builtins.pybind11_object

The JobsContainer class contains a list of JobsOPs. It permits the list to be versatile – for example, if one wishes to load only a subset of jobs into memory at any given time.

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

__getitem__(self: pyrosetta.rosetta.protocols.jd2.JobsContainer, index: int) → protocols::jd2::Job

Get a specific job, by number.

Should work even if jobs have been deleted, since this uses a map instead of an array.

C++: protocols::jd2::JobsContainer::operator[](const unsigned long) –> class std::shared_ptr<class protocols::jd2::Job>

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: pyrosetta.rosetta.protocols.jd2.JobsContainer) -> None
2. __init__(self: pyrosetta.rosetta.protocols.jd2.JobsContainer, arg0: pyrosetta.rosetta.protocols.jd2.JobsContainer) -> 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.jd2.JobsContainer, src: pyrosetta.rosetta.protocols.jd2.JobsContainer) → pyrosetta.rosetta.protocols.jd2.JobsContainer

Assignment operator.

C++: protocols::jd2::JobsContainer::operator=(const class protocols::jd2::JobsContainer &) –> class protocols::jd2::JobsContainer &

back(self: pyrosetta.rosetta.protocols.jd2.JobsContainer) → protocols::jd2::Job

Access the last element.

C++: protocols::jd2::JobsContainer::back() –> class std::shared_ptr<class protocols::jd2::Job>

can_be_deleted(self: pyrosetta.rosetta.protocols.jd2.JobsContainer, index: int) → bool

Can the job with the given index be deleted?

C++: protocols::jd2::JobsContainer::can_be_deleted(const unsigned long) const –> bool

clear(self: pyrosetta.rosetta.protocols.jd2.JobsContainer) → None

Clear the jobs list

C++: protocols::jd2::JobsContainer::clear() –> void

erase(self: pyrosetta.rosetta.protocols.jd2.JobsContainer, index: int) → None

Erase an element in the jobs list

C++: protocols::jd2::JobsContainer::erase(const unsigned long) –> void

force_job_purging(self: pyrosetta.rosetta.protocols.jd2.JobsContainer) → bool

Get whether or not this JobsContainer forces job purging when higher-numbered jobs are requested.

If true, and if a job inputter is used that limits the number of jobs in memory at any given time, then when a higher job index is requested than exists in memory, the JobsContainer will force job purging until that job exists in memory. If false (the default), then only deletable jobs will be purged, and the job inputter can attempt to add jobs up to the requested job (which might fail, if the requested job’s number is too high).

C++: protocols::jd2::JobsContainer::force_job_purging() const –> bool

get_loaded_job_indices(self: pyrosetta.rosetta.protocols.jd2.JobsContainer, output: pyrosetta.rosetta.utility.vector1_unsigned_long) → None

Get a list of job indices currently in memory.

The output vector is cleared and populated with the current job indices in memory.

C++: protocols::jd2::JobsContainer::get_loaded_job_indices(class utility::vector1<unsigned long, class std::allocator<unsigned long> > &) const –> void

get_self_ptr(self: pyrosetta.rosetta.protocols.jd2.JobsContainer) → pyrosetta.rosetta.protocols.jd2.JobsContainer

Get self owning pointers.

C++: protocols::jd2::JobsContainer::get_self_ptr() –> class std::shared_ptr<class protocols::jd2::JobsContainer>

has_job(self: pyrosetta.rosetta.protocols.jd2.JobsContainer, index: int) → bool

Does the job with the given index exist in the currently-loaded list of jobs?

C++: protocols::jd2::JobsContainer::has_job(const unsigned long) const –> bool

highest_job_index(self: pyrosetta.rosetta.protocols.jd2.JobsContainer) → int

Return the index of the highest job currently loaded in memory.

C++: protocols::jd2::JobsContainer::highest_job_index() const –> unsigned long

push_back(self: pyrosetta.rosetta.protocols.jd2.JobsContainer, new_job: protocols::jd2::Job) → None

Add a job to the list of jobs.

C++: protocols::jd2::JobsContainer::push_back(class std::shared_ptr<class protocols::jd2::Job>) –> void

set_all_current_jobs_as_deletable(self: pyrosetta.rosetta.protocols.jd2.JobsContainer) → None

Mark all jobs currently in memory as deletable.

This will result in all jobs being purged the next time a higher-index job is requeted.

C++: protocols::jd2::JobsContainer::set_all_current_jobs_as_deletable() –> void

set_force_job_purging(*args, **kwargs)

Overloaded function.

1. set_force_job_purging(self: pyrosetta.rosetta.protocols.jd2.JobsContainer) -> None
2. set_force_job_purging(self: pyrosetta.rosetta.protocols.jd2.JobsContainer, val: bool) -> None

Set whether or not this JobsContainer forces job purging when higher-numbered jobs are requested.

If true, and if a job inputter is used that limits the number of jobs in memory at any given time, then when a higher job index is requested than exists in memory, the JobsContainer will force job purging until that job exists in memory. If false (the default), then only deletable jobs will be purged, and the job inputter can attempt to add jobs up to the requested job (which might fail, if the requested job’s number is too high).

C++: protocols::jd2::JobsContainer::set_force_job_purging(const bool) –> void

set_job_inputter(self: pyrosetta.rosetta.protocols.jd2.JobsContainer, jobinputter: pyrosetta.rosetta.protocols.jd2.JobInputter) → None

Set the job inputter.

Needed if the job list is to be updated by the job inputter.

C++: protocols::jd2::JobsContainer::set_job_inputter(class std::shared_ptr<class protocols::jd2::JobInputter>) –> void

set_total_jobs(self: pyrosetta.rosetta.protocols.jd2.JobsContainer, total_jobs: int) → None

Set the total number of jobs.

This overrides whatever the length of the joblist_ is.

C++: protocols::jd2::JobsContainer::set_total_jobs(const unsigned long) –> void

shuffle(self: pyrosetta.rosetta.protocols.jd2.JobsContainer) → None

Randomize the order of elements (the map keys)

C++: protocols::jd2::JobsContainer::shuffle() –> void

size(self: pyrosetta.rosetta.protocols.jd2.JobsContainer) → int

Get the total number of jobs.

Might not be the number in the joblist_ map, if we’re only holding a subset in memory at any given time.

C++: protocols::jd2::JobsContainer::size() const –> unsigned long

class pyrosetta.rosetta.protocols.jd2.LargeNstructJobInputter

Bases: pyrosetta.rosetta.protocols.jd2.JobInputter

This is an implementation of JobInputter for cases where it’s not possible to list all jobs at once.

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: pyrosetta.rosetta.protocols.jd2.LargeNstructJobInputter) -> None
2. __init__(self: pyrosetta.rosetta.protocols.jd2.LargeNstructJobInputter, arg0: pyrosetta.rosetta.protocols.jd2.LargeNstructJobInputter) -> 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.jd2.LargeNstructJobInputter, : pyrosetta.rosetta.protocols.jd2.LargeNstructJobInputter) → pyrosetta.rosetta.protocols.jd2.LargeNstructJobInputter

C++: protocols::jd2::LargeNstructJobInputter::operator=(const class protocols::jd2::LargeNstructJobInputter &) –> class protocols::jd2::LargeNstructJobInputter &

fill_jobs(self: pyrosetta.rosetta.protocols.jd2.LargeNstructJobInputter, jobs: pyrosetta.rosetta.protocols.jd2.JobsContainer) → None

This function determines what jobs exist.

Unlike the GenericJobInputter, this version only ever has a subset of total jobs in

memory at any given time.

C++: protocols::jd2::LargeNstructJobInputter::fill_jobs(class protocols::jd2::JobsContainer &) –> void

get_self_ptr(self: pyrosetta.rosetta.protocols.jd2.JobInputter) → pyrosetta.rosetta.protocols.jd2.JobInputter

Get self owning pointers.

C++: protocols::jd2::JobInputter::get_self_ptr() –> class std::shared_ptr<class protocols::jd2::JobInputter>

get_self_weak_ptr(self: pyrosetta.rosetta.protocols.jd2.JobInputter) → pyrosetta.rosetta.std.weak_ptr_protocols_jd2_JobInputter_t

Get self weak pointers.

C++: protocols::jd2::JobInputter::get_self_weak_ptr() –> class std::weak_ptr<class protocols::jd2::JobInputter>

input_source(self: pyrosetta.rosetta.protocols.jd2.LargeNstructJobInputter) → pyrosetta.rosetta.protocols.jd2.JobInputterInputSource.Enum

Return the type of input source that the LargeNstructJobInputter is currently

using.

Always POSE.

C++: protocols::jd2::LargeNstructJobInputter::input_source() const –> enum protocols::jd2::JobInputterInputSource::Enum

job_inputter_input_source_to_string(source: pyrosetta.rosetta.protocols.jd2.JobInputterInputSource.Enum) → str

call this with input_source() to get the input source of a

particular job inputter

C++: protocols::jd2::JobInputter::job_inputter_input_source_to_string(enum protocols::jd2::JobInputterInputSource::Enum) –> std::string

pose_from_job(self: pyrosetta.rosetta.protocols.jd2.LargeNstructJobInputter, pose: pyrosetta.rosetta.core.pose.Pose, job: pyrosetta.rosetta.protocols.jd2.Job) → None

this function is responsible for filling the pose reference with

the pose indicated by the job. The Job object (within its InnerJob) contains a PoseCOP. This function needs to either fill the pose reference from the InnerJob or, on first demand of a pose from that InnerJob, instantiate the pose, hand off a COP to the InnerJob, and fill the reference.

C++: protocols::jd2::LargeNstructJobInputter::pose_from_job(class core::pose::Pose &, class std::shared_ptr<class protocols::jd2::Job>) –> void

update_jobs_list(self: pyrosetta.rosetta.protocols.jd2.LargeNstructJobInputter, jobs: pyrosetta.rosetta.protocols.jd2.JobsContainer) → None

This function is only called by certain JobInputters to update the jobs list after it has already been created.

An example case would be the LargeNstructJobInputter, which uses this function to load additional jobs after the first N have started to come back.

C++: protocols::jd2::LargeNstructJobInputter::update_jobs_list(class std::shared_ptr<class protocols::jd2::JobsContainer>) –> void

updates_jobs_list(self: pyrosetta.rosetta.protocols.jd2.LargeNstructJobInputter) → bool

Does this type of JobInputter update the jobs list?

False by default. Override this function in derived classes to make it true. The LargeNstructJobInputter overrides this, and returns true.

C++: protocols::jd2::LargeNstructJobInputter::updates_jobs_list() const –> bool

class pyrosetta.rosetta.protocols.jd2.MPIFileBufJobDistributor

Bases: pyrosetta.rosetta.protocols.jd2.JobDistributor

This JobDistributor is intended for machines where you have a large number of processors. two dedicated processes are used to handle JobDistribution and File-IO. all other processes (higher rank ) are used for computation. the file_buf_rank_ process runs the MpiFileBuffer which is at the receiving end of all ozstream output that is rerouted via MPI from the slave nodes. This means all slaves write to the same file without FileSystem congestion and interlacing in the file – IO is handled from a single dedicated process The other dedicated process (master_rank) runs the actual JobDistributor and is only used to distribute jobs to slaves and receive their notification of successful or failed execution in case you have only a small number of processors you can put say 10 MPI processes on 8 processors to get optimal CPU usage.

__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.jd2.MPIFileBufJobDistributor, arg0: pyrosetta.rosetta.protocols.jd2.MPIFileBufJobDistributor) → None

__init_subclass__()

This method is called when a class is subclassed.

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

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

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

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

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

add_batch(*args, **kwargs)

Overloaded function.

1. add_batch(self: pyrosetta.rosetta.protocols.jd2.JobDistributor, : str) -> None
2. add_batch(self: pyrosetta.rosetta.protocols.jd2.JobDistributor, : str, id: int) -> None

add a new batch ( name will be interpreted as flag_file )

C++: protocols::jd2::JobDistributor::add_batch(const class std::basic_string<char> &, unsigned long) –> void

assign(self: pyrosetta.rosetta.protocols.jd2.JobDistributor, : pyrosetta.rosetta.protocols.jd2.JobDistributor) → pyrosetta.rosetta.protocols.jd2.JobDistributor

C++: protocols::jd2::JobDistributor::operator=(const class protocols::jd2::JobDistributor &) –> class protocols::jd2::JobDistributor &

current_batch_id(self: pyrosetta.rosetta.protocols.jd2.JobDistributor) → int

what is the current batch number ? — refers to position in batches_

C++: protocols::jd2::JobDistributor::current_batch_id() const –> unsigned long

current_job(self: pyrosetta.rosetta.protocols.jd2.JobDistributor) → protocols::jd2::Job

Movers may ask their controlling job distributor for information about the current job.

They may also write information to this job for later output, though this use is now discouraged as the addition of the MultiplePoseMover now means that a single job may include several separate trajectories.

C++: protocols::jd2::JobDistributor::current_job() const –> class std::shared_ptr<class protocols::jd2::Job>

current_job_id(self: pyrosetta.rosetta.protocols.jd2.JobDistributor) → int

integer access - which job are we on?

C++: protocols::jd2::JobDistributor::current_job_id() const –> unsigned long

current_output_name(self: pyrosetta.rosetta.protocols.jd2.JobDistributor) → str

Movers may ask their controlling job distributor for the output name as defined by the Job and JobOutputter.

C++: protocols::jd2::JobDistributor::current_output_name() const –> std::string

get_current_batch(self: pyrosetta.rosetta.protocols.jd2.JobDistributor) → str

what is the current batch ? — name refers to the flag-file used for this batch

C++: protocols::jd2::JobDistributor::get_current_batch() const –> std::string

get_instance() → pyrosetta.rosetta.protocols.jd2.JobDistributor

C++: protocols::jd2::JobDistributor::get_instance() –> class protocols::jd2::JobDistributor *

get_new_job_id(self: pyrosetta.rosetta.protocols.jd2.MPIFileBufJobDistributor) → int

dummy for master/slave version

C++: protocols::jd2::MPIFileBufJobDistributor::get_new_job_id() –> unsigned long

go(self: pyrosetta.rosetta.protocols.jd2.MPIFileBufJobDistributor, mover: pyrosetta.rosetta.protocols.moves.Mover) → None

dummy for master/slave version

C++: protocols::jd2::MPIFileBufJobDistributor::go(class std::shared_ptr<class protocols::moves::Mover>) –> void

increment_client_rank(self: pyrosetta.rosetta.protocols.jd2.MPIFileBufJobDistributor) → int

C++: protocols::jd2::MPIFileBufJobDistributor::increment_client_rank() –> unsigned long

job_failed(self: pyrosetta.rosetta.protocols.jd2.MPIFileBufJobDistributor, pose: pyrosetta.rosetta.core.pose.Pose, will_retry: bool) → None

C++: protocols::jd2::MPIFileBufJobDistributor::job_failed(class core::pose::Pose &, bool) –> void

job_inputter(self: pyrosetta.rosetta.protocols.jd2.JobDistributor) → pyrosetta.rosetta.protocols.jd2.JobInputter

JobInputter access

C++: protocols::jd2::JobDistributor::job_inputter() const –> class std::shared_ptr<class protocols::jd2::JobInputter>

job_inputter_input_source(self: pyrosetta.rosetta.protocols.jd2.JobDistributor) → pyrosetta.rosetta.protocols.jd2.JobInputterInputSource.Enum

The input source for the current JobInputter.

C++: protocols::jd2::JobDistributor::job_inputter_input_source() const –> enum protocols::jd2::JobInputterInputSource::Enum

job_outputter(self: pyrosetta.rosetta.protocols.jd2.JobDistributor) → pyrosetta.rosetta.protocols.jd2.JobOutputter

Movers (or derived classes) may ask for the JobOutputter

C++: protocols::jd2::JobDistributor::job_outputter() const –> class std::shared_ptr<class protocols::jd2::JobOutputter>

job_succeeded(self: pyrosetta.rosetta.protocols.jd2.MPIFileBufJobDistributor, pose: pyrosetta.rosetta.core.pose.Pose, runtime: float, tag: str) → None

dummy for master/slave version

C++: protocols::jd2::MPIFileBufJobDistributor::job_succeeded(class core::pose::Pose &, double, const class std::basic_string<char> &) –> void

mark_current_job_id_for_repetition(self: pyrosetta.rosetta.protocols.jd2.MPIFileBufJobDistributor) → None

dummy for master/slave version

C++: protocols::jd2::MPIFileBufJobDistributor::mark_current_job_id_for_repetition() –> void

min_client_rank(self: pyrosetta.rosetta.protocols.jd2.MPIFileBufJobDistributor) → int

return rank of first worker process (there might be more dedicated processes, e.g., ArchiveManager…)

C++: protocols::jd2::MPIFileBufJobDistributor::min_client_rank() const –> unsigned long

mpi_finalize(self: pyrosetta.rosetta.protocols.jd2.JobDistributor, finalize: bool) → None

should the go() function call MPI_finalize()? It probably should, this is true by default.

C++: protocols::jd2::JobDistributor::mpi_finalize(bool) –> void

remove_bad_inputs_from_job_list(self: pyrosetta.rosetta.protocols.jd2.MPIFileBufJobDistributor) → None

dummy for master/slave version

C++: protocols::jd2::MPIFileBufJobDistributor::remove_bad_inputs_from_job_list() –> void

restart(self: pyrosetta.rosetta.protocols.jd2.JobDistributor) → None

C++: protocols::jd2::JobDistributor::restart() –> void

set_job_inputter(self: pyrosetta.rosetta.protocols.jd2.JobDistributor, new_job_inputter: pyrosetta.rosetta.protocols.jd2.JobInputter) → None

Set the JobInputter and reset the Job list – this is not something you want to do

after go() has been called, but before it has returned.

C++: protocols::jd2::JobDistributor::set_job_inputter(class std::shared_ptr<class protocols::jd2::JobInputter>) –> void

set_job_outputter(self: pyrosetta.rosetta.protocols.jd2.JobDistributor, new_job_outputter: pyrosetta.rosetta.protocols.jd2.JobOutputter) → None

Movers (or derived classes) may ask for the JobOutputter

C++: protocols::jd2::JobDistributor::set_job_outputter(const class std::shared_ptr<class protocols::jd2::JobOutputter> &) –> void

total_nr_jobs(self: pyrosetta.rosetta.protocols.jd2.JobDistributor) → int

C++: protocols::jd2::JobDistributor::total_nr_jobs() const –> unsigned long

class pyrosetta.rosetta.protocols.jd2.MPIMultiCommJobDistributor

Bases: pyrosetta.rosetta.protocols.jd2.MPIFileBufJobDistributor

This JobDistributor is intended for JD2 controlled runs of multiple parallel simulations that use multiple replicas: e.g., N trajectories of M replicas on N*M+2 processes. (2 processes for central JD2 and MPIFileBuf ) derived from MPIFileBufJobDistributor: two dedicated processes are used to handle JobDistribution and File-IO. all other processes (higher rank ) are used for computation.

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

Initialize self. See help(type(self)) for accurate signature.

__init_subclass__()

This method is called when a class is subclassed.

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

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

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

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

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

add_batch(*args, **kwargs)

Overloaded function.

1. add_batch(self: pyrosetta.rosetta.protocols.jd2.JobDistributor, : str) -> None
2. add_batch(self: pyrosetta.rosetta.protocols.jd2.JobDistributor, : str, id: int) -> None

add a new batch ( name will be interpreted as flag_file )

C++: protocols::jd2::JobDistributor::add_batch(const class std::basic_string<char> &, unsigned long) –> void

assign(self: pyrosetta.rosetta.protocols.jd2.JobDistributor, : pyrosetta.rosetta.protocols.jd2.JobDistributor) → pyrosetta.rosetta.protocols.jd2.JobDistributor

C++: protocols::jd2::JobDistributor::operator=(const class protocols::jd2::JobDistributor &) –> class protocols::jd2::JobDistributor &

current_batch_id(self: pyrosetta.rosetta.protocols.jd2.JobDistributor) → int

what is the current batch number ? — refers to position in batches_

C++: protocols::jd2::JobDistributor::current_batch_id() const –> unsigned long

current_job(self: pyrosetta.rosetta.protocols.jd2.JobDistributor) → protocols::jd2::Job

Movers may ask their controlling job distributor for information about the current job.

They may also write information to this job for later output, though this use is now discouraged as the addition of the MultiplePoseMover now means that a single job may include several separate trajectories.

C++: protocols::jd2::JobDistributor::current_job() const –> class std::shared_ptr<class protocols::jd2::Job>

current_job_id(self: pyrosetta.rosetta.protocols.jd2.JobDistributor) → int

integer access - which job are we on?

C++: protocols::jd2::JobDistributor::current_job_id() const –> unsigned long

current_output_name(self: pyrosetta.rosetta.protocols.jd2.JobDistributor) → str

Movers may ask their controlling job distributor for the output name as defined by the Job and JobOutputter.

C++: protocols::jd2::JobDistributor::current_output_name() const –> std::string

get_current_batch(self: pyrosetta.rosetta.protocols.jd2.JobDistributor) → str

what is the current batch ? — name refers to the flag-file used for this batch

C++: protocols::jd2::JobDistributor::get_current_batch() const –> std::string

get_instance() → pyrosetta.rosetta.protocols.jd2.JobDistributor

C++: protocols::jd2::JobDistributor::get_instance() –> class protocols::jd2::JobDistributor *

get_new_job_id(self: pyrosetta.rosetta.protocols.jd2.MPIMultiCommJobDistributor) → int

dummy for master/slave version

C++: protocols::jd2::MPIMultiCommJobDistributor::get_new_job_id() –> unsigned long

go(self: pyrosetta.rosetta.protocols.jd2.MPIFileBufJobDistributor, mover: pyrosetta.rosetta.protocols.moves.Mover) → None

dummy for master/slave version

C++: protocols::jd2::MPIFileBufJobDistributor::go(class std::shared_ptr<class protocols::moves::Mover>) –> void

increment_client_rank(self: pyrosetta.rosetta.protocols.jd2.MPIFileBufJobDistributor) → int

C++: protocols::jd2::MPIFileBufJobDistributor::increment_client_rank() –> unsigned long

job_failed(self: pyrosetta.rosetta.protocols.jd2.MPIMultiCommJobDistributor, pose: pyrosetta.rosetta.core.pose.Pose, : bool) → None

overloaded to suppress message from higher-rank replicas

C++: protocols::jd2::MPIMultiCommJobDistributor::job_failed(class core::pose::Pose &, bool) –> void

job_inputter(self: pyrosetta.rosetta.protocols.jd2.JobDistributor) → pyrosetta.rosetta.protocols.jd2.JobInputter

JobInputter access

C++: protocols::jd2::JobDistributor::job_inputter() const –> class std::shared_ptr<class protocols::jd2::JobInputter>

job_inputter_input_source(self: pyrosetta.rosetta.protocols.jd2.JobDistributor) → pyrosetta.rosetta.protocols.jd2.JobInputterInputSource.Enum

The input source for the current JobInputter.

C++: protocols::jd2::JobDistributor::job_inputter_input_source() const –> enum protocols::jd2::JobInputterInputSource::Enum

job_outputter(self: pyrosetta.rosetta.protocols.jd2.JobDistributor) → pyrosetta.rosetta.protocols.jd2.JobOutputter

Movers (or derived classes) may ask for the JobOutputter

C++: protocols::jd2::JobDistributor::job_outputter() const –> class std::shared_ptr<class protocols::jd2::JobOutputter>

job_succeeded(self: pyrosetta.rosetta.protocols.jd2.MPIMultiCommJobDistributor, pose: pyrosetta.rosetta.core.pose.Pose, run_timei: float, tag: str) → None

overloaded to suppress message from higher-rank replicas

C++: protocols::jd2::MPIMultiCommJobDistributor::job_succeeded(class core::pose::Pose &, double, const class std::basic_string<char> &) –> void

mark_current_job_id_for_repetition(self: pyrosetta.rosetta.protocols.jd2.MPIFileBufJobDistributor) → None

dummy for master/slave version

C++: protocols::jd2::MPIFileBufJobDistributor::mark_current_job_id_for_repetition() –> void

min_client_rank(self: pyrosetta.rosetta.protocols.jd2.MPIFileBufJobDistributor) → int

return rank of first worker process (there might be more dedicated processes, e.g., ArchiveManager…)

C++: protocols::jd2::MPIFileBufJobDistributor::min_client_rank() const –> unsigned long

mpi_finalize(self: pyrosetta.rosetta.protocols.jd2.JobDistributor, finalize: bool) → None

should the go() function call MPI_finalize()? It probably should, this is true by default.

C++: protocols::jd2::JobDistributor::mpi_finalize(bool) –> void

remove_bad_inputs_from_job_list(self: pyrosetta.rosetta.protocols.jd2.MPIFileBufJobDistributor) → None

dummy for master/slave version

C++: protocols::jd2::MPIFileBufJobDistributor::remove_bad_inputs_from_job_list() –> void

restart(self: pyrosetta.rosetta.protocols.jd2.JobDistributor) → None

C++: protocols::jd2::JobDistributor::restart() –> void

set_job_inputter(self: pyrosetta.rosetta.protocols.jd2.JobDistributor, new_job_inputter: pyrosetta.rosetta.protocols.jd2.JobInputter) → None

Set the JobInputter and reset the Job list – this is not something you want to do

after go() has been called, but before it has returned.

C++: protocols::jd2::JobDistributor::set_job_inputter(class std::shared_ptr<class protocols::jd2::JobInputter>) –> void

set_job_outputter(self: pyrosetta.rosetta.protocols.jd2.JobDistributor, new_job_outputter: pyrosetta.rosetta.protocols.jd2.JobOutputter) → None

Movers (or derived classes) may ask for the JobOutputter

C++: protocols::jd2::JobDistributor::set_job_outputter(const class std::shared_ptr<class protocols::jd2::JobOutputter> &) –> void

sub_rank(self: pyrosetta.rosetta.protocols.jd2.MPIMultiCommJobDistributor) → int

C++: protocols::jd2::MPIMultiCommJobDistributor::sub_rank() –> unsigned long

total_nr_jobs(self: pyrosetta.rosetta.protocols.jd2.JobDistributor) → int

C++: protocols::jd2::JobDistributor::total_nr_jobs() const –> unsigned long

class pyrosetta.rosetta.protocols.jd2.MPIWorkPartitionJobDistributor

Bases: pyrosetta.rosetta.protocols.jd2.JobDistributor

This job distributor is meant for running jobs where the number of jobs is equal to the number of processors (or, similarly, the jobs % processors calculation is very close to the number of processors and NOT a small number). It will blindly divide up jobs across processors and then start running them; it will NOT attempt load-balancing by giving more jobs to the processors that finished their original jobs. This is intended for use on smaller numbers of processors, and/or where the jobs are known to be equal in runtime. (The WorkPool implementation is meant for when runtimes are uncertain, or you have many many processors). It does not “waste” a processor as a master node, instead all processors run jobs.

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

Initialize self. See help(type(self)) for accurate signature.

__init_subclass__()

This method is called when a class is subclassed.

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

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

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

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

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

add_batch(*args, **kwargs)

Overloaded function.

1. add_batch(self: pyrosetta.rosetta.protocols.jd2.JobDistributor, : str) -> None
2. add_batch(self: pyrosetta.rosetta.protocols.jd2.JobDistributor, : str, id: int) -> None

add a new batch ( name will be interpreted as flag_file )

C++: protocols::jd2::JobDistributor::add_batch(const class std::basic_string<char> &, unsigned long) –> void

assign(self: pyrosetta.rosetta.protocols.jd2.MPIWorkPartitionJobDistributor, : pyrosetta.rosetta.protocols.jd2.MPIWorkPartitionJobDistributor) → pyrosetta.rosetta.protocols.jd2.MPIWorkPartitionJobDistributor

C++: protocols::jd2::MPIWorkPartitionJobDistributor::operator=(const class protocols::jd2::MPIWorkPartitionJobDistributor &) –> class protocols::jd2::MPIWorkPartitionJobDistributor &

current_batch_id(self: pyrosetta.rosetta.protocols.jd2.JobDistributor) → int

what is the current batch number ? — refers to position in batches_

C++: protocols::jd2::JobDistributor::current_batch_id() const –> unsigned long

current_job(self: pyrosetta.rosetta.protocols.jd2.JobDistributor) → protocols::jd2::Job

Movers may ask their controlling job distributor for information about the current job.

They may also write information to this job for later output, though this use is now discouraged as the addition of the MultiplePoseMover now means that a single job may include several separate trajectories.

C++: protocols::jd2::JobDistributor::current_job() const –> class std::shared_ptr<class protocols::jd2::Job>

current_job_id(self: pyrosetta.rosetta.protocols.jd2.JobDistributor) → int

integer access - which job are we on?

C++: protocols::jd2::JobDistributor::current_job_id() const –> unsigned long

current_output_name(self: pyrosetta.rosetta.protocols.jd2.JobDistributor) → str

Movers may ask their controlling job distributor for the output name as defined by the Job and JobOutputter.

C++: protocols::jd2::JobDistributor::current_output_name() const –> std::string

get_current_batch(self: pyrosetta.rosetta.protocols.jd2.JobDistributor) → str

what is the current batch ? — name refers to the flag-file used for this batch

C++: protocols::jd2::JobDistributor::get_current_batch() const –> std::string

get_instance() → pyrosetta.rosetta.protocols.jd2.JobDistributor

C++: protocols::jd2::JobDistributor::get_instance() –> class protocols::jd2::JobDistributor *

get_new_job_id(self: pyrosetta.rosetta.protocols.jd2.MPIWorkPartitionJobDistributor) → int

C++: protocols::jd2::MPIWorkPartitionJobDistributor::get_new_job_id() –> unsigned long

go(self: pyrosetta.rosetta.protocols.jd2.MPIWorkPartitionJobDistributor, mover: pyrosetta.rosetta.protocols.moves.Mover) → None

C++: protocols::jd2::MPIWorkPartitionJobDistributor::go(class std::shared_ptr<class protocols::moves::Mover>) –> void

job_inputter(self: pyrosetta.rosetta.protocols.jd2.JobDistributor) → pyrosetta.rosetta.protocols.jd2.JobInputter

JobInputter access

C++: protocols::jd2::JobDistributor::job_inputter() const –> class std::shared_ptr<class protocols::jd2::JobInputter>

job_inputter_input_source(self: pyrosetta.rosetta.protocols.jd2.JobDistributor) → pyrosetta.rosetta.protocols.jd2.JobInputterInputSource.Enum

The input source for the current JobInputter.

C++: protocols::jd2::JobDistributor::job_inputter_input_source() const –> enum protocols::jd2::JobInputterInputSource::Enum

job_outputter(self: pyrosetta.rosetta.protocols.jd2.JobDistributor) → pyrosetta.rosetta.protocols.jd2.JobOutputter

Movers (or derived classes) may ask for the JobOutputter

C++: protocols::jd2::JobDistributor::job_outputter() const –> class std::shared_ptr<class protocols::jd2::JobOutputter>

mark_current_job_id_for_repetition(self: pyrosetta.rosetta.protocols.jd2.MPIWorkPartitionJobDistributor) → None

C++: protocols::jd2::MPIWorkPartitionJobDistributor::mark_current_job_id_for_repetition() –> void

mpi_finalize(self: pyrosetta.rosetta.protocols.jd2.JobDistributor, finalize: bool) → None

should the go() function call MPI_finalize()? It probably should, this is true by default.

C++: protocols::jd2::JobDistributor::mpi_finalize(bool) –> void

remove_bad_inputs_from_job_list(self: pyrosetta.rosetta.protocols.jd2.MPIWorkPartitionJobDistributor) → None

C++: protocols::jd2::MPIWorkPartitionJobDistributor::remove_bad_inputs_from_job_list() –> void

restart(self: pyrosetta.rosetta.protocols.jd2.JobDistributor) → None

C++: protocols::jd2::JobDistributor::restart() –> void

set_job_inputter(self: pyrosetta.rosetta.protocols.jd2.JobDistributor, new_job_inputter: pyrosetta.rosetta.protocols.jd2.JobInputter) → None

Set the JobInputter and reset the Job list – this is not something you want to do

after go() has been called, but before it has returned.

C++: protocols::jd2::JobDistributor::set_job_inputter(class std::shared_ptr<class protocols::jd2::JobInputter>) –> void

set_job_outputter(self: pyrosetta.rosetta.protocols.jd2.JobDistributor, new_job_outputter: pyrosetta.rosetta.protocols.jd2.JobOutputter) → None

Movers (or derived classes) may ask for the JobOutputter

C++: protocols::jd2::JobDistributor::set_job_outputter(const class std::shared_ptr<class protocols::jd2::JobOutputter> &) –> void

total_nr_jobs(self: pyrosetta.rosetta.protocols.jd2.JobDistributor) → int

C++: protocols::jd2::JobDistributor::total_nr_jobs() const –> unsigned long

class pyrosetta.rosetta.protocols.jd2.MPIWorkPoolJobDistributor

Bases: pyrosetta.rosetta.protocols.jd2.JobDistributor

This job distributor is meant for running jobs where the machine you are using has a large number of processors, the number of jobs is much greater than the number of processors, or the runtimes of the individual jobs could vary greatly. It dedicates the head node (whichever processor gets processor rank #0) to handling job requests from the slave nodes (all nonzero ranks). Unlike the MPIWorkPartitionJobDistributor, this JD will not work at all without MPI and the implementations of all but the interface functions have been put inside of ifdef directives. Generally each function has a master and slave version, and the interface functions call one or the other depending on processor rank.

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

Initialize self. See help(type(self)) for accurate signature.

__init_subclass__()

This method is called when a class is subclassed.

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

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

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

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

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

add_batch(*args, **kwargs)

Overloaded function.

1. add_batch(self: pyrosetta.rosetta.protocols.jd2.JobDistributor, : str) -> None
2. add_batch(self: pyrosetta.rosetta.protocols.jd2.JobDistributor, : str, id: int) -> None

add a new batch ( name will be interpreted as flag_file )

C++: protocols::jd2::JobDistributor::add_batch(const class std::basic_string<char> &, unsigned long) –> void

assign(self: pyrosetta.rosetta.protocols.jd2.MPIWorkPoolJobDistributor, : pyrosetta.rosetta.protocols.jd2.MPIWorkPoolJobDistributor) → pyrosetta.rosetta.protocols.jd2.MPIWorkPoolJobDistributor

C++: protocols::jd2::MPIWorkPoolJobDistributor::operator=(const class protocols::jd2::MPIWorkPoolJobDistributor &) –> class protocols::jd2::MPIWorkPoolJobDistributor &

current_batch_id(self: pyrosetta.rosetta.protocols.jd2.JobDistributor) → int

what is the current batch number ? — refers to position in batches_

C++: protocols::jd2::JobDistributor::current_batch_id() const –> unsigned long

current_job(self: pyrosetta.rosetta.protocols.jd2.JobDistributor) → protocols::jd2::Job

Movers may ask their controlling job distributor for information about the current job.

They may also write information to this job for later output, though this use is now discouraged as the addition of the MultiplePoseMover now means that a single job may include several separate trajectories.

C++: protocols::jd2::JobDistributor::current_job() const –> class std::shared_ptr<class protocols::jd2::Job>

current_job_id(self: pyrosetta.rosetta.protocols.jd2.JobDistributor) → int

integer access - which job are we on?

C++: protocols::jd2::JobDistributor::current_job_id() const –> unsigned long

current_output_name(self: pyrosetta.rosetta.protocols.jd2.JobDistributor) → str

Movers may ask their controlling job distributor for the output name as defined by the Job and JobOutputter.

C++: protocols::jd2::JobDistributor::current_output_name() const –> std::string

get_current_batch(self: pyrosetta.rosetta.protocols.jd2.JobDistributor) → str

what is the current batch ? — name refers to the flag-file used for this batch

C++: protocols::jd2::JobDistributor::get_current_batch() const –> std::string

get_instance() → pyrosetta.rosetta.protocols.jd2.JobDistributor

C++: protocols::jd2::JobDistributor::get_instance() –> class protocols::jd2::JobDistributor *

get_new_job_id(self: pyrosetta.rosetta.protocols.jd2.MPIWorkPoolJobDistributor) → int

dummy for master/slave version

C++: protocols::jd2::MPIWorkPoolJobDistributor::get_new_job_id() –> unsigned long

go(self: pyrosetta.rosetta.protocols.jd2.MPIWorkPoolJobDistributor, mover: pyrosetta.rosetta.protocols.moves.Mover) → None

dummy for master/slave version

C++: protocols::jd2::MPIWorkPoolJobDistributor::go(class std::shared_ptr<class protocols::moves::Mover>) –> void

job_failed(self: pyrosetta.rosetta.protocols.jd2.MPIWorkPoolJobDistributor, pose: pyrosetta.rosetta.core.pose.Pose, will_retry: bool) → None

Called if job fails.

C++: protocols::jd2::MPIWorkPoolJobDistributor::job_failed(class core::pose::Pose &, bool) –> void

job_inputter(self: pyrosetta.rosetta.protocols.jd2.JobDistributor) → pyrosetta.rosetta.protocols.jd2.JobInputter

JobInputter access

C++: protocols::jd2::JobDistributor::job_inputter() const –> class std::shared_ptr<class protocols::jd2::JobInputter>

job_inputter_input_source(self: pyrosetta.rosetta.protocols.jd2.JobDistributor) → pyrosetta.rosetta.protocols.jd2.JobInputterInputSource.Enum

The input source for the current JobInputter.

C++: protocols::jd2::JobDistributor::job_inputter_input_source() const –> enum protocols::jd2::JobInputterInputSource::Enum

job_outputter(self: pyrosetta.rosetta.protocols.jd2.JobDistributor) → pyrosetta.rosetta.protocols.jd2.JobOutputter

Movers (or derived classes) may ask for the JobOutputter

C++: protocols::jd2::JobDistributor::job_outputter() const –> class std::shared_ptr<class protocols::jd2::JobOutputter>

job_succeeded(self: pyrosetta.rosetta.protocols.jd2.MPIWorkPoolJobDistributor, pose: pyrosetta.rosetta.core.pose.Pose, run_time: float, tag: str) → None

dummy for master/slave version

C++: protocols::jd2::MPIWorkPoolJobDistributor::job_succeeded(class core::pose::Pose &, double, const class std::basic_string<char> &) –> void

mark_current_job_id_for_repetition(self: pyrosetta.rosetta.protocols.jd2.MPIWorkPoolJobDistributor) → None

dummy for master/slave version

C++: protocols::jd2::MPIWorkPoolJobDistributor::mark_current_job_id_for_repetition() –> void

mpi_finalize(self: pyrosetta.rosetta.protocols.jd2.MPIWorkPoolJobDistributor, finalize: bool) → None

should the go() function call MPI_finalize()? It probably should, this is true by default.

C++: protocols::jd2::MPIWorkPoolJobDistributor::mpi_finalize(bool) –> void

remove_bad_inputs_from_job_list(self: pyrosetta.rosetta.protocols.jd2.MPIWorkPoolJobDistributor) → None

dummy for master/slave version

C++: protocols::jd2::MPIWorkPoolJobDistributor::remove_bad_inputs_from_job_list() –> void

restart(self: pyrosetta.rosetta.protocols.jd2.JobDistributor) → None

C++: protocols::jd2::JobDistributor::restart() –> void

set_job_inputter(self: pyrosetta.rosetta.protocols.jd2.JobDistributor, new_job_inputter: pyrosetta.rosetta.protocols.jd2.JobInputter) → None

Set the JobInputter and reset the Job list – this is not something you want to do

after go() has been called, but before it has returned.

C++: protocols::jd2::JobDistributor::set_job_inputter(class std::shared_ptr<class protocols::jd2::JobInputter>) –> void

set_job_outputter(self: pyrosetta.rosetta.protocols.jd2.JobDistributor, new_job_outputter: pyrosetta.rosetta.protocols.jd2.JobOutputter) → None

Movers (or derived classes) may ask for the JobOutputter

C++: protocols::jd2::JobDistributor::set_job_outputter(const class std::shared_ptr<class protocols::jd2::JobOutputter> &) –> void

total_nr_jobs(self: pyrosetta.rosetta.protocols.jd2.JobDistributor) → int

C++: protocols::jd2::JobDistributor::total_nr_jobs() const –> unsigned long

class pyrosetta.rosetta.protocols.jd2.NoOutputJobOutputter

Bases: pyrosetta.rosetta.protocols.jd2.JobOutputter

the NoOutputJobOutputter class is responsible for NOT dealing with output

__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.jd2.NoOutputJobOutputter) → None

__init_subclass__()

This method is called when a class is subclassed.

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

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

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

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

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

add_evaluation(self: pyrosetta.rosetta.protocols.jd2.JobOutputter, : pyrosetta.rosetta.protocols.evaluation.PoseEvaluator) → None

////////////////////////////// evaluator interface ////////////////////////////////////////////

C++: protocols::jd2::JobOutputter::add_evaluation(class std::shared_ptr<class protocols::evaluation::PoseEvaluator>) –> void

call_output_observers(self: pyrosetta.rosetta.protocols.jd2.JobOutputter, pose: pyrosetta.rosetta.core.pose.Pose, job: protocols::jd2::Job) → None

call all output_observers

C++: protocols::jd2::JobOutputter::call_output_observers(const class core::pose::Pose &, class std::shared_ptr<class protocols::jd2::Job>) const –> void

clear_evaluators(self: pyrosetta.rosetta.protocols.jd2.JobOutputter) → None

C++: protocols::jd2::JobOutputter::clear_evaluators() –> void

evaluate(self: pyrosetta.rosetta.protocols.jd2.JobOutputter, pose: pyrosetta.rosetta.core.pose.Pose, tag: str, pss: pyrosetta.rosetta.core.io.silent.SilentStruct) → None

C++: protocols::jd2::JobOutputter::evaluate(class core::pose::Pose &, class std::basic_string<char>, class core::io::silent::SilentStruct &) const –> void

evaluators(self: pyrosetta.rosetta.protocols.jd2.JobOutputter) → pyrosetta.rosetta.protocols.evaluation.MetaPoseEvaluator

C++: protocols::jd2::JobOutputter::evaluators() const –> class std::shared_ptr<const class protocols::evaluation::MetaPoseEvaluator>

file(self: pyrosetta.rosetta.protocols.jd2.NoOutputJobOutputter, : pyrosetta.rosetta.protocols.jd2.Job, : str) → None

this function takes a string and writes it to disk (separately from Tracer output). use some sort of extention option system - default .dat? .data?

C++: protocols::jd2::NoOutputJobOutputter::file(class std::shared_ptr<const class protocols::jd2::Job>, const class std::basic_string<char> &) –> void

filename(self: pyrosetta.rosetta.protocols.jd2.JobOutputter, : protocols::jd2::Job) → str

C++: protocols::jd2::JobOutputter::filename(class std::shared_ptr<const class protocols::jd2::Job>) const –> std::string

final_pose(self: pyrosetta.rosetta.protocols.jd2.NoOutputJobOutputter, : pyrosetta.rosetta.protocols.jd2.Job, : pyrosetta.rosetta.core.pose.Pose, : str) → None

this function outputs the final result of a job.

C++: protocols::jd2::NoOutputJobOutputter::final_pose(class std::shared_ptr<class protocols::jd2::Job>, const class core::pose::Pose &, const class std::basic_string<char> &) –> void

flush(self: pyrosetta.rosetta.protocols.jd2.JobOutputter) → None

this function is meant to be redefined in child classes to allow for flushing of memory buffers.

Here’s the long version: The SilentFileJobOutputter wanted to buffer output, but needed to guaruntee that the output would be flushed at end of runtime. The original implementation was to A) bend over backward to ensure that the destructor was run (JobOutputter lives inside static JobDistributor, which was previously not destructed because it’s static) and B) flush the buffers in the destructor. This caused a problem because the buffer-flushing tried to use the Tracers, which had already been destructed…boom crash.

New solution: re-forbid use of destructors within the static JobDistributor system, and create a flush function to force this stuff out. So here it is:

C++: protocols::jd2::JobOutputter::flush() –> void

job_has_completed(self: pyrosetta.rosetta.protocols.jd2.NoOutputJobOutputter, : pyrosetta.rosetta.protocols.jd2.Job) → bool

this function is not used for output, but it belongs here since it needs to check the same output locations as the class normally writes to. This class checks wherever output goes to see if the job’s expected output already exists (on disk or whatever). This is the most basic form of checkpointing.

C++: protocols::jd2::NoOutputJobOutputter::job_has_completed(class std::shared_ptr<const class protocols::jd2::Job>) –> bool

other_pose(self: pyrosetta.rosetta.protocols.jd2.NoOutputJobOutputter, : pyrosetta.rosetta.protocols.jd2.Job, : pyrosetta.rosetta.core.pose.Pose, : str, : int, : bool) → None

this function is intended for saving mid-protocol poses; for example the final centroid structure in a combined centroid/fullatom protocol.

C++: protocols::jd2::NoOutputJobOutputter::other_pose(class std::shared_ptr<class protocols::jd2::Job>, const class core::pose::Pose &, const class std::basic_string<char> &, int, bool) –> void

output_name(self: pyrosetta.rosetta.protocols.jd2.NoOutputJobOutputter, job: pyrosetta.rosetta.protocols.jd2.Job) → str

C++: protocols::jd2::NoOutputJobOutputter::output_name(class std::shared_ptr<const class protocols::jd2::Job>) –> std::string

set_defaults(self: pyrosetta.rosetta.protocols.jd2.JobOutputter) → None

C++: protocols::jd2::JobOutputter::set_defaults() –> void

set_evaluators(self: pyrosetta.rosetta.protocols.jd2.JobOutputter, : pyrosetta.rosetta.protocols.evaluation.MetaPoseEvaluator) → None

C++: protocols::jd2::JobOutputter::set_evaluators(const class protocols::evaluation::MetaPoseEvaluator &) –> void

starting_pose(self: pyrosetta.rosetta.protocols.jd2.JobOutputter, : pyrosetta.rosetta.core.pose.Pose) → None

optionally pass a starting (reference) pose to a JobOutputter for later comparison

purposes and/or as interface for initializing evaluators

C++: protocols::jd2::JobOutputter::starting_pose(const class core::pose::Pose &) –> void

class pyrosetta.rosetta.protocols.jd2.PDBJobInputter

Bases: pyrosetta.rosetta.protocols.jd2.JobInputter

This is the simplest implementation of JobInputter, which reads from -s/-l and PDB files.

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: pyrosetta.rosetta.protocols.jd2.PDBJobInputter) -> None
2. __init__(self: pyrosetta.rosetta.protocols.jd2.PDBJobInputter, arg0: pyrosetta.rosetta.protocols.jd2.PDBJobInputter) -> 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.jd2.PDBJobInputter, : pyrosetta.rosetta.protocols.jd2.PDBJobInputter) → pyrosetta.rosetta.protocols.jd2.PDBJobInputter

C++: protocols::jd2::PDBJobInputter::operator=(const class protocols::jd2::PDBJobInputter &) –> class protocols::jd2::PDBJobInputter &

fill_jobs(self: pyrosetta.rosetta.protocols.jd2.PDBJobInputter, jobs: pyrosetta.rosetta.protocols.jd2.JobsContainer) → None

this function determines what jobs exist from -s/-l

C++: protocols::jd2::PDBJobInputter::fill_jobs(class protocols::jd2::JobsContainer &) –> void

get_self_ptr(self: pyrosetta.rosetta.protocols.jd2.JobInputter) → pyrosetta.rosetta.protocols.jd2.JobInputter

Get self owning pointers.

C++: protocols::jd2::JobInputter::get_self_ptr() –> class std::shared_ptr<class protocols::jd2::JobInputter>

get_self_weak_ptr(self: pyrosetta.rosetta.protocols.jd2.JobInputter) → pyrosetta.rosetta.std.weak_ptr_protocols_jd2_JobInputter_t

Get self weak pointers.

C++: protocols::jd2::JobInputter::get_self_weak_ptr() –> class std::weak_ptr<class protocols::jd2::JobInputter>

input_source(self: pyrosetta.rosetta.protocols.jd2.PDBJobInputter) → pyrosetta.rosetta.protocols.jd2.JobInputterInputSource.Enum

Return the type of input source that the PDBJobInputter is currently

using.

Always PDB_FILE.

C++: protocols::jd2::PDBJobInputter::input_source() const –> enum protocols::jd2::JobInputterInputSource::Enum

job_inputter_input_source_to_string(source: pyrosetta.rosetta.protocols.jd2.JobInputterInputSource.Enum) → str

call this with input_source() to get the input source of a

particular job inputter

C++: protocols::jd2::JobInputter::job_inputter_input_source_to_string(enum protocols::jd2::JobInputterInputSource::Enum) –> std::string

pose_from_job(self: pyrosetta.rosetta.protocols.jd2.PDBJobInputter, pose: pyrosetta.rosetta.core.pose.Pose, job: protocols::jd2::Job) → None

this function is responsible for filling the pose reference with the pose indicated by the job. The Job object (within its InnerJob) contains a PoseCOP. This function needs to either fill the pose reference from the InnerJob or, on first demand of a pose from that InnerJob, instantiate the pose, hand off a COP to the InnerJob, and fill the reference. This implementation uses pose_from_pdb

C++: protocols::jd2::PDBJobInputter::pose_from_job(class core::pose::Pose &, class std::shared_ptr<class protocols::jd2::Job>) –> void

update_jobs_list(self: pyrosetta.rosetta.protocols.jd2.JobInputter, jobs: protocols::jd2::JobsContainer) → None

This function is only called by certain JobInputters to update the jobs list after it has already been created.

An example case would be the LargeNstructJobInputter, which uses this function to load additional jobs after the first N have started to come back.

C++: protocols::jd2::JobInputter::update_jobs_list(class std::shared_ptr<class protocols::jd2::JobsContainer>) –> void

updates_jobs_list(self: pyrosetta.rosetta.protocols.jd2.JobInputter) → bool

Does this type of JobInputter update the jobs list?

False by default. Override this function in derived classes to make it true.

C++: protocols::jd2::JobInputter::updates_jobs_list() const –> bool

class pyrosetta.rosetta.protocols.jd2.PDBJobOutputter

Bases: pyrosetta.rosetta.protocols.jd2.wwPDBJobOutputter

this simplest implementation of JobOutputter outputs raw PDBs and associated files, uncompressed.

__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.jd2.PDBJobOutputter) → None

__init_subclass__()

This method is called when a class is subclassed.

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

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

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

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

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

add_evaluation(self: pyrosetta.rosetta.protocols.jd2.JobOutputter, : pyrosetta.rosetta.protocols.evaluation.PoseEvaluator) → None

////////////////////////////// evaluator interface ////////////////////////////////////////////

C++: protocols::jd2::JobOutputter::add_evaluation(class std::shared_ptr<class protocols::evaluation::PoseEvaluator>) –> void

call_output_observers(self: pyrosetta.rosetta.protocols.jd2.JobOutputter, pose: pyrosetta.rosetta.core.pose.Pose, job: protocols::jd2::Job) → None

call all output_observers

C++: protocols::jd2::JobOutputter::call_output_observers(const class core::pose::Pose &, class std::shared_ptr<class protocols::jd2::Job>) const –> void

clear_evaluators(self: pyrosetta.rosetta.protocols.jd2.JobOutputter) → None

C++: protocols::jd2::JobOutputter::clear_evaluators() –> void

evaluate(self: pyrosetta.rosetta.protocols.jd2.JobOutputter, pose: pyrosetta.rosetta.core.pose.Pose, tag: str, pss: pyrosetta.rosetta.core.io.silent.SilentStruct) → None

C++: protocols::jd2::JobOutputter::evaluate(class core::pose::Pose &, class std::basic_string<char>, class core::io::silent::SilentStruct &) const –> void

evaluators(self: pyrosetta.rosetta.protocols.jd2.JobOutputter) → pyrosetta.rosetta.protocols.evaluation.MetaPoseEvaluator

C++: protocols::jd2::JobOutputter::evaluators() const –> class std::shared_ptr<const class protocols::evaluation::MetaPoseEvaluator>

file(self: pyrosetta.rosetta.protocols.jd2.FileJobOutputter, job: protocols::jd2::Job, data: str) → None

this function takes a string and writes it to disk (separately from Tracer output).

C++: protocols::jd2::FileJobOutputter::file(class std::shared_ptr<const class protocols::jd2::Job>, const class std::basic_string<char> &) –> void

filename(self: pyrosetta.rosetta.protocols.jd2.JobOutputter, : protocols::jd2::Job) → str

C++: protocols::jd2::JobOutputter::filename(class std::shared_ptr<const class protocols::jd2::Job>) const –> std::string

final_pose(self: pyrosetta.rosetta.protocols.jd2.wwPDBJobOutputter, job: protocols::jd2::Job, pose: pyrosetta.rosetta.core.pose.Pose, tag: str) → None

this function outputs the final result of a job. This implementation will write a wwPDB-format file (plus scores). It calls a pure virtual so that child classes can write PDB or mmCIF format.

C++: protocols::jd2::wwPDBJobOutputter::final_pose(class std::shared_ptr<class protocols::jd2::Job>, const class core::pose::Pose &, const class std::basic_string<char> &) –> void

flush(self: pyrosetta.rosetta.protocols.jd2.JobOutputter) → None

this function is meant to be redefined in child classes to allow for flushing of memory buffers.

Here’s the long version: The SilentFileJobOutputter wanted to buffer output, but needed to guaruntee that the output would be flushed at end of runtime. The original implementation was to A) bend over backward to ensure that the destructor was run (JobOutputter lives inside static JobDistributor, which was previously not destructed because it’s static) and B) flush the buffers in the destructor. This caused a problem because the buffer-flushing tried to use the Tracers, which had already been destructed…boom crash.

New solution: re-forbid use of destructors within the static JobDistributor system, and create a flush function to force this stuff out. So here it is:

C++: protocols::jd2::JobOutputter::flush() –> void

job_has_completed(self: pyrosetta.rosetta.protocols.jd2.wwPDBJobOutputter, job: protocols::jd2::Job) → bool

this function is not used for output, but it belongs here since it needs to check the same output locations as the class normally writes to. This class checks wherever output goes to see if the job’s expected output already exists (on disk or whatever). This is the most basic form of checkpointing. The base implementation looks for a pdb/cif with the job’s name already in existence.

C++: protocols::jd2::wwPDBJobOutputter::job_has_completed(class std::shared_ptr<const class protocols::jd2::Job>) –> bool

other_pose(*args, **kwargs)

Overloaded function.

1. other_pose(self: pyrosetta.rosetta.protocols.jd2.wwPDBJobOutputter, job: protocols::jd2::Job, pose: pyrosetta.rosetta.core.pose.Pose, tag: str) -> None
2. other_pose(self: pyrosetta.rosetta.protocols.jd2.wwPDBJobOutputter, job: protocols::jd2::Job, pose: pyrosetta.rosetta.core.pose.Pose, tag: str, copy_count: int) -> None
3. other_pose(self: pyrosetta.rosetta.protocols.jd2.wwPDBJobOutputter, job: protocols::jd2::Job, pose: pyrosetta.rosetta.core.pose.Pose, tag: str, copy_count: int, score_only: bool) -> None

this function is intended for saving mid-protocol poses; for example the final centroid structure in a combined centroid/fullatom protocol. This implementation will write a wwPDB-format file (plus scores). It calls a pure virtual so that child classes can write PDB or mmCIF format.

C++: protocols::jd2::wwPDBJobOutputter::other_pose(class std::shared_ptr<class protocols::jd2::Job>, const class core::pose::Pose &, const class std::basic_string<char> &, int, bool) –> void

output_name(self: pyrosetta.rosetta.protocols.jd2.wwPDBJobOutputter, job: protocols::jd2::Job) → str

this is the master function for determining the unique output identifier for a job

C++: protocols::jd2::wwPDBJobOutputter::output_name(class std::shared_ptr<const class protocols::jd2::Job>) –> std::string

scorefile_name(self: pyrosetta.rosetta.protocols.jd2.FileJobOutputter) → pyrosetta.rosetta.utility.file.FileName

C++: protocols::jd2::FileJobOutputter::scorefile_name() –> const class utility::file::FileName &

set_defaults(self: pyrosetta.rosetta.protocols.jd2.FileJobOutputter) → None

C++: protocols::jd2::FileJobOutputter::set_defaults() –> void

set_evaluators(self: pyrosetta.rosetta.protocols.jd2.JobOutputter, : pyrosetta.rosetta.protocols.evaluation.MetaPoseEvaluator) → None

C++: protocols::jd2::JobOutputter::set_evaluators(const class protocols::evaluation::MetaPoseEvaluator &) –> void

starting_pose(self: pyrosetta.rosetta.protocols.jd2.JobOutputter, : pyrosetta.rosetta.core.pose.Pose) → None

optionally pass a starting (reference) pose to a JobOutputter for later comparison

purposes and/or as interface for initializing evaluators

C++: protocols::jd2::JobOutputter::starting_pose(const class core::pose::Pose &) –> void

write_scorefile(self: pyrosetta.rosetta.protocols.jd2.FileJobOutputter) → bool

C++: protocols::jd2::FileJobOutputter::write_scorefile() const –> bool

class pyrosetta.rosetta.protocols.jd2.PoseInputStreamJobInputter

Bases: pyrosetta.rosetta.protocols.jd2.JobInputter

This is the simplest implementation of JobInputter, which reads from -s/-l and SilentFile files.

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: pyrosetta.rosetta.protocols.jd2.PoseInputStreamJobInputter) -> None
2. __init__(self: pyrosetta.rosetta.protocols.jd2.PoseInputStreamJobInputter, arg0: pyrosetta.rosetta.protocols.jd2.PoseInputStreamJobInputter) -> 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.jd2.PoseInputStreamJobInputter, : pyrosetta.rosetta.protocols.jd2.PoseInputStreamJobInputter) → pyrosetta.rosetta.protocols.jd2.PoseInputStreamJobInputter

C++: protocols::jd2::PoseInputStreamJobInputter::operator=(const class protocols::jd2::PoseInputStreamJobInputter &) –> class protocols::jd2::PoseInputStreamJobInputter &

fill_jobs(self: pyrosetta.rosetta.protocols.jd2.PoseInputStreamJobInputter, jobs: pyrosetta.rosetta.protocols.jd2.JobsContainer) → None

C++: protocols::jd2::PoseInputStreamJobInputter::fill_jobs(class protocols::jd2::JobsContainer &) –> void

get_self_ptr(self: pyrosetta.rosetta.protocols.jd2.JobInputter) → pyrosetta.rosetta.protocols.jd2.JobInputter

Get self owning pointers.

C++: protocols::jd2::JobInputter::get_self_ptr() –> class std::shared_ptr<class protocols::jd2::JobInputter>

get_self_weak_ptr(self: pyrosetta.rosetta.protocols.jd2.JobInputter) → pyrosetta.rosetta.std.weak_ptr_protocols_jd2_JobInputter_t

Get self weak pointers.

C++: protocols::jd2::JobInputter::get_self_weak_ptr() –> class std::weak_ptr<class protocols::jd2::JobInputter>

input_source(self: pyrosetta.rosetta.protocols.jd2.PoseInputStreamJobInputter) → pyrosetta.rosetta.protocols.jd2.JobInputterInputSource.Enum

Return the type of input source that the PoseInputStreamJobInputter is currently

using.

C++: protocols::jd2::PoseInputStreamJobInputter::input_source() const –> enum protocols::jd2::JobInputterInputSource::Enum

job_inputter_input_source_to_string(source: pyrosetta.rosetta.protocols.jd2.JobInputterInputSource.Enum) → str

call this with input_source() to get the input source of a

particular job inputter

C++: protocols::jd2::JobInputter::job_inputter_input_source_to_string(enum protocols::jd2::JobInputterInputSource::Enum) –> std::string

pose_from_job(self: pyrosetta.rosetta.protocols.jd2.PoseInputStreamJobInputter, pose: pyrosetta.rosetta.core.pose.Pose, job: pyrosetta.rosetta.protocols.jd2.Job) → None

This implementation simply calls fill_pose on the PoseInputStream

object.

C++: protocols::jd2::PoseInputStreamJobInputter::pose_from_job(class core::pose::Pose &, class std::shared_ptr<class protocols::jd2::Job>) –> void

update_jobs_list(self: pyrosetta.rosetta.protocols.jd2.JobInputter, jobs: protocols::jd2::JobsContainer) → None

This function is only called by certain JobInputters to update the jobs list after it has already been created.

An example case would be the LargeNstructJobInputter, which uses this function to load additional jobs after the first N have started to come back.

C++: protocols::jd2::JobInputter::update_jobs_list(class std::shared_ptr<class protocols::jd2::JobsContainer>) –> void

updates_jobs_list(self: pyrosetta.rosetta.protocols.jd2.JobInputter) → bool

Does this type of JobInputter update the jobs list?

False by default. Override this function in derived classes to make it true.

C++: protocols::jd2::JobInputter::updates_jobs_list() const –> bool

class pyrosetta.rosetta.protocols.jd2.ScoreOnlyJobOutputter

Bases: pyrosetta.rosetta.protocols.jd2.FileJobOutputter

Joboutputter that only outputs score files, useful for screening protocols

__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.jd2.ScoreOnlyJobOutputter) → None

__init_subclass__()

This method is called when a class is subclassed.

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

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

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

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

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

add_evaluation(self: pyrosetta.rosetta.protocols.jd2.JobOutputter, : pyrosetta.rosetta.protocols.evaluation.PoseEvaluator) → None

////////////////////////////// evaluator interface ////////////////////////////////////////////

C++: protocols::jd2::JobOutputter::add_evaluation(class std::shared_ptr<class protocols::evaluation::PoseEvaluator>) –> void

call_output_observers(self: pyrosetta.rosetta.protocols.jd2.JobOutputter, pose: pyrosetta.rosetta.core.pose.Pose, job: protocols::jd2::Job) → None

call all output_observers

C++: protocols::jd2::JobOutputter::call_output_observers(const class core::pose::Pose &, class std::shared_ptr<class protocols::jd2::Job>) const –> void

clear_evaluators(self: pyrosetta.rosetta.protocols.jd2.JobOutputter) → None

C++: protocols::jd2::JobOutputter::clear_evaluators() –> void

evaluate(self: pyrosetta.rosetta.protocols.jd2.JobOutputter, pose: pyrosetta.rosetta.core.pose.Pose, tag: str, pss: pyrosetta.rosetta.core.io.silent.SilentStruct) → None

C++: protocols::jd2::JobOutputter::evaluate(class core::pose::Pose &, class std::basic_string<char>, class core::io::silent::SilentStruct &) const –> void

evaluators(self: pyrosetta.rosetta.protocols.jd2.JobOutputter) → pyrosetta.rosetta.protocols.evaluation.MetaPoseEvaluator

C++: protocols::jd2::JobOutputter::evaluators() const –> class std::shared_ptr<const class protocols::evaluation::MetaPoseEvaluator>

file(self: pyrosetta.rosetta.protocols.jd2.FileJobOutputter, job: protocols::jd2::Job, data: str) → None

this function takes a string and writes it to disk (separately from Tracer output).

C++: protocols::jd2::FileJobOutputter::file(class std::shared_ptr<const class protocols::jd2::Job>, const class std::basic_string<char> &) –> void

filename(self: pyrosetta.rosetta.protocols.jd2.JobOutputter, : protocols::jd2::Job) → str

C++: protocols::jd2::JobOutputter::filename(class std::shared_ptr<const class protocols::jd2::Job>) const –> std::string

final_pose(self: pyrosetta.rosetta.protocols.jd2.ScoreOnlyJobOutputter, job: pyrosetta.rosetta.protocols.jd2.Job, pose: pyrosetta.rosetta.core.pose.Pose, tag: str) → None

this function outputs the final result of a job.

C++: protocols::jd2::ScoreOnlyJobOutputter::final_pose(class std::shared_ptr<class protocols::jd2::Job>, const class core::pose::Pose &, const class std::basic_string<char> &) –> void

flush(self: pyrosetta.rosetta.protocols.jd2.JobOutputter) → None

this function is meant to be redefined in child classes to allow for flushing of memory buffers.

Here’s the long version: The SilentFileJobOutputter wanted to buffer output, but needed to guaruntee that the output would be flushed at end of runtime. The original implementation was to A) bend over backward to ensure that the destructor was run (JobOutputter lives inside static JobDistributor, which was previously not destructed because it’s static) and B) flush the buffers in the destructor. This caused a problem because the buffer-flushing tried to use the Tracers, which had already been destructed…boom crash.

New solution: re-forbid use of destructors within the static JobDistributor system, and create a flush function to force this stuff out. So here it is:

C++: protocols::jd2::JobOutputter::flush() –> void

job_has_completed(self: pyrosetta.rosetta.protocols.jd2.ScoreOnlyJobOutputter, job: pyrosetta.rosetta.protocols.jd2.Job) → bool

this function is not used for output, but it belongs here since it needs to check the same output locations as the class normally writes to. This class checks wherever output goes to see if the job’s expected output already exists (on disk or whatever). This is the most basic form of checkpointing.

C++: protocols::jd2::ScoreOnlyJobOutputter::job_has_completed(class std::shared_ptr<const class protocols::jd2::Job>) –> bool

other_pose(*args, **kwargs)

Overloaded function.

1. other_pose(self: pyrosetta.rosetta.protocols.jd2.ScoreOnlyJobOutputter, job: pyrosetta.rosetta.protocols.jd2.Job, pose: pyrosetta.rosetta.core.pose.Pose, tag: str) -> None
2. other_pose(self: pyrosetta.rosetta.protocols.jd2.ScoreOnlyJobOutputter, job: pyrosetta.rosetta.protocols.jd2.Job, pose: pyrosetta.rosetta.core.pose.Pose, tag: str, copy_count: int) -> None
3. other_pose(self: pyrosetta.rosetta.protocols.jd2.ScoreOnlyJobOutputter, job: pyrosetta.rosetta.protocols.jd2.Job, pose: pyrosetta.rosetta.core.pose.Pose, tag: str, copy_count: int, score_only: bool) -> None

this function is intended for saving mid-protocol poses; for example the final centroid structure in a combined centroid/fullatom protocol.

C++: protocols::jd2::ScoreOnlyJobOutputter::other_pose(class std::shared_ptr<class protocols::jd2::Job>, const class core::pose::Pose &, const class std::basic_string<char> &, int, bool) –> void

output_name(self: pyrosetta.rosetta.protocols.jd2.ScoreOnlyJobOutputter, job: pyrosetta.rosetta.protocols.jd2.Job) → str

C++: protocols::jd2::ScoreOnlyJobOutputter::output_name(class std::shared_ptr<const class protocols::jd2::Job>) –> std::string

scorefile_name(self: pyrosetta.rosetta.protocols.jd2.FileJobOutputter) → pyrosetta.rosetta.utility.file.FileName

C++: protocols::jd2::FileJobOutputter::scorefile_name() –> const class utility::file::FileName &

set_defaults(self: pyrosetta.rosetta.protocols.jd2.FileJobOutputter) → None

C++: protocols::jd2::FileJobOutputter::set_defaults() –> void

set_evaluators(self: pyrosetta.rosetta.protocols.jd2.JobOutputter, : pyrosetta.rosetta.protocols.evaluation.MetaPoseEvaluator) → None

C++: protocols::jd2::JobOutputter::set_evaluators(const class protocols::evaluation::MetaPoseEvaluator &) –> void

starting_pose(self: pyrosetta.rosetta.protocols.jd2.JobOutputter, : pyrosetta.rosetta.core.pose.Pose) → None

optionally pass a starting (reference) pose to a JobOutputter for later comparison

purposes and/or as interface for initializing evaluators

C++: protocols::jd2::JobOutputter::starting_pose(const class core::pose::Pose &) –> void

write_scorefile(self: pyrosetta.rosetta.protocols.jd2.FileJobOutputter) → bool

C++: protocols::jd2::FileJobOutputter::write_scorefile() const –> bool

class pyrosetta.rosetta.protocols.jd2.SilentFileJobInputter

Bases: pyrosetta.rosetta.protocols.jd2.JobInputter

This is the simplest implementation of JobInputter, which reads from -s/-l and SilentFile files.

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: pyrosetta.rosetta.protocols.jd2.SilentFileJobInputter) -> None
2. __init__(self: pyrosetta.rosetta.protocols.jd2.SilentFileJobInputter, arg0: pyrosetta.rosetta.protocols.jd2.SilentFileJobInputter) -> 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.jd2.SilentFileJobInputter, : pyrosetta.rosetta.protocols.jd2.SilentFileJobInputter) → pyrosetta.rosetta.protocols.jd2.SilentFileJobInputter

C++: protocols::jd2::SilentFileJobInputter::operator=(const class protocols::jd2::SilentFileJobInputter &) –> class protocols::jd2::SilentFileJobInputter &

fill_jobs(self: pyrosetta.rosetta.protocols.jd2.SilentFileJobInputter, jobs: pyrosetta.rosetta.protocols.jd2.JobsContainer) → None

this function determines what jobs exist from -in::file::silent and

-in::file::tags.

C++: protocols::jd2::SilentFileJobInputter::fill_jobs(class protocols::jd2::JobsContainer &) –> void

get_self_ptr(self: pyrosetta.rosetta.protocols.jd2.JobInputter) → pyrosetta.rosetta.protocols.jd2.JobInputter

Get self owning pointers.

C++: protocols::jd2::JobInputter::get_self_ptr() –> class std::shared_ptr<class protocols::jd2::JobInputter>

get_self_weak_ptr(self: pyrosetta.rosetta.protocols.jd2.JobInputter) → pyrosetta.rosetta.std.weak_ptr_protocols_jd2_JobInputter_t

Get self weak pointers.

C++: protocols::jd2::JobInputter::get_self_weak_ptr() –> class std::weak_ptr<class protocols::jd2::JobInputter>

input_source(self: pyrosetta.rosetta.protocols.jd2.SilentFileJobInputter) → pyrosetta.rosetta.protocols.jd2.JobInputterInputSource.Enum

Return the type of input source that the SilentFileJobInputter is currently

using.

Always SILENT_FILE.

C++: protocols::jd2::SilentFileJobInputter::input_source() const –> enum protocols::jd2::JobInputterInputSource::Enum

job_inputter_input_source_to_string(source: pyrosetta.rosetta.protocols.jd2.JobInputterInputSource.Enum) → str

call this with input_source() to get the input source of a

particular job inputter

C++: protocols::jd2::JobInputter::job_inputter_input_source_to_string(enum protocols::jd2::JobInputterInputSource::Enum) –> std::string

pose_from_job(self: pyrosetta.rosetta.protocols.jd2.SilentFileJobInputter, pose: pyrosetta.rosetta.core.pose.Pose, job: pyrosetta.rosetta.protocols.jd2.Job) → None

this function is responsible for filling the pose reference with

the pose indicated by the job. The Job object (within its InnerJob) contains a PoseCOP. This function needs to either fill the pose reference from the InnerJob or, on first demand of a pose from that InnerJob, instantiate the pose, hand off a COP to the InnerJob, and fill the reference. This implementation uses pose_from_pdb

C++: protocols::jd2::SilentFileJobInputter::pose_from_job(class core::pose::Pose &, class std::shared_ptr<class protocols::jd2::Job>) –> void

silent_file_data(self: pyrosetta.rosetta.protocols.jd2.SilentFileJobInputter) → pyrosetta.rosetta.core.io.silent.SilentFileData

C++: protocols::jd2::SilentFileJobInputter::silent_file_data() const –> const class core::io::silent::SilentFileData &

struct_from_job(self: pyrosetta.rosetta.protocols.jd2.SilentFileJobInputter, job: pyrosetta.rosetta.protocols.jd2.Job) → pyrosetta.rosetta.core.io.silent.SilentStruct

this function returns the SilentStruct that belongs to the given job

C++: protocols::jd2::SilentFileJobInputter::struct_from_job(class std::shared_ptr<class protocols::jd2::Job>) –> const class core::io::silent::SilentStruct &

update_jobs_list(self: pyrosetta.rosetta.protocols.jd2.JobInputter, jobs: protocols::jd2::JobsContainer) → None

This function is only called by certain JobInputters to update the jobs list after it has already been created.

An example case would be the LargeNstructJobInputter, which uses this function to load additional jobs after the first N have started to come back.

C++: protocols::jd2::JobInputter::update_jobs_list(class std::shared_ptr<class protocols::jd2::JobsContainer>) –> void

updates_jobs_list(self: pyrosetta.rosetta.protocols.jd2.JobInputter) → bool

Does this type of JobInputter update the jobs list?

False by default. Override this function in derived classes to make it true.

C++: protocols::jd2::JobInputter::updates_jobs_list() const –> bool

class pyrosetta.rosetta.protocols.jd2.SilentFileJobOutputter

Bases: pyrosetta.rosetta.protocols.jd2.FileJobOutputter

this is a implementation of JobOutputter for silent-file-based output.

__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.jd2.SilentFileJobOutputter) → None

__init_subclass__()

This method is called when a class is subclassed.

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

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

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

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

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

add_evaluation(self: pyrosetta.rosetta.protocols.jd2.JobOutputter, : pyrosetta.rosetta.protocols.evaluation.PoseEvaluator) → None

////////////////////////////// evaluator interface ////////////////////////////////////////////

C++: protocols::jd2::JobOutputter::add_evaluation(class std::shared_ptr<class protocols::evaluation::PoseEvaluator>) –> void

call_output_observers(self: pyrosetta.rosetta.protocols.jd2.JobOutputter, pose: pyrosetta.rosetta.core.pose.Pose, job: protocols::jd2::Job) → None

call all output_observers

C++: protocols::jd2::JobOutputter::call_output_observers(const class core::pose::Pose &, class std::shared_ptr<class protocols::jd2::Job>) const –> void

clear_evaluators(self: pyrosetta.rosetta.protocols.jd2.JobOutputter) → None

C++: protocols::jd2::JobOutputter::clear_evaluators() –> void

evaluate(self: pyrosetta.rosetta.protocols.jd2.JobOutputter, pose: pyrosetta.rosetta.core.pose.Pose, tag: str, pss: pyrosetta.rosetta.core.io.silent.SilentStruct) → None

C++: protocols::jd2::JobOutputter::evaluate(class core::pose::Pose &, class std::basic_string<char>, class core::io::silent::SilentStruct &) const –> void

evaluators(self: pyrosetta.rosetta.protocols.jd2.JobOutputter) → pyrosetta.rosetta.protocols.evaluation.MetaPoseEvaluator

C++: protocols::jd2::JobOutputter::evaluators() const –> class std::shared_ptr<const class protocols::evaluation::MetaPoseEvaluator>

file(self: pyrosetta.rosetta.protocols.jd2.FileJobOutputter, job: protocols::jd2::Job, data: str) → None

this function takes a string and writes it to disk (separately from Tracer output).

C++: protocols::jd2::FileJobOutputter::file(class std::shared_ptr<const class protocols::jd2::Job>, const class std::basic_string<char> &) –> void

filename(self: pyrosetta.rosetta.protocols.jd2.SilentFileJobOutputter, : pyrosetta.rosetta.protocols.jd2.Job) → str

C++: protocols::jd2::SilentFileJobOutputter::filename(class std::shared_ptr<const class protocols::jd2::Job>) const –> std::string

final_pose(self: pyrosetta.rosetta.protocols.jd2.SilentFileJobOutputter, job: pyrosetta.rosetta.protocols.jd2.Job, pose: pyrosetta.rosetta.core.pose.Pose, tag: str) → None

///////////////////////////creating output functions/////////////////////////////////////////

this function outputs the final result of a job.

C++: protocols::jd2::SilentFileJobOutputter::final_pose(class std::shared_ptr<class protocols::jd2::Job>, const class core::pose::Pose &, const class std::basic_string<char> &) –> void

flush(self: pyrosetta.rosetta.protocols.jd2.SilentFileJobOutputter) → None

this function flushes any internal buffers - see parent class for explanation

C++: protocols::jd2::SilentFileJobOutputter::flush() –> void

job_has_completed(self: pyrosetta.rosetta.protocols.jd2.SilentFileJobOutputter, job: pyrosetta.rosetta.protocols.jd2.Job) → bool

this function is not used for output, but it

belongs here since it needs to check the same output locations as the class normally writes to. This class checks wherever output goes to see if the job’s expected output already exists (on disk or whatever). This is the most basic form of checkpointing.

C++: protocols::jd2::SilentFileJobOutputter::job_has_completed(class std::shared_ptr<const class protocols::jd2::Job>) –> bool

other_pose(*args, **kwargs)

Overloaded function.

1. other_pose(self: pyrosetta.rosetta.protocols.jd2.SilentFileJobOutputter, job: pyrosetta.rosetta.protocols.jd2.Job, pose: pyrosetta.rosetta.core.pose.Pose, tag: str) -> None
2. other_pose(self: pyrosetta.rosetta.protocols.jd2.SilentFileJobOutputter, job: pyrosetta.rosetta.protocols.jd2.Job, pose: pyrosetta.rosetta.core.pose.Pose, tag: str, copy_count: int) -> None
3. other_pose(self: pyrosetta.rosetta.protocols.jd2.SilentFileJobOutputter, job: pyrosetta.rosetta.protocols.jd2.Job, pose: pyrosetta.rosetta.core.pose.Pose, tag: str, copy_count: int, score_only: bool) -> None

this function is intended for saving

mid-protocol poses; for example the final centroid structure in a combined centroid/fullatom protocol. —>these go to file silent_filename+tag

C++: protocols::jd2::SilentFileJobOutputter::other_pose(class std::shared_ptr<class protocols::jd2::Job>, const class core::pose::Pose &, const class std::basic_string<char> &, int, bool) –> void

output_name(self: pyrosetta.rosetta.protocols.jd2.SilentFileJobOutputter, job: pyrosetta.rosetta.protocols.jd2.Job) → str

this is the master function for determining the

unique output identifier for a job

C++: protocols::jd2::SilentFileJobOutputter::output_name(class std::shared_ptr<const class protocols::jd2::Job>) –> std::string

scorefile_name(self: pyrosetta.rosetta.protocols.jd2.FileJobOutputter) → pyrosetta.rosetta.utility.file.FileName

C++: protocols::jd2::FileJobOutputter::scorefile_name() –> const class utility::file::FileName &

set_defaults(self: pyrosetta.rosetta.protocols.jd2.FileJobOutputter) → None

C++: protocols::jd2::FileJobOutputter::set_defaults() –> void

set_evaluators(self: pyrosetta.rosetta.protocols.jd2.JobOutputter, : pyrosetta.rosetta.protocols.evaluation.MetaPoseEvaluator) → None

C++: protocols::jd2::JobOutputter::set_evaluators(const class protocols::evaluation::MetaPoseEvaluator &) –> void

set_forced_silent_struct_type(self: pyrosetta.rosetta.protocols.jd2.SilentFileJobOutputter, : str) → None

C++: protocols::jd2::SilentFileJobOutputter::set_forced_silent_struct_type(const class std::basic_string<char> &) –> void

set_silent_file_name(self: pyrosetta.rosetta.protocols.jd2.SilentFileJobOutputter, name: pyrosetta.rosetta.utility.file.FileName) → None

C++: protocols::jd2::SilentFileJobOutputter::set_silent_file_name(class utility::file::FileName) –> void

set_write_no_structures(*args, **kwargs)

Overloaded function.

1. set_write_no_structures(self: pyrosetta.rosetta.protocols.jd2.SilentFileJobOutputter) -> None
2. set_write_no_structures(self: pyrosetta.rosetta.protocols.jd2.SilentFileJobOutputter, value: bool) -> None

C++: protocols::jd2::SilentFileJobOutputter::set_write_no_structures(bool) –> void

set_write_separate_scorefile(self: pyrosetta.rosetta.protocols.jd2.SilentFileJobOutputter, write_separate_scorefile: bool) → None

C++: protocols::jd2::SilentFileJobOutputter::set_write_separate_scorefile(bool) –> void

starting_pose(self: pyrosetta.rosetta.protocols.jd2.JobOutputter, : pyrosetta.rosetta.core.pose.Pose) → None

optionally pass a starting (reference) pose to a JobOutputter for later comparison

purposes and/or as interface for initializing evaluators

C++: protocols::jd2::JobOutputter::starting_pose(const class core::pose::Pose &) –> void

write_scorefile(self: pyrosetta.rosetta.protocols.jd2.FileJobOutputter) → bool

C++: protocols::jd2::FileJobOutputter::write_scorefile() const –> bool

class pyrosetta.rosetta.protocols.jd2.SingleFileBuffer

Bases: pybind11_builtins.pybind11_object

this is a implementation of Buffer for silent-file-based output.

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: pyrosetta.rosetta.protocols.jd2.SingleFileBuffer, filename: str, channel: int, status: int) -> None
2. __init__(self: pyrosetta.rosetta.protocols.jd2.SingleFileBuffer, arg0: pyrosetta.rosetta.protocols.jd2.SingleFileBuffer) -> 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.jd2.SingleFileBuffer, : pyrosetta.rosetta.protocols.jd2.SingleFileBuffer) → pyrosetta.rosetta.protocols.jd2.SingleFileBuffer

C++: protocols::jd2::SingleFileBuffer::operator=(const class protocols::jd2::SingleFileBuffer &) –> class protocols::jd2::SingleFileBuffer &

block(self: pyrosetta.rosetta.protocols.jd2.SingleFileBuffer, slave: int) → None

C++: protocols::jd2::SingleFileBuffer::block(unsigned long) –> void

close(self: pyrosetta.rosetta.protocols.jd2.SingleFileBuffer, slave: int) → None

C++: protocols::jd2::SingleFileBuffer::close(unsigned long) –> void

filename(self: pyrosetta.rosetta.protocols.jd2.SingleFileBuffer) → str

C++: protocols::jd2::SingleFileBuffer::filename() –> const std::string &

flush(self: pyrosetta.rosetta.protocols.jd2.SingleFileBuffer, slave: int) → None

C++: protocols::jd2::SingleFileBuffer::flush(unsigned long) –> void

has_open_slaves(self: pyrosetta.rosetta.protocols.jd2.SingleFileBuffer) → bool

C++: protocols::jd2::SingleFileBuffer::has_open_slaves() const –> bool

length(self: pyrosetta.rosetta.protocols.jd2.SingleFileBuffer, slave: int) → int

C++: protocols::jd2::SingleFileBuffer::length(unsigned long) –> unsigned long

nr_open_slaves(self: pyrosetta.rosetta.protocols.jd2.SingleFileBuffer) → int

C++: protocols::jd2::SingleFileBuffer::nr_open_slaves() const –> unsigned long

store_line(self: pyrosetta.rosetta.protocols.jd2.SingleFileBuffer, slave: int, channel: int, line: str) → None

C++: protocols::jd2::SingleFileBuffer::store_line(unsigned long, unsigned long, const class std::basic_string<char> &) –> void

write_lines(self: pyrosetta.rosetta.protocols.jd2.SingleFileBuffer, : pyrosetta.rosetta.utility.vector1_std_string) → None

C++: protocols::jd2::SingleFileBuffer::write_lines(const class utility::vector1<class std::basic_string<char>, class std::allocator<class std::basic_string<char> > > &) –> void

pyrosetta.rosetta.protocols.jd2.add_current_job_data_to_ss(ss: pyrosetta.rosetta.core.io.silent.SilentStruct) → None

C++: protocols::jd2::add_current_job_data_to_ss(class std::shared_ptr<class core::io::silent::SilentStruct>) –> void

pyrosetta.rosetta.protocols.jd2.add_job_data_to_ss(ss: pyrosetta.rosetta.core.io.silent.SilentStruct, job_op: pyrosetta.rosetta.protocols.jd2.Job) → None

C++: protocols::jd2::add_job_data_to_ss(class std::shared_ptr<class core::io::silent::SilentStruct>, class std::shared_ptr<const class protocols::jd2::Job>) –> void

pyrosetta.rosetta.protocols.jd2.add_string_real_pair_to_current_job(string_in: str, real_in: float) → None

add a string/real pair

C++: protocols::jd2::add_string_real_pair_to_current_job(const class std::basic_string<char> &, double) –> void

pyrosetta.rosetta.protocols.jd2.add_string_string_pair_to_current_job(string1: str, string2: str) → None

add a string/string pair

C++: protocols::jd2::add_string_string_pair_to_current_job(const class std::basic_string<char> &, const class std::basic_string<char> &) –> void

pyrosetta.rosetta.protocols.jd2.add_string_to_current_job(string_in: str) → None

add output string

C++: protocols::jd2::add_string_to_current_job(const class std::basic_string<char> &) –> void

pyrosetta.rosetta.protocols.jd2.add_strings_to_current_job(strings: pyrosetta.rosetta.std.list_std_string_std_allocator_std_string_t) → None

add output strings

C++: protocols::jd2::add_strings_to_current_job(const class std::list<class std::basic_string<char>, class std::allocator<class std::basic_string<char> > > &) –> void

pyrosetta.rosetta.protocols.jd2.current_batch() → str

C++: protocols::jd2::current_batch() –> std::string

pyrosetta.rosetta.protocols.jd2.current_batch_id() → int

C++: protocols::jd2::current_batch_id() –> unsigned long

pyrosetta.rosetta.protocols.jd2.current_input_tag() → str

What is the tag of the current input structure?

C++: protocols::jd2::current_input_tag() –> std::string

pyrosetta.rosetta.protocols.jd2.current_nstruct_index() → int

What ‘nstruct’ value are we currently processing?

C++: protocols::jd2::current_nstruct_index() –> unsigned long

pyrosetta.rosetta.protocols.jd2.current_output_filename() → str

call the ‘filename’ accessor of the current job-distributor with the current job

C++: protocols::jd2::current_output_filename() –> std::string

pyrosetta.rosetta.protocols.jd2.current_output_name() → str

gets used output name of pose

ask jd for current-job —> ask jobOutputter for name of this job

C++: protocols::jd2::current_output_name() –> std::string

pyrosetta.rosetta.protocols.jd2.current_replica() → int

returns 0 if no replicas (i.e., multiple processes per job )

otherwise it returns the sub-rank of the process within the job starting at 1

C++: protocols::jd2::current_replica() –> unsigned long

pyrosetta.rosetta.protocols.jd2.get_current_job() → pyrosetta.rosetta.protocols.jd2.Job

C++: protocols::jd2::get_current_job() –> class std::shared_ptr<class protocols::jd2::Job>

pyrosetta.rosetta.protocols.jd2.get_current_jobs_starting_pose() → pyrosetta.rosetta.core.pose.Pose

Get the starting structure for the current run.

Will return a null pointer if that is not possible.

C++: protocols::jd2::get_current_jobs_starting_pose() –> class std::shared_ptr<const class core::pose::Pose>

pyrosetta.rosetta.protocols.jd2.get_string_real_pairs_from_current_job() → pyrosetta.rosetta.std.map_std_string_double

C++: protocols::jd2::get_string_real_pairs_from_current_job() –> class std::map<std::string, double, struct std::less<std::string >, class std::allocator<struct std::pair<const std::string, double> > >

pyrosetta.rosetta.protocols.jd2.get_string_string_pairs_from_current_job() → pyrosetta.rosetta.std.map_std_string_std_string

C++: protocols::jd2::get_string_string_pairs_from_current_job() –> class std::map<std::string, std::string, struct std::less<std::string >, class std::allocator<struct std::pair<const std::string, std::string > > >

pyrosetta.rosetta.protocols.jd2.get_strings_from_current_job() → pyrosetta.rosetta.std.list_std_string_std_allocator_std_string_t

C++: protocols::jd2::get_strings_from_current_job() –> class std::list<std::string, class std::allocator<std::string > >

pyrosetta.rosetta.protocols.jd2.input_pdb_files_from_command_line() → pyrosetta.rosetta.utility.vector1_utility_file_FileName

Read the -s and -l flags to get a list of PDB files that should be

read in and operated upon.

C++: protocols::jd2::input_pdb_files_from_command_line() –> class utility::vector1<class utility::file::FileName, class std::allocator<class utility::file::FileName> >

pyrosetta.rosetta.protocols.jd2.jd2_used() → bool

is this application running with JD2

Useful for code that might not be running under JD2

C++: protocols::jd2::jd2_used() –> bool

pyrosetta.rosetta.protocols.jd2.max_nstruct_index() → int

What’s the maximum nstruct we’re processing?

C++: protocols::jd2::max_nstruct_index() –> unsigned long

class pyrosetta.rosetta.protocols.jd2.mmCIFJobOutputter

Bases: pyrosetta.rosetta.protocols.jd2.wwPDBJobOutputter

outputs mmCIFs and associated files, uncompressed.

__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.jd2.mmCIFJobOutputter) → None

__init_subclass__()

This method is called when a class is subclassed.

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

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

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

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

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

add_evaluation(self: pyrosetta.rosetta.protocols.jd2.JobOutputter, : pyrosetta.rosetta.protocols.evaluation.PoseEvaluator) → None

////////////////////////////// evaluator interface ////////////////////////////////////////////

C++: protocols::jd2::JobOutputter::add_evaluation(class std::shared_ptr<class protocols::evaluation::PoseEvaluator>) –> void

call_output_observers(self: pyrosetta.rosetta.protocols.jd2.JobOutputter, pose: pyrosetta.rosetta.core.pose.Pose, job: protocols::jd2::Job) → None

call all output_observers

C++: protocols::jd2::JobOutputter::call_output_observers(const class core::pose::Pose &, class std::shared_ptr<class protocols::jd2::Job>) const –> void

clear_evaluators(self: pyrosetta.rosetta.protocols.jd2.JobOutputter) → None

C++: protocols::jd2::JobOutputter::clear_evaluators() –> void

evaluate(self: pyrosetta.rosetta.protocols.jd2.JobOutputter, pose: pyrosetta.rosetta.core.pose.Pose, tag: str, pss: pyrosetta.rosetta.core.io.silent.SilentStruct) → None

C++: protocols::jd2::JobOutputter::evaluate(class core::pose::Pose &, class std::basic_string<char>, class core::io::silent::SilentStruct &) const –> void

evaluators(self: pyrosetta.rosetta.protocols.jd2.JobOutputter) → pyrosetta.rosetta.protocols.evaluation.MetaPoseEvaluator

C++: protocols::jd2::JobOutputter::evaluators() const –> class std::shared_ptr<const class protocols::evaluation::MetaPoseEvaluator>

file(self: pyrosetta.rosetta.protocols.jd2.FileJobOutputter, job: protocols::jd2::Job, data: str) → None

this function takes a string and writes it to disk (separately from Tracer output).

C++: protocols::jd2::FileJobOutputter::file(class std::shared_ptr<const class protocols::jd2::Job>, const class std::basic_string<char> &) –> void

filename(self: pyrosetta.rosetta.protocols.jd2.JobOutputter, : protocols::jd2::Job) → str

C++: protocols::jd2::JobOutputter::filename(class std::shared_ptr<const class protocols::jd2::Job>) const –> std::string

final_pose(self: pyrosetta.rosetta.protocols.jd2.wwPDBJobOutputter, job: protocols::jd2::Job, pose: pyrosetta.rosetta.core.pose.Pose, tag: str) → None

this function outputs the final result of a job. This implementation will write a wwPDB-format file (plus scores). It calls a pure virtual so that child classes can write PDB or mmCIF format.

C++: protocols::jd2::wwPDBJobOutputter::final_pose(class std::shared_ptr<class protocols::jd2::Job>, const class core::pose::Pose &, const class std::basic_string<char> &) –> void

flush(self: pyrosetta.rosetta.protocols.jd2.JobOutputter) → None

this function is meant to be redefined in child classes to allow for flushing of memory buffers.

Here’s the long version: The SilentFileJobOutputter wanted to buffer output, but needed to guaruntee that the output would be flushed at end of runtime. The original implementation was to A) bend over backward to ensure that the destructor was run (JobOutputter lives inside static JobDistributor, which was previously not destructed because it’s static) and B) flush the buffers in the destructor. This caused a problem because the buffer-flushing tried to use the Tracers, which had already been destructed…boom crash.

New solution: re-forbid use of destructors within the static JobDistributor system, and create a flush function to force this stuff out. So here it is:

C++: protocols::jd2::JobOutputter::flush() –> void

job_has_completed(self: pyrosetta.rosetta.protocols.jd2.wwPDBJobOutputter, job: protocols::jd2::Job) → bool

this function is not used for output, but it belongs here since it needs to check the same output locations as the class normally writes to. This class checks wherever output goes to see if the job’s expected output already exists (on disk or whatever). This is the most basic form of checkpointing. The base implementation looks for a pdb/cif with the job’s name already in existence.

C++: protocols::jd2::wwPDBJobOutputter::job_has_completed(class std::shared_ptr<const class protocols::jd2::Job>) –> bool

other_pose(*args, **kwargs)

Overloaded function.

1. other_pose(self: pyrosetta.rosetta.protocols.jd2.wwPDBJobOutputter, job: protocols::jd2::Job, pose: pyrosetta.rosetta.core.pose.Pose, tag: str) -> None
2. other_pose(self: pyrosetta.rosetta.protocols.jd2.wwPDBJobOutputter, job: protocols::jd2::Job, pose: pyrosetta.rosetta.core.pose.Pose, tag: str, copy_count: int) -> None
3. other_pose(self: pyrosetta.rosetta.protocols.jd2.wwPDBJobOutputter, job: protocols::jd2::Job, pose: pyrosetta.rosetta.core.pose.Pose, tag: str, copy_count: int, score_only: bool) -> None

this function is intended for saving mid-protocol poses; for example the final centroid structure in a combined centroid/fullatom protocol. This implementation will write a wwPDB-format file (plus scores). It calls a pure virtual so that child classes can write PDB or mmCIF format.

C++: protocols::jd2::wwPDBJobOutputter::other_pose(class std::shared_ptr<class protocols::jd2::Job>, const class core::pose::Pose &, const class std::basic_string<char> &, int, bool) –> void

output_name(self: pyrosetta.rosetta.protocols.jd2.wwPDBJobOutputter, job: protocols::jd2::Job) → str

this is the master function for determining the unique output identifier for a job

C++: protocols::jd2::wwPDBJobOutputter::output_name(class std::shared_ptr<const class protocols::jd2::Job>) –> std::string

scorefile_name(self: pyrosetta.rosetta.protocols.jd2.FileJobOutputter) → pyrosetta.rosetta.utility.file.FileName

C++: protocols::jd2::FileJobOutputter::scorefile_name() –> const class utility::file::FileName &

set_defaults(self: pyrosetta.rosetta.protocols.jd2.FileJobOutputter) → None

C++: protocols::jd2::FileJobOutputter::set_defaults() –> void

set_evaluators(self: pyrosetta.rosetta.protocols.jd2.JobOutputter, : pyrosetta.rosetta.protocols.evaluation.MetaPoseEvaluator) → None

C++: protocols::jd2::JobOutputter::set_evaluators(const class protocols::evaluation::MetaPoseEvaluator &) –> void

starting_pose(self: pyrosetta.rosetta.protocols.jd2.JobOutputter, : pyrosetta.rosetta.core.pose.Pose) → None

optionally pass a starting (reference) pose to a JobOutputter for later comparison

purposes and/or as interface for initializing evaluators

C++: protocols::jd2::JobOutputter::starting_pose(const class core::pose::Pose &) –> void

write_scorefile(self: pyrosetta.rosetta.protocols.jd2.FileJobOutputter) → bool

C++: protocols::jd2::FileJobOutputter::write_scorefile() const –> bool

pyrosetta.rosetta.protocols.jd2.output_intermediate_pose(*args, **kwargs)

Overloaded function.

1. output_intermediate_pose(pose: pyrosetta.rosetta.core.pose.Pose, stage_tag: str) -> None
2. output_intermediate_pose(pose: pyrosetta.rosetta.core.pose.Pose, stage_tag: str, copy_count: int) -> None
3. output_intermediate_pose(pose: pyrosetta.rosetta.core.pose.Pose, stage_tag: str, copy_count: int, score_only: bool) -> None

writes pose to intermediate-scorefile using current Job and JobOutputter ..

copy count is used if multiple poses with same job-tag are written as for instance into a trajectory.

-1 indicates no copy count >=0 copy_count will be attached as zerofilled postfix to job-tag

C++: protocols::jd2::output_intermediate_pose(const class core::pose::Pose &, const class std::basic_string<char> &, int, bool) –> void

pyrosetta.rosetta.protocols.jd2.register_options() → None

C++: protocols::jd2::register_options() –> void

pyrosetta.rosetta.protocols.jd2.set_native_in_mover(mover: pyrosetta.rosetta.protocols.moves.Mover) → None

C++: protocols::jd2::set_native_in_mover(class protocols::moves::Mover &) –> void

pyrosetta.rosetta.protocols.jd2.write_score_tracer(pose_in: pyrosetta.rosetta.core.pose.Pose, tag: str) → None

C++: protocols::jd2::write_score_tracer(const class core::pose::Pose &, class std::basic_string<char>) –> void

class pyrosetta.rosetta.protocols.jd2.wwPDBJobOutputter

Bases: pyrosetta.rosetta.protocols.jd2.FileJobOutputter

this simplest implementation of JobOutputter outputs raw wwPDBs and associated files, uncompressed.

__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.jd2.wwPDBJobOutputter) → None

__init_subclass__()

This method is called when a class is subclassed.

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

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

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

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

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

add_evaluation(self: pyrosetta.rosetta.protocols.jd2.JobOutputter, : pyrosetta.rosetta.protocols.evaluation.PoseEvaluator) → None

////////////////////////////// evaluator interface ////////////////////////////////////////////

C++: protocols::jd2::JobOutputter::add_evaluation(class std::shared_ptr<class protocols::evaluation::PoseEvaluator>) –> void

call_output_observers(self: pyrosetta.rosetta.protocols.jd2.JobOutputter, pose: pyrosetta.rosetta.core.pose.Pose, job: protocols::jd2::Job) → None

call all output_observers

C++: protocols::jd2::JobOutputter::call_output_observers(const class core::pose::Pose &, class std::shared_ptr<class protocols::jd2::Job>) const –> void

clear_evaluators(self: pyrosetta.rosetta.protocols.jd2.JobOutputter) → None

C++: protocols::jd2::JobOutputter::clear_evaluators() –> void

evaluate(self: pyrosetta.rosetta.protocols.jd2.JobOutputter, pose: pyrosetta.rosetta.core.pose.Pose, tag: str, pss: pyrosetta.rosetta.core.io.silent.SilentStruct) → None

C++: protocols::jd2::JobOutputter::evaluate(class core::pose::Pose &, class std::basic_string<char>, class core::io::silent::SilentStruct &) const –> void

evaluators(self: pyrosetta.rosetta.protocols.jd2.JobOutputter) → pyrosetta.rosetta.protocols.evaluation.MetaPoseEvaluator

C++: protocols::jd2::JobOutputter::evaluators() const –> class std::shared_ptr<const class protocols::evaluation::MetaPoseEvaluator>

file(self: pyrosetta.rosetta.protocols.jd2.FileJobOutputter, job: protocols::jd2::Job, data: str) → None

this function takes a string and writes it to disk (separately from Tracer output).

C++: protocols::jd2::FileJobOutputter::file(class std::shared_ptr<const class protocols::jd2::Job>, const class std::basic_string<char> &) –> void

filename(self: pyrosetta.rosetta.protocols.jd2.JobOutputter, : protocols::jd2::Job) → str

C++: protocols::jd2::JobOutputter::filename(class std::shared_ptr<const class protocols::jd2::Job>) const –> std::string

final_pose(self: pyrosetta.rosetta.protocols.jd2.wwPDBJobOutputter, job: protocols::jd2::Job, pose: pyrosetta.rosetta.core.pose.Pose, tag: str) → None

this function outputs the final result of a job. This implementation will write a wwPDB-format file (plus scores). It calls a pure virtual so that child classes can write PDB or mmCIF format.

C++: protocols::jd2::wwPDBJobOutputter::final_pose(class std::shared_ptr<class protocols::jd2::Job>, const class core::pose::Pose &, const class std::basic_string<char> &) –> void

flush(self: pyrosetta.rosetta.protocols.jd2.JobOutputter) → None

this function is meant to be redefined in child classes to allow for flushing of memory buffers.

Here’s the long version: The SilentFileJobOutputter wanted to buffer output, but needed to guaruntee that the output would be flushed at end of runtime. The original implementation was to A) bend over backward to ensure that the destructor was run (JobOutputter lives inside static JobDistributor, which was previously not destructed because it’s static) and B) flush the buffers in the destructor. This caused a problem because the buffer-flushing tried to use the Tracers, which had already been destructed…boom crash.

New solution: re-forbid use of destructors within the static JobDistributor system, and create a flush function to force this stuff out. So here it is:

C++: protocols::jd2::JobOutputter::flush() –> void

job_has_completed(self: pyrosetta.rosetta.protocols.jd2.wwPDBJobOutputter, job: protocols::jd2::Job) → bool

this function is not used for output, but it belongs here since it needs to check the same output locations as the class normally writes to. This class checks wherever output goes to see if the job’s expected output already exists (on disk or whatever). This is the most basic form of checkpointing. The base implementation looks for a pdb/cif with the job’s name already in existence.

C++: protocols::jd2::wwPDBJobOutputter::job_has_completed(class std::shared_ptr<const class protocols::jd2::Job>) –> bool

other_pose(*args, **kwargs)

Overloaded function.

1. other_pose(self: pyrosetta.rosetta.protocols.jd2.wwPDBJobOutputter, job: protocols::jd2::Job, pose: pyrosetta.rosetta.core.pose.Pose, tag: str) -> None
2. other_pose(self: pyrosetta.rosetta.protocols.jd2.wwPDBJobOutputter, job: protocols::jd2::Job, pose: pyrosetta.rosetta.core.pose.Pose, tag: str, copy_count: int) -> None
3. other_pose(self: pyrosetta.rosetta.protocols.jd2.wwPDBJobOutputter, job: protocols::jd2::Job, pose: pyrosetta.rosetta.core.pose.Pose, tag: str, copy_count: int, score_only: bool) -> None

this function is intended for saving mid-protocol poses; for example the final centroid structure in a combined centroid/fullatom protocol. This implementation will write a wwPDB-format file (plus scores). It calls a pure virtual so that child classes can write PDB or mmCIF format.

C++: protocols::jd2::wwPDBJobOutputter::other_pose(class std::shared_ptr<class protocols::jd2::Job>, const class core::pose::Pose &, const class std::basic_string<char> &, int, bool) –> void

output_name(self: pyrosetta.rosetta.protocols.jd2.wwPDBJobOutputter, job: protocols::jd2::Job) → str

this is the master function for determining the unique output identifier for a job

C++: protocols::jd2::wwPDBJobOutputter::output_name(class std::shared_ptr<const class protocols::jd2::Job>) –> std::string

scorefile_name(self: pyrosetta.rosetta.protocols.jd2.FileJobOutputter) → pyrosetta.rosetta.utility.file.FileName

C++: protocols::jd2::FileJobOutputter::scorefile_name() –> const class utility::file::FileName &

set_defaults(self: pyrosetta.rosetta.protocols.jd2.FileJobOutputter) → None

C++: protocols::jd2::FileJobOutputter::set_defaults() –> void

set_evaluators(self: pyrosetta.rosetta.protocols.jd2.JobOutputter, : pyrosetta.rosetta.protocols.evaluation.MetaPoseEvaluator) → None

C++: protocols::jd2::JobOutputter::set_evaluators(const class protocols::evaluation::MetaPoseEvaluator &) –> void

starting_pose(self: pyrosetta.rosetta.protocols.jd2.JobOutputter, : pyrosetta.rosetta.core.pose.Pose) → None

optionally pass a starting (reference) pose to a JobOutputter for later comparison

purposes and/or as interface for initializing evaluators

C++: protocols::jd2::JobOutputter::starting_pose(const class core::pose::Pose &) –> void

write_scorefile(self: pyrosetta.rosetta.protocols.jd2.FileJobOutputter) → bool

C++: protocols::jd2::FileJobOutputter::write_scorefile() const –> bool