rosetta.basic.resource_manager
index
(built-in)

Bindings for basic::resource_manager namespace

 
Modules
       
rosetta.basic.resource_manager.fallback_configuration
rosetta.basic.resource_manager.locator

 
Classes
       
builtins.object
FallbackConfiguration
FallbackConfigurationCreator
JobOptions
ResourceConfiguration
ResourceLoader
ResourceLoaderCreator
ResourceLocator
ResourceLocatorCreator
ResourceManager
LazyResourceManager
ResourceManagerCreator
ResourceOptions
ResourceOptionsCreator
ResourceStream
rosetta.utility.SingletonBase_basic_resource_manager_FallbackConfigurationFactory_t(builtins.object)
FallbackConfigurationFactory
rosetta.utility.SingletonBase_basic_resource_manager_ResourceLoaderFactory_t(builtins.object)
ResourceLoaderFactory
rosetta.utility.SingletonBase_basic_resource_manager_ResourceLocatorFactory_t(builtins.object)
ResourceLocatorFactory
rosetta.utility.SingletonBase_basic_resource_manager_ResourceManagerFactory_t(builtins.object)
ResourceManagerFactory
rosetta.utility.SingletonBase_basic_resource_manager_ResourceOptionsFactory_t(builtins.object)
ResourceOptionsFactory

 
class FallbackConfiguration(builtins.object)
    The %FallbackConfiguration class describes how a resource should
be created if the ResourceManager is not being used, i.e., if resources
have been specified through flags on the command line instead of through
a resource-definition file.
 
A protocol will still query the ResourceManager
for its desired resource in such a case (by its "resource_description")
and if no resource has been provided for that description, then the
ResourceManager will ask the FallbackConfigurationFactory for the
%FallbackConfiguration that has been registered for that resource
description (this registration logic is handled by the
FallbackConfigurationCreator) and ask it to provide the information
necessary to create the appropriate resource from the command line.
 
For example, a user can define the loop they are interested in modeling to
the loop-modeling protocol via the LoopsFileData resource.  The loop modeling
protocol once was but is no longer responsible for opening a text file
and creating a LoopsFileData object from that text file; instead it asks the
ResourceManager directly for the resource.  For the sake of backwards
compatibility, the ResourceManager must have some way of creating a
LoopsFileData object from the command line.  If someone is using the loop modeling
application, but does not provide a resource definition, then the
LoopsFileFallbackConfiguration (derived from %FallbackConfiguration)
will be called upon by the ResourceManager for three things:
1) the name of the ResourceLoader to use to create the resource ("LoopsFile"),
2) the locator_id for the Resource (which it goes to the command line to find), and
3) a ResourceOptionsOP which is either null (meaning "use the default") or is in
some way initialized with options from the command line.  With these three bits, the
ResourceManager will go the appropriate ResourceLoader and request the construction
of the Resource as usual, opening the file using the default ResourceLocator
(for the JD2ResourceManager, this is the FileSystemResourceLocator).
 
  Methods defined here:
__init__(...) from builtins.PyCapsule
__init__(*args, **kwargs)
Overloaded function.
 
1. __init__(rosetta.basic.resource_manager.FallbackConfiguration) -> NoneType
 
2. __init__(rosetta.basic.resource_manager.FallbackConfiguration, rosetta.basic.resource_manager.FallbackConfiguration) -> NoneType
__new__(*args, **kwargs) from builtins.type
Create and return a new object.  See help(type) for accurate signature.
assign(...) from builtins.PyCapsule
assign(self : rosetta.basic.resource_manager.FallbackConfiguration,  : rosetta.basic.resource_manager.FallbackConfiguration) -> rosetta.basic.resource_manager.FallbackConfiguration
could_not_create_resource_error_message(...) from builtins.PyCapsule
could_not_create_resource_error_message(self : rosetta.basic.resource_manager.FallbackConfiguration, desc : str) -> str
 
If the %FallbackConfiguration has not been provided the appropriate set
 of command line flags needed to construct the Resource given the
 resource description, then return an error message informing the user
 what options must be provided on the command line.
fallback_specified(...) from builtins.PyCapsule
fallback_specified(self : rosetta.basic.resource_manager.FallbackConfiguration, desc : str) -> bool
 
Return true if a fallback been provided for the given resource description.
 It is possible that the fallback configuration would be unable to deliver
 a requested resource, e.g. if the appropriate command line option has not been provided.
get_locator_id(...) from builtins.PyCapsule
get_locator_id(self : rosetta.basic.resource_manager.FallbackConfiguration, desc : str) -> str
 
Return the locator id that the resource locator should use to
 find the data used to construct the desired resource - e.g. the file name.
get_resource_loader(...) from builtins.PyCapsule
get_resource_loader(self : rosetta.basic.resource_manager.FallbackConfiguration, desc : str) -> str
 
Return the name of the resource loader that should be used to instantiate the
 desired resource
get_resource_options(...) from builtins.PyCapsule
get_resource_options(self : rosetta.basic.resource_manager.FallbackConfiguration, desc : str) -> rosetta.basic.resource_manager.ResourceOptions
 
Return a pointer to the ResourceOptions object that the
 ResourceLoader will use to instantiate the given resource.  Return 0
 if the default ResourceOptions specified by the appropriate ResourceLoader
 should be used.

 
class FallbackConfigurationCreator(builtins.object)
    The ResourceManager looks to a FallbackConfiguration when a resource is
requested by a resource description string but no resource definition file
has been provided.  In such a case, the FallbackConfiguration will provide
the information the ResourceManager needs to create the resource.  It's the
%FallbackConfigurationCreator's job to inform the ResourceManager which
FallbackConfiguration to talk to.
 
Each class derived from the %FallbackConfigurationCreator will
instantiate a single FallbackConfiguration and act to pair a string,
a "resource description," with that FallbackConfiguration.  For example
"LoopFile" as a resource description will be paired by the
LoopFileFallbackConfigurationCreator with the LoopFileFallbackConfiguration.
Multiple resource descriptions can be paired with a single FallbackConfiguration.
 
  Methods defined here:
__init__(...) from builtins.PyCapsule
__init__(*args, **kwargs)
Overloaded function.
 
1. __init__(rosetta.basic.resource_manager.FallbackConfigurationCreator) -> NoneType
 
2. __init__(rosetta.basic.resource_manager.FallbackConfigurationCreator, rosetta.basic.resource_manager.FallbackConfigurationCreator) -> NoneType
__new__(*args, **kwargs) from builtins.type
Create and return a new object.  See help(type) for accurate signature.
assign(...) from builtins.PyCapsule
assign(self : rosetta.basic.resource_manager.FallbackConfigurationCreator,  : rosetta.basic.resource_manager.FallbackConfigurationCreator) -> rosetta.basic.resource_manager.FallbackConfigurationCreator
create_fallback_configuration(...) from builtins.PyCapsule
create_fallback_configuration(rosetta.basic.resource_manager.FallbackConfigurationCreator) -> rosetta.basic.resource_manager.FallbackConfiguration
resource_description(...) from builtins.PyCapsule
resource_description(rosetta.basic.resource_manager.FallbackConfigurationCreator) -> str

 
class FallbackConfigurationFactory(rosetta.utility.SingletonBase_basic_resource_manager_FallbackConfigurationFactory_t)
    The %FallbackConfigurationFactory is a singleton factory with which
FallbackConfigurationCreator objects should be registered.  The "fallback" system
serves as a mechanism for preserving command-line functionality even
while switching more protocols from requesting resources from the
ResourceManager rather than reading directly from the command line.
 
