jd3

Bindings for protocols::jd3 namespace

class pyrosetta.rosetta.protocols.jd3.CompletedJobOutput

Bases: pybind11_builtins.pybind11_object

Each Job will return a JobStatus and a list of JobSummary/JobResult pairs. A pair’s index in th job_results vector is used as its identifier for when the JobResult is used as input for another job, or when it is to be output by the JobQueen.

class pyrosetta.rosetta.protocols.jd3.InnerLarvalJob

Bases: pybind11_builtins.pybind11_object

The %InnerLarvalJob class is responsible for holding the input requirements for a given job - how many nstruct, and what the input is. %InnerLarvalJobs are relatively heavy; there is no need to duplicate a series of %InnerLarvalJobs for each index into nstruct. The companion Job class handles the nstruct index and has a pointer to an InnerLarvalJob (which is shared across many Jobs). The JobQueen has considerable leeway in how she shares data held in the %InnerLarvalJobs she creates: if all of the options for a set of %InnerLarvalJob are identical, and they differ only in their input structure, then she can, e.g. share a single JobOptions object between all of them. InnerLarvalJobs are serialized by the JobDistributor and shipped between nodes. For this reason, they should not be loaded with ResourceManager-managed data (that data should not get shipped between nodes, though it should be instantiatable on any node), but they may need to store Poses, as would be necessary in any multi-round protocol, where the JobResults from round i are the starting points for round i+1.

add_input_job_result_index(self: pyrosetta.rosetta.protocols.jd3.InnerLarvalJob, job_result_id: Tuple[int, int]) → None
Add a required input by the pair representing 1) the global index of the job
that produced the JobResult, and 2) the index of that JobResult among all the results produced by that job.

C++: protocols::jd3::InnerLarvalJob::add_input_job_result_index(struct std::pair<unsigned long, unsigned long>) –> void

assign(self: pyrosetta.rosetta.protocols.jd3.InnerLarvalJob, : pyrosetta.rosetta.protocols.jd3.InnerLarvalJob) → pyrosetta.rosetta.protocols.jd3.InnerLarvalJob

C++: protocols::jd3::InnerLarvalJob::operator=(const class protocols::jd3::InnerLarvalJob &) –> class protocols::jd3::InnerLarvalJob &

bad(self: pyrosetta.rosetta.protocols.jd3.InnerLarvalJob) → bool

Has this job been labeled as bad?

C++: protocols::jd3::InnerLarvalJob::bad() const –> bool

clear_input_sources(self: pyrosetta.rosetta.protocols.jd3.InnerLarvalJob) → None

Clear the vector of InputSources

C++: protocols::jd3::InnerLarvalJob::clear_input_sources() –> void

const_data_map(self: pyrosetta.rosetta.protocols.jd3.InnerLarvalJob) → pyrosetta.rosetta.basic.datacache.ConstDataMap
Write access to the ConstDataMap that the %InnerLarvalJob holds. The objects pointed
to by the const data map can be shared between two %InnerLarvalJobs, but the data maps themselves should not be shared.

C++: protocols::jd3::InnerLarvalJob::const_data_map() –> class basic::datacache::ConstDataMap &

input_job_result_indices(self: pyrosetta.rosetta.protocols.jd3.InnerLarvalJob) → pyrosetta.rosetta.utility.vector1_std_pair_unsigned_long_unsigned_long_t
The list of the JobResults required to mature this %LarvalJob, by global index of the
already-executed (Lavral)Jobs

C++: protocols::jd3::InnerLarvalJob::input_job_result_indices() const –> const class utility::vector1<struct std::pair<unsigned long, unsigned long>, class std::allocator<struct std::pair<unsigned long, unsigned long> > > &

input_tag(*args, **kwargs)

Overloaded function.

  1. input_tag(self: pyrosetta.rosetta.protocols.jd3.InnerLarvalJob) -> str
Return the input tag – a string that describes the input structure, but that
is in no way a complete description of the job. The job_tag instead should be looked to as the name to use to identify information about this job: a single input structure may be used for multiple jobs.

C++: protocols::jd3::InnerLarvalJob::input_tag() const –> std::string

  1. input_tag(self: pyrosetta.rosetta.protocols.jd3.InnerLarvalJob, setting: str) -> None
Set the input tag – if it is not set, then the InputSources will be used,
the file names / tags being concatenated together, separated by underscores.

