datacache¶

Bindings for basic::datacache namespace

class pyrosetta.rosetta.basic.datacache.BasicDataCache¶

Bases: DataCache_basic_datacache_CacheableData_t

A DataCache storing objects derived from: basic::datacache::CacheableData.

See DataCache base class for usage details.

assign(self: pyrosetta.rosetta.basic.datacache.BasicDataCache, rval: pyrosetta.rosetta.basic.datacache.BasicDataCache) → pyrosetta.rosetta.basic.datacache.BasicDataCache¶

copy assignment

C++: basic::datacache::BasicDataCache::operator=(const class basic::datacache::BasicDataCache &) –> class basic::datacache::BasicDataCache &

clear(*args, **kwargs)¶

Overloaded function.

clear(self: pyrosetta.rosetta.basic.datacache.DataCache_basic_datacache_CacheableData_t) -> None

C++: basic::datacache::DataCache<basic::datacache::CacheableData>::clear() –> void

clear(self: pyrosetta.rosetta.basic.datacache.DataCache_basic_datacache_CacheableData_t, slot: int) -> None

C++: basic::datacache::DataCache<basic::datacache::CacheableData>::clear(unsigned long) –> void

get(self: pyrosetta.rosetta.basic.datacache.DataCache_basic_datacache_CacheableData_t, slot: int) → basic::datacache::CacheableData¶: C++: basic::datacache::DataCache<basic::datacache::CacheableData>::get(unsigned long) –> class basic::datacache::CacheableData &

get_const_ptr(self: pyrosetta.rosetta.basic.datacache.DataCache_basic_datacache_CacheableData_t, slot: int) → basic::datacache::CacheableData¶: C++: basic::datacache::DataCache<basic::datacache::CacheableData>::get_const_ptr(unsigned long) const –> class std::shared_ptr<const class basic::datacache::CacheableData>

get_ptr(self: pyrosetta.rosetta.basic.datacache.DataCache_basic_datacache_CacheableData_t, slot: int) → basic::datacache::CacheableData¶: C++: basic::datacache::DataCache<basic::datacache::CacheableData>::get_ptr(unsigned long) –> class std::shared_ptr<class basic::datacache::CacheableData>

get_raw_const_ptr(self: pyrosetta.rosetta.basic.datacache.DataCache_basic_datacache_CacheableData_t, slot: int) → basic::datacache::CacheableData¶: C++: basic::datacache::DataCache<basic::datacache::CacheableData>::get_raw_const_ptr(unsigned long) const –> const class basic::datacache::CacheableData *

get_raw_ptr(self: pyrosetta.rosetta.basic.datacache.DataCache_basic_datacache_CacheableData_t, slot: int) → basic::datacache::CacheableData¶: C++: basic::datacache::DataCache<basic::datacache::CacheableData>::get_raw_ptr(unsigned long) –> class basic::datacache::CacheableData *

has(self: pyrosetta.rosetta.basic.datacache.DataCache_basic_datacache_CacheableData_t, slot: int) → bool¶: C++: basic::datacache::DataCache<basic::datacache::CacheableData>::has(unsigned long) const –> bool

resize(self: pyrosetta.rosetta.basic.datacache.DataCache_basic_datacache_CacheableData_t, n_slots: int) → None¶: C++: basic::datacache::DataCache<basic::datacache::CacheableData>::resize(unsigned long) –> void

set(self: pyrosetta.rosetta.basic.datacache.DataCache_basic_datacache_CacheableData_t, slot: int, new_data: basic::datacache::CacheableData) → None¶: C++: basic::datacache::DataCache<basic::datacache::CacheableData>::set(unsigned long, class std::shared_ptr<class basic::datacache::CacheableData>) –> void

size(self: pyrosetta.rosetta.basic.datacache.DataCache_basic_datacache_CacheableData_t) → int¶: C++: basic::datacache::DataCache<basic::datacache::CacheableData>::size() const –> unsigned long

class pyrosetta.rosetta.basic.datacache.CacheableData¶

Bases: pybind11_object

base class for data storable within a DataCache

assign(self: pyrosetta.rosetta.basic.datacache.CacheableData, : pyrosetta.rosetta.basic.datacache.CacheableData) → pyrosetta.rosetta.basic.datacache.CacheableData¶: C++: basic::datacache::CacheableData::operator=(const class basic::datacache::CacheableData &) –> class basic::datacache::CacheableData &

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

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

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

class pyrosetta.rosetta.basic.datacache.CacheableResRotPairFloatMap¶

Bases: CacheableData

Wrapper for std::map< uint64_t, MathMatrix<float> >

assign(self: pyrosetta.rosetta.basic.datacache.CacheableResRotPairFloatMap, ot: pyrosetta.rosetta.basic.datacache.CacheableResRotPairFloatMap) → pyrosetta.rosetta.basic.datacache.CacheableResRotPairFloatMap¶: C++: basic::datacache::CacheableResRotPairFloatMap::operator=(const class basic::datacache::CacheableResRotPairFloatMap &) –> class basic::datacache::CacheableResRotPairFloatMap &

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

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

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