When a resource with a particular resource-description string is requested
from the ResourceManager, and the ResourceManager does not have any instructions
on how to load a resource matching that description, then the ResourceManager
will then ask the FallbackConfigurationFactory for help.  The
FallbackConfigurationFactory can first answer "does this resource description
match any resource descriptions for which you have a registered
FallbackConfigurationCreator?" and if the answer is "yes", then the
ResourceManager can request that FallbackConfigurationCreator and ask,
first, if it is able to construct a resource (FallbackConfigurations
often read from the command line, and it's possible that the required
flags have not been put on the command line), and if so, then request data
from the FallbackConfiguration needed to contruct that resource.
 
 
Method resolution order:
FallbackConfigurationFactory
rosetta.utility.SingletonBase_basic_resource_manager_FallbackConfigurationFactory_t
builtins.object

Methods defined here:
__init__(self, /, *args, **kwargs)
Initialize self.  See help(type(self)) for accurate signature.
__new__(*args, **kwargs) from builtins.type
Create and return a new object.  See help(type) for accurate signature.
create_fallback_configuration(...) from builtins.PyCapsule
create_fallback_configuration(self : rosetta.basic.resource_manager.FallbackConfigurationFactory, resource_description : str) -> rosetta.basic.resource_manager.FallbackConfiguration
factory_register(...) from builtins.PyCapsule
factory_register(self : rosetta.basic.resource_manager.FallbackConfigurationFactory, creator : rosetta.basic.resource_manager.FallbackConfigurationCreator) -> NoneType
has_fallback_for_resource(...) from builtins.PyCapsule
has_fallback_for_resource(self : rosetta.basic.resource_manager.FallbackConfigurationFactory, desc : str) -> bool
set_throw_on_double_registration(...) from builtins.PyCapsule
set_throw_on_double_registration(rosetta.basic.resource_manager.FallbackConfigurationFactory) -> NoneType
 
Only useful for unit testing.  Since factory registration happens (sometimes) at
 load time, there may be no one to catch a thrown exception in the event of a name collision
 two FallbackConfigurationCreators that register for the same

Methods inherited from rosetta.utility.SingletonBase_basic_resource_manager_FallbackConfigurationFactory_t:
get_instance(...) from builtins.PyCapsule
get_instance() -> basic::resource_manager::FallbackConfigurationFactory

 
class JobOptions(builtins.object)
    The %JobOptions class holds job-specific options (i.e. command line flags).  It can be used
by the ResourceManager to hold options for a particular job, so that the ResourceManager can
retrieve those options as needed. It is basically a bag for 12 OptionKey/OptionKeyValue
maps, one for every kind of OptionKey.
 
  Methods defined here:
__eq__(...) from builtins.PyCapsule
__eq__(self : rosetta.basic.resource_manager.JobOptions, rhs : rosetta.basic.resource_manager.JobOptions) -> bool
__init__(...) from builtins.PyCapsule
__init__(*args, **kwargs)
Overloaded function.
 
1. __init__(handle) -> NoneType
 
2. __init__(handle, rosetta.basic.resource_manager.JobOptions) -> NoneType
__new__(*args, **kwargs) from builtins.type
Create and return a new object.  See help(type) for accurate signature.
__str__(...) from builtins.PyCapsule
__str__(rosetta.basic.resource_manager.JobOptions) -> str
add_option(...) from builtins.PyCapsule
add_option(*args, **kwargs)
Overloaded function.
 
1. add_option(self : rosetta.basic.resource_manager.JobOptions, key : rosetta.utility.options.BooleanOptionKey, val : bool) -> NoneType
 
Set the value for the indicated boolean option
 
2. add_option(self : rosetta.basic.resource_manager.JobOptions, key : rosetta.utility.options.BooleanVectorOptionKey, val : rosetta.utility.vector1_bool) -> NoneType
 
Set the value for the indicated boolean-vector option
 
3. add_option(self : rosetta.basic.resource_manager.JobOptions, key : rosetta.utility.options.FileOptionKey, val : rosetta.utility.file.FileName) -> NoneType
 
Set the value for the indicated file option
 
4. add_option(self : rosetta.basic.resource_manager.JobOptions, key : rosetta.utility.options.FileVectorOptionKey, val : rosetta.utility.vector1_utility_file_FileName) -> NoneType
 
Set the value for the indicated file-vector option
 
5. add_option(self : rosetta.basic.resource_manager.JobOptions, key : rosetta.utility.options.IntegerOptionKey, val : int) -> NoneType
 
Set the value for the indicated integer option
 
6. add_option(self : rosetta.basic.resource_manager.JobOptions, key : rosetta.utility.options.IntegerVectorOptionKey, val : rosetta.utility.vector1_int) -> NoneType
 
Set the value for the indicated integer-vector option
 
7. add_option(self : rosetta.basic.resource_manager.JobOptions, key : rosetta.utility.options.PathOptionKey, val : rosetta.utility.file.PathName) -> NoneType
 
Set the value for the indicated path option
 
8. add_option(self : rosetta.basic.resource_manager.JobOptions, key : rosetta.utility.options.PathVectorOptionKey, val : rosetta.utility.vector1_utility_file_PathName) -> NoneType
 
Set the value for the indicated path-vector option
 
9. add_option(self : rosetta.basic.resource_manager.JobOptions, key : rosetta.utility.options.RealOptionKey, val : float) -> NoneType
 
Set the value for the indicated real option
 
10. add_option(self : rosetta.basic.resource_manager.JobOptions, key : rosetta.utility.options.RealVectorOptionKey, val : rosetta.utility.vector1_double) -> NoneType
 
Set the value for the indicated real-vector option
 
11. add_option(self : rosetta.basic.resource_manager.JobOptions, key : rosetta.utility.options.StringOptionKey, val : str) -> NoneType
 
Set the value for the indicated string option
 
12. add_option(self : rosetta.basic.resource_manager.JobOptions, key : rosetta.utility.options.StringVectorOptionKey, val : rosetta.utility.vector1_std_string) -> NoneType
 
Set the value for the indicated string-vector option
assign(...) from builtins.PyCapsule
assign(self : rosetta.basic.resource_manager.JobOptions,  : rosetta.basic.resource_manager.JobOptions) -> rosetta.basic.resource_manager.JobOptions
get_option(...) from builtins.PyCapsule
get_option(*args, **kwargs)
Overloaded function.
 
1. get_option(self : rosetta.basic.resource_manager.JobOptions, key : rosetta.utility.options.BooleanOptionKey) -> bool
 
Return the value of the indicated boolean option
 
2. get_option(self : rosetta.basic.resource_manager.JobOptions, key : rosetta.utility.options.BooleanVectorOptionKey) -> rosetta.utility.vector1_bool
 
Return the value of the indicated boolean-vector option
 
3. get_option(self : rosetta.basic.resource_manager.JobOptions, key : rosetta.utility.options.FileOptionKey) -> rosetta.utility.file.FileName
 
Return the value of the indicated file option
 
4. get_option(self : rosetta.basic.resource_manager.JobOptions, key : rosetta.utility.options.FileVectorOptionKey) -> rosetta.utility.vector1_utility_file_FileName
 
Return the value of the indicated file-vector option
 
5. get_option(self : rosetta.basic.resource_manager.JobOptions, key : rosetta.utility.options.IntegerOptionKey) -> int
 
Return the value of the indicated integer option
 
6. get_option(self : rosetta.basic.resource_manager.JobOptions, key : rosetta.utility.options.IntegerVectorOptionKey) -> rosetta.utility.vector1_int
 
Return the value of the indicated integer-vector option
 
7. get_option(self : rosetta.basic.resource_manager.JobOptions, key : rosetta.utility.options.PathOptionKey) -> rosetta.utility.file.PathName
 
Return the value of the indicated path option
 
8. get_option(self : rosetta.basic.resource_manager.JobOptions, key : rosetta.utility.options.PathVectorOptionKey) -> rosetta.utility.vector1_utility_file_PathName
 
Return the value of the indicated path-vector option
 
9. get_option(self : rosetta.basic.resource_manager.JobOptions, key : rosetta.utility.options.RealOptionKey) -> float
 
Return the value of the indicated real option
 