C++: protocols::jd3::InnerLarvalJob::input_tag(const class std::basic_string<char> &) –> void

job_tag(*args, **kwargs)

Overloaded function.

  1. job_tag(self: pyrosetta.rosetta.protocols.jd3.InnerLarvalJob) -> str
Return the job tag – a string that describes what task is being performed and

and (usually) what input structure that job is being performed upon. This is the tag can be defined by the user in the job-definition XML file.

Can be overridden by child classes that require distinct logic.

C++: protocols::jd3::InnerLarvalJob::job_tag() const –> std::string

  1. job_tag(self: pyrosetta.rosetta.protocols.jd3.InnerLarvalJob, setting: str) -> None

Set the job tag. If not set, then the input tag will be returned.

C++: protocols::jd3::InnerLarvalJob::job_tag(const class std::basic_string<char> &) –> void

jobdef_tag(*args, **kwargs)

Overloaded function.

  1. jobdef_tag(self: pyrosetta.rosetta.protocols.jd3.InnerLarvalJob) -> pyrosetta.rosetta.utility.tag.Tag

C++: protocols::jd3::InnerLarvalJob::jobdef_tag() const –> class std::shared_ptr<const class utility::tag::Tag>

  1. jobdef_tag(self: pyrosetta.rosetta.protocols.jd3.InnerLarvalJob, setting: pyrosetta.rosetta.utility.tag.Tag) -> None

C++: protocols::jd3::InnerLarvalJob::jobdef_tag(class std::shared_ptr<const class utility::tag::Tag>) –> void

n_input_sources(self: pyrosetta.rosetta.protocols.jd3.InnerLarvalJob) → int

Return the number of pose input sources for this job.

C++: protocols::jd3::InnerLarvalJob::n_input_sources() const –> unsigned long

nstruct_max(*args, **kwargs)

Overloaded function.

  1. nstruct_max(self: pyrosetta.rosetta.protocols.jd3.InnerLarvalJob) -> int

The number of job replicates to be performed for this %InnerLarvalJob.

C++: protocols::jd3::InnerLarvalJob::nstruct_max() const –> unsigned long

  1. nstruct_max(self: pyrosetta.rosetta.protocols.jd3.InnerLarvalJob, setting: int) -> None

C++: protocols::jd3::InnerLarvalJob::nstruct_max(unsigned long) –> void

outputter(*args, **kwargs)

Overloaded function.

  1. outputter(self: pyrosetta.rosetta.protocols.jd3.InnerLarvalJob) -> str

Return the outputter class; i.e. the key used by the PoseOutputterFactory

C++: protocols::jd3::InnerLarvalJob::outputter() const –> std::string

  1. outputter(self: pyrosetta.rosetta.protocols.jd3.InnerLarvalJob, setting: str) -> None

Set the outputter class for this job; i.e. the key used by the PoseOutputterFactory

C++: protocols::jd3::InnerLarvalJob::outputter(const class std::basic_string<char> &) –> void

same_type(self: pyrosetta.rosetta.protocols.jd3.InnerLarvalJob, other: pyrosetta.rosetta.protocols.jd3.InnerLarvalJob) → bool
returns true if this is the same type as other;
does not call other.same_type()

C++: protocols::jd3::InnerLarvalJob::same_type(const class protocols::jd3::InnerLarvalJob &) const –> bool

set_bad(*args, **kwargs)

Overloaded function.

  1. set_bad(self: pyrosetta.rosetta.protocols.jd3.InnerLarvalJob) -> None
  2. set_bad(self: pyrosetta.rosetta.protocols.jd3.InnerLarvalJob, setting: bool) -> None
Store the fact that this job is bad, for some reason or another, e.g. it has
malformed inputs.

C++: protocols::jd3::InnerLarvalJob::set_bad(bool) –> void

show(self: pyrosetta.rosetta.protocols.jd3.InnerLarvalJob, out: pyrosetta.rosetta.std.ostream) → None

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

sources_same(self: pyrosetta.rosetta.protocols.jd3.InnerLarvalJob, other: pyrosetta.rosetta.protocols.jd3.InnerLarvalJob) → bool

Determine if two jobs are defined with the same set of InputSources

C++: protocols::jd3::InnerLarvalJob::sources_same(const class protocols::jd3::InnerLarvalJob &) const –> bool