map(self: pyrosetta.rosetta.basic.datacache.CacheableResRotPairFloatMap) → pyrosetta.rosetta.std.unordered_map_basic_datacache_ResRotPair_float_basic_datacache_ResRotPairHasher_std_equal_to_basic_datacache_ResRotPair_std_allocator_std_pair_const_basic_datacache_ResRotPair_float_t¶: C++: basic::datacache::CacheableResRotPairFloatMap::map() –> class std::unordered_map<struct basic::datacache::ResRotPair, float, struct basic::datacache::ResRotPairHasher, struct std::equal_to<struct basic::datacache::ResRotPair>, class std::allocator<struct std::pair<const struct basic::datacache::ResRotPair, float> > > &

set_shallow_copy(self: pyrosetta.rosetta.basic.datacache.CacheableResRotPairFloatMap, shallow: bool) → None¶

Only perform a shallow copy when clone() is called

C++: basic::datacache::CacheableResRotPairFloatMap::set_shallow_copy(bool) –> void

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

class pyrosetta.rosetta.basic.datacache.CacheableString¶

Bases: CacheableData

Wrapper for std::string

assign(self: pyrosetta.rosetta.basic.datacache.CacheableString, : pyrosetta.rosetta.basic.datacache.CacheableString) → pyrosetta.rosetta.basic.datacache.CacheableString¶: C++: basic::datacache::CacheableString::operator=(const class basic::datacache::CacheableString &) –> class basic::datacache::CacheableString &

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

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

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

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

str(self: pyrosetta.rosetta.basic.datacache.CacheableString) → str¶: C++: basic::datacache::CacheableString::str() const –> const std::string &

class pyrosetta.rosetta.basic.datacache.CacheableStringFloatMap¶

Bases: CacheableData

Wrapper for std::map< std::string, float >

assign(self: pyrosetta.rosetta.basic.datacache.CacheableStringFloatMap, : pyrosetta.rosetta.basic.datacache.CacheableStringFloatMap) → pyrosetta.rosetta.basic.datacache.CacheableStringFloatMap¶: C++: basic::datacache::CacheableStringFloatMap::operator=(const class basic::datacache::CacheableStringFloatMap &) –> class basic::datacache::CacheableStringFloatMap &

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

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

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

map(self: pyrosetta.rosetta.basic.datacache.CacheableStringFloatMap) → pyrosetta.rosetta.std.map_std_string_float¶: C++: basic::datacache::CacheableStringFloatMap::map() –> class std::map<std::string, float, struct std::less<std::string >, class std::allocator<struct std::pair<const std::string, float> > > &

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

class pyrosetta.rosetta.basic.datacache.CacheableStringIntegerMap¶

Bases: CacheableData

Wrapper for std::map< std::string, integer >

assign(self: pyrosetta.rosetta.basic.datacache.CacheableStringIntegerMap, : pyrosetta.rosetta.basic.datacache.CacheableStringIntegerMap) → pyrosetta.rosetta.basic.datacache.CacheableStringIntegerMap¶: C++: basic::datacache::CacheableStringIntegerMap::operator=(const class basic::datacache::CacheableStringIntegerMap &) –> class basic::datacache::CacheableStringIntegerMap &

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

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

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

map(self: pyrosetta.rosetta.basic.datacache.CacheableStringIntegerMap) → pyrosetta.rosetta.std.map_std_string_int¶: C++: basic::datacache::CacheableStringIntegerMap::map() –> class std::map<std::string, int, struct std::less<std::string >, class std::allocator<struct std::pair<const std::string, int> > > &

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

class pyrosetta.rosetta.basic.datacache.CacheableStringMap¶

Bases: CacheableData

Wrapper for a map< string, string >.

assign(self: pyrosetta.rosetta.basic.datacache.CacheableStringMap, : pyrosetta.rosetta.basic.datacache.CacheableStringMap) → pyrosetta.rosetta.basic.datacache.CacheableStringMap¶: C++: basic::datacache::CacheableStringMap::operator=(const class basic::datacache::CacheableStringMap &) –> class basic::datacache::CacheableStringMap &

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

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

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

map(self: pyrosetta.rosetta.basic.datacache.CacheableStringMap) → pyrosetta.rosetta.std.map_std_string_std_string¶: C++: basic::datacache::CacheableStringMap::map() –> class std::map<std::string, std::string, struct std::less<std::string >, class std::allocator<struct std::pair<const std::string, std::string > > > &

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

class pyrosetta.rosetta.basic.datacache.CacheableUint64MathMatrixFloatMap¶

Bases: CacheableData

Wrapper for std::map< uint64_t, MathMatrix<float> >