10. get_option(self : rosetta.basic.resource_manager.JobOptions, key : rosetta.utility.options.RealVectorOptionKey) -> rosetta.utility.vector1_double
 
Return the value of the indicated real-vector option
 
11. get_option(self : rosetta.basic.resource_manager.JobOptions, key : rosetta.utility.options.StringOptionKey) -> str
 
Return the value of the indicated string option
 
12. get_option(self : rosetta.basic.resource_manager.JobOptions, key : rosetta.utility.options.StringVectorOptionKey) -> rosetta.utility.vector1_std_string
 
Return the value of the indicated string-vector option
has_option(...) from builtins.PyCapsule
has_option(*args, **kwargs)
Overloaded function.
 
1. has_option(self : rosetta.basic.resource_manager.JobOptions, key : rosetta.utility.options.BooleanOptionKey) -> bool
 
Return true if a value for the indicated boolean option has been set
 
2. has_option(self : rosetta.basic.resource_manager.JobOptions, key : rosetta.utility.options.BooleanVectorOptionKey) -> bool
 
Return true if a value for the indicated boolean-vector option has been set
 
3. has_option(self : rosetta.basic.resource_manager.JobOptions, key : rosetta.utility.options.FileOptionKey) -> bool
 
Return true if a value for the indicated file option has been set
 
4. has_option(self : rosetta.basic.resource_manager.JobOptions, key : rosetta.utility.options.FileVectorOptionKey) -> bool
 
Return true if a value for the indicated file-vector option has been set
 
5. has_option(self : rosetta.basic.resource_manager.JobOptions, key : rosetta.utility.options.IntegerOptionKey) -> bool
 
Return true if a value for the indicated integer option has been set
 
6. has_option(self : rosetta.basic.resource_manager.JobOptions, key : rosetta.utility.options.IntegerVectorOptionKey) -> bool
 
Return true if a value for the indicated integer-vector option has been set
 
7. has_option(self : rosetta.basic.resource_manager.JobOptions, key : rosetta.utility.options.PathOptionKey) -> bool
 
Return true if a value for the indicated path option has been set
 
8. has_option(self : rosetta.basic.resource_manager.JobOptions, key : rosetta.utility.options.PathVectorOptionKey) -> bool
 
Return true if a value for the indicated path-vector option has been set
 
9. has_option(self : rosetta.basic.resource_manager.JobOptions, key : rosetta.utility.options.RealOptionKey) -> bool
 
Return true if a value for the indicated real option has been set
 
10. has_option(self : rosetta.basic.resource_manager.JobOptions, key : rosetta.utility.options.RealVectorOptionKey) -> bool
 
Return true if a value for the indicated real-vector option has been set
 
11. has_option(self : rosetta.basic.resource_manager.JobOptions, key : rosetta.utility.options.StringOptionKey) -> bool
 
Return true if a value for the indicated string option has been set
 
12. has_option(self : rosetta.basic.resource_manager.JobOptions, key : rosetta.utility.options.StringVectorOptionKey) -> bool
 
Return true if a value for the indicated string-vector option has been set
insertion_order(...) from builtins.PyCapsule
insertion_order(rosetta.basic.resource_manager.JobOptions) -> rosetta.std.list_std_pair_utility_options_OptionTypes_std_string_std_allocator_std_pair_utility_options_OptionTypes_std_string_t
remove_option(...) from builtins.PyCapsule
remove_option(*args, **kwargs)
Overloaded function.
 
1. remove_option(self : rosetta.basic.resource_manager.JobOptions, key : rosetta.utility.options.BooleanOptionKey) -> NoneType
 
Unset the value for the indicated boolean option
 
2. remove_option(self : rosetta.basic.resource_manager.JobOptions, key : rosetta.utility.options.BooleanVectorOptionKey) -> NoneType
 
Unset the value for the indicated boolean-vector option
 
3. remove_option(self : rosetta.basic.resource_manager.JobOptions, key : rosetta.utility.options.FileOptionKey) -> NoneType
 
Unset the value for the indicated file option
 
4. remove_option(self : rosetta.basic.resource_manager.JobOptions, key : rosetta.utility.options.FileVectorOptionKey) -> NoneType
 
Unset the value for the indicated file-vector option
 
5. remove_option(self : rosetta.basic.resource_manager.JobOptions, key : rosetta.utility.options.IntegerOptionKey) -> NoneType
 
Unset the value for the indicated integer option
 
6. remove_option(self : rosetta.basic.resource_manager.JobOptions, key : rosetta.utility.options.IntegerVectorOptionKey) -> NoneType
 
Unset the value for the indicated integer-vector option
 
7. remove_option(self : rosetta.basic.resource_manager.JobOptions, key : rosetta.utility.options.PathOptionKey) -> NoneType
 
Unset the value for the indicated path option
 
8. remove_option(self : rosetta.basic.resource_manager.JobOptions, key : rosetta.utility.options.PathVectorOptionKey) -> NoneType
 
Unset the value for the indicated path-vector option
 
9. remove_option(self : rosetta.basic.resource_manager.JobOptions, key : rosetta.utility.options.RealOptionKey) -> NoneType
 
Unset the value for the indicated real option
 
10. remove_option(self : rosetta.basic.resource_manager.JobOptions, key : rosetta.utility.options.RealVectorOptionKey) -> NoneType
 
Unset the value for the indicated real-vector option
 
11. remove_option(self : rosetta.basic.resource_manager.JobOptions, key : rosetta.utility.options.StringOptionKey) -> NoneType
 
Unset the value for the indicated string option
 
12. remove_option(self : rosetta.basic.resource_manager.JobOptions, key : rosetta.utility.options.StringVectorOptionKey) -> NoneType
 
Unset the value for the indicated string-vector option
track_insertion_order(...) from builtins.PyCapsule
track_insertion_order(self : rosetta.basic.resource_manager.JobOptions, setting : bool) -> NoneType

 
class LazyResourceManager(ResourceManager)
    This is a mule class, meant to be derived from.  It's job
is to hold ResourceOptions and ResourceLocator objects by name (tag)
as well as the ResourceConfigurations which serve as complete
descriptions for how to construct a Resource.  It should be thought
of as a mule by classes that derive from it:  it won't do anything
on its own, but it can be directed to do things.  The point of the
class is to ake it easier to create ResourceManagers besides the
JD2ResourceManager, which, at the time of this documentation,
is the only class that derives from the LazyResourceManager.
 
 
Method resolution order:
LazyResourceManager
ResourceManager
builtins.object

Methods defined here:
__init__(self, /, *args, **kwargs)
Initialize self.  See help(type(self)) for accurate signature.
__new__(*args, **kwargs) from builtins.type
Create and return a new object.  See help(type) for accurate signature.
__str__(...) from builtins.PyCapsule
__str__(rosetta.basic.resource_manager.LazyResourceManager) -> str
add_job_options(...) from builtins.PyCapsule
add_job_options(self : rosetta.basic.resource_manager.LazyResourceManager, job_tag : str, job_options : rosetta.basic.resource_manager.JobOptions) -> NoneType
add_resource_configuration(...) from builtins.PyCapsule
add_resource_configuration(self : rosetta.basic.resource_manager.LazyResourceManager, resource_tag : str, resource_configuration : rosetta.basic.resource_manager.ResourceConfiguration) -> NoneType
add_resource_locator(...) from builtins.PyCapsule
add_resource_locator(self : rosetta.basic.resource_manager.LazyResourceManager, locator_tag : str, resource_locator : basic::resource_manager::ResourceLocator) -> NoneType
add_resource_options(...) from builtins.PyCapsule
add_resource_options(self : rosetta.basic.resource_manager.LazyResourceManager, resource_options_tag : str, resource_options : rosetta.basic.resource_manager.ResourceOptions) -> NoneType
add_resource_tag_by_job_tag(...) from builtins.PyCapsule
add_resource_tag_by_job_tag(self : rosetta.basic.resource_manager.LazyResourceManager, resource_description : str, job_tag : str, resource_tag : str) -> NoneType
assign(...) from builtins.PyCapsule
assign(self : rosetta.basic.resource_manager.LazyResourceManager,  : rosetta.basic.resource_manager.LazyResourceManager) -> rosetta.basic.resource_manager.LazyResourceManager
clear(...) from builtins.PyCapsule
clear(rosetta.basic.resource_manager.LazyResourceManager) -> NoneType
 