class pyrosetta.rosetta.protocols.jd3.Job

Bases: pybind11_builtins.pybind11_object

%protocols::jd3::Job, which is created by the JobQueen from a LarvalJob, is responsible for executing some protocol from beginning to end in its “run” method. It must write all of its output data to the JobResult object that it creates and returns.

Note that in JD2, the currently running Job was globally accessible. That is not the case in JD3. Any data that should be output by a running job must be tucked inside the JobResult to be eventually retrieved by the JobQueen or by a JobDataOutputter at the end of execution.

assign(self: pyrosetta.rosetta.protocols.jd3.Job, : pyrosetta.rosetta.protocols.jd3.Job) → pyrosetta.rosetta.protocols.jd3.Job

C++: protocols::jd3::Job::operator=(const class protocols::jd3::Job &) –> class protocols::jd3::Job &

run(self: pyrosetta.rosetta.protocols.jd3.Job) → pyrosetta.rosetta.protocols.jd3.CompletedJobOutput
This is the main function of the Job object. It will be invoked by the JobDistributor.
The Job will return a JobResult at the conclusion of its execution, and the JobResult will be serialized and sent to the appropriate JobQueen for processing and output. The Job itself will be discarded. Large constant data that might be shared between multiple jobs can be held by the Job object (or by classes that the Job object holds) but that data should not be put into the JobResult – large data should not be repeatedly serialized and shipped between nodes.

C++: protocols::jd3::Job::run() –> struct protocols::jd3::CompletedJobOutput

class pyrosetta.rosetta.protocols.jd3.JobOutputIndex

Bases: pybind11_builtins.pybind11_object

The %JobOutputIndex holds the four relevant counts for describing the “name” for an output (e.g. a Pose) that is going to be written out to disk

assign(self: pyrosetta.rosetta.protocols.jd3.JobOutputIndex, : pyrosetta.rosetta.protocols.jd3.JobOutputIndex) → pyrosetta.rosetta.protocols.jd3.JobOutputIndex

C++: protocols::jd3::JobOutputIndex::operator=(const struct protocols::jd3::JobOutputIndex &) –> struct protocols::jd3::JobOutputIndex &

class pyrosetta.rosetta.protocols.jd3.JobQueen

Bases: pybind11_builtins.pybind11_object

The %JobQueen class (think of a queen bee) has quite a few responsibilities: - determining what jobs should be run and representing them as larval job objects - taking a larval job object and maturing it into a fully functional Job that can be run - processing the JobResult produced by a Job when it runs - determining the number of rounds of larval-job creation and job execution that should

be performed.

The %JobQueen is responsible for creating all of the LarvalJobs, grouped into “batches” which are dispatched by the JobDistributor; the queen then matures the larval jobs into the mature form (a Job, e.g. a Mover/Pose pair) and gives them up to the JobDistributor to actually execute the work. The JobDistributor then actually calls the Job’s “run” method, which produces a JobResult. It then hands this JobResult (e.g. a Pose or several Poses) back to the %JobQueen for output. In fact, in MPI contexts, the JobDistributor guarantees that it will hand all of the completed JobResults for a single batch to a single %JobQueen, so that she can compute aggregate statistics (e.g. averaging energies) or can look at the

results from that round of jobs and decide which to carry forward into the next

round of execution.

assign(self: pyrosetta.rosetta.protocols.jd3.JobQueen, : pyrosetta.rosetta.protocols.jd3.JobQueen) → pyrosetta.rosetta.protocols.jd3.JobQueen

C++: protocols::jd3::JobQueen::operator=(const class protocols::jd3::JobQueen &) –> class protocols::jd3::JobQueen &

completed_job_summary(*args, **kwargs)

Overloaded function.

  1. completed_job_summary(self: pyrosetta.rosetta.protocols.jd3.JobQueen, job: protocols::jd3::LarvalJob, result_index: int, summary: protocols::jd3::JobSummary) -> None
The JobDistributor guarnatees that exactly one JobQueen will see every
JobSummary generated within a Job batch. This guarantee allows the JobQueen to aggregate data across all of the Jobs so that Rosetta is able to compute data from structures instead of forcing that computation into accessory scripts.