assign(self: pyrosetta.rosetta.basic.datacache.CacheableUint64MathMatrixFloatMap, : pyrosetta.rosetta.basic.datacache.CacheableUint64MathMatrixFloatMap) → pyrosetta.rosetta.basic.datacache.CacheableUint64MathMatrixFloatMap¶: C++: basic::datacache::CacheableUint64MathMatrixFloatMap::operator=(const class basic::datacache::CacheableUint64MathMatrixFloatMap &) –> class basic::datacache::CacheableUint64MathMatrixFloatMap &

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

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

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

map(self: pyrosetta.rosetta.basic.datacache.CacheableUint64MathMatrixFloatMap) → pyrosetta.rosetta.std.unordered_map_unsigned_long_numeric_MathMatrix_float_t¶: C++: basic::datacache::CacheableUint64MathMatrixFloatMap::map() –> class std::unordered_map<unsigned long, class numeric::MathMatrix<float>, struct std::hash<unsigned long>, struct std::equal_to<unsigned long>, class std::allocator<struct std::pair<const unsigned long, class numeric::MathMatrix<float> > > > &

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

class pyrosetta.rosetta.basic.datacache.ConstDataMap¶

Bases: pybind11_object

general-purpose store for any kind of object with the particular copy semantics of copying by value. This is effectively a map of string pairs to (constant) pointers. The first string represents the category of the object, and the second being a name for that particular object. The guarantee with the ConstDataMap is that if an object is put into the map, it may be read from, but it will not be changed underneath you. Data stored in the ConstDataMap can safely be shared between threads.

assign(self: pyrosetta.rosetta.basic.datacache.ConstDataMap, rhs: pyrosetta.rosetta.basic.datacache.ConstDataMap) → pyrosetta.rosetta.basic.datacache.ConstDataMap¶

Performs a shallow copy of all of the pointers stored in rhs into this.

C++: basic::datacache::ConstDataMap::operator=(const class basic::datacache::ConstDataMap &) –> class basic::datacache::ConstDataMap &

has(*args, **kwargs)¶

Overloaded function.

has(self: pyrosetta.rosetta.basic.datacache.ConstDataMap, category: str) -> bool

are there any objects in the outer map with the given category?

C++: basic::datacache::ConstDataMap::has(const std::string &) const –> bool

has(self: pyrosetta.rosetta.basic.datacache.ConstDataMap, category: str, name: str) -> bool

Is there an object with the given category and the given name?

C++: basic::datacache::ConstDataMap::has(const std::string &, const std::string &) const –> bool

size(self: pyrosetta.rosetta.basic.datacache.ConstDataMap) → int¶

returns the number of objects contained in the map

C++: basic::datacache::ConstDataMap::size() const –> unsigned long

class pyrosetta.rosetta.basic.datacache.DataCache_CacheableData¶

Bases: DataCache_basic_datacache_CacheableData_t

assign(self: pyrosetta.rosetta.basic.datacache.DataCache_CacheableData, : pyrosetta.rosetta.basic.datacache.DataCache_CacheableData) → pyrosetta.rosetta.basic.datacache.DataCache_CacheableData¶: C++: basic::datacache::DataCache_CacheableData::operator=(const class basic::datacache::DataCache_CacheableData &) –> class basic::datacache::DataCache_CacheableData &

clear(*args, **kwargs)¶

Overloaded function.

clear(self: pyrosetta.rosetta.basic.datacache.DataCache_basic_datacache_CacheableData_t) -> None

C++: basic::datacache::DataCache<basic::datacache::CacheableData>::clear() –> void

clear(self: pyrosetta.rosetta.basic.datacache.DataCache_basic_datacache_CacheableData_t, slot: int) -> None

C++: basic::datacache::DataCache<basic::datacache::CacheableData>::clear(unsigned long) –> void

get(self: pyrosetta.rosetta.basic.datacache.DataCache_basic_datacache_CacheableData_t, slot: int) → basic::datacache::CacheableData¶: C++: basic::datacache::DataCache<basic::datacache::CacheableData>::get(unsigned long) –> class basic::datacache::CacheableData &

get_const_ptr(self: pyrosetta.rosetta.basic.datacache.DataCache_basic_datacache_CacheableData_t, slot: int) → basic::datacache::CacheableData¶: C++: basic::datacache::DataCache<basic::datacache::CacheableData>::get_const_ptr(unsigned long) const –> class std::shared_ptr<const class basic::datacache::CacheableData>

get_ptr(self: pyrosetta.rosetta.basic.datacache.DataCache_basic_datacache_CacheableData_t, slot: int) → basic::datacache::CacheableData¶: C++: basic::datacache::DataCache<basic::datacache::CacheableData>::get_ptr(unsigned long) –> class std::shared_ptr<class basic::datacache::CacheableData>