wipe out all data; useful for unit testing, but hard to fathom how it would be useful
 otherwise.
create_resources(...) from builtins.PyCapsule
create_resources(self : rosetta.basic.resource_manager.LazyResourceManager,  : str) -> NoneType
 
Create all the resources for a particular job; this should be implemented by the derived
 class.  The implementation in this class calls utility::exit
find_resource_configuration(...) from builtins.PyCapsule
find_resource_configuration(self : rosetta.basic.resource_manager.LazyResourceManager, resource_tag : str) -> rosetta.basic.resource_manager.ResourceConfiguration
find_resource_locator(...) from builtins.PyCapsule
find_resource_locator(self : rosetta.basic.resource_manager.LazyResourceManager, locator_tag : str) -> basic::resource_manager::ResourceLocator
find_resource_options(...) from builtins.PyCapsule
find_resource_options(self : rosetta.basic.resource_manager.LazyResourceManager, resource_options_tag : str) -> rosetta.basic.resource_manager.ResourceOptions
find_resource_tag_by_job_tag(...) from builtins.PyCapsule
find_resource_tag_by_job_tag(self : rosetta.basic.resource_manager.LazyResourceManager, resource_description : str, job_tag : str) -> str
free_resource_by_job_tag(...) from builtins.PyCapsule
free_resource_by_job_tag(self : rosetta.basic.resource_manager.LazyResourceManager, resource_description : str, job_tag : str) -> NoneType
free_resource_by_tag(...) from builtins.PyCapsule
free_resource_by_tag(self : rosetta.basic.resource_manager.LazyResourceManager, resource_tag : str) -> NoneType
get_count_of_jobs_associated_with_resource_tag(...) from builtins.PyCapsule
get_count_of_jobs_associated_with_resource_tag(self : rosetta.basic.resource_manager.LazyResourceManager, resource_tag : str) -> int
get_job_options(...) from builtins.PyCapsule
get_job_options(self : rosetta.basic.resource_manager.LazyResourceManager, job_tag : str) -> rosetta.basic.resource_manager.JobOptions
get_resource_tags_for_job_tag(...) from builtins.PyCapsule
get_resource_tags_for_job_tag(self : rosetta.basic.resource_manager.LazyResourceManager, job_tag : str) -> rosetta.std.list_std_string_std_allocator_std_string_t
has_job_options(...) from builtins.PyCapsule
has_job_options(self : rosetta.basic.resource_manager.LazyResourceManager, job_tag : str) -> bool
has_resource(...) from builtins.PyCapsule
has_resource(self : rosetta.basic.resource_manager.LazyResourceManager, resource_tag : str) -> bool
 
Does a resource with a given name exist?
has_resource_configuration(...) from builtins.PyCapsule
has_resource_configuration(self : rosetta.basic.resource_manager.LazyResourceManager, resource_tag : str) -> bool
 
has a ResourceConfiguration been provided to the LazyResourceManager for a Resource with a particular ResourceTag?
has_resource_locator(...) from builtins.PyCapsule
has_resource_locator(self : rosetta.basic.resource_manager.LazyResourceManager, locator_tag : str) -> bool
 
has a ResourceLocator object been provided to the LazyResourceManager which has a particular LocatorTag?
has_resource_options(...) from builtins.PyCapsule
has_resource_options(self : rosetta.basic.resource_manager.LazyResourceManager, resource_options_tag : str) -> bool
 
has a ResourceOptions object been provided to the LazyResourceManager which has a particular ResourceOptionsTag?
has_resource_tag_by_job_tag(...) from builtins.PyCapsule
has_resource_tag_by_job_tag(self : rosetta.basic.resource_manager.LazyResourceManager, resource_description : str, job_tag : str) -> bool
mark_job_tag_as_complete(...) from builtins.PyCapsule
mark_job_tag_as_complete(self : rosetta.basic.resource_manager.LazyResourceManager, job_tag : str) -> NoneType
 
remove the Job tag from incomplete_job_sets_ for each resource

Methods inherited from ResourceManager:
get_instance(...) from builtins.PyCapsule
get_instance() -> rosetta.basic.resource_manager.ResourceManager
 
Deprecated access to a global (not-quite singleton) ResourceManager instance that
 should be removed
get_option(...) from builtins.PyCapsule
get_option(*args, **kwargs)
Overloaded function.
 
1. get_option(self : rosetta.basic.resource_manager.ResourceManager, key : rosetta.utility.options.BooleanOptionKey) -> bool
 
Retrieve the boolean value represented by the given option key
 
2. get_option(self : rosetta.basic.resource_manager.ResourceManager, key : rosetta.utility.options.BooleanVectorOptionKey) -> rosetta.utility.vector1_bool
 
Retrieve the vector of boolean values represented by the given option key
 
3. get_option(self : rosetta.basic.resource_manager.ResourceManager, key : rosetta.utility.options.FileOptionKey) -> rosetta.utility.file.FileName
 
Retrieve the FileName value represented by the given option key
 
4. get_option(self : rosetta.basic.resource_manager.ResourceManager, key : rosetta.utility.options.FileVectorOptionKey) -> rosetta.utility.vector1_utility_file_FileName
 
Retrieve the vector of FileName values represented by the given option key
 
5. get_option(self : rosetta.basic.resource_manager.ResourceManager, key : rosetta.utility.options.IntegerOptionKey) -> int
 
Retrieve the integer value represented by the given option key
 
6. get_option(self : rosetta.basic.resource_manager.ResourceManager, key : rosetta.utility.options.IntegerVectorOptionKey) -> rosetta.utility.vector1_int
 
Retrieve the vector of integer values represented by the given option key
 
7. get_option(self : rosetta.basic.resource_manager.ResourceManager, key : rosetta.utility.options.PathOptionKey) -> rosetta.utility.file.PathName
 
Retrieve the PathName value represented by the given option key
 
8. get_option(self : rosetta.basic.resource_manager.ResourceManager, key : rosetta.utility.options.PathVectorOptionKey) -> rosetta.utility.vector1_utility_file_PathName
 
Retrieve the vector of PathName values represented by the given option key
 
9. get_option(self : rosetta.basic.resource_manager.ResourceManager, key : rosetta.utility.options.RealOptionKey) -> float
 
Retrieve the Real value represented by the given option key
 
10. get_option(self : rosetta.basic.resource_manager.ResourceManager, key : rosetta.utility.options.RealVectorOptionKey) -> rosetta.utility.vector1_double
 
Retrieve the vector of Real values represented by the given option key
 
11. get_option(self : rosetta.basic.resource_manager.ResourceManager, key : rosetta.utility.options.StringOptionKey) -> str
 
Retrieve the string value represented by the given option key
 
12. get_option(self : rosetta.basic.resource_manager.ResourceManager, key : rosetta.utility.options.StringVectorOptionKey) -> rosetta.utility.vector1_std_string
 
Retrieve the vector of string values represented by the given option key
has_option(...) from builtins.PyCapsule
has_option(*args, **kwargs)
Overloaded function.
 
1. has_option(self : rosetta.basic.resource_manager.ResourceManager, key : rosetta.utility.options.BooleanOptionKey) -> bool
 
Return whether or not a value has been provided for the given option key either
 on the command line or through for the current job.
 
2. has_option(self : rosetta.basic.resource_manager.ResourceManager, key : rosetta.utility.options.BooleanVectorOptionKey) -> bool
 
Return whether or not a value has been provided for the given option key either
 on the command line or through for the current job.
 