C++: protocols::jd3::JobQueen::completed_job_summary(class std::shared_ptr<const class protocols::jd3::LarvalJob>, unsigned long, class std::shared_ptr<class protocols::jd3::JobSummary>) –> void

  1. completed_job_summary(self: pyrosetta.rosetta.protocols.jd3.JobQueen, job_id: int, result_index: int, summary: protocols::jd3::JobSummary) -> None
The JobDistributor guarnatees that exactly one JobQueen will see every
JobSummary generated within a Job batch. This guarantee allows the JobQueen to aggregate data across all of the Jobs so that Rosetta is able to compute data from structures instead of forcing that computation into accessory scripts.

C++: protocols::jd3::JobQueen::completed_job_summary(unsigned long, unsigned long, class std::shared_ptr<class protocols::jd3::JobSummary>) –> void

flush(self: pyrosetta.rosetta.protocols.jd3.JobQueen) → None
Send all buffered output to disk – called by the JobDistributor right before it shuts down
if it hits an error or catches an exception that it cannot ignore.

C++: protocols::jd3::JobQueen::flush() –> void

has_job_completed(self: pyrosetta.rosetta.protocols.jd3.JobQueen, job: protocols::jd3::LarvalJob) → bool
The JobQueen must be able to determine if a particular job has already
completed (or alternatively, has already been started by another process), and if so, the JobDistributor will not re-run the job. The JobQueen returns “true” if the job has completed (or started elsewhere), and “false” otherwise.

C++: protocols::jd3::JobQueen::has_job_completed(class std::shared_ptr<const class protocols::jd3::LarvalJob>) –> bool

job_definition_xsd(self: pyrosetta.rosetta.protocols.jd3.JobQueen) → str
All JobQueens must describe their job input XML format in the form of an XSD
(XML Schema Definition), and they must validate their job input files against their XSDs. If the JobDistributor is awakened with the flag “jd3::output_job_xsd <output file>” on the command line, then the JobDistributor will write out the XSD to the output file.

C++: protocols::jd3::JobQueen::job_definition_xsd() const –> std::string

job_results_that_should_be_discarded(self: pyrosetta.rosetta.protocols.jd3.JobQueen) → pyrosetta.rosetta.std.list_std_pair_unsigned_long_unsigned_long_std_allocator_std_pair_unsigned_long_unsigned_long_t
The JobDistributor, to manage memory use, asks the JobQueen which JobResults may be
discarded because they will not be used in the future. The JobDistributor will exit with an error message if the %JobQueen gives it a LarvalJob that lists one of these discarded JobResults as a required input for that LarvalJob.

C++: protocols::jd3::JobQueen::job_results_that_should_be_discarded() –> class std::list<struct std::pair<unsigned long, unsigned long>, class std::allocator<struct std::pair<unsigned long, unsigned long> > >

jobs_that_should_be_output(self: pyrosetta.rosetta.protocols.jd3.JobQueen) → pyrosetta.rosetta.std.list_std_shared_ptr_protocols_jd3_output_OutputSpecification_std_allocator_std_shared_ptr_protocols_jd3_output_OutputSpecification_t
The JobDistributor asks the JobQueen which JobResults should be queued for output.
The JobQueen should reply by returning a list of OutputSpecification objects. Each OutputSpecification indicates a particular JobResult using the JobResultID object that the Specification holds. It also indicates how the JobResult should be output by whatever object will be doing to job outputting. The JobQueen should ask for a given JobResult to be output only once. After a job result is output, the JobDistributor will discard the JobResult, so the JobQueen should not tell the JobDistributor to output a job if it will be used as an input to another job in the future. Note that this method will only be called on the master-node JobQueen (aka JQ0), but that she will not necessarily be the JobQueen to actually return the ResultOutputter for the jobs that will be output. The JobDistributor holds the option to distribute output to other nodes

C++: protocols::jd3::JobQueen::jobs_that_should_be_output() –> class std::list<class std::shared_ptr<class protocols::jd3::output::OutputSpecification>, class std::allocator<class std::shared_ptr<class protocols::jd3::output::OutputSpecification> > >

larval_job_needed_for_completed_job_summary(self: pyrosetta.rosetta.protocols.jd3.JobQueen) → bool
There are two interfaces to completed_job_summary: one in which the
job index alone is passed in, a second in which the entire LarvalJob is provided.

C++: protocols::jd3::JobQueen::larval_job_needed_for_completed_job_summary() const –> bool