get_raw_const_ptr(self: pyrosetta.rosetta.basic.datacache.DataCache_basic_datacache_CacheableData_t, slot: int) → basic::datacache::CacheableData¶: C++: basic::datacache::DataCache<basic::datacache::CacheableData>::get_raw_const_ptr(unsigned long) const –> const class basic::datacache::CacheableData *

get_raw_ptr(self: pyrosetta.rosetta.basic.datacache.DataCache_basic_datacache_CacheableData_t, slot: int) → basic::datacache::CacheableData¶: C++: basic::datacache::DataCache<basic::datacache::CacheableData>::get_raw_ptr(unsigned long) –> class basic::datacache::CacheableData *

has(self: pyrosetta.rosetta.basic.datacache.DataCache_basic_datacache_CacheableData_t, slot: int) → bool¶: C++: basic::datacache::DataCache<basic::datacache::CacheableData>::has(unsigned long) const –> bool

resize(self: pyrosetta.rosetta.basic.datacache.DataCache_basic_datacache_CacheableData_t, n_slots: int) → None¶: C++: basic::datacache::DataCache<basic::datacache::CacheableData>::resize(unsigned long) –> void

set(self: pyrosetta.rosetta.basic.datacache.DataCache_basic_datacache_CacheableData_t, slot: int, new_data: basic::datacache::CacheableData) → None¶: C++: basic::datacache::DataCache<basic::datacache::CacheableData>::set(unsigned long, class std::shared_ptr<class basic::datacache::CacheableData>) –> void

size(self: pyrosetta.rosetta.basic.datacache.DataCache_basic_datacache_CacheableData_t) → int¶: C++: basic::datacache::DataCache<basic::datacache::CacheableData>::size() const –> unsigned long

class pyrosetta.rosetta.basic.datacache.DataCache_basic_datacache_CacheableData_t¶

Bases: pybind11_object

assign(self: pyrosetta.rosetta.basic.datacache.DataCache_basic_datacache_CacheableData_t, src: pyrosetta.rosetta.basic.datacache.DataCache_basic_datacache_CacheableData_t) → pyrosetta.rosetta.basic.datacache.DataCache_basic_datacache_CacheableData_t¶: C++: basic::datacache::DataCache<basic::datacache::CacheableData>::operator=(const class basic::datacache::DataCache<class basic::datacache::CacheableData> &) –> class basic::datacache::DataCache<class basic::datacache::CacheableData> &

clear(*args, **kwargs)¶

Overloaded function.

clear(self: pyrosetta.rosetta.basic.datacache.DataCache_basic_datacache_CacheableData_t) -> None

C++: basic::datacache::DataCache<basic::datacache::CacheableData>::clear() –> void

clear(self: pyrosetta.rosetta.basic.datacache.DataCache_basic_datacache_CacheableData_t, slot: int) -> None

C++: basic::datacache::DataCache<basic::datacache::CacheableData>::clear(unsigned long) –> void

get(self: pyrosetta.rosetta.basic.datacache.DataCache_basic_datacache_CacheableData_t, slot: int) → basic::datacache::CacheableData¶: C++: basic::datacache::DataCache<basic::datacache::CacheableData>::get(unsigned long) –> class basic::datacache::CacheableData &

get_const_ptr(self: pyrosetta.rosetta.basic.datacache.DataCache_basic_datacache_CacheableData_t, slot: int) → basic::datacache::CacheableData¶: C++: basic::datacache::DataCache<basic::datacache::CacheableData>::get_const_ptr(unsigned long) const –> class std::shared_ptr<const class basic::datacache::CacheableData>

get_ptr(self: pyrosetta.rosetta.basic.datacache.DataCache_basic_datacache_CacheableData_t, slot: int) → basic::datacache::CacheableData¶: C++: basic::datacache::DataCache<basic::datacache::CacheableData>::get_ptr(unsigned long) –> class std::shared_ptr<class basic::datacache::CacheableData>

get_raw_const_ptr(self: pyrosetta.rosetta.basic.datacache.DataCache_basic_datacache_CacheableData_t, slot: int) → basic::datacache::CacheableData¶: C++: basic::datacache::DataCache<basic::datacache::CacheableData>::get_raw_const_ptr(unsigned long) const –> const class basic::datacache::CacheableData *

get_raw_ptr(self: pyrosetta.rosetta.basic.datacache.DataCache_basic_datacache_CacheableData_t, slot: int) → basic::datacache::CacheableData¶: C++: basic::datacache::DataCache<basic::datacache::CacheableData>::get_raw_ptr(unsigned long) –> class basic::datacache::CacheableData *

has(self: pyrosetta.rosetta.basic.datacache.DataCache_basic_datacache_CacheableData_t, slot: int) → bool¶: C++: basic::datacache::DataCache<basic::datacache::CacheableData>::has(unsigned long) const –> bool

resize(self: pyrosetta.rosetta.basic.datacache.DataCache_basic_datacache_CacheableData_t, n_slots: int) → None¶: C++: basic::datacache::DataCache<basic::datacache::CacheableData>::resize(unsigned long) –> void