3. has_option(self : rosetta.basic.resource_manager.ResourceManager, key : rosetta.utility.options.FileOptionKey) -> bool
 
Return whether or not a value has been provided for the given option key either
 on the command line or through for the current job.
 
4. has_option(self : rosetta.basic.resource_manager.ResourceManager, key : rosetta.utility.options.FileVectorOptionKey) -> bool
 
Return whether or not a value has been provided for the given option key either
 on the command line or through for the current job.
 
5. has_option(self : rosetta.basic.resource_manager.ResourceManager, key : rosetta.utility.options.IntegerOptionKey) -> bool
 
Return whether or not a value has been provided for the given option key either
 on the command line or through for the current job.
 
6. has_option(self : rosetta.basic.resource_manager.ResourceManager, key : rosetta.utility.options.IntegerVectorOptionKey) -> bool
 
Return whether or not a value has been provided for the given option key either
 on the command line or through for the current job.
 
7. has_option(self : rosetta.basic.resource_manager.ResourceManager, key : rosetta.utility.options.PathOptionKey) -> bool
 
Return whether or not a value has been provided for the given option key either
 on the command line or through for the current job.
 
8. has_option(self : rosetta.basic.resource_manager.ResourceManager, key : rosetta.utility.options.PathVectorOptionKey) -> bool
 
Return whether or not a value has been provided for the given option key either
 on the command line or through for the current job.
 
9. has_option(self : rosetta.basic.resource_manager.ResourceManager, key : rosetta.utility.options.RealOptionKey) -> bool
 
Return whether or not a value has been provided for the given option key either
 on the command line or through for the current job.
 
10. has_option(self : rosetta.basic.resource_manager.ResourceManager, key : rosetta.utility.options.RealVectorOptionKey) -> bool
 
Return whether or not a value has been provided for the given option key either
 on the command line or through for the current job.
 
11. has_option(self : rosetta.basic.resource_manager.ResourceManager, key : rosetta.utility.options.StringOptionKey) -> bool
 
Return whether or not a value has been provided for the given option key either
 on the command line or through for the current job.
 
12. has_option(self : rosetta.basic.resource_manager.ResourceManager, key : rosetta.utility.options.StringVectorOptionKey) -> bool
 
Return whether or not a value has been provided for the given option key either
 on the command line or through for the current job.
has_resource_with_description(...) from builtins.PyCapsule
has_resource_with_description(self : rosetta.basic.resource_manager.ResourceManager, resource_description : str) -> bool
 