larval_job_needed_for_note_job_completed(self: pyrosetta.rosetta.protocols.jd3.JobQueen) → bool
There are two interfaces to note_job_completed: one in which the
job index alone is passed in, a second in which the entire LarvalJob is provided.

C++: protocols::jd3::JobQueen::larval_job_needed_for_note_job_completed() const –> bool

mark_job_as_having_begun(self: pyrosetta.rosetta.protocols.jd3.JobQueen, job: protocols::jd3::LarvalJob) → None
Some (but not all) JobDistributors mark which jobs are in the process of
being run by asking the JobQueen to create a temporary file marking that fact on the file system.

C++: protocols::jd3::JobQueen::mark_job_as_having_begun(class std::shared_ptr<const class protocols::jd3::LarvalJob>) –> void

note_job_completed(*args, **kwargs)

Overloaded function.

  1. note_job_completed(self: pyrosetta.rosetta.protocols.jd3.JobQueen, job: protocols::jd3::LarvalJob, status: pyrosetta.rosetta.protocols.jd3.JobStatus, nresults: int) -> None
The JobDistributor will call this function to inform the JobQueen that
a job has “completed” – in the sense that it will not be run in the future. It does not guarantee that the job was run on this CPU or that it successfully completed anywhere. The JobStatus indicates whether the job completed or whether it failed. The nresults count lists how many JobSummary/JobResult pairs were produced by the completed job.

C++: protocols::jd3::JobQueen::note_job_completed(class std::shared_ptr<const class protocols::jd3::LarvalJob>, enum protocols::jd3::JobStatus, unsigned long) –> void

  1. note_job_completed(self: pyrosetta.rosetta.protocols.jd3.JobQueen, job_id: int, status: pyrosetta.rosetta.protocols.jd3.JobStatus, nresults: int) -> None
The JobDistributor will call this function to inform the JobQueen that
a job has “completed” – in the sense that it will not be run in the future. It does not guarantee that the job was run on this CPU or that it successfully completed anywhere. The JobStatus indicates whether the job completed or whether it failed. The nresults count lists how many JobSummary/JobResult pairs were produced by the completed job.

C++: protocols::jd3::JobQueen::note_job_completed(unsigned long, enum protocols::jd3::JobStatus, unsigned long) –> void

resource_definition_xsd(self: pyrosetta.rosetta.protocols.jd3.JobQueen) → str
JobQueens may optionally define an XSD for their resource definition file
which is fed to their resource manager (if they control one). If the JobDistributor is awakened with the flag “jd3::output_resource_xsd <output file>” on the command line, and if the derived JobQueen defines an XSD for resources she uses, then the JobDistributor will write out the resource definition XSD to the output file. The derived queen may return an empty string to indicate that no resources are definable for the resource manager.

C++: protocols::jd3::JobQueen::resource_definition_xsd() const –> std::string

result_outputter(self: pyrosetta.rosetta.protocols.jd3.JobQueen, output_specification: protocols::jd3::output::OutputSpecification) → protocols::jd3::output::ResultOutputter
The JobDistributor will ask the JobQueen to provide an outputter for a result
giving it an annotated-with-job-distributor-specific-prefix OutputSpecification. The JobQueen must guarantee that a distinct ResultOutputter is given for each distinct JD prefix and that no two ResultOutputters share non-(bitwise-)constant data as the JobDistributor may use multiple threads to perform output. Note that the JobQueen that creates the outputter may not have been the JobQueen to request that output be performed. This function is thus similar to mature_larval_job: it requires that the JobQueen make few assumptions about the state of her data in order for this behavior to translate from the VanillaJobDistributor to the MPIWorkPoolJobDistributor.

C++: protocols::jd3::JobQueen::result_outputter(const class protocols::jd3::output::OutputSpecification &) –> class std::shared_ptr<class protocols::jd3::output::ResultOutputter>

class pyrosetta.rosetta.protocols.jd3.JobResult

Bases: pybind11_builtins.pybind11_object

%JobResult class holds the output that’s generated by a Job over the course of its execution. The %JobResult is handed by the JobQueen to the JobOutputWriter objects, each of which have the opportunity to pull data out of the JobResult class.

assign(self: pyrosetta.rosetta.protocols.jd3.JobResult, : pyrosetta.rosetta.protocols.jd3.JobResult) → pyrosetta.rosetta.protocols.jd3.JobResult