set(self: pyrosetta.rosetta.basic.datacache.DataCache_basic_datacache_CacheableData_t, slot: int, new_data: basic::datacache::CacheableData) → None¶: C++: basic::datacache::DataCache<basic::datacache::CacheableData>::set(unsigned long, class std::shared_ptr<class basic::datacache::CacheableData>) –> void

size(self: pyrosetta.rosetta.basic.datacache.DataCache_basic_datacache_CacheableData_t) → int¶: C++: basic::datacache::DataCache<basic::datacache::CacheableData>::size() const –> unsigned long

class pyrosetta.rosetta.basic.datacache.DataCache_core_pose_datacache_CacheableObserver_t¶

Bases: pybind11_object

assign(self: pyrosetta.rosetta.basic.datacache.DataCache_core_pose_datacache_CacheableObserver_t, src: pyrosetta.rosetta.basic.datacache.DataCache_core_pose_datacache_CacheableObserver_t) → pyrosetta.rosetta.basic.datacache.DataCache_core_pose_datacache_CacheableObserver_t¶: C++: basic::datacache::DataCache<core::pose::datacache::CacheableObserver>::operator=(const class basic::datacache::DataCache<class core::pose::datacache::CacheableObserver> &) –> class basic::datacache::DataCache<class core::pose::datacache::CacheableObserver> &

clear(*args, **kwargs)¶

Overloaded function.

clear(self: pyrosetta.rosetta.basic.datacache.DataCache_core_pose_datacache_CacheableObserver_t) -> None

C++: basic::datacache::DataCache<core::pose::datacache::CacheableObserver>::clear() –> void

clear(self: pyrosetta.rosetta.basic.datacache.DataCache_core_pose_datacache_CacheableObserver_t, slot: int) -> None

C++: basic::datacache::DataCache<core::pose::datacache::CacheableObserver>::clear(unsigned long) –> void

get(self: pyrosetta.rosetta.basic.datacache.DataCache_core_pose_datacache_CacheableObserver_t, slot: int) → core::pose::datacache::CacheableObserver¶: C++: basic::datacache::DataCache<core::pose::datacache::CacheableObserver>::get(unsigned long) –> class core::pose::datacache::CacheableObserver &

get_const_ptr(self: pyrosetta.rosetta.basic.datacache.DataCache_core_pose_datacache_CacheableObserver_t, slot: int) → core::pose::datacache::CacheableObserver¶: C++: basic::datacache::DataCache<core::pose::datacache::CacheableObserver>::get_const_ptr(unsigned long) const –> class std::shared_ptr<const class core::pose::datacache::CacheableObserver>

get_ptr(self: pyrosetta.rosetta.basic.datacache.DataCache_core_pose_datacache_CacheableObserver_t, slot: int) → core::pose::datacache::CacheableObserver¶: C++: basic::datacache::DataCache<core::pose::datacache::CacheableObserver>::get_ptr(unsigned long) –> class std::shared_ptr<class core::pose::datacache::CacheableObserver>

get_raw_const_ptr(self: pyrosetta.rosetta.basic.datacache.DataCache_core_pose_datacache_CacheableObserver_t, slot: int) → core::pose::datacache::CacheableObserver¶: C++: basic::datacache::DataCache<core::pose::datacache::CacheableObserver>::get_raw_const_ptr(unsigned long) const –> const class core::pose::datacache::CacheableObserver *

get_raw_ptr(self: pyrosetta.rosetta.basic.datacache.DataCache_core_pose_datacache_CacheableObserver_t, slot: int) → core::pose::datacache::CacheableObserver¶: C++: basic::datacache::DataCache<core::pose::datacache::CacheableObserver>::get_raw_ptr(unsigned long) –> class core::pose::datacache::CacheableObserver *

has(self: pyrosetta.rosetta.basic.datacache.DataCache_core_pose_datacache_CacheableObserver_t, slot: int) → bool¶: C++: basic::datacache::DataCache<core::pose::datacache::CacheableObserver>::has(unsigned long) const –> bool

resize(self: pyrosetta.rosetta.basic.datacache.DataCache_core_pose_datacache_CacheableObserver_t, n_slots: int) → None¶: C++: basic::datacache::DataCache<core::pose::datacache::CacheableObserver>::resize(unsigned long) –> void

set(self: pyrosetta.rosetta.basic.datacache.DataCache_core_pose_datacache_CacheableObserver_t, slot: int, new_data: core::pose::datacache::CacheableObserver) → None¶: C++: basic::datacache::DataCache<core::pose::datacache::CacheableObserver>::set(unsigned long, class std::shared_ptr<class core::pose::datacache::CacheableObserver>) –> void

size(self: pyrosetta.rosetta.basic.datacache.DataCache_core_pose_datacache_CacheableObserver_t) → int¶: C++: basic::datacache::DataCache<core::pose::datacache::CacheableObserver>::size() const –> unsigned long