A protocol may ask whether a resource with a given resource description
 has been provided.  It is possible that some resources are available sometimes
 when running a protocol, but not always (e.g. when running abinitio, sometimes
 you don't know what the native structure is).

 
class ResourceConfiguration(builtins.object)
    The set of strings necessary to describe how a resource
should be constructed.
 
  Methods defined here:
__init__(...) from builtins.PyCapsule
__init__(*args, **kwargs)
Overloaded function.
 
1. __init__(handle) -> NoneType
 
2. __init__(handle, rosetta.basic.resource_manager.ResourceConfiguration) -> NoneType
__new__(*args, **kwargs) from builtins.type
Create and return a new object.  See help(type) for accurate signature.
__str__(...) from builtins.PyCapsule
__str__(rosetta.basic.resource_manager.ResourceConfiguration) -> str
assign(...) from builtins.PyCapsule
assign(self : rosetta.basic.resource_manager.ResourceConfiguration,  : rosetta.basic.resource_manager.ResourceConfiguration) -> rosetta.basic.resource_manager.ResourceConfiguration

Data descriptors defined here:
loader_type
locator_id
locator_tag
resource_options_tag
resource_tag

 
class ResourceLoader(builtins.object)
    The ResourceLoader is responsible for instantiating a Resource object
and initializing it.  In order to do so, the ResourceLoader is given an input
stream and a ResourceOptions object.  Note that the ResourceOptions object has
to be of the right type, or the ResourceLoader will not be able to read the
data that it needs out of it.  If the ResourceLoader is given the wrong kind
of ResourceOptions object, it will throw an exception.
 
  Methods defined here:
__init__(self, /, *args, **kwargs)
Initialize self.  See help(type(self)) for accurate signature.
__new__(*args, **kwargs) from builtins.type
Create and return a new object.  See help(type) for accurate signature.
assign(...) from builtins.PyCapsule
assign(self : rosetta.basic.resource_manager.ResourceLoader,  : rosetta.basic.resource_manager.ResourceLoader) -> rosetta.basic.resource_manager.ResourceLoader
default_options(...) from builtins.PyCapsule
default_options(rosetta.basic.resource_manager.ResourceLoader) -> rosetta.basic.resource_manager.ResourceOptions

 
class ResourceLoaderCreator(builtins.object)
    Instantiates a ResourceLoader as part of the ResourceLoaderFactory scheme.
Derived classes should be registered with the ResourceLoaderFactory in one of
the library init.cc files with a ResourceLoaderRegistrator
 
  Methods defined here:
__init__(...) from builtins.PyCapsule
__init__(*args, **kwargs)
Overloaded function.
 
1. __init__(rosetta.basic.resource_manager.ResourceLoaderCreator) -> NoneType
 
2. __init__(rosetta.basic.resource_manager.ResourceLoaderCreator, rosetta.basic.resource_manager.ResourceLoaderCreator) -> NoneType
__new__(*args, **kwargs) from builtins.type
Create and return a new object.  See help(type) for accurate signature.
assign(...) from builtins.PyCapsule
assign(self : rosetta.basic.resource_manager.ResourceLoaderCreator,  : rosetta.basic.resource_manager.ResourceLoaderCreator) -> rosetta.basic.resource_manager.ResourceLoaderCreator
create_resource_loader(...) from builtins.PyCapsule
create_resource_loader(rosetta.basic.resource_manager.ResourceLoaderCreator) -> rosetta.basic.resource_manager.ResourceLoader
 
Instantiate a ResourceLoader
loader_type(...) from builtins.PyCapsule
loader_type(rosetta.basic.resource_manager.ResourceLoaderCreator) -> str
 
Give the name of the ResourceLoader that this Creator will instantiate.

 
class ResourceLoaderFactory(rosetta.utility.SingletonBase_basic_resource_manager_ResourceLoaderFactory_t)
    Instantiates ResourceLoaders.  Creators may be registered with
the Factory at any point, though it is recommended they be registered
at load time.  If two Creators are registered and they both give the
same name for the ResourceLoader they say they will instantiate, then
the Factory will exit with an error message.
 
 
Method resolution order:
ResourceLoaderFactory
rosetta.utility.SingletonBase_basic_resource_manager_ResourceLoaderFactory_t
builtins.object

Methods defined here:
__init__(self, /, *args, **kwargs)
Initialize self.  See help(type(self)) for accurate signature.
__new__(*args, **kwargs) from builtins.type
Create and return a new object.  See help(type) for accurate signature.
available_resource_loaders(...) from builtins.PyCapsule
available_resource_loaders(rosetta.basic.resource_manager.ResourceLoaderFactory) -> rosetta.std.list_std_string_std_allocator_std_string_t
 
Return a list of all the resource loaders available
create_resource_loader(...) from builtins.PyCapsule
create_resource_loader(self : rosetta.basic.resource_manager.ResourceLoaderFactory, loader_type : str) -> rosetta.basic.resource_manager.ResourceLoader
 
Instantiates a resource loader ofa  given type; throws
 an exception if no loader with this type has been previously
 registered.
factory_register(...) from builtins.PyCapsule
factory_register(self : rosetta.basic.resource_manager.ResourceLoaderFactory, creator : rosetta.basic.resource_manager.ResourceLoaderCreator) -> NoneType
 
Register a ResourceLoaderCreator with the factory.  The factory
 asks the Creator for the name of the ResourceLoader that it will create;
 if another Creator has already registered with the factory that proports
 to instantiate another ResourceLoader with the same name, then it will
 exit with an error message, or, if set_throw_on_double_registration()
 has previously been called, throw an exception.
has_resource_loader(...) from builtins.PyCapsule
has_resource_loader(self : rosetta.basic.resource_manager.ResourceLoaderFactory, loader_type : str) -> bool
 
Returns true if a resource loader of the given type has been
 registered with the factory
set_throw_on_double_registration(...) from builtins.PyCapsule
set_throw_on_double_registration(rosetta.basic.resource_manager.ResourceLoaderFactory) -> NoneType
 
Only useful for unit testing.  Since factory registration happens (sometimes) at
 load time, there may be no one to catch a thrown exception in the event of a name collision
 two FallbackConfigurationCreators that register for the same

Methods inherited from rosetta.utility.SingletonBase_basic_resource_manager_ResourceLoaderFactory_t:
get_instance(...) from builtins.PyCapsule
get_instance() -> basic::resource_manager::ResourceLoaderFactory

 
class ResourceLocator(builtins.object)
    %ResourceLocator classes are responsible for retrieving data
from a data store that will be used to construct a Resource.  This
data store could be a file system or a database or any other
place where data is stored.
 
The ResourceManager asks the ResourceLocator to produce a
ResourceStream object when given a "locator_id."  A "locator_id"
is what's needed to identify a data source from a data store:
for example, for the FileSystemResourceLocator, the locator id
is a file name; for the DatabaseResourceLocator, it would be
a database query.
 
  Methods defined here:
__init__(self, /, *args, **kwargs)
Initialize self.  See help(type(self)) for accurate signature.
__new__(*args, **kwargs) from builtins.type
Create and return a new object.  See help(type) for accurate signature.
assign(...) from builtins.PyCapsule
assign(self : rosetta.basic.resource_manager.ResourceLocator,  : rosetta.basic.resource_manager.ResourceLocator) -> rosetta.basic.resource_manager.ResourceLocator
locate_resource_stream(...) from builtins.PyCapsule
locate_resource_stream(self : rosetta.basic.resource_manager.ResourceLocator, locator_id : str) -> rosetta.basic.resource_manager.ResourceStream
 
Create and return a ResourceStream object from the given locator_id
 so that its stream can be passed to the ResourceLoader
locator_tag(...) from builtins.PyCapsule
locator_tag(*args, **kwargs)
Overloaded function.
 
1. locator_tag(self : rosetta.basic.resource_manager.ResourceLocator, locator_tag : str) -> NoneType
 
Set the name for this %ResourceLocator
 
2. locator_tag(rosetta.basic.resource_manager.ResourceLocator) -> str
 
Return the name for this %ResourceLocator
parse_my_tag(...) from builtins.PyCapsule
parse_my_tag(self : rosetta.basic.resource_manager.ResourceLocator, tag : utility::tag::Tag) -> NoneType
 
Initialize the parameters for this %ResourceLocator from the contents of
 an XML file.
type(...) from builtins.PyCapsule
type(rosetta.basic.resource_manager.ResourceLocator) -> str
 
Return the class name for this %ResourceLocator instance.
 This function allows for better error message delivery.

 
class ResourceLocatorCreator(builtins.object)
    The %ResourceLocatorCreator class serves to link the name of
a locator type and the (derived) ResourceLocator class that's responsible
for retrieving data from a data store.
 
  Methods defined here:
__init__(...) from builtins.PyCapsule
__init__(rosetta.basic.resource_manager.ResourceLocatorCreator) -> NoneType
__new__(*args, **kwargs) from builtins.type
Create and return a new object.  See help(type) for accurate signature.
assign(...) from builtins.PyCapsule
assign(self : rosetta.basic.resource_manager.ResourceLocatorCreator,  : rosetta.basic.resource_manager.ResourceLocatorCreator) -> rosetta.basic.resource_manager.ResourceLocatorCreator
create_resource_locator(...) from builtins.PyCapsule
create_resource_locator(rosetta.basic.resource_manager.ResourceLocatorCreator) -> rosetta.basic.resource_manager.ResourceLocator
locator_type(...) from builtins.PyCapsule
locator_type(rosetta.basic.resource_manager.ResourceLocatorCreator) -> str

 
class ResourceLocatorFactory(rosetta.utility.SingletonBase_basic_resource_manager_ResourceLocatorFactory_t)
    The %ResourceLocatorFactory instantiates ResourceLocator objects given their corresponding
locator-type strings.  It uses the load-time factory registration scheme, meaning that it is a
singleton and takes an instance of a Creator object (a ResourceLocatorCreator) in its
"factory_register" method.  Templated instances of the ResourceLocatorRegistrator classes should
be placed in the library init.cc files  (e.g. core/init/init.cc or
protocols/init/init.ResourceLocatorRegistrators.ihh)
 
 
Method resolution order:
ResourceLocatorFactory
rosetta.utility.SingletonBase_basic_resource_manager_ResourceLocatorFactory_t
builtins.object

Methods defined here:
__init__(self, /, *args, **kwargs)
Initialize self.  See help(type(self)) for accurate signature.
__new__(*args, **kwargs) from builtins.type
Create and return a new object.  See help(type) for accurate signature.
create_resource_locator(...) from builtins.PyCapsule
create_resource_locator(self : rosetta.basic.resource_manager.ResourceLocatorFactory, locator_type : str, locator_tag : str, tags : utility::tag::Tag) -> rosetta.basic.resource_manager.ResourceLocator
 
Create a ResourceLocator given its locator_type, giving the newly created instance the name locator_tag
factory_register(...) from builtins.PyCapsule
factory_register(self : rosetta.basic.resource_manager.ResourceLocatorFactory, creator : rosetta.basic.resource_manager.ResourceLocatorCreator) -> NoneType
 
This function is called on the singleton instance to give a ResourceLocatorCreator to the
 factory, usually through the constructor of a ResourceLocatorRegistrator class.
set_throw_on_double_registration(...) from builtins.PyCapsule
set_throw_on_double_registration(rosetta.basic.resource_manager.ResourceLocatorFactory) -> NoneType
 
Only useful for unit testing.  Since factory registration happens (sometimes) at
 load time, there may be no one to catch a thrown exception in the event of a name collision
 between two ResourceLocatorCreators that register for the same name.

Methods inherited from rosetta.utility.SingletonBase_basic_resource_manager_ResourceLocatorFactory_t:
get_instance(...) from builtins.PyCapsule
get_instance() -> basic::resource_manager::ResourceLocatorFactory

 
class ResourceManager(builtins.object)
    The ResourceManager is a singleton class responsible for holding, distributing,
and eventually deallocating resources which may be shared between multiple jobs.  A
protocol may communicate directly with the ResourceManager, requesting resources, but
remaining unaware of where those resources came from, or whether the same resource is
being used in multiple contexts.
 
A protocol should request a resource using a "resource description" (a string), which
is a generic way of referring to a piece of data.  For example, a protocol might request
the native Pose, by asking for a resource with the description "native".  The
ResourceManager's job is to return the resource matching that description; when
the "native" is requested, it is requested in some context (e.g. in a protocol running
under JD2) and the ResourceManager serves as a backbone in which to deliever
context-specific data to the protocol, while keeping the protocol ignorant and
independent of the surrounding context.  That way protocols can run in JD2 just as
effectively as the could run in some other job-management environment, without
having to assume responsibility for instantiating resources themselves.
 
NOTE: Because the logic for deciding which of the derived ResourceManager classes
should be instantiated depends on the options system, the ResourceManager should
not be requested until after core::init::init() has been called (i.e. it should not
be requested at load time.)
 
  Methods defined here:
__init__(self, /, *args, **kwargs)
Initialize self.  See help(type(self)) for accurate signature.
__new__(*args, **kwargs) from builtins.type
Create and return a new object.  See help(type) for accurate signature.
__str__(...) from builtins.PyCapsule
__str__(rosetta.basic.resource_manager.ResourceManager) -> str
assign(...) from builtins.PyCapsule
assign(self : rosetta.basic.resource_manager.ResourceManager,  : rosetta.basic.resource_manager.ResourceManager) -> rosetta.basic.resource_manager.ResourceManager
clear(...) from builtins.PyCapsule
clear(rosetta.basic.resource_manager.ResourceManager) -> NoneType
 
wipe out all data; useful for unit testing, but hard to
 fathom how it would be useful otherwise.
get_instance(...) from builtins.PyCapsule
get_instance() -> rosetta.basic.resource_manager.ResourceManager
 
Deprecated access to a global (not-quite singleton) ResourceManager instance that
 should be removed
get_option(...) from builtins.PyCapsule
get_option(*args, **kwargs)
Overloaded function.
 
1. get_option(self : rosetta.basic.resource_manager.ResourceManager, key : rosetta.utility.options.BooleanOptionKey) -> bool
 
Retrieve the boolean value represented by the given option key
 
2. get_option(self : rosetta.basic.resource_manager.ResourceManager, key : rosetta.utility.options.BooleanVectorOptionKey) -> rosetta.utility.vector1_bool
 
Retrieve the vector of boolean values represented by the given option key
 
3. get_option(self : rosetta.basic.resource_manager.ResourceManager, key : rosetta.utility.options.FileOptionKey) -> rosetta.utility.file.FileName
 
Retrieve the FileName value represented by the given option key
 
4. get_option(self : rosetta.basic.resource_manager.ResourceManager, key : rosetta.utility.options.FileVectorOptionKey) -> rosetta.utility.vector1_utility_file_FileName
 
Retrieve the vector of FileName values represented by the given option key
 
5. get_option(self : rosetta.basic.resource_manager.ResourceManager, key : rosetta.utility.options.IntegerOptionKey) -> int
 
Retrieve the integer value represented by the given option key
 
6. get_option(self : rosetta.basic.resource_manager.ResourceManager, key : rosetta.utility.options.IntegerVectorOptionKey) -> rosetta.utility.vector1_int
 
Retrieve the vector of integer values represented by the given option key
 
7. get_option(self : rosetta.basic.resource_manager.ResourceManager, key : rosetta.utility.options.PathOptionKey) -> rosetta.utility.file.PathName
 
Retrieve the PathName value represented by the given option key
 
8. get_option(self : rosetta.basic.resource_manager.ResourceManager, key : rosetta.utility.options.PathVectorOptionKey) -> rosetta.utility.vector1_utility_file_PathName
 
Retrieve the vector of PathName values represented by the given option key
 
9. get_option(self : rosetta.basic.resource_manager.ResourceManager, key : rosetta.utility.options.RealOptionKey) -> float
 
Retrieve the Real value represented by the given option key
 
10. get_option(self : rosetta.basic.resource_manager.ResourceManager, key : rosetta.utility.options.RealVectorOptionKey) -> rosetta.utility.vector1_double
 
Retrieve the vector of Real values represented by the given option key
 
11. get_option(self : rosetta.basic.resource_manager.ResourceManager, key : rosetta.utility.options.StringOptionKey) -> str
 
Retrieve the string value represented by the given option key
 
12. get_option(self : rosetta.basic.resource_manager.ResourceManager, key : rosetta.utility.options.StringVectorOptionKey) -> rosetta.utility.vector1_std_string
 
Retrieve the vector of string values represented by the given option key
has_option(...) from builtins.PyCapsule
has_option(*args, **kwargs)
Overloaded function.
 
1. has_option(self : rosetta.basic.resource_manager.ResourceManager, key : rosetta.utility.options.BooleanOptionKey) -> bool
 
Return whether or not a value has been provided for the given option key either
 on the command line or through for the current job.
 
2. has_option(self : rosetta.basic.resource_manager.ResourceManager, key : rosetta.utility.options.BooleanVectorOptionKey) -> bool
 
Return whether or not a value has been provided for the given option key either
 on the command line or through for the current job.
 
3. has_option(self : rosetta.basic.resource_manager.ResourceManager, key : rosetta.utility.options.FileOptionKey) -> bool
 
Return whether or not a value has been provided for the given option key either
 on the command line or through for the current job.
 
4. has_option(self : rosetta.basic.resource_manager.ResourceManager, key : rosetta.utility.options.FileVectorOptionKey) -> bool
 
Return whether or not a value has been provided for the given option key either
 on the command line or through for the current job.
 
5. has_option(self : rosetta.basic.resource_manager.ResourceManager, key : rosetta.utility.options.IntegerOptionKey) -> bool
 
Return whether or not a value has been provided for the given option key either
 on the command line or through for the current job.
 
6. has_option(self : rosetta.basic.resource_manager.ResourceManager, key : rosetta.utility.options.IntegerVectorOptionKey) -> bool
 
Return whether or not a value has been provided for the given option key either
 on the command line or through for the current job.
 
7. has_option(self : rosetta.basic.resource_manager.ResourceManager, key : rosetta.utility.options.PathOptionKey) -> bool
 
Return whether or not a value has been provided for the given option key either
 on the command line or through for the current job.
 
8. has_option(self : rosetta.basic.resource_manager.ResourceManager, key : rosetta.utility.options.PathVectorOptionKey) -> bool
 
Return whether or not a value has been provided for the given option key either
 on the command line or through for the current job.
 
9. has_option(self : rosetta.basic.resource_manager.ResourceManager, key : rosetta.utility.options.RealOptionKey) -> bool
 
Return whether or not a value has been provided for the given option key either
 on the command line or through for the current job.
 
10. has_option(self : rosetta.basic.resource_manager.ResourceManager, key : rosetta.utility.options.RealVectorOptionKey) -> bool
 
Return whether or not a value has been provided for the given option key either
 on the command line or through for the current job.
 
11. has_option(self : rosetta.basic.resource_manager.ResourceManager, key : rosetta.utility.options.StringOptionKey) -> bool
 
Return whether or not a value has been provided for the given option key either
 on the command line or through for the current job.
 
12. has_option(self : rosetta.basic.resource_manager.ResourceManager, key : rosetta.utility.options.StringVectorOptionKey) -> bool
 
Return whether or not a value has been provided for the given option key either
 on the command line or through for the current job.
has_resource(...) from builtins.PyCapsule
has_resource(self : rosetta.basic.resource_manager.ResourceManager, resource_tag : str) -> bool
 
Does a resource with a given name exist?
has_resource_with_description(...) from builtins.PyCapsule
has_resource_with_description(self : rosetta.basic.resource_manager.ResourceManager, resource_description : str) -> bool
 
A protocol may ask whether a resource with a given resource description
 has been provided.  It is possible that some resources are available sometimes
 when running a protocol, but not always (e.g. when running abinitio, sometimes
 you don't know what the native structure is).

 
class ResourceManagerCreator(builtins.object)
    Derived classes will be used by the ResourceManagerFactory to decide which
of the various ResourceManagers should be instantiated.  The ResourceManager
is a singleton, but, different ResourceManagers can be instantiated in different
contexts.
 
  Methods defined here:
__init__(self, /, *args, **kwargs)
Initialize self.  See help(type(self)) for accurate signature.
__new__(*args, **kwargs) from builtins.type
Create and return a new object.  See help(type) for accurate signature.
assign(...) from builtins.PyCapsule
assign(self : rosetta.basic.resource_manager.ResourceManagerCreator,  : rosetta.basic.resource_manager.ResourceManagerCreator) -> rosetta.basic.resource_manager.ResourceManagerCreator

 
class ResourceManagerFactory(rosetta.utility.SingletonBase_basic_resource_manager_ResourceManagerFactory_t)
    A factory class for managing the instantiation of the singleton
ResourceManager: only one of the various derived classes will be instantiated.
Currently, it asks for the JD2ResourceManager; in the future, this should be
fixed so that it reads from the options system to figure out which ResourceManager
to instantiate.
 
 
Method resolution order:
ResourceManagerFactory
rosetta.utility.SingletonBase_basic_resource_manager_ResourceManagerFactory_t
builtins.object

Methods defined here:
__init__(self, /, *args, **kwargs)
Initialize self.  See help(type(self)) for accurate signature.
__new__(*args, **kwargs) from builtins.type
Create and return a new object.  See help(type) for accurate signature.
create_resource_manager_from_options_system(...) from builtins.PyCapsule
create_resource_manager_from_options_system(rosetta.basic.resource_manager.ResourceManagerFactory) -> rosetta.basic.resource_manager.ResourceManager
 
Should only be called by the ResourceManager in its singleton construction!
factory_register(...) from builtins.PyCapsule
factory_register(self : rosetta.basic.resource_manager.ResourceManagerFactory, creator : rosetta.basic.resource_manager.ResourceManagerCreator) -> NoneType

Methods inherited from rosetta.utility.SingletonBase_basic_resource_manager_ResourceManagerFactory_t:
get_instance(...) from builtins.PyCapsule
get_instance() -> basic::resource_manager::ResourceManagerFactory

 
class ResourceOptions(builtins.object)
    The %ResourceOptions class is responsible for describing all
the data requried for instanting a particular resource, except for the
data stream (i.e. the file) that contains the data for the resource.
For example, when reading in a PDB file, there are 30 different options
for how that PDB file should be turned into a Pose.  That data is now
held in an ImportPoseOptions object.  The purpose of the %ResourceOptions
class is to allow different jobs to load resources in different ways, or
for one job to load two different resources of the same type in different
ways. For example, a protocol may need both a centroid pose and a
fullatom pose to be loaded in from disk; however, if the logic for
loading a pose in from disk is controlled by the options system alone,
this becomes impossible.
 
  Methods defined here:
__init__(...) from builtins.PyCapsule
__init__(*args, **kwargs)
Overloaded function.
 
1. __init__(rosetta.basic.resource_manager.ResourceOptions) -> NoneType
 
2. __init__(self : rosetta.basic.resource_manager.ResourceOptions, name : str) -> NoneType
 
3. __init__(rosetta.basic.resource_manager.ResourceOptions, rosetta.basic.resource_manager.ResourceOptions) -> NoneType
__new__(*args, **kwargs) from builtins.type
Create and return a new object.  See help(type) for accurate signature.
__str__(...) from builtins.PyCapsule
__str__(rosetta.basic.resource_manager.ResourceOptions) -> str
assign(...) from builtins.PyCapsule
assign(self : rosetta.basic.resource_manager.ResourceOptions,  : rosetta.basic.resource_manager.ResourceOptions) -> rosetta.basic.resource_manager.ResourceOptions
name(...) from builtins.PyCapsule
name(*args, **kwargs)
Overloaded function.
 
1. name(rosetta.basic.resource_manager.ResourceOptions) -> str
 
A name given to a particular ResourceOptions instance.
 This function allows for better error message delivery.
 
2. name(self : rosetta.basic.resource_manager.ResourceOptions, setting : str) -> NoneType
 
Set the name for this %ResoureOptions instance.
parse_my_tag(...) from builtins.PyCapsule
parse_my_tag(self : rosetta.basic.resource_manager.ResourceOptions, tag : utility::tag::Tag) -> NoneType
 
Initialize from the recursive "tag" structure.
type(...) from builtins.PyCapsule
type(rosetta.basic.resource_manager.ResourceOptions) -> str
 
The class name (its type) for a particular ResourceOptions instance.
 This function allows for better error message delivery.

 
class ResourceOptionsCreator(builtins.object)
    Each derived %ResourceOptionsCreator class is responsible for instantiating
a (specific) derived ResourceOptions class, and for telling the
ResourceOptionsFactory the string which identifies that class.  There should
be one derived ResourceOptionsCreator class for each ResourceOptions class.
 
  Methods defined here:
__init__(...) from builtins.PyCapsule
__init__(*args, **kwargs)
Overloaded function.
 
1. __init__(rosetta.basic.resource_manager.ResourceOptionsCreator) -> NoneType
 
2. __init__(rosetta.basic.resource_manager.ResourceOptionsCreator, rosetta.basic.resource_manager.ResourceOptionsCreator) -> NoneType
__new__(*args, **kwargs) from builtins.type
Create and return a new object.  See help(type) for accurate signature.
assign(...) from builtins.PyCapsule
assign(self : rosetta.basic.resource_manager.ResourceOptionsCreator,  : rosetta.basic.resource_manager.ResourceOptionsCreator) -> rosetta.basic.resource_manager.ResourceOptionsCreator
create_options(...) from builtins.PyCapsule
create_options(rosetta.basic.resource_manager.ResourceOptionsCreator) -> rosetta.basic.resource_manager.ResourceOptions
options_type(...) from builtins.PyCapsule
options_type(rosetta.basic.resource_manager.ResourceOptionsCreator) -> str

 
class ResourceOptionsFactory(rosetta.utility.SingletonBase_basic_resource_manager_ResourceOptionsFactory_t)
    The %ResourceOptionsFactory class is responsible for maintaining the map
between the names of the ResourceOptions classes (strings) and the ResourceOptionsCreator
classes that are responsible for instantiating the ResourceOption classes.  This
is a singleton class.  It is initialized at load time -- or at least after the call to
devel::init( argc, argv ) -- and populated with the help of ResourceOptionsRegistrator
instances.
 
 
Method resolution order:
ResourceOptionsFactory
rosetta.utility.SingletonBase_basic_resource_manager_ResourceOptionsFactory_t
builtins.object

Methods defined here:
__init__(self, /, *args, **kwargs)
Initialize self.  See help(type(self)) for accurate signature.
__new__(*args, **kwargs) from builtins.type
Create and return a new object.  See help(type) for accurate signature.
create_resource_options(...) from builtins.PyCapsule
create_resource_options(self : rosetta.basic.resource_manager.ResourceOptionsFactory, options_type : str, tag : utility::tag::Tag) -> rosetta.basic.resource_manager.ResourceOptions
 
Create an instance of a ResourceOptions class given the name of the class
 (options_type) and initialize it from the given tag object.  Throws an
 EXCN_Msg_Exception exception if the options_type string is not recognized.
factory_register(...) from builtins.PyCapsule
factory_register(self : rosetta.basic.resource_manager.ResourceOptionsFactory, creator : rosetta.basic.resource_manager.ResourceOptionsCreator) -> NoneType
 
Register the given ResourceOptionsCreator object with the factory.  Invoked by an
 instance of the templated ResourceOptionsRegistrator class.
set_throw_on_double_registration(...) from builtins.PyCapsule
set_throw_on_double_registration(rosetta.basic.resource_manager.ResourceOptionsFactory) -> NoneType
 
Instruct the %ResourceOptionsFactory to throw an exception if two ResourceOptionCreators
 are registered with the factory that report the same "options_type" string instead of invoking
 utility_exit_with_message.

Methods inherited from rosetta.utility.SingletonBase_basic_resource_manager_ResourceOptionsFactory_t:
get_instance(...) from builtins.PyCapsule
get_instance() -> basic::resource_manager::ResourceOptionsFactory

 
class ResourceStream(builtins.object)
    The %ResourceStream represents an abstract class for packaging
up a standard istream so that data that the ResourceLocator needs to
deliver to a ResourceLoader can come from arbitrary sources (e.g.
from either a file or from a database).
 
  Methods defined here:
__init__(self, /, *args, **kwargs)
Initialize self.  See help(type(self)) for accurate signature.
__new__(*args, **kwargs) from builtins.type
Create and return a new object.  See help(type) for accurate signature.
assign(...) from builtins.PyCapsule
assign(self : rosetta.basic.resource_manager.ResourceStream,  : rosetta.basic.resource_manager.ResourceStream) -> rosetta.basic.resource_manager.ResourceStream