C++: protocols::jd3::JobResult::operator=(const class protocols::jd3::JobResult &) –> class protocols::jd3::JobResult &

status(self: pyrosetta.rosetta.protocols.jd3.JobResult) → pyrosetta.rosetta.protocols.jd3.JobStatus

C++: protocols::jd3::JobResult::status() const –> enum protocols::jd3::JobStatus

class pyrosetta.rosetta.protocols.jd3.JobStatus

Bases: pybind11_builtins.pybind11_object

Members:

jd3_job_status_success

jd3_job_previously_executed

jd3_job_status_inputs_were_bad

jd3_job_status_failed_w_exception

jd3_job_status_failed_retry

jd3_job_status_failed_max_retries

jd3_job_status_failed_do_not_retry

class pyrosetta.rosetta.protocols.jd3.JobSummary

Bases: pybind11_builtins.pybind11_object

%JobSummary class holds the output that’s generated by a Job over the course of its execution. The %JobSummary is handed by the JobQueen to the JobOutputWriter objects, each of which have the opportunity to pull data out of the JobSummary class.

assign(self: pyrosetta.rosetta.protocols.jd3.JobSummary, : pyrosetta.rosetta.protocols.jd3.JobSummary) → pyrosetta.rosetta.protocols.jd3.JobSummary

C++: protocols::jd3::JobSummary::operator=(const class protocols::jd3::JobSummary &) –> class protocols::jd3::JobSummary &

class pyrosetta.rosetta.protocols.jd3.LarvalJob

Bases: pybind11_builtins.pybind11_object

%protocols::jd3::LarvalJob, which is initialized by the JobQueen, during its intitialize_job_list method, is an immature form of the. It is matured into a Job that can be run by the JobQueen’s mature_job method. A LarvalJob may be one of several LarvalJobs that have the same inputs, but differ in their random number seed (i.e. replicates); two jobs that share the same input are meant to point to the same “InnerLarvalJob” to avoid spending too much memory representing identical data.

Note that in JD2, the currently running Job was globally accessible. That is not the case in JD3. Any data that should be output by a running job must be tucked by a Mover inside the JobOutputData to be eventually retrieved by the JobQueen or by a JobDataOutputter at the end of execution.

assign(self: pyrosetta.rosetta.protocols.jd3.LarvalJob, : pyrosetta.rosetta.protocols.jd3.LarvalJob) → pyrosetta.rosetta.protocols.jd3.LarvalJob

C++: protocols::jd3::LarvalJob::operator=(const class protocols::jd3::LarvalJob &) –> class protocols::jd3::LarvalJob &

bad(*args, **kwargs)

Overloaded function.

  1. bad(self: pyrosetta.rosetta.protocols.jd3.LarvalJob) -> bool

C++: protocols::jd3::LarvalJob::bad() const –> bool

  1. bad(self: pyrosetta.rosetta.protocols.jd3.LarvalJob, setting: bool) -> None

C++: protocols::jd3::LarvalJob::bad(bool) –> void

completed(*args, **kwargs)

Overloaded function.

  1. completed(self: pyrosetta.rosetta.protocols.jd3.LarvalJob) -> bool

C++: protocols::jd3::LarvalJob::completed() const –> bool

  1. completed(self: pyrosetta.rosetta.protocols.jd3.LarvalJob, setting: bool) -> None

C++: protocols::jd3::LarvalJob::completed(bool) –> void

defines_retry_limit(self: pyrosetta.rosetta.protocols.jd3.LarvalJob) → bool

C++: protocols::jd3::LarvalJob::defines_retry_limit() const –> bool

inner_job(self: pyrosetta.rosetta.protocols.jd3.LarvalJob) → pyrosetta.rosetta.protocols.jd3.InnerLarvalJob

read access to the inner-job

C++: protocols::jd3::LarvalJob::inner_job() const –> class std::shared_ptr<const class protocols::jd3::InnerLarvalJob>

input_job_result_indices(self: pyrosetta.rosetta.protocols.jd3.LarvalJob) → pyrosetta.rosetta.utility.vector1_std_pair_unsigned_long_unsigned_long_t
The list of the JobResults required to mature this %LarvalJob, by global index of the
already-executed (Lavral)Jobs and the result_index for that job.