class pyrosetta.rosetta.basic.datacache.DataMap¶

Bases: pybind11_object

general-purpose store for any reference-count derived object

assign(self: pyrosetta.rosetta.basic.datacache.DataMap, : pyrosetta.rosetta.basic.datacache.DataMap) → pyrosetta.rosetta.basic.datacache.DataMap¶: C++: basic::datacache::DataMap::operator=(const class basic::datacache::DataMap &) –> class basic::datacache::DataMap &

has(*args, **kwargs)¶

Overloaded function.

has(self: pyrosetta.rosetta.basic.datacache.DataMap, type: str) -> bool
has(self: pyrosetta.rosetta.basic.datacache.DataMap, type: str, name: str) -> bool

Does the data map contain an entry with a specific name in the given type?

calling this function without providing a name is just plain wrong and makes no sense and I would be changing that right now if Kale hadn’t already found out that some code relies on this bad behavior back in pull request #187

C++: basic::datacache::DataMap::has(const std::string &, const std::string &) const –> bool

has_resource(self: pyrosetta.rosetta.basic.datacache.DataMap, resource_name: str) → bool¶

Does the data map contain a resource with the given name?

C++: basic::datacache::DataMap::has_resource(const std::string &) const –> bool

has_type(self: pyrosetta.rosetta.basic.datacache.DataMap, type: str) → bool¶

Does the data map contain the given type?

C++: basic::datacache::DataMap::has_type(const std::string &) const –> bool

size(self: pyrosetta.rosetta.basic.datacache.DataMap) → int¶