C++: protocols::jd3::LarvalJob::input_job_result_indices() const –> const class utility::vector1<struct std::pair<unsigned long, unsigned long>, class std::allocator<struct std::pair<unsigned long, unsigned long> > > &

input_tag(self: pyrosetta.rosetta.protocols.jd3.LarvalJob) → str
The input tag (a short string, generally), is used to specify the input structure,
but is not a complete description of the LarvalJob, and certainly not the identifier with which to identify output structures.

C++: protocols::jd3::LarvalJob::input_tag() const –> std::string

job_index(self: pyrosetta.rosetta.protocols.jd3.LarvalJob) → int

The “global” index for this job among all jobs created by the JobQueen

C++: protocols::jd3::LarvalJob::job_index() const –> unsigned long

job_tag(self: pyrosetta.rosetta.protocols.jd3.LarvalJob) → str
The job tag is a combination of the input tag and any other data that the
JobQueen uses to describe the job, or that has been provided by the user in the job-definition XML file.

C++: protocols::jd3::LarvalJob::job_tag() const –> std::string

job_tag_with_index_suffix(*args, **kwargs)

Overloaded function.

  1. job_tag_with_index_suffix(self: pyrosetta.rosetta.protocols.jd3.LarvalJob, output_index: pyrosetta.rosetta.protocols.jd3.JobOutputIndex) -> str
  2. job_tag_with_index_suffix(self: pyrosetta.rosetta.protocols.jd3.LarvalJob, output_index: pyrosetta.rosetta.protocols.jd3.JobOutputIndex, min_digits: int) -> str
For output purposes, construct a string for a particular output of this job given
a JobOutputIndex.

C++: protocols::jd3::LarvalJob::job_tag_with_index_suffix(const struct protocols::jd3::JobOutputIndex &, const unsigned long) const –> std::string

nonconst_inner_job(self: pyrosetta.rosetta.protocols.jd3.LarvalJob) → pyrosetta.rosetta.protocols.jd3.InnerLarvalJob
write access to the inner-job; this should be reserved for the JobQueen only
as she edits the inner job during its construction

C++: protocols::jd3::LarvalJob::nonconst_inner_job() const –> class std::shared_ptr<class protocols::jd3::InnerLarvalJob>

nstruct_index(self: pyrosetta.rosetta.protocols.jd3.LarvalJob) → int
The index used to identify which job this is out of many that have identical inputs
but different random number seeds (controlled by the command-line flag “nstruct”)

C++: protocols::jd3::LarvalJob::nstruct_index() const –> unsigned long

nstruct_max(self: pyrosetta.rosetta.protocols.jd3.LarvalJob) → int

The total number of jobs with the same inputs, but different random number seeds.

C++: protocols::jd3::LarvalJob::nstruct_max() const –> unsigned long

retry_limit(*args, **kwargs)

Overloaded function.

  1. retry_limit(self: pyrosetta.rosetta.protocols.jd3.LarvalJob) -> int

C++: protocols::jd3::LarvalJob::retry_limit() const –> unsigned long

  1. retry_limit(self: pyrosetta.rosetta.protocols.jd3.LarvalJob, setting: int) -> None

C++: protocols::jd3::LarvalJob::retry_limit(unsigned long) –> void

set_status_prefix(self: pyrosetta.rosetta.protocols.jd3.LarvalJob, prefix: str) → None

C++: protocols::jd3::LarvalJob::set_status_prefix(const class std::basic_string<char> &) –> void

set_status_suffix(self: pyrosetta.rosetta.protocols.jd3.LarvalJob, suffix: str) → None

C++: protocols::jd3::LarvalJob::set_status_suffix(const class std::basic_string<char> &) –> void

show(self: pyrosetta.rosetta.protocols.jd3.LarvalJob, out: pyrosetta.rosetta.std.ostream) → None

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

status_prefix(self: pyrosetta.rosetta.protocols.jd3.LarvalJob) → str

C++: protocols::jd3::LarvalJob::status_prefix() const –> const std::string &

status_suffix(self: pyrosetta.rosetta.protocols.jd3.LarvalJob) → str

C++: protocols::jd3::LarvalJob::status_suffix() const –> const std::string &

to_do(self: pyrosetta.rosetta.protocols.jd3.LarvalJob) → bool

C++: protocols::jd3::LarvalJob::to_do() const –> bool