returns the size of the map (how many different types are in data_map_

C++: basic::datacache::DataMap::size() const –> unsigned long

class pyrosetta.rosetta.basic.datacache.DiagnosticData¶

Bases: CacheableData

Wrapper for std::map<string, Real>

assign(self: pyrosetta.rosetta.basic.datacache.DiagnosticData, : pyrosetta.rosetta.basic.datacache.DiagnosticData) → pyrosetta.rosetta.basic.datacache.DiagnosticData¶: C++: basic::datacache::DiagnosticData::operator=(const class basic::datacache::DiagnosticData &) –> class basic::datacache::DiagnosticData &

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

data(self: pyrosetta.rosetta.basic.datacache.DiagnosticData) → pyrosetta.rosetta.std.map_std_string_double¶: C++: basic::datacache::DiagnosticData::data() –> class std::map<std::string, double, struct std::less<std::string >, class std::allocator<struct std::pair<const std::string, double> > > &

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

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

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

class pyrosetta.rosetta.basic.datacache.HierarchicalDataMap¶

Bases: pybind11_object

A data map designed to help create hierarchies with complicated shared data requirements.

To explain what exactly this class is supposed to do, consider the following mover hierarchy (which comes from the loop modeling framework and was the actual motivation for this code):

A ~ | ~

+——-+——+——+——+ ~ | | | | | ~ B C D E F ~

/ / / ~

G H I J K L ~

| / /| ~

M N O P Q R ~

To explain this diagram a little, each letter corresponds to a mover. The movers are mostly of different classes, although they all inherit from the same abstract base class. This whole hierarchy is constructed by A. When A.apply() is called, it calls B.apply(), C.apply(), D.apply(), E.apply(), and F.apply() in that order. When B.apply() is called, it calls G.apply() and H.apply(), and so on. If you are interested in seeing exactly how this hierarchy is implemented, here are the classes the letters correspond to:

protocols::loop_modeling::LoopModeler
protocols::loop_modeling::utilities::PrepareForCentroid
protocols::loop_modeling::LoopBuilder
protocols::loop_modeling::LoopProtocol
protocols::loop_modeling::utilities::PrepareForFullatom
protocols::loop_modeling::LoopProtocol
protocols::kinematic_closure::KicMover
protocols::loop_modeling::refiners::MinimizationRefiner
protocols::loop_modeling::utilities::LoopMoverGroup
protocols::loop_modeling::utilities::LoopMoverGroup
protocols::loop_modeling::utilities::LoopMoverGroup
protocols::loop_modeling::utilities::LoopMoverGroup
protocols::kinematic_closure::KicMover
protocols::loop_modeling::refiners::MinimizationRefiner
protocols::kinematic_closure::KicMover
protocols::loop_modeling::refiners::RepackingRefiner
protocols::loop_modeling::refiners::RotamerTrialsRefiner
protocols::loop_modeling::refiners::MinimizationRefiner

This hierarchy had the following shared data requirements:

Everything in the hierarchy has to share a loops object.
A has to know about centroid and fullatom score functions.
B, D, and all their children have to use the centroid score function.
F and all its children have to use the fullatom score function.
A has to provide a default task factory to all its children.
Only P and Q have any use for a task factory, and they may want to override the default provided by A.

Many of these requirements have a similar form: movers higher in the hierarchy must be able to provide default attributes to all their children, and movers lower in the hierarchy must be able to override those defaults. This class supports that pattern by being a data map that asks its parent for missing values.

More specifically, this class stores two pieces of information: a DataMap and a pointer to a parent HierarchicalDataMap. The DataMap provides the basic attribute lookup capability: it’s just a string to owning pointer map. The parent pointer allows the HierarchicalDataMap to recursively access default values from parent maps for key that aren’t in it’s own DataMap.

Going back to the example hierarchy above: A needs to provide a default task factory that P and Q can override. To accomplish this, we start by giving all the objects in the hierarchy HierarchicalDataMap objects that have been properly connected to their parents. Then A sets the default “task_ops” attribute in it’s own HierarchicalDataMap as soon as it’s constructed. P and Q provide convenience methods like get_task_ops() and set_task_ops() to allow the “task_ops” field of their HierarchicalDataMaps to be accessed publicly. Since the data maps in P and Q are connected to A via L and F, the attributes stored in A will serve as defaults for P and Q.

It’s worth noting that in this example, it is also possible to get the right behavior by putting a task operations data member in the shared base class. However, this is a poor solution for two reasons. The first is that it requires many classes that have no need for task operations to have a task operations attribute. Second, it requires that you write the default logic for each attribute that needs it, which is a duplication of effort. Using HierarchicalDataMap addresses both of these problems.

When using this class to help build a hierarchy like the one illustrated above, you might find it useful to move public accessor methods (like get_task_ops() and set_task_ops() in P and Q) into a reusable mixin class. This takes a little bit of C++ template magic, because you have to use the “curiously recurring template pattern” (CRTP). But you can see how this works by looking at protocols::loop_modeling::RepackingLoopMover (P in the example) and protocols::loop_modeling::utilites::TaskFactoryMixin (the mixin class).

assign(self: pyrosetta.rosetta.basic.datacache.HierarchicalDataMap, : pyrosetta.rosetta.basic.datacache.HierarchicalDataMap) → pyrosetta.rosetta.basic.datacache.HierarchicalDataMap¶: C++: basic::datacache::HierarchicalDataMap::operator=(const class basic::datacache::HierarchicalDataMap &) –> class basic::datacache::HierarchicalDataMap &

set_parent(self: pyrosetta.rosetta.basic.datacache.HierarchicalDataMap, parent: pyrosetta.rosetta.std.weak_ptr_const_basic_datacache_HierarchicalDataMap_t) → None¶

Set a parent for this data map.

If a key is requested and not found in this data map, the search will continue (recursively) in the parent. Having a parent is optional.

C++: basic::datacache::HierarchicalDataMap::set_parent(class std::weak_ptr<const class basic::datacache::HierarchicalDataMap>) –> void

unset_parent(self: pyrosetta.rosetta.basic.datacache.HierarchicalDataMap) → None¶

Unset the parent for this data map.

When a data map doesn’t have a parent, it will only return keys it is holding itself. Having a parent is optional.

C++: basic::datacache::HierarchicalDataMap::unset_parent() –> void

class pyrosetta.rosetta.basic.datacache.ResRotPair¶

Bases: pybind11_object

property first_res¶

property first_rot¶

property second_res¶

property second_rot¶

class pyrosetta.rosetta.basic.datacache.ResRotPairHasher¶

Bases: pybind11_object

assign(self: pyrosetta.rosetta.basic.datacache.ResRotPairHasher, : pyrosetta.rosetta.basic.datacache.ResRotPairHasher) → pyrosetta.rosetta.basic.datacache.ResRotPairHasher¶: C++: basic::datacache::ResRotPairHasher::operator=(const struct basic::datacache::ResRotPairHasher &) –> struct basic::datacache::ResRotPairHasher &

class pyrosetta.rosetta.basic.datacache.WriteableCacheableData¶

Bases: CacheableData

base class for data storable within a DataCache

assign(self: pyrosetta.rosetta.basic.datacache.WriteableCacheableData, : pyrosetta.rosetta.basic.datacache.WriteableCacheableData) → pyrosetta.rosetta.basic.datacache.WriteableCacheableData¶: C++: basic::datacache::WriteableCacheableData::operator=(const class basic::datacache::WriteableCacheableData &) –> class basic::datacache::WriteableCacheableData &

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

datatype(self: pyrosetta.rosetta.basic.datacache.WriteableCacheableData) → str¶: C++: basic::datacache::WriteableCacheableData::datatype() const –> std::string

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

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

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

write(self: pyrosetta.rosetta.basic.datacache.WriteableCacheableData, out: pyrosetta.rosetta.std.ostream) → None¶: C++: basic::datacache::WriteableCacheableData::write(std::ostream &) const –> void

class pyrosetta.rosetta.basic.datacache.WriteableCacheableDataCreator¶

Bases: pybind11_object

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

assign(self: pyrosetta.rosetta.basic.datacache.WriteableCacheableDataCreator, : pyrosetta.rosetta.basic.datacache.WriteableCacheableDataCreator) → pyrosetta.rosetta.basic.datacache.WriteableCacheableDataCreator¶: C++: basic::datacache::WriteableCacheableDataCreator::operator=(const class basic::datacache::WriteableCacheableDataCreator &) –> class basic::datacache::WriteableCacheableDataCreator &

create_data(self: pyrosetta.rosetta.basic.datacache.WriteableCacheableDataCreator, in: pyrosetta.rosetta.std.istream) → pyrosetta.rosetta.basic.datacache.WriteableCacheableData¶: C++: basic::datacache::WriteableCacheableDataCreator::create_data(std::istream &) const –> class std::shared_ptr<class basic::datacache::WriteableCacheableData>

keyname(self: pyrosetta.rosetta.basic.datacache.WriteableCacheableDataCreator) → str¶: C++: basic::datacache::WriteableCacheableDataCreator::keyname() const –> std::string

class pyrosetta.rosetta.basic.datacache.WriteableCacheableDataFactory¶

Bases: SingletonBase_basic_datacache_WriteableCacheableDataFactory_t

factory_register(self: pyrosetta.rosetta.basic.datacache.WriteableCacheableDataFactory, creator: pyrosetta.rosetta.basic.datacache.WriteableCacheableDataCreator) → None¶: C++: basic::datacache::WriteableCacheableDataFactory::factory_register(class std::shared_ptr<class basic::datacache::WriteableCacheableDataCreator>) –> void

static get_instance() → basic::datacache::WriteableCacheableDataFactory¶: C++: utility::SingletonBase<basic::datacache::WriteableCacheableDataFactory>::get_instance() –> class basic::datacache::WriteableCacheableDataFactory *

new_data_instance(self: pyrosetta.rosetta.basic.datacache.WriteableCacheableDataFactory, data_type_name: str, in: pyrosetta.rosetta.std.istream) → pyrosetta.rosetta.basic.datacache.WriteableCacheableData¶

Create a data instance given its identifying string

C++: basic::datacache::WriteableCacheableDataFactory::new_data_instance(const std::string &, std::istream &) –> class std::shared_ptr<class basic::datacache::WriteableCacheableData>

class pyrosetta.rosetta.basic.datacache.WriteableCacheableMap¶

Bases: CacheableData

Wrapper for a map< string, string >.

assign(self: pyrosetta.rosetta.basic.datacache.WriteableCacheableMap, : pyrosetta.rosetta.basic.datacache.WriteableCacheableMap) → pyrosetta.rosetta.basic.datacache.WriteableCacheableMap¶: C++: basic::datacache::WriteableCacheableMap::operator=(const class basic::datacache::WriteableCacheableMap &) –> class basic::datacache::WriteableCacheableMap &

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

erase(self: pyrosetta.rosetta.basic.datacache.WriteableCacheableMap, d: pyrosetta.rosetta.basic.datacache.WriteableCacheableData) → None¶: C++: basic::datacache::WriteableCacheableMap::erase(class std::shared_ptr<class basic::datacache::WriteableCacheableData>) –> void

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

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

has(self: pyrosetta.rosetta.basic.datacache.WriteableCacheableMap, data: pyrosetta.rosetta.basic.datacache.WriteableCacheableData) → bool¶: C++: basic::datacache::WriteableCacheableMap::has(class std::shared_ptr<class basic::datacache::WriteableCacheableData>) –> bool

insert(self: pyrosetta.rosetta.basic.datacache.WriteableCacheableMap, data: pyrosetta.rosetta.basic.datacache.WriteableCacheableData) → None¶: C++: basic::datacache::WriteableCacheableMap::insert(class std::shared_ptr<class basic::datacache::WriteableCacheableData>) –> void

map(self: pyrosetta.rosetta.basic.datacache.WriteableCacheableMap) → pyrosetta.rosetta.std.map_std_string_std_set_std_shared_ptr_basic_datacache_WriteableCacheableData_t_std_allocator_std_pair_const_std_string_std_set_std_shared_ptr_basic_datacache_WriteableCacheableData_t¶: C++: basic::datacache::WriteableCacheableMap::map() –> class std::map<std::string, class std::set<class std::shared_ptr<class basic::datacache::WriteableCacheableData>, struct std::less<class std::shared_ptr<class basic::datacache::WriteableCacheableData> >, class std::allocator<class std::shared_ptr<class basic::datacache::WriteableCacheableData> > >, struct std::less<std::string >, class std::allocator<struct std::pair<const std::string, class std::set<class std::shared_ptr<class basic::datacache::WriteableCacheableData>, struct std::less<class std::shared_ptr<class basic::datacache::WriteableCacheableData> >, class std::allocator<class std::shared_ptr<class basic::datacache::WriteableCacheableData> > > > > > &

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