tag

Bindings for utility::tag namespace

class pyrosetta.rosetta.utility.tag.AutoBool

Bases: pybind11_object

Members:

False

True

Auto

Auto = <AutoBool.Auto: 2>

False = <AutoBool.False: 0>

True = <AutoBool.True: 1>

property name

property value

class pyrosetta.rosetta.utility.tag.CTGenSubelementBehavior

Bases: pybind11_object

Members:

se_none

se_repeatable

se_choice_req

se_choice_opt

se_single_req

se_single_opt

se_single_req_ordered

se_ordered_sets

property name

se_choice_opt = <CTGenSubelementBehavior.se_choice_opt: 3>

se_choice_req = <CTGenSubelementBehavior.se_choice_req: 2>

se_none = <CTGenSubelementBehavior.se_none: 0>

se_ordered_sets = <CTGenSubelementBehavior.se_ordered_sets: 7>

se_repeatable = <CTGenSubelementBehavior.se_repeatable: 1>

se_single_opt = <CTGenSubelementBehavior.se_single_opt: 5>

se_single_req = <CTGenSubelementBehavior.se_single_req: 4>

se_single_req_ordered = <CTGenSubelementBehavior.se_single_req_ordered: 6>

property value

class pyrosetta.rosetta.utility.tag.Tag

Bases: pybind11_object

addTag(self: pyrosetta.rosetta.utility.tag.Tag, tag: pyrosetta.rosetta.utility.tag.Tag) → None

C++: utility::tag::Tag::addTag(class std::shared_ptr<class utility::tag::Tag>) –> void

assign(self: pyrosetta.rosetta.utility.tag.Tag, other: pyrosetta.rosetta.utility.tag.Tag) → pyrosetta.rosetta.utility.tag.Tag

C++: utility::tag::Tag::operator=(const class utility::tag::Tag &) –> class utility::tag::Tag &

clear(self: pyrosetta.rosetta.utility.tag.Tag) → None

C++: utility::tag::Tag::clear() –> void

clone(self: pyrosetta.rosetta.utility.tag.Tag) → pyrosetta.rosetta.utility.tag.Tag

C++: utility::tag::Tag::clone() const –> class std::shared_ptr<class utility::tag::Tag>

static create(*args, **kwargs)

Overloaded function.

1. create(in: pyrosetta.rosetta.std.istream) -> pyrosetta.rosetta.utility.tag.Tag

C++: utility::tag::Tag::create(std::istream &) –> class std::shared_ptr<class utility::tag::Tag>

2. create(instring: str) -> pyrosetta.rosetta.utility.tag.Tag

C++: utility::tag::Tag::create(const std::string &) –> class std::shared_ptr<class utility::tag::Tag>

die_for_unaccessed_options(self: pyrosetta.rosetta.utility.tag.Tag) → None

C++: utility::tag::Tag::die_for_unaccessed_options() const –> void

die_for_unaccessed_options_recursively(self: pyrosetta.rosetta.utility.tag.Tag) → None

C++: utility::tag::Tag::die_for_unaccessed_options_recursively() const –> void

getName(self: pyrosetta.rosetta.utility.tag.Tag) → str

C++: utility::tag::Tag::getName() const –> const std::string &

getOption(*args, **kwargs)

Overloaded function.

1. getOption(self: pyrosetta.rosetta.utility.tag.Tag, key: str, t_default: bool) -> bool

This is explicit specialization for boolean values

to allow for use of “true” “false” etc. in addition to 1 and 0

C++: utility::tag::Tag::getOption(const std::string &, const bool &) const –> bool

2. getOption(self: pyrosetta.rosetta.utility.tag.Tag, key: str, t_default: pyrosetta.rosetta.utility.tag.AutoBool) -> pyrosetta.rosetta.utility.tag.AutoBool

C++: utility::tag::Tag::getOption(const std::string &, const enum utility::tag::AutoBool &) const –> enum utility::tag::AutoBool

3. getOption(self: pyrosetta.rosetta.utility.tag.Tag, key: str, default_int: int) -> int

Special-casing to ensure that 0 gets interpreted as Size(0) rather than nullptr.

Vikram K. Mulligan (vmulligan.org).

C++: utility::tag::Tag::getOption(const std::string &, const int) const –> unsigned long

4. getOption(self: pyrosetta.rosetta.utility.tag.Tag, key: str, default_int: int) -> int

Special-casing for signed ints.

Vikram K. Mulligan (vmulligan.org).

C++: utility::tag::Tag::getOption(const std::string &, const int) const –> int

5. getOption(self: pyrosetta.rosetta.utility.tag.Tag, key: str, default_int: int) -> int

Special-casing for int64_t.

Vikram K. Mulligan (vmulligan.org).

C++: utility::tag::Tag::getOption(const std::string &, const int) const –> long

6. getOption(self: pyrosetta.rosetta.utility.tag.Tag, key: str, default_as_string_literal: str) -> bool

This is for the variant in which someone has specified a default

using “true” instead of true, or “false” instead of false.

Vikram K. Mulligan (vmulligan.org).

C++: utility::tag::Tag::getOption(const std::string &, const char *) const –> bool

7. getOption(self: pyrosetta.rosetta.utility.tag.Tag, key: str, default_as_string_literal: str) -> pyrosetta.rosetta.utility.tag.AutoBool

This is for the variant in which someone has specified a default

using “true” instead of true, or “false” instead of false.

Vikram K. Mulligan (vmulligan.org).

C++: utility::tag::Tag::getOption(const std::string &, const char *) const –> enum utility::tag::AutoBool

8. getOption(self: pyrosetta.rosetta.utility.tag.Tag, key: str, default_as_string_literal: str) -> str

Special-casing the string literal version for string options. In this case,

there shouldn’t be an error thrown. A string literal should be allowed to set the default value for a string.

Vikram K. Mulligan (vmulligan.org).

C++: utility::tag::Tag::getOption(const std::string &, const char *) const –> std::string

9. getOption(self: pyrosetta.rosetta.utility.tag.Tag, key: str) -> bool

C++: utility::tag::Tag::getOption(const std::string &) const –> bool

10. getOption(self: pyrosetta.rosetta.utility.tag.Tag, key: str) -> pyrosetta.rosetta.utility.tag.AutoBool

C++: utility::tag::Tag::getOption(const std::string &) const –> enum utility::tag::AutoBool

getOptions(self: pyrosetta.rosetta.utility.tag.Tag) → pyrosetta.rosetta.std.map_std_string_std_string

C++: utility::tag::Tag::getOptions() const –> const class std::map<std::string, std::string, struct std::less<std::string >, class std::allocator<struct std::pair<const std::string, std::string > > > &

getParent(self: pyrosetta.rosetta.utility.tag.Tag) → pyrosetta.rosetta.std.weak_ptr_const_utility_tag_Tag_t

C++: utility::tag::Tag::getParent() const –> const class std::weak_ptr<const class utility::tag::Tag> &

getTag(self: pyrosetta.rosetta.utility.tag.Tag, name: str) → pyrosetta.rosetta.utility.tag.Tag

C++: utility::tag::Tag::getTag(const std::string &) const –> const class std::shared_ptr<const class utility::tag::Tag> &

getTags(*args, **kwargs)

Overloaded function.

1. getTags(self: pyrosetta.rosetta.utility.tag.Tag) -> pyrosetta.rosetta.utility.vector0_std_shared_ptr_const_utility_tag_Tag_t

C++: utility::tag::Tag::getTags() const –> const class utility::vector0<class std::shared_ptr<const class utility::tag::Tag>, class std::allocator<class std::shared_ptr<const class utility::tag::Tag> > > &

2. getTags(self: pyrosetta.rosetta.utility.tag.Tag, name: str) -> pyrosetta.rosetta.utility.vector0_std_shared_ptr_const_utility_tag_Tag_t

C++: utility::tag::Tag::getTags(const std::string &) const –> const class utility::vector0<class std::shared_ptr<const class utility::tag::Tag>, class std::allocator<class std::shared_ptr<const class utility::tag::Tag> > > &

get_option_bool(*args, **kwargs)

Overloaded function.

1. get_option_bool(self: pyrosetta.rosetta.utility.tag.Tag, key: str) -> bool

C++: utility::tag::Tag::get_option_bool(const std::string &) const –> bool

2. get_option_bool(self: pyrosetta.rosetta.utility.tag.Tag, key: str, default_as_string_literal: str) -> bool

C++: utility::tag::Tag::get_option_bool(const std::string &, const char *) const –> bool

3. get_option_bool(self: pyrosetta.rosetta.utility.tag.Tag, key: str, t_default: bool) -> bool

C++: utility::tag::Tag::get_option_bool(const std::string &, const bool &) const –> bool

get_option_int(*args, **kwargs)

Overloaded function.

1. get_option_int(self: pyrosetta.rosetta.utility.tag.Tag, key: str) -> int

C++: utility::tag::Tag::get_option_int(const std::string &) const –> int

2. get_option_int(self: pyrosetta.rosetta.utility.tag.Tag, key: str, t_default: int) -> int

C++: utility::tag::Tag::get_option_int(const std::string &, const int &) const –> int

get_option_real(*args, **kwargs)

Overloaded function.

1. get_option_real(self: pyrosetta.rosetta.utility.tag.Tag, key: str) -> float

C++: utility::tag::Tag::get_option_real(const std::string &) const –> double

2. get_option_real(self: pyrosetta.rosetta.utility.tag.Tag, key: str, t_default: float) -> float

C++: utility::tag::Tag::get_option_real(const std::string &, const double &) const –> double

get_option_size(*args, **kwargs)

Overloaded function.

1. get_option_size(self: pyrosetta.rosetta.utility.tag.Tag, key: str) -> int

C++: utility::tag::Tag::get_option_size(const std::string &) const –> unsigned long

2. get_option_size(self: pyrosetta.rosetta.utility.tag.Tag, key: str, t_default: int) -> int

C++: utility::tag::Tag::get_option_size(const std::string &, const unsigned long &) const –> unsigned long

get_option_string(*args, **kwargs)

Overloaded function.

1. get_option_string(self: pyrosetta.rosetta.utility.tag.Tag, key: str) -> str

C++: utility::tag::Tag::get_option_string(const std::string &) const –> std::string

2. get_option_string(self: pyrosetta.rosetta.utility.tag.Tag, key: str, t_default: str) -> str

C++: utility::tag::Tag::get_option_string(const std::string &, const std::string &) const –> std::string

get_self_ptr(self: pyrosetta.rosetta.utility.tag.Tag) → pyrosetta.rosetta.utility.tag.Tag

C++: utility::tag::Tag::get_self_ptr() –> class std::shared_ptr<class utility::tag::Tag>

get_self_weak_ptr(self: pyrosetta.rosetta.utility.tag.Tag) → pyrosetta.rosetta.std.weak_ptr_utility_tag_Tag_t

C++: utility::tag::Tag::get_self_weak_ptr() –> class std::weak_ptr<class utility::tag::Tag>

hasOption(self: pyrosetta.rosetta.utility.tag.Tag, key: str) → bool

Does the Tag have a specific option?

C++: utility::tag::Tag::hasOption(const std::string &) const –> bool

hasTag(self: pyrosetta.rosetta.utility.tag.Tag, name: str) → bool

Does the Tag have a specific sub-tag (branch) within (such as a MoveMap, etc.)?

C++: utility::tag::Tag::hasTag(const std::string &) const –> bool

read(*args, **kwargs)

Overloaded function.

1. read(self: pyrosetta.rosetta.utility.tag.Tag, in: pyrosetta.rosetta.std.istream) -> None

C++: utility::tag::Tag::read(std::istream &) –> void

2. read(self: pyrosetta.rosetta.utility.tag.Tag, tag_string: str) -> None

C++: utility::tag::Tag::read(const std::string &) –> void

reset_accessed_options(self: pyrosetta.rosetta.utility.tag.Tag) → None

Recursively reset that accessed_options_ variable so that a re-parsing of the tag

can identify options that have been given but that have not been read.

C++: utility::tag::Tag::reset_accessed_options() const –> void

setAccessed(self: pyrosetta.rosetta.utility.tag.Tag, key: str) → None

Set the ‘accessed’ annotation of this option, without bothering to get the value.

Used to prevent no-longer relevant options from crashing the XML parsing.

C++: utility::tag::Tag::setAccessed(const std::string &) const –> void

setName(self: pyrosetta.rosetta.utility.tag.Tag, name: str) → None

C++: utility::tag::Tag::setName(const std::string &) –> void

setOptions(self: pyrosetta.rosetta.utility.tag.Tag, options: pyrosetta.rosetta.std.map_std_string_std_string) → None

C++: utility::tag::Tag::setOptions(const class std::map<std::string, std::string, struct std::less<std::string >, class std::allocator<struct std::pair<const std::string, std::string > > > &) –> void

set_quote_options(self: pyrosetta.rosetta.utility.tag.Tag, quote_options_val: bool) → None

if true, options will be quoted when the tag is outputted

if false, options will be left as-is (default)

Whether or not option values should be quoted.

Default=false

C++: utility::tag::Tag::set_quote_options(const bool) –> void

size(self: pyrosetta.rosetta.utility.tag.Tag) → int

C++: utility::tag::Tag::size() const –> unsigned long

to_string(*args, **kwargs)

Overloaded function.

1. to_string(self: pyrosetta.rosetta.utility.tag.Tag) -> str

2. to_string(self: pyrosetta.rosetta.utility.tag.Tag, num_tabs: int) -> str

returns the string that would be written by write()

C++: utility::tag::Tag::to_string(int) const –> std::string

write(*args, **kwargs)

Overloaded function.

1. write(self: pyrosetta.rosetta.utility.tag.Tag, out: pyrosetta.rosetta.std.ostream) -> None

2. write(self: pyrosetta.rosetta.utility.tag.Tag, out: pyrosetta.rosetta.std.ostream, num_tabs: int) -> None

C++: utility::tag::Tag::write(std::ostream &, int) const –> void

class pyrosetta.rosetta.utility.tag.XMLErrorHandler

Bases: pybind11_object

errors(self: pyrosetta.rosetta.utility.tag.XMLErrorHandler) → pyrosetta.rosetta.std.list_std_string_t

C++: utility::tag::XMLErrorHandler::errors() const –> const class std::list<std::string, class std::allocator<std::string > > &

handle_xml_error(self: pyrosetta.rosetta.utility.tag.XMLErrorHandler, message: str, line: int) → None

C++: utility::tag::XMLErrorHandler::handle_xml_error(const std::string &, int) –> void

handle_xml_warning(self: pyrosetta.rosetta.utility.tag.XMLErrorHandler, message: str, line: int) → None

C++: utility::tag::XMLErrorHandler::handle_xml_warning(const std::string &, int) –> void

pop_node(self: pyrosetta.rosetta.utility.tag.XMLErrorHandler) → None

C++: utility::tag::XMLErrorHandler::pop_node() –> void

push_node(self: pyrosetta.rosetta.utility.tag.XMLErrorHandler, node: pyrosetta.rosetta._xmlNode) → None

C++: utility::tag::XMLErrorHandler::push_node(struct _xmlNode *) –> void

set_file_contents(self: pyrosetta.rosetta.utility.tag.XMLErrorHandler, file_contents: str) → None

C++: utility::tag::XMLErrorHandler::set_file_contents(const std::string &) –> void

warnings(self: pyrosetta.rosetta.utility.tag.XMLErrorHandler) → pyrosetta.rosetta.std.list_std_string_t

C++: utility::tag::XMLErrorHandler::warnings() const –> const class std::list<std::string, class std::allocator<std::string > > &

class pyrosetta.rosetta.utility.tag.XMLSchemaAttribute

Bases: XMLSchemaTopLevelElement

class %XMLSchemaAttribute represents what we refer to in Rosetta as an option for a tag. An attribute would reside inside of a tag, such as “scorefxn” in this tag (this XML Element): <MinMover name=”min” scorefxn=”talaris2014”/>

The “name” of an attribute is what will live on the left-hand side of the equals sign, e.g. “scorefxn” in the MinMover example above. The type of the attribute refers to the structure of the data on the right-hand side of the equals sign. Attributes may also define a default value, which is a useful way to communicate default behaviors to users. Finally, an attribute can be listed as being required or not. By default, attributes are not required, so not specifying whether the attribute is required means that it is not required. An example of a required attribute would be the “name” attribute for the MinMover.

Once all of the details of an XMLAttribute have been set, it will write its definition to an output stream in its write_definition method.

assign(self: pyrosetta.rosetta.utility.tag.XMLSchemaAttribute, : pyrosetta.rosetta.utility.tag.XMLSchemaAttribute) → pyrosetta.rosetta.utility.tag.XMLSchemaAttribute

C++: utility::tag::XMLSchemaAttribute::operator=(const class utility::tag::XMLSchemaAttribute &) –> class utility::tag::XMLSchemaAttribute &

static attribute_w_default(name: str, type: pyrosetta.rosetta.utility.tag.XMLSchemaType, desc: str, default_value: str) → pyrosetta.rosetta.utility.tag.XMLSchemaAttribute

C++: utility::tag::XMLSchemaAttribute::attribute_w_default(const std::string &, class utility::tag::XMLSchemaType, const std::string &, const std::string &) –> class utility::tag::XMLSchemaAttribute

default_value(self: pyrosetta.rosetta.utility.tag.XMLSchemaAttribute, setting: str) → pyrosetta.rosetta.utility.tag.XMLSchemaAttribute

C++: utility::tag::XMLSchemaAttribute::default_value(const std::string &) –> class utility::tag::XMLSchemaAttribute &

description(self: pyrosetta.rosetta.utility.tag.XMLSchemaAttribute, setting: str) → pyrosetta.rosetta.utility.tag.XMLSchemaAttribute

C++: utility::tag::XMLSchemaAttribute::description(const std::string &) –> class utility::tag::XMLSchemaAttribute &

element_name(self: pyrosetta.rosetta.utility.tag.XMLSchemaAttribute) → str

C++: utility::tag::XMLSchemaAttribute::element_name() const –> const std::string &

is_required(self: pyrosetta.rosetta.utility.tag.XMLSchemaAttribute, setting: bool) → pyrosetta.rosetta.utility.tag.XMLSchemaAttribute

C++: utility::tag::XMLSchemaAttribute::is_required(bool) –> class utility::tag::XMLSchemaAttribute &

name(self: pyrosetta.rosetta.utility.tag.XMLSchemaAttribute, setting: str) → pyrosetta.rosetta.utility.tag.XMLSchemaAttribute

C++: utility::tag::XMLSchemaAttribute::name(const std::string &) –> class utility::tag::XMLSchemaAttribute &

prepare_for_output(self: pyrosetta.rosetta.utility.tag.XMLSchemaAttribute, xsd: utility::tag::XMLSchemaDefinition) → None

C++: utility::tag::XMLSchemaAttribute::prepare_for_output(class utility::tag::XMLSchemaDefinition &) const –> void

static required_attribute(name: str, type: pyrosetta.rosetta.utility.tag.XMLSchemaType, desc: str) → pyrosetta.rosetta.utility.tag.XMLSchemaAttribute

C++: utility::tag::XMLSchemaAttribute::required_attribute(const std::string &, class utility::tag::XMLSchemaType, const std::string &) –> class utility::tag::XMLSchemaAttribute

type(*args, **kwargs)

Overloaded function.

1. type(self: pyrosetta.rosetta.utility.tag.XMLSchemaAttribute, setting: pyrosetta.rosetta.utility.tag.XMLSchemaType) -> pyrosetta.rosetta.utility.tag.XMLSchemaAttribute

C++: utility::tag::XMLSchemaAttribute::type(class utility::tag::XMLSchemaType) –> class utility::tag::XMLSchemaAttribute &

2. type(self: pyrosetta.rosetta.utility.tag.XMLSchemaAttribute) -> pyrosetta.rosetta.utility.tag.XMLSchemaType

C++: utility::tag::XMLSchemaAttribute::type() const –> const class utility::tag::XMLSchemaType &

write_definition(self: pyrosetta.rosetta.utility.tag.XMLSchemaAttribute, indentation: int, os: pyrosetta.rosetta.std.ostream) → None

C++: utility::tag::XMLSchemaAttribute::write_definition(int, std::ostream &) const –> void

class pyrosetta.rosetta.utility.tag.XMLSchemaCommonType

Bases: pybind11_object

An enum listing lots of commonly-used simple types so they don’t have to be added manually

in lots of places. If you create an XMLSchemaType using this enum, then the corresponding restriction will be added to the XMLSchemaDefintion automatically

Members:

xsct_none

xsct_int_cslist

xsct_string_cslist

xsct_int_wsslist

xsct_nnegative_int_cslist

xsct_nnegative_int_wsslist

xsct_real

xsct_real_cslist

xsct_real_cslist_w_ws

xsct_real_wsslist

xsct_bool_cslist

xsct_bool_wsslist

xsct_positive_integer_cslist

xsct_positive_integer_wsslist

xsct_non_negative_integer

xsct_positive_integer

xsct_rosetta_bool

xsct_rosetta_autobool

xsct_residue_number

xsct_residue_number_cslist

xsct_refpose_enabled_residue_number

xsct_refpose_enabled_residue_number_cslist

xsct_char

xsct_minimizer_type

xsct_size_cs_pair

xsct_chain_cslist

xsct_dssp_string

xsct_canonical_res_char

xsct_packer_palette

xsct_task_operation

xsct_task_operation_comma_separated_list

xsct_pose_cached_task_operation

property name

property value

xsct_bool_cslist = <XMLSchemaCommonType.xsct_bool_cslist: 10>

xsct_bool_wsslist = <XMLSchemaCommonType.xsct_bool_wsslist: 11>

xsct_canonical_res_char = <XMLSchemaCommonType.xsct_canonical_res_char: 27>

xsct_chain_cslist = <XMLSchemaCommonType.xsct_chain_cslist: 25>

xsct_char = <XMLSchemaCommonType.xsct_char: 22>

xsct_dssp_string = <XMLSchemaCommonType.xsct_dssp_string: 26>

xsct_int_cslist = <XMLSchemaCommonType.xsct_int_cslist: 1>

xsct_int_wsslist = <XMLSchemaCommonType.xsct_int_wsslist: 3>

xsct_minimizer_type = <XMLSchemaCommonType.xsct_minimizer_type: 23>

xsct_nnegative_int_cslist = <XMLSchemaCommonType.xsct_nnegative_int_cslist: 4>

xsct_nnegative_int_wsslist = <XMLSchemaCommonType.xsct_nnegative_int_wsslist: 5>

xsct_non_negative_integer = <XMLSchemaCommonType.xsct_non_negative_integer: 14>

xsct_none = <XMLSchemaCommonType.xsct_none: 0>

xsct_packer_palette = <XMLSchemaCommonType.xsct_packer_palette: 28>

xsct_pose_cached_task_operation = <XMLSchemaCommonType.xsct_pose_cached_task_operation: 31>

xsct_positive_integer = <XMLSchemaCommonType.xsct_positive_integer: 15>

xsct_positive_integer_cslist = <XMLSchemaCommonType.xsct_positive_integer_cslist: 12>

xsct_positive_integer_wsslist = <XMLSchemaCommonType.xsct_positive_integer_wsslist: 13>

xsct_real = <XMLSchemaCommonType.xsct_real: 6>

xsct_real_cslist = <XMLSchemaCommonType.xsct_real_cslist: 7>

xsct_real_cslist_w_ws = <XMLSchemaCommonType.xsct_real_cslist_w_ws: 8>

xsct_real_wsslist = <XMLSchemaCommonType.xsct_real_wsslist: 9>

xsct_refpose_enabled_residue_number = <XMLSchemaCommonType.xsct_refpose_enabled_residue_number: 20>

xsct_refpose_enabled_residue_number_cslist = <XMLSchemaCommonType.xsct_refpose_enabled_residue_number_cslist: 21>

xsct_residue_number = <XMLSchemaCommonType.xsct_residue_number: 18>

xsct_residue_number_cslist = <XMLSchemaCommonType.xsct_residue_number_cslist: 19>

xsct_rosetta_autobool = <XMLSchemaCommonType.xsct_rosetta_autobool: 17>

xsct_rosetta_bool = <XMLSchemaCommonType.xsct_rosetta_bool: 16>

xsct_size_cs_pair = <XMLSchemaCommonType.xsct_size_cs_pair: 24>

xsct_string_cslist = <XMLSchemaCommonType.xsct_string_cslist: 2>

xsct_task_operation = <XMLSchemaCommonType.xsct_task_operation: 29>

xsct_task_operation_comma_separated_list = <XMLSchemaCommonType.xsct_task_operation_comma_separated_list: 30>

class pyrosetta.rosetta.utility.tag.XMLSchemaComplexType

Bases: XMLSchemaTopLevelElement

class %XMLSchemaComplexType represents the definition of the type for an element – that is, the structure of a set of elements with the same name. If an XMLSchemaElement is analogous to a utility::tag::Tag, an %XMLSchemaComplexType is analogous to the wiki page describing the valid format for an instance of that Tag.

%XMLSchemaComplexTypes can be named or unnamed: if they are named, then the are inserted into the XMLSchemaDefinition on their own, and can be referred to by name in other XMLSchemaElements; if they are unnamed, then they are given as an in-line definition for an XMLSchemaElement. So a name is not required for an %XMLSchemaComplexType. That said: the recommended structure for defining an XML Schema is that complex types should be named and to live on their own – elements should refer to these complex types by name.

(There are some who recommend that instead elements be defined at “global scope” – i.e. directly beneath the xs:schema tag – and that complex types be unnamed. The principle disadvantage of that idea is that you cannot have two elements in different contexts with the same name but different structures. This problem of “name collisions” is addressed in XML Schema through the use of “namespacing,” which is horrendous, so we won’t use it. By giving complex types names, we can avoid name collision by just giving the complex types different names, which has no effect on the apperance of the XML file itself.)

Complex types must be one of the five options in the XMLSchemaComplexTypeType. They are either: * empty (xsctt_empty) meaning that they do not contain any sub-elements, though they may contain attributes.

Most of the complex types in Rosetta will be declared as empty.

• sequence (xsctt_sequence) meaning that they may contain attributes, and that they expect every one of the listed sub-elements to appear inside of them in the order defined.

• all (xsctt_all) meaning that they may contain attributes, and that they expect every one of the listed sub-elements to appear inside of them, but that these sub-elements may appear in any order

• choice (xsctt_choice) meaning that they may contain attributes, and that they expect exactly one of the listed sub-elements to appear, or

• group (xsctt_group) in which case, attributes are not allowed, and a list of subelements are given. The group category is perhaps the most confusing: a complex type with a group type will contain a sub-complex-type with either a sequence, all, or choice designation. A group can be written out by name, and then referred to within one or more complex types. Interestingly, the way to define flexible, recursive data types is to use a group. For example, if the ParsedProtocolMover type can contain any mover, including a ParsedProtocolMover, then to represent this in XML schema requires defining a group for all movers – and then saying that instances of this group can appear within the ParsedProtocolMoverType. Similarly, residue selectors can contain other residue selectors. Look at ResidueSelectorFactory::define_residue_selector_xml_schema for an example of how a group is defined.

A complex type may refer to a reference type, and then extend that type, e.g. by adding extra attributes.

In the case of a “group” complex type, the complex type needs to contain a subtype. E.g. the group complex-type defined by ResidueSelectorFactory holds a choice complex-type.

Complex types may contain subelements; these subelements can be added through a model group (e.g. “xs:all”) that itself contains elements and possibly other model groups.

Complex types may contain attributes; these attributes can be added through the add_attribute method.

Complex types may be repeated, e.g., in the sequence or group cases. You may specify the minimum and maximum number of times the complex type is to appaer.

add_attribute(self: pyrosetta.rosetta.utility.tag.XMLSchemaComplexType, attribute: pyrosetta.rosetta.utility.tag.XMLSchemaAttribute) → pyrosetta.rosetta.utility.tag.XMLSchemaComplexType

C++: utility::tag::XMLSchemaComplexType::add_attribute(class utility::tag::XMLSchemaAttribute) –> class utility::tag::XMLSchemaComplexType &

add_attributes(self: pyrosetta.rosetta.utility.tag.XMLSchemaComplexType, attributes: pyrosetta.rosetta.std.list_utility_tag_XMLSchemaAttribute_t) → pyrosetta.rosetta.utility.tag.XMLSchemaComplexType

C++: utility::tag::XMLSchemaComplexType::add_attributes(const class std::list<class utility::tag::XMLSchemaAttribute, class std::allocator<class utility::tag::XMLSchemaAttribute> > &) –> class utility::tag::XMLSchemaComplexType &

assign(self: pyrosetta.rosetta.utility.tag.XMLSchemaComplexType, : pyrosetta.rosetta.utility.tag.XMLSchemaComplexType) → pyrosetta.rosetta.utility.tag.XMLSchemaComplexType

C++: utility::tag::XMLSchemaComplexType::operator=(const class utility::tag::XMLSchemaComplexType &) –> class utility::tag::XMLSchemaComplexType &

description(self: pyrosetta.rosetta.utility.tag.XMLSchemaComplexType, setting: str) → pyrosetta.rosetta.utility.tag.XMLSchemaComplexType

C++: utility::tag::XMLSchemaComplexType::description(const std::string &) –> class utility::tag::XMLSchemaComplexType &

element_name(self: pyrosetta.rosetta.utility.tag.XMLSchemaComplexType) → str

C++: utility::tag::XMLSchemaComplexType::element_name() const –> const std::string &

name(self: pyrosetta.rosetta.utility.tag.XMLSchemaComplexType, setting: str) → pyrosetta.rosetta.utility.tag.XMLSchemaComplexType

C++: utility::tag::XMLSchemaComplexType::name(const std::string &) –> class utility::tag::XMLSchemaComplexType &

prepare_for_output(self: pyrosetta.rosetta.utility.tag.XMLSchemaComplexType, xsd: utility::tag::XMLSchemaDefinition) → None

C++: utility::tag::XMLSchemaComplexType::prepare_for_output(class utility::tag::XMLSchemaDefinition &) const –> void

set_model_group(self: pyrosetta.rosetta.utility.tag.XMLSchemaComplexType, model_group: pyrosetta.rosetta.utility.tag.XMLSchemaModelGroup) → pyrosetta.rosetta.utility.tag.XMLSchemaComplexType

C++: utility::tag::XMLSchemaComplexType::set_model_group(class std::shared_ptr<const class utility::tag::XMLSchemaModelGroup>) –> class utility::tag::XMLSchemaComplexType &

write_definition(self: pyrosetta.rosetta.utility.tag.XMLSchemaComplexType, indentation: int, os: pyrosetta.rosetta.std.ostream) → None

C++: utility::tag::XMLSchemaComplexType::write_definition(int, std::ostream &) const –> void

class pyrosetta.rosetta.utility.tag.XMLSchemaComplexTypeGenerator

Bases: pybind11_object

The %XMLComplexTypeSchemaGenerator is used to define the schema for a complex type as they typically occurr in Rosetta.

There are seven main categories of complexTypes that regularly appear in Rosetta’s XML Schemas, listed in order of most common to least common:

1. complexTypes that contain only attributes, but no subelements

2. complexTypes that contain subelements that can repeat and that need not appear at all e.g. <DsspDesignOperation blueprint=”somefile”>

   <Strand aa=”ACDEFGH”/> <Helix aa=”ACDEFG”/> <all append=”IKLMNP”/> <Helix exclude=”P”/>

   </DsspDesignOperation>

   (Perhaps a repreat presence of “Helix” could be avoided, but the way DsspDesignOperation works currently, repeat appearances are perfectly legal and sensical).

3. complexTypes that contain subelements that must appear once, where the subelements are allowed to appear in any order,

4. complexTypes that contain subelements that can can appear zero or one times, where the subelements are allowed to appear in any order,

5. complexTypes where one of a set of subelements must be chosen,

6. complexTypes where zero or one of a set of subelements can be chosen,

7. complexTypes where elements must appear in a particular order (which is required if you have two “xs:group” model groups you want both of, as is the case for the OperateOnResidueSubset task operation which can hold both a “residue_selector” group and a “res_lvl_task_op” group), and

8. complexTypes that have ordered sets of subelements where each set is either:

   1. repeatable,

   2. optional,

   3. required,

   4. pick-one-from-a-list, or

   5. pick-one-or-none-from-a-list.

   In these complexTypes, no elements may appear in multiple sets.

   For example, it’s ok if you want to say “the <Option> subtag is first and it’s either there or not, and then afterwards you can have as many <ScoreFunction> and <TaskOperation> tags as you want in any order, and finally, you can put either a single <PackRotamersMover> tag or a <RotamerTrialsMover> tag.” This would be like saying that the first set has an <Option> element, and that it is optional, that the second set has both a <ScoreFunction> element and a <TaskOperation> element and the elements of this set are repeatable, and that finally, a third set contains the <PackRotamersMover> element and the <RotamerTrialsMover>, and that neither has to appear but only one of the two may appear, and only once.

   However, you cannot say “The <Option> subtag is first, and its either there or not, and then afterwards, you can have as many <ScoreFunction> and <TaskOperation> tags as you want, and then afterwards you may have another <Option> subtag,” because then the <Option> tag would appear in two sets (the first and the third). (The reason for this is restriction is to avoid violating the unique particle attribution rule of XML Schema: https://en.wikipedia.org/wiki/Unique_Particle_Attribution )

Clearly XML Schema can support more kinds of elements than the eight that are supported by this class, but these are the ones that seem to appear the most frequently. All functionality provided by this class can also be accomplished using the XMLSchemaComplexType and XMLSchemaElement classes, but would require a deeper understanding of XML Schema. The niche that this class fills is to make it easy for developers to provide XSDs for these most-common case. Adding additional functionality to this class comes at the expense of making it less clear how the class should be used. Write me if you feel that there categories that should be added.

A description must be provided for every complex type even if that description is an empty string; do not forget to provide a description (your code will compile but will not run).

add_attribute(self: pyrosetta.rosetta.utility.tag.XMLSchemaComplexTypeGenerator, attribute: pyrosetta.rosetta.utility.tag.XMLSchemaAttribute) → pyrosetta.rosetta.utility.tag.XMLSchemaComplexTypeGenerator

C++: utility::tag::XMLSchemaComplexTypeGenerator::add_attribute(const class utility::tag::XMLSchemaAttribute &) –> class utility::tag::XMLSchemaComplexTypeGenerator &

add_attributes(self: pyrosetta.rosetta.utility.tag.XMLSchemaComplexTypeGenerator, attributes: pyrosetta.rosetta.std.list_utility_tag_XMLSchemaAttribute_t) → pyrosetta.rosetta.utility.tag.XMLSchemaComplexTypeGenerator

C++: utility::tag::XMLSchemaComplexTypeGenerator::add_attributes(const class std::list<class utility::tag::XMLSchemaAttribute, class std::allocator<class utility::tag::XMLSchemaAttribute> > &) –> class utility::tag::XMLSchemaComplexTypeGenerator &

add_optional_name_attribute(*args, **kwargs)

Overloaded function.

1. add_optional_name_attribute(self: pyrosetta.rosetta.utility.tag.XMLSchemaComplexTypeGenerator) -> pyrosetta.rosetta.utility.tag.XMLSchemaComplexTypeGenerator

2. add_optional_name_attribute(self: pyrosetta.rosetta.utility.tag.XMLSchemaComplexTypeGenerator, desc: str) -> pyrosetta.rosetta.utility.tag.XMLSchemaComplexTypeGenerator

C++: utility::tag::XMLSchemaComplexTypeGenerator::add_optional_name_attribute(const std::string &) –> class utility::tag::XMLSchemaComplexTypeGenerator &

add_ordered_subelement_set_as_optional(self: pyrosetta.rosetta.utility.tag.XMLSchemaComplexTypeGenerator, subelements: pyrosetta.rosetta.utility.tag.XMLSchemaSimpleSubelementList) → pyrosetta.rosetta.utility.tag.XMLSchemaComplexTypeGenerator

Add a subelement list to a growing set of ordered subelements, where elements in

this set are labeled as being optional. There should be only a single element in the input subelement list. This function corresponds to case 8b in the list of behaviors above and calling it overrides any of the functions for cases 1-7.

C++: utility::tag::XMLSchemaComplexTypeGenerator::add_ordered_subelement_set_as_optional(const class utility::tag::XMLSchemaSimpleSubelementList &) –> class utility::tag::XMLSchemaComplexTypeGenerator &

add_ordered_subelement_set_as_pick_one(self: pyrosetta.rosetta.utility.tag.XMLSchemaComplexTypeGenerator, subelements: pyrosetta.rosetta.utility.tag.XMLSchemaSimpleSubelementList) → pyrosetta.rosetta.utility.tag.XMLSchemaComplexTypeGenerator

Add a subelement list to a growing set of ordered subelements, where elements in

this set are labeled as “pick exactly one”. There should be more than one element in the input subelement list. This function corresponds to case 8d in the list of behaviors above and calling it overrides any of the functions for cases 1-7.

C++: utility::tag::XMLSchemaComplexTypeGenerator::add_ordered_subelement_set_as_pick_one(const class utility::tag::XMLSchemaSimpleSubelementList &) –> class utility::tag::XMLSchemaComplexTypeGenerator &

add_ordered_subelement_set_as_pick_one_or_none(self: pyrosetta.rosetta.utility.tag.XMLSchemaComplexTypeGenerator, subelements: pyrosetta.rosetta.utility.tag.XMLSchemaSimpleSubelementList) → pyrosetta.rosetta.utility.tag.XMLSchemaComplexTypeGenerator

Add a subelement list to a growing set of ordered subelements, where elements in

this set are labeled as “pick one or none”. There should be more than one element in the input subelement list. This function corresponds to case 8e in the list of behaviors above and calling it overrides any of the functions for cases 1-7.

C++: utility::tag::XMLSchemaComplexTypeGenerator::add_ordered_subelement_set_as_pick_one_or_none(const class utility::tag::XMLSchemaSimpleSubelementList &) –> class utility::tag::XMLSchemaComplexTypeGenerator &

add_ordered_subelement_set_as_repeatable(self: pyrosetta.rosetta.utility.tag.XMLSchemaComplexTypeGenerator, subelements: pyrosetta.rosetta.utility.tag.XMLSchemaSimpleSubelementList) → pyrosetta.rosetta.utility.tag.XMLSchemaComplexTypeGenerator

Add a subelement list to a growing set of ordered subelements, where elements in

this set are labeled as being repeatable. This function corresponds to case 8a in the list of behaviors above and calling it overrides any of the functions for cases 1-7.

C++: utility::tag::XMLSchemaComplexTypeGenerator::add_ordered_subelement_set_as_repeatable(const class utility::tag::XMLSchemaSimpleSubelementList &) –> class utility::tag::XMLSchemaComplexTypeGenerator &

add_ordered_subelement_set_as_required(self: pyrosetta.rosetta.utility.tag.XMLSchemaComplexTypeGenerator, subelements: pyrosetta.rosetta.utility.tag.XMLSchemaSimpleSubelementList) → pyrosetta.rosetta.utility.tag.XMLSchemaComplexTypeGenerator

Add a subelement list to a growing set of ordered subelements, where elements in

this set are labeled as being requried. There should be only a single element in the input subelement list. This function corresponds to case 8c in the list of behaviors above and calling it overrides any of the functions for cases 1-7.

C++: utility::tag::XMLSchemaComplexTypeGenerator::add_ordered_subelement_set_as_required(const class utility::tag::XMLSchemaSimpleSubelementList &) –> class utility::tag::XMLSchemaComplexTypeGenerator &

add_required_name_attribute(*args, **kwargs)

Overloaded function.

1. add_required_name_attribute(self: pyrosetta.rosetta.utility.tag.XMLSchemaComplexTypeGenerator) -> pyrosetta.rosetta.utility.tag.XMLSchemaComplexTypeGenerator

2. add_required_name_attribute(self: pyrosetta.rosetta.utility.tag.XMLSchemaComplexTypeGenerator, desc: str) -> pyrosetta.rosetta.utility.tag.XMLSchemaComplexTypeGenerator

C++: utility::tag::XMLSchemaComplexTypeGenerator::add_required_name_attribute(const std::string &) –> class utility::tag::XMLSchemaComplexTypeGenerator &

complex_type_naming_func(self: pyrosetta.rosetta.utility.tag.XMLSchemaComplexTypeGenerator, naming_function: std::function<std::string (std::string const&)>) → pyrosetta.rosetta.utility.tag.XMLSchemaComplexTypeGenerator

C++: utility::tag::XMLSchemaComplexTypeGenerator::complex_type_naming_func(const class std::function<std::string (const std::string &)> &) –> class utility::tag::XMLSchemaComplexTypeGenerator &

description(self: pyrosetta.rosetta.utility.tag.XMLSchemaComplexTypeGenerator, : str) → pyrosetta.rosetta.utility.tag.XMLSchemaComplexTypeGenerator

Provide the description for this complex type – this is a function that must be called, even

if you are passing in an empty string for the description.

C++: utility::tag::XMLSchemaComplexTypeGenerator::description(const std::string &) –> class utility::tag::XMLSchemaComplexTypeGenerator &

element_name(self: pyrosetta.rosetta.utility.tag.XMLSchemaComplexTypeGenerator, : str) → pyrosetta.rosetta.utility.tag.XMLSchemaComplexTypeGenerator

C++: utility::tag::XMLSchemaComplexTypeGenerator::element_name(const std::string &) –> class utility::tag::XMLSchemaComplexTypeGenerator &

set_subelements_pick_one(self: pyrosetta.rosetta.utility.tag.XMLSchemaComplexTypeGenerator, subelements: pyrosetta.rosetta.utility.tag.XMLSchemaSimpleSubelementList) → pyrosetta.rosetta.utility.tag.XMLSchemaComplexTypeGenerator

set the set of subelements with the stipulation that exactly one must be chosen.

This function represents case 5 in the list of behaviors above.

C++: utility::tag::XMLSchemaComplexTypeGenerator::set_subelements_pick_one(const class utility::tag::XMLSchemaSimpleSubelementList &) –> class utility::tag::XMLSchemaComplexTypeGenerator &

set_subelements_pick_one_or_none(self: pyrosetta.rosetta.utility.tag.XMLSchemaComplexTypeGenerator, subelements: pyrosetta.rosetta.utility.tag.XMLSchemaSimpleSubelementList) → pyrosetta.rosetta.utility.tag.XMLSchemaComplexTypeGenerator

set the set of subelements with the stipulation that one or none should be chosen.

This function represents case 6 in the list of behaviors above.

C++: utility::tag::XMLSchemaComplexTypeGenerator::set_subelements_pick_one_or_none(const class utility::tag::XMLSchemaSimpleSubelementList &) –> class utility::tag::XMLSchemaComplexTypeGenerator &

set_subelements_repeatable(*args, **kwargs)

Overloaded function.

1. set_subelements_repeatable(self: pyrosetta.rosetta.utility.tag.XMLSchemaComplexTypeGenerator, subelements: pyrosetta.rosetta.utility.tag.XMLSchemaSimpleSubelementList) -> pyrosetta.rosetta.utility.tag.XMLSchemaComplexTypeGenerator

2. set_subelements_repeatable(self: pyrosetta.rosetta.utility.tag.XMLSchemaComplexTypeGenerator, subelements: pyrosetta.rosetta.utility.tag.XMLSchemaSimpleSubelementList, min_occurs: int) -> pyrosetta.rosetta.utility.tag.XMLSchemaComplexTypeGenerator

3. set_subelements_repeatable(self: pyrosetta.rosetta.utility.tag.XMLSchemaComplexTypeGenerator, subelements: pyrosetta.rosetta.utility.tag.XMLSchemaSimpleSubelementList, min_occurs: int, max_occurs: int) -> pyrosetta.rosetta.utility.tag.XMLSchemaComplexTypeGenerator

set subelements as repeatable (and optional); setting the sub-elements replaces any sub-elements that were

previously set. These repeatable subelements are allowed to appear in any order from the point of view of the XML Schema, which is not to say that the order in which they appear cannot matter to the code reading these subelements. This function represents case 2 in the list of behaviors above.

C++: utility::tag::XMLSchemaComplexTypeGenerator::set_subelements_repeatable(const class utility::tag::XMLSchemaSimpleSubelementList &, int, int) –> class utility::tag::XMLSchemaComplexTypeGenerator &

set_subelements_single_appearance_optional(self: pyrosetta.rosetta.utility.tag.XMLSchemaComplexTypeGenerator, subelements: pyrosetta.rosetta.utility.tag.XMLSchemaSimpleSubelementList) → pyrosetta.rosetta.utility.tag.XMLSchemaComplexTypeGenerator

set subelements as single-appearance (and optional); setting the sub-elements replaces any sub-elements that were previously set.

These single-appearance subelements are allowed to appear in any order from the point of view of the XML Schema, which is not to say that the order in which they appear cannot matter to the code reading these subelements. This function represents case 4 in the list of behaviors above.

C++: utility::tag::XMLSchemaComplexTypeGenerator::set_subelements_single_appearance_optional(const class utility::tag::XMLSchemaSimpleSubelementList &) –> class utility::tag::XMLSchemaComplexTypeGenerator &

set_subelements_single_appearance_required(self: pyrosetta.rosetta.utility.tag.XMLSchemaComplexTypeGenerator, subelements: pyrosetta.rosetta.utility.tag.XMLSchemaSimpleSubelementList) → pyrosetta.rosetta.utility.tag.XMLSchemaComplexTypeGenerator

set subelements as single-appearance (and required); setting the sub-elements replaces any sub-elements that were previously set.

These single-appearance subelements are allowed to appear in any order from the point of view of the XML Schema, which is not to say that the order in which they appear cannot matter to the code reading these subelements. Due to limitations of XML Schema, if you have a “group” subelement, then it must appear alone; it may not appear with any other group subelements, and it may not appear with other “regular” subelements. This function represents case 3 in the list of behaviors above.

C++: utility::tag::XMLSchemaComplexTypeGenerator::set_subelements_single_appearance_required(const class utility::tag::XMLSchemaSimpleSubelementList &) –> class utility::tag::XMLSchemaComplexTypeGenerator &

set_subelements_single_appearance_required_and_ordered(self: pyrosetta.rosetta.utility.tag.XMLSchemaComplexTypeGenerator, subelements: pyrosetta.rosetta.utility.tag.XMLSchemaSimpleSubelementList) → pyrosetta.rosetta.utility.tag.XMLSchemaComplexTypeGenerator

set subelements as single-appearance (and required) with a specified order;

setting the sub-elements replaces any sub-elements that were previously set. This function represents case 7 in the list of behaviors above.

C++: utility::tag::XMLSchemaComplexTypeGenerator::set_subelements_single_appearance_required_and_ordered(const class utility::tag::XMLSchemaSimpleSubelementList &) –> class utility::tag::XMLSchemaComplexTypeGenerator &

subelement_behavior(self: pyrosetta.rosetta.utility.tag.XMLSchemaComplexTypeGenerator) → pyrosetta.rosetta.utility.tag.CTGenSubelementBehavior

Return what the internal settings of the instance have been set to;

this lets one class give another class access to a generator, and then inspect it on a crude level when it gets it back.

C++: utility::tag::XMLSchemaComplexTypeGenerator::subelement_behavior() const –> enum utility::tag::CTGenSubelementBehavior

write_complex_type_to_schema(self: pyrosetta.rosetta.utility.tag.XMLSchemaComplexTypeGenerator, xsd: pyrosetta.rosetta.utility.tag.XMLSchemaDefinition) → None

C++: utility::tag::XMLSchemaComplexTypeGenerator::write_complex_type_to_schema(class utility::tag::XMLSchemaDefinition &) –> void

class pyrosetta.rosetta.utility.tag.XMLSchemaDataType

Bases: pybind11_object

The simple types provided by the XMLSchema language itself.

These are not always the types that you want to use.

In particular, xs_decimal does not support scientific notation, so you probably want to use xsct_real (defined in the XMLSchemaCommonType enumeration in XMLSchemaGeneration.hh) to represent real-valued numbers.

Also, the boolean-value reading function in tag::getOption< bool > accepts more values for “true” and “false” than the xs_boolean so you want to use xsct_rosetta_bool in your schemas instead.

Members:

xs_string

xs_decimal

xs_integer

xs_boolean

xs_date

xs_time

xs_common

xs_custom

property name

property value

xs_boolean = <XMLSchemaDataType.xs_boolean: 3>

xs_common = <XMLSchemaDataType.xs_common: 6>

xs_custom = <XMLSchemaDataType.xs_custom: 7>

xs_date = <XMLSchemaDataType.xs_date: 4>

xs_decimal = <XMLSchemaDataType.xs_decimal: 1>

xs_integer = <XMLSchemaDataType.xs_integer: 2>

xs_string = <XMLSchemaDataType.xs_string: 0>

xs_time = <XMLSchemaDataType.xs_time: 5>

class pyrosetta.rosetta.utility.tag.XMLSchemaDefinition

Bases: pybind11_object

The %XMLSchemaDefinition class’s purpose is to collect all of the elements that go into an XML Schema, to filter out the elements that are repeated (e.g. a restriction such as the “int_cslist” given in the description for XMLSchemaRestriction above may be reported twice to the %XMLSchemaDefinition by several attributes that rely upon it), to detect non-identical duplicates that have the same name, and to write out the elements that it has been handed into a single string. The %XMLSchemaDefinition is intended to be passed between static functions / non-class-member functions as a container for the XML Schema representations that these functions define. Such functions will always take an %XMLSchemaDefinition reference as one of their input parameters. It is perfectly legitimate / recommended for one XML-schema-defining function that relies on a complexType or restriction that it does not itself define to pass its input %XMLSchemaDefinition to the function that does define that complexType or restriction.

add_top_level_element(self: pyrosetta.rosetta.utility.tag.XMLSchemaDefinition, element: pyrosetta.rosetta.utility.tag.XMLSchemaTopLevelElement) → None

C++: utility::tag::XMLSchemaDefinition::add_top_level_element(const class utility::tag::XMLSchemaTopLevelElement &) –> void

assign(self: pyrosetta.rosetta.utility.tag.XMLSchemaDefinition, : pyrosetta.rosetta.utility.tag.XMLSchemaDefinition) → pyrosetta.rosetta.utility.tag.XMLSchemaDefinition

C++: utility::tag::XMLSchemaDefinition::operator=(const class utility::tag::XMLSchemaDefinition &) –> class utility::tag::XMLSchemaDefinition &

full_definition(self: pyrosetta.rosetta.utility.tag.XMLSchemaDefinition) → str

Returns the full XML schema definition, in XML format.

C++: utility::tag::XMLSchemaDefinition::full_definition() const –> std::string

has_top_level_element(self: pyrosetta.rosetta.utility.tag.XMLSchemaDefinition, element_name: str) → bool

C++: utility::tag::XMLSchemaDefinition::has_top_level_element(const std::string &) const –> bool

human_readable_summary(*args, **kwargs)

Overloaded function.

1. human_readable_summary(self: pyrosetta.rosetta.utility.tag.XMLSchemaDefinition) -> str

2. human_readable_summary(self: pyrosetta.rosetta.utility.tag.XMLSchemaDefinition, component_name: str) -> str

3. human_readable_summary(self: pyrosetta.rosetta.utility.tag.XMLSchemaDefinition, component_name: str, component_type: str) -> str

4. human_readable_summary(self: pyrosetta.rosetta.utility.tag.XMLSchemaDefinition, component_name: str, component_type: str, citation_text: str) -> str

Returns a human-readable summary of the XML schema definition.

SLOW! Must generate the summary for every invocation.

If component_name and component_type are provided, then summary information is only returned for that particular object type. For example, component_name=”DeclareBond” and component_type=”mover” would return information on the DeclareBond mover. Also note, this function uses raw pointers, unfortunately – the libxml2 functions that I’m calling require it. As such, no premature return statements should be added prior to the xmlFreeDoc and xmlCleanupParser statements at the end of the function.

Vikram K. Mulligan (vmullig.edu)

C++: utility::tag::XMLSchemaDefinition::human_readable_summary(const std::string &, const std::string &, const std::string &) const –> std::string

include_citation_info(*args, **kwargs)

Overloaded function.

1. include_citation_info(self: pyrosetta.rosetta.utility.tag.XMLSchemaDefinition) -> bool

Adding citation info requires instantiating classes.

If we don’t need it (e.g. during Validation) just skip it.

C++: utility::tag::XMLSchemaDefinition::include_citation_info() const –> bool

2. include_citation_info(self: pyrosetta.rosetta.utility.tag.XMLSchemaDefinition, setting: bool) -> None

C++: utility::tag::XMLSchemaDefinition::include_citation_info(bool) –> void

class pyrosetta.rosetta.utility.tag.XMLSchemaElement

Bases: XMLSchemaParticle

An XMLSchema element, e.g. the FixbbMover “tag” <FixbbMover name=”fixbb” task_operations=”ex1,ex2”/> or the And element which contains a sub-element: <And><Chain id=”A”/></And>. An element can be defined with an unnamed complex type in-line, or it can say that its type is that of a complex type defined elsewhere. (In XML naming a tag is a single block beginning with “<” and ending with “>”, so both “<And>” and “</And>” are tags. The block between the opening and closing tags is called an element. The utility::tag::Tag class represents a complete Element, and not simply the opening or closing tag of an element. This is certainly confusing.

An element may either have its type definition given inline (i.e. as a sub-tag / sub-element of the element declaration) as either a complex type or a restriction – or it may have its type definition given by reference to a (named) type defined elsewhere in the XML Schema. In Rosetta’s style of XML, the type of an element is universally a complex type; if the element’s type were given as either a primitive type, or a restriction, then the data would have to appear between two tags, e.g.

<FirstName> Andrew </FirstName>

and in Rosetta’s XML, we ignore everything that appears outside of a tag, and store all of the data in attributes (aka options) inside of tags. The elements in Rosetta either are “empty” or they contain sub-elements: both of these are classified as complex types in XML Schema.

Elements may appear multiple times, and the number of times they must/may appear are controlled by the min_occurs and max_occurs functions. If you are setting no limit on max_occurs, use the “xsminmax_unbounded” value of the XMLSchemaMinOccursMaxOccurs enumeration.

assign(self: pyrosetta.rosetta.utility.tag.XMLSchemaElement, : pyrosetta.rosetta.utility.tag.XMLSchemaElement) → pyrosetta.rosetta.utility.tag.XMLSchemaElement

C++: utility::tag::XMLSchemaElement::operator=(const class utility::tag::XMLSchemaElement &) –> class utility::tag::XMLSchemaElement &

element_name(self: pyrosetta.rosetta.utility.tag.XMLSchemaElement) → str

C++: utility::tag::XMLSchemaElement::element_name() const –> const std::string &

element_type_def(self: pyrosetta.rosetta.utility.tag.XMLSchemaElement, setting: pyrosetta.rosetta.utility.tag.XMLSchemaComplexType) → pyrosetta.rosetta.utility.tag.XMLSchemaElement

C++: utility::tag::XMLSchemaElement::element_type_def(class std::shared_ptr<class utility::tag::XMLSchemaComplexType>) –> class utility::tag::XMLSchemaElement &

max_occurs(*args, **kwargs)

Overloaded function.

1. max_occurs(self: pyrosetta.rosetta.utility.tag.XMLSchemaParticle, setting: int) -> pyrosetta.rosetta.utility.tag.XMLSchemaParticle

C++: utility::tag::XMLSchemaParticle::max_occurs(int) –> class utility::tag::XMLSchemaParticle &

2. max_occurs(self: pyrosetta.rosetta.utility.tag.XMLSchemaParticle) -> int

C++: utility::tag::XMLSchemaParticle::max_occurs() const –> int

min_occurs(*args, **kwargs)

Overloaded function.

1. min_occurs(self: pyrosetta.rosetta.utility.tag.XMLSchemaParticle, setting: int) -> pyrosetta.rosetta.utility.tag.XMLSchemaParticle

C++: utility::tag::XMLSchemaParticle::min_occurs(int) –> class utility::tag::XMLSchemaParticle &

2. min_occurs(self: pyrosetta.rosetta.utility.tag.XMLSchemaParticle) -> int

C++: utility::tag::XMLSchemaParticle::min_occurs() const –> int

name(self: pyrosetta.rosetta.utility.tag.XMLSchemaElement, setting: str) → pyrosetta.rosetta.utility.tag.XMLSchemaElement

C++: utility::tag::XMLSchemaElement::name(const std::string &) –> class utility::tag::XMLSchemaElement &

prepare_for_output(self: pyrosetta.rosetta.utility.tag.XMLSchemaElement, xsd: utility::tag::XMLSchemaDefinition) → None

C++: utility::tag::XMLSchemaElement::prepare_for_output(class utility::tag::XMLSchemaDefinition &) const –> void

reference_name(self: pyrosetta.rosetta.utility.tag.XMLSchemaElement, setting: str) → pyrosetta.rosetta.utility.tag.XMLSchemaElement

C++: utility::tag::XMLSchemaElement::reference_name(const std::string &) –> class utility::tag::XMLSchemaElement &

set_abstract(self: pyrosetta.rosetta.utility.tag.XMLSchemaElement) → pyrosetta.rosetta.utility.tag.XMLSchemaElement

C++: utility::tag::XMLSchemaElement::set_abstract() –> class utility::tag::XMLSchemaElement &

substitution_group(self: pyrosetta.rosetta.utility.tag.XMLSchemaElement, setting: str) → pyrosetta.rosetta.utility.tag.XMLSchemaElement

C++: utility::tag::XMLSchemaElement::substitution_group(const std::string &) –> class utility::tag::XMLSchemaElement &

type_name(self: pyrosetta.rosetta.utility.tag.XMLSchemaElement, setting: pyrosetta.rosetta.utility.tag.XMLSchemaType) → pyrosetta.rosetta.utility.tag.XMLSchemaElement

C++: utility::tag::XMLSchemaElement::type_name(class utility::tag::XMLSchemaType) –> class utility::tag::XMLSchemaElement &

write_definition(self: pyrosetta.rosetta.utility.tag.XMLSchemaElement, indentation: int, os: pyrosetta.rosetta.std.ostream) → None

C++: utility::tag::XMLSchemaElement::write_definition(int, std::ostream &) const –> void

class pyrosetta.rosetta.utility.tag.XMLSchemaElementCategory

Bases: pybind11_object

Members:

xs_element_is_type_reference

xs_element_is_abstract

xs_element_is_complex_type_w_definition

xs_element_is_element_reference

property name

property value

xs_element_is_abstract = <XMLSchemaElementCategory.xs_element_is_abstract: 1>

xs_element_is_complex_type_w_definition = <XMLSchemaElementCategory.xs_element_is_complex_type_w_definition: 2>

xs_element_is_element_reference = <XMLSchemaElementCategory.xs_element_is_element_reference: 3>

xs_element_is_type_reference = <XMLSchemaElementCategory.xs_element_is_type_reference: 0>

class pyrosetta.rosetta.utility.tag.XMLSchemaMinOccursMaxOccurs

Bases: pybind11_object

Members:

xsminmax_unbounded

xsminmax_unspecified

property name

property value

xsminmax_unbounded = <XMLSchemaMinOccursMaxOccurs.xsminmax_unbounded: -2>

xsminmax_unspecified = <XMLSchemaMinOccursMaxOccurs.xsminmax_unspecified: -1>

class pyrosetta.rosetta.utility.tag.XMLSchemaModelGroup

Bases: XMLSchemaParticle

The ModelGroup covers four XML Schema model groups: xs:sequence, xs:choice, xs:all, and xs:group. A ModelGroup may contain any number of XMLSchemaParticles, interchanging between XMLElements and XMLModelGroups, BUT there are some fairly heavy restrictions on the xs:all model group, marginally enforced by this class and by XMLSchemaComplexType. This class is not exactly a top-level element, in that only xs:group is allowed to appear at the top level, but it is definitely worthwhile for this class to implement the write_definition funciton.

append_particle(self: pyrosetta.rosetta.utility.tag.XMLSchemaModelGroup, particle: pyrosetta.rosetta.utility.tag.XMLSchemaParticle) → pyrosetta.rosetta.utility.tag.XMLSchemaModelGroup

C++: utility::tag::XMLSchemaModelGroup::append_particle(class std::shared_ptr<const class utility::tag::XMLSchemaParticle>) –> class utility::tag::XMLSchemaModelGroup &

append_particles(self: pyrosetta.rosetta.utility.tag.XMLSchemaModelGroup, particles: pyrosetta.rosetta.std.list_std_shared_ptr_const_utility_tag_XMLSchemaParticle_t) → pyrosetta.rosetta.utility.tag.XMLSchemaModelGroup

C++: utility::tag::XMLSchemaModelGroup::append_particles(const class std::list<class std::shared_ptr<const class utility::tag::XMLSchemaParticle>, class std::allocator<class std::shared_ptr<const class utility::tag::XMLSchemaParticle> > > &) –> class utility::tag::XMLSchemaModelGroup &

assign(self: pyrosetta.rosetta.utility.tag.XMLSchemaModelGroup, : pyrosetta.rosetta.utility.tag.XMLSchemaModelGroup) → pyrosetta.rosetta.utility.tag.XMLSchemaModelGroup

C++: utility::tag::XMLSchemaModelGroup::operator=(const class utility::tag::XMLSchemaModelGroup &) –> class utility::tag::XMLSchemaModelGroup &

element_name(self: pyrosetta.rosetta.utility.tag.XMLSchemaModelGroup) → str

C++: utility::tag::XMLSchemaModelGroup::element_name() const –> const std::string &

group_name(self: pyrosetta.rosetta.utility.tag.XMLSchemaModelGroup, name: str) → pyrosetta.rosetta.utility.tag.XMLSchemaModelGroup

C++: utility::tag::XMLSchemaModelGroup::group_name(const std::string &) –> class utility::tag::XMLSchemaModelGroup &

max_occurs(*args, **kwargs)

Overloaded function.

1. max_occurs(self: pyrosetta.rosetta.utility.tag.XMLSchemaParticle, setting: int) -> pyrosetta.rosetta.utility.tag.XMLSchemaParticle

C++: utility::tag::XMLSchemaParticle::max_occurs(int) –> class utility::tag::XMLSchemaParticle &

2. max_occurs(self: pyrosetta.rosetta.utility.tag.XMLSchemaParticle) -> int

C++: utility::tag::XMLSchemaParticle::max_occurs() const –> int

min_occurs(*args, **kwargs)

Overloaded function.

1. min_occurs(self: pyrosetta.rosetta.utility.tag.XMLSchemaParticle, setting: int) -> pyrosetta.rosetta.utility.tag.XMLSchemaParticle

C++: utility::tag::XMLSchemaParticle::min_occurs(int) –> class utility::tag::XMLSchemaParticle &

2. min_occurs(self: pyrosetta.rosetta.utility.tag.XMLSchemaParticle) -> int

C++: utility::tag::XMLSchemaParticle::min_occurs() const –> int

prepare_for_output(self: pyrosetta.rosetta.utility.tag.XMLSchemaModelGroup, xsd: utility::tag::XMLSchemaDefinition) → None

C++: utility::tag::XMLSchemaModelGroup::prepare_for_output(class utility::tag::XMLSchemaDefinition &) const –> void

type(self: pyrosetta.rosetta.utility.tag.XMLSchemaModelGroup, type: pyrosetta.rosetta.utility.tag.XMLSchemaModelGroupType) → pyrosetta.rosetta.utility.tag.XMLSchemaModelGroup

C++: utility::tag::XMLSchemaModelGroup::type(enum utility::tag::XMLSchemaModelGroupType) –> class utility::tag::XMLSchemaModelGroup &

write_definition(self: pyrosetta.rosetta.utility.tag.XMLSchemaModelGroup, indentation: int, os: pyrosetta.rosetta.std.ostream) → None

C++: utility::tag::XMLSchemaModelGroup::write_definition(int, std::ostream &) const –> void

class pyrosetta.rosetta.utility.tag.XMLSchemaModelGroupType

Bases: pybind11_object

Members:

xsmgt_sequence

xsmgt_all

xsmgt_choice

xsmgt_group

property name

property value

xsmgt_all = <XMLSchemaModelGroupType.xsmgt_all: 1>

xsmgt_choice = <XMLSchemaModelGroupType.xsmgt_choice: 2>

xsmgt_group = <XMLSchemaModelGroupType.xsmgt_group: 3>

xsmgt_sequence = <XMLSchemaModelGroupType.xsmgt_sequence: 0>

class pyrosetta.rosetta.utility.tag.XMLSchemaParticle

Bases: XMLSchemaTopLevelElement

This abstract class is meant to represent either an XMLSChemaElement or an XMLSchemaModelGroup so that the interchangable set of these objects in a ModelGroup can be represented. I may be misusing the term “particle” in the way that it is meant within XML Schema – so the mapping of this term to the term used in XML Schema is probably imperfect.

assign(self: pyrosetta.rosetta.utility.tag.XMLSchemaParticle, : pyrosetta.rosetta.utility.tag.XMLSchemaParticle) → pyrosetta.rosetta.utility.tag.XMLSchemaParticle

C++: utility::tag::XMLSchemaParticle::operator=(const class utility::tag::XMLSchemaParticle &) –> class utility::tag::XMLSchemaParticle &

element_name(self: pyrosetta.rosetta.utility.tag.XMLSchemaTopLevelElement) → str

C++: utility::tag::XMLSchemaTopLevelElement::element_name() const –> const std::string &

max_occurs(*args, **kwargs)

Overloaded function.

1. max_occurs(self: pyrosetta.rosetta.utility.tag.XMLSchemaParticle, setting: int) -> pyrosetta.rosetta.utility.tag.XMLSchemaParticle

C++: utility::tag::XMLSchemaParticle::max_occurs(int) –> class utility::tag::XMLSchemaParticle &

2. max_occurs(self: pyrosetta.rosetta.utility.tag.XMLSchemaParticle) -> int

C++: utility::tag::XMLSchemaParticle::max_occurs() const –> int

min_occurs(*args, **kwargs)

Overloaded function.

1. min_occurs(self: pyrosetta.rosetta.utility.tag.XMLSchemaParticle, setting: int) -> pyrosetta.rosetta.utility.tag.XMLSchemaParticle

C++: utility::tag::XMLSchemaParticle::min_occurs(int) –> class utility::tag::XMLSchemaParticle &

2. min_occurs(self: pyrosetta.rosetta.utility.tag.XMLSchemaParticle) -> int

C++: utility::tag::XMLSchemaParticle::min_occurs() const –> int

prepare_for_output(self: pyrosetta.rosetta.utility.tag.XMLSchemaTopLevelElement, xsd: utility::tag::XMLSchemaDefinition) → None

C++: utility::tag::XMLSchemaTopLevelElement::prepare_for_output(class utility::tag::XMLSchemaDefinition &) const –> void

write_definition(self: pyrosetta.rosetta.utility.tag.XMLSchemaTopLevelElement, indentation: int, os: pyrosetta.rosetta.std.ostream) → None

C++: utility::tag::XMLSchemaTopLevelElement::write_definition(int, std::ostream &) const –> void

class pyrosetta.rosetta.utility.tag.XMLSchemaRepeatableCTNode

Bases: pybind11_object

add_child(self: pyrosetta.rosetta.utility.tag.XMLSchemaRepeatableCTNode, child_element: pyrosetta.rosetta.utility.tag.XMLSchemaRepeatableCTNode) → pyrosetta.rosetta.utility.tag.XMLSchemaRepeatableCTNode

C++: utility::tag::XMLSchemaRepeatableCTNode::add_child(class std::shared_ptr<class utility::tag::XMLSchemaRepeatableCTNode>) –> class utility::tag::XMLSchemaRepeatableCTNode &

assign(self: pyrosetta.rosetta.utility.tag.XMLSchemaRepeatableCTNode, : pyrosetta.rosetta.utility.tag.XMLSchemaRepeatableCTNode) → pyrosetta.rosetta.utility.tag.XMLSchemaRepeatableCTNode

C++: utility::tag::XMLSchemaRepeatableCTNode::operator=(const class utility::tag::XMLSchemaRepeatableCTNode &) –> class utility::tag::XMLSchemaRepeatableCTNode &

get_self_ptr(self: pyrosetta.rosetta.utility.tag.XMLSchemaRepeatableCTNode) → pyrosetta.rosetta.utility.tag.XMLSchemaRepeatableCTNode

C++: utility::tag::XMLSchemaRepeatableCTNode::get_self_ptr() –> class std::shared_ptr<class utility::tag::XMLSchemaRepeatableCTNode>

get_self_weak_ptr(self: pyrosetta.rosetta.utility.tag.XMLSchemaRepeatableCTNode) → pyrosetta.rosetta.std.weak_ptr_utility_tag_XMLSchemaRepeatableCTNode_t

C++: utility::tag::XMLSchemaRepeatableCTNode::get_self_weak_ptr() –> class std::weak_ptr<class utility::tag::XMLSchemaRepeatableCTNode>

recursively_write_ct_to_schema(self: pyrosetta.rosetta.utility.tag.XMLSchemaRepeatableCTNode, xsd: pyrosetta.rosetta.utility.tag.XMLSchemaDefinition) → None

C++: utility::tag::XMLSchemaRepeatableCTNode::recursively_write_ct_to_schema(class utility::tag::XMLSchemaDefinition &) –> void

set_already_defined_element(self: pyrosetta.rosetta.utility.tag.XMLSchemaRepeatableCTNode, name: str, naming_func: std::function<std::string (std::string const&)>) → pyrosetta.rosetta.utility.tag.XMLSchemaRepeatableCTNode

C++: utility::tag::XMLSchemaRepeatableCTNode::set_already_defined_element(const std::string &, const class std::function<std::string (const std::string &)> &) –> class utility::tag::XMLSchemaRepeatableCTNode &

set_already_defined_element_w_alt_name(self: pyrosetta.rosetta.utility.tag.XMLSchemaRepeatableCTNode, name: str, reference_element_name: str, naming_func: std::function<std::string (std::string const&)>) → pyrosetta.rosetta.utility.tag.XMLSchemaRepeatableCTNode

C++: utility::tag::XMLSchemaRepeatableCTNode::set_already_defined_element_w_alt_name(const std::string &, const std::string &, const class std::function<std::string (const std::string &)> &) –> class utility::tag::XMLSchemaRepeatableCTNode &

set_element_w_attributes(self: pyrosetta.rosetta.utility.tag.XMLSchemaRepeatableCTNode, name: str, atts: pyrosetta.rosetta.std.list_utility_tag_XMLSchemaAttribute_t, description: str) → pyrosetta.rosetta.utility.tag.XMLSchemaRepeatableCTNode

C++: utility::tag::XMLSchemaRepeatableCTNode::set_element_w_attributes(const std::string &, const class std::list<class utility::tag::XMLSchemaAttribute, class std::allocator<class utility::tag::XMLSchemaAttribute> > &, const std::string &) –> class utility::tag::XMLSchemaRepeatableCTNode &

set_group_subelement(self: pyrosetta.rosetta.utility.tag.XMLSchemaRepeatableCTNode, group_name_function: std::function<std::string ()>) → pyrosetta.rosetta.utility.tag.XMLSchemaRepeatableCTNode

C++: utility::tag::XMLSchemaRepeatableCTNode::set_group_subelement(const class std::function<std::string (void)> &) –> class utility::tag::XMLSchemaRepeatableCTNode &

set_kids_naming_func(self: pyrosetta.rosetta.utility.tag.XMLSchemaRepeatableCTNode, naming_func: std::function<std::string (std::string const&)>) → pyrosetta.rosetta.utility.tag.XMLSchemaRepeatableCTNode

C++: utility::tag::XMLSchemaRepeatableCTNode::set_kids_naming_func(const class std::function<std::string (const std::string &)> &) –> class utility::tag::XMLSchemaRepeatableCTNode &

set_root_node_naming_func(self: pyrosetta.rosetta.utility.tag.XMLSchemaRepeatableCTNode, naming_func: std::function<std::string (std::string const&)>) → pyrosetta.rosetta.utility.tag.XMLSchemaRepeatableCTNode

C++: utility::tag::XMLSchemaRepeatableCTNode::set_root_node_naming_func(const class std::function<std::string (const std::string &)> &) –> class utility::tag::XMLSchemaRepeatableCTNode &

class pyrosetta.rosetta.utility.tag.XMLSchemaRestriction

Bases: XMLSchemaTopLevelElement

class %XMLSchemaRestriction describes a refinement on the behavior of existing types. For example, one could define a restriction representing a list of residue indexes separating commas: “15,44,102” and then describe an attribute of a complex type as having to conform to that restriction. An xml-schema validator would be able to say that an input file with “fifteen,fortyfour,onehundredandtwo” did not meet the schema.

See the description of XML schema restrictions here: http://www.w3schools.com/xml/schema_facets.asp Restrictions are given as pairs of restriction types and then values for those restriction types. The restriction types are defined in an enumeration in XMLSchemaGeneration.fwd.hh.

An example of a useful XMLSchemaRestriction is oen to define a comma-separated list of integers. The elements in the XMLSchema that would define such a restriction look like this:

add_restriction(self: pyrosetta.rosetta.utility.tag.XMLSchemaRestriction, type: pyrosetta.rosetta.utility.tag.XMLSchemaRestrictionType, value: str) → None

C++: utility::tag::XMLSchemaRestriction::add_restriction(enum utility::tag::XMLSchemaRestrictionType, const std::string &) –> void

assign(self: pyrosetta.rosetta.utility.tag.XMLSchemaRestriction, : pyrosetta.rosetta.utility.tag.XMLSchemaRestriction) → pyrosetta.rosetta.utility.tag.XMLSchemaRestriction

C++: utility::tag::XMLSchemaRestriction::operator=(const class utility::tag::XMLSchemaRestriction &) –> class utility::tag::XMLSchemaRestriction &

base_type(self: pyrosetta.rosetta.utility.tag.XMLSchemaRestriction, setting: pyrosetta.rosetta.utility.tag.XMLSchemaType) → None

C++: utility::tag::XMLSchemaRestriction::base_type(class utility::tag::XMLSchemaType) –> void

element_name(self: pyrosetta.rosetta.utility.tag.XMLSchemaRestriction) → str

C++: utility::tag::XMLSchemaRestriction::element_name() const –> const std::string &

name(self: pyrosetta.rosetta.utility.tag.XMLSchemaRestriction, setting: str) → None

C++: utility::tag::XMLSchemaRestriction::name(const std::string &) –> void

prepare_for_output(self: pyrosetta.rosetta.utility.tag.XMLSchemaRestriction, xsd: utility::tag::XMLSchemaDefinition) → None

C++: utility::tag::XMLSchemaRestriction::prepare_for_output(class utility::tag::XMLSchemaDefinition &) const –> void

write_definition(self: pyrosetta.rosetta.utility.tag.XMLSchemaRestriction, indentation: int, os: pyrosetta.rosetta.std.ostream) → None

C++: utility::tag::XMLSchemaRestriction::write_definition(int, std::ostream &) const –> void

class pyrosetta.rosetta.utility.tag.XMLSchemaRestrictionType

Bases: pybind11_object

Members:

xsr_enumeration

xsr_fractionDigits

xsr_length

xsr_maxExclusive

xsr_maxInclusive

xsr_maxLength

xsr_minExclusive

xsr_minInclusive

xsr_minLength

xsr_pattern

xsr_totalDigits

xsr_whitespace

property name

property value

xsr_enumeration = <XMLSchemaRestrictionType.xsr_enumeration: 0>

xsr_fractionDigits = <XMLSchemaRestrictionType.xsr_fractionDigits: 1>

xsr_length = <XMLSchemaRestrictionType.xsr_length: 2>

xsr_maxExclusive = <XMLSchemaRestrictionType.xsr_maxExclusive: 3>

xsr_maxInclusive = <XMLSchemaRestrictionType.xsr_maxInclusive: 4>

xsr_maxLength = <XMLSchemaRestrictionType.xsr_maxLength: 5>

xsr_minExclusive = <XMLSchemaRestrictionType.xsr_minExclusive: 6>

xsr_minInclusive = <XMLSchemaRestrictionType.xsr_minInclusive: 7>

xsr_minLength = <XMLSchemaRestrictionType.xsr_minLength: 8>

xsr_pattern = <XMLSchemaRestrictionType.xsr_pattern: 9>

xsr_totalDigits = <XMLSchemaRestrictionType.xsr_totalDigits: 10>

xsr_whitespace = <XMLSchemaRestrictionType.xsr_whitespace: 11>

class pyrosetta.rosetta.utility.tag.XMLSchemaSimpleSubelementList

Bases: pybind11_object

The XMLSchemaSimpleSubelementList class defines an interface that can be used by those wishing to define a complexType that contains sub-elements. The structure of the XML Schema for the sub-elements will determined by how this list is given to the XMLSchemaComplexTypeGenerator. “simple” subelements are those which themselves contain no subelements (but may contain attributes). Also allowed are subelements that refer to previously-defined complexTypes or those that refer to previously defined xs:groups.

class ElementSummary

Bases: pybind11_object

class ElementType

Bases: pybind11_object

Members:

ct_simple

ct_ref

ct_group

ct_group = <ElementType.ct_group: 2>

ct_ref = <ElementType.ct_ref: 1>

ct_simple = <ElementType.ct_simple: 0>

property name

property value

assign(self: pyrosetta.rosetta.utility.tag.XMLSchemaSimpleSubelementList.ElementSummary, : pyrosetta.rosetta.utility.tag.XMLSchemaSimpleSubelementList.ElementSummary) → pyrosetta.rosetta.utility.tag.XMLSchemaSimpleSubelementList.ElementSummary

C++: utility::tag::XMLSchemaSimpleSubelementList::ElementSummary::operator=(const struct utility::tag::XMLSchemaSimpleSubelementList::ElementSummary &) –> struct utility::tag::XMLSchemaSimpleSubelementList::ElementSummary &

property attributes

ct_group = <ElementType.ct_group: 2>

property ct_name

ct_ref = <ElementType.ct_ref: 1>

ct_simple = <ElementType.ct_simple: 0>

property description

property element_name

property element_type

property max_occurs

property min_occurs

property min_or_max_occurs_set

add_already_defined_subelement(*args, **kwargs)

Overloaded function.

1. add_already_defined_subelement(self: pyrosetta.rosetta.utility.tag.XMLSchemaSimpleSubelementList, name: str, ct_naming_function: std::function<std::string (std::string const&)>) -> pyrosetta.rosetta.utility.tag.XMLSchemaSimpleSubelementList

Add a new subelement to the growing list of subelements, but one whose complexType definition has been provided

elsewhere and where the name of the complexType for this subelement is derived from the subelement’s name using the provided function. (Why pass a function to define the name for the complex type instead of just passing the result of the function? Because such an interface would also let you bypass a function entirely and let you pass in a raw string, and that would lead to brittle code. If we should want to change the complexType naming rule for a particular class of elements in the schema, we want to be able to change only a single function and have that change ripple outwards through all the parts of the schema that interacted with those elements.)

C++: utility::tag::XMLSchemaSimpleSubelementList::add_already_defined_subelement(const std::string &, const class std::function<std::string (const std::string &)> &) –> class utility::tag::XMLSchemaSimpleSubelementList &

2. add_already_defined_subelement(self: pyrosetta.rosetta.utility.tag.XMLSchemaSimpleSubelementList, name: str, ct_naming_function: std::function<std::string (std::string const&)>, min_occurs: int) -> pyrosetta.rosetta.utility.tag.XMLSchemaSimpleSubelementList

3. add_already_defined_subelement(self: pyrosetta.rosetta.utility.tag.XMLSchemaSimpleSubelementList, name: str, ct_naming_function: std::function<std::string (std::string const&)>, min_occurs: int, max_occurs: int) -> pyrosetta.rosetta.utility.tag.XMLSchemaSimpleSubelementList

Add a new subelement to the growing list of subelements, but where the minimum and maximum number of

occurrences for this subelement has been set; note: usually, the min and max are set by the XMLSchemaComplexTypeGenerator, and so tension could arise between the generator and your settings. Consider this an advanced function.

C++: utility::tag::XMLSchemaSimpleSubelementList::add_already_defined_subelement(const std::string &, const class std::function<std::string (const std::string &)> &, int, int) –> class utility::tag::XMLSchemaSimpleSubelementList &

add_already_defined_subelement_w_alt_element_name(*args, **kwargs)

Overloaded function.

1. add_already_defined_subelement_w_alt_element_name(self: pyrosetta.rosetta.utility.tag.XMLSchemaSimpleSubelementList, alt_element_name: str, reference_element_name: str, ct_naming_function: std::function<std::string (std::string const&)>) -> pyrosetta.rosetta.utility.tag.XMLSchemaSimpleSubelementList

Add a subelement with a different name than the complex type was created with so that to get the

correct name for the complex type, the original name must also be provided. E.g. The PROTOCOLS subelement takes its structure from the ParsedProtocol mover. Instead of duplicating the complex type for that mover, instead, create an element whose type will be given by the protocols::moves::complex_type_name_for_mover function when given the “ParsedProtocol” element name.

C++: utility::tag::XMLSchemaSimpleSubelementList::add_already_defined_subelement_w_alt_element_name(const std::string &, const std::string &, const class std::function<std::string (const std::string &)> &) –> class utility::tag::XMLSchemaSimpleSubelementList &

2. add_already_defined_subelement_w_alt_element_name(self: pyrosetta.rosetta.utility.tag.XMLSchemaSimpleSubelementList, alt_element_name: str, reference_element_name: str, ct_naming_function: std::function<std::string (std::string const&)>, min_occurs: int) -> pyrosetta.rosetta.utility.tag.XMLSchemaSimpleSubelementList

3. add_already_defined_subelement_w_alt_element_name(self: pyrosetta.rosetta.utility.tag.XMLSchemaSimpleSubelementList, alt_element_name: str, reference_element_name: str, ct_naming_function: std::function<std::string (std::string const&)>, min_occurs: int, max_occurs: int) -> pyrosetta.rosetta.utility.tag.XMLSchemaSimpleSubelementList

Add a subelement with a different name than the complex type was created with so that to get the

correct name for the complex type, the original name must also be provided. E.g. The PROTOCOLS subelement takes its structure from the ParsedProtocol mover. Instead of duplicating the complex type for that mover, instead, create an element whose type will be given by the protocols::moves::complex_type_name_for_mover function when given the “ParsedProtocol” element name.

C++: utility::tag::XMLSchemaSimpleSubelementList::add_already_defined_subelement_w_alt_element_name(const std::string &, const std::string &, const class std::function<std::string (const std::string &)> &, int, int) –> class utility::tag::XMLSchemaSimpleSubelementList &

add_group_subelement(*args, **kwargs)

Overloaded function.

1. add_group_subelement(self: pyrosetta.rosetta.utility.tag.XMLSchemaSimpleSubelementList, group_name_function: std::function<std::string ()>) -> pyrosetta.rosetta.utility.tag.XMLSchemaSimpleSubelementList

Add a new subelement to the growing list of subelements which refers to an already existing group

whose name is given by the input function.

C++: utility::tag::XMLSchemaSimpleSubelementList::add_group_subelement(const class std::function<std::string (void)> &) –> class utility::tag::XMLSchemaSimpleSubelementList &

2. add_group_subelement(self: pyrosetta.rosetta.utility.tag.XMLSchemaSimpleSubelementList, group_name_function: std::function<std::string ()>, min_occurs: int) -> pyrosetta.rosetta.utility.tag.XMLSchemaSimpleSubelementList

3. add_group_subelement(self: pyrosetta.rosetta.utility.tag.XMLSchemaSimpleSubelementList, group_name_function: std::function<std::string ()>, min_occurs: int, max_occurs: int) -> pyrosetta.rosetta.utility.tag.XMLSchemaSimpleSubelementList

Add a new subelement to the growing list of subelements, but where the minimum and maximum number of

occurrences for this subelement has been set; note: usually, the min and max are set by the XMLSchemaComplexTypeGenerator, and so tension could arise between the generator and your settings. Consider this an advanced function.

C++: utility::tag::XMLSchemaSimpleSubelementList::add_group_subelement(const class std::function<std::string (void)> &, int, int) –> class utility::tag::XMLSchemaSimpleSubelementList &

add_simple_subelement(*args, **kwargs)

Overloaded function.

1. add_simple_subelement(self: pyrosetta.rosetta.utility.tag.XMLSchemaSimpleSubelementList, name: str, : pyrosetta.rosetta.std.list_utility_tag_XMLSchemaAttribute_t, description: str) -> pyrosetta.rosetta.utility.tag.XMLSchemaSimpleSubelementList

Add a new subelement to the growing list of subelements, defined by its name and a (possibly empty) list of attributes

This subelement may not itself contain other subelements, however. The name for the complexType of this element will be derived from the function given in complex_type_naming_func, if provided, and otherwise, the complexType for this element will be listed within the element declaration and will be unnamed.

C++: utility::tag::XMLSchemaSimpleSubelementList::add_simple_subelement(const std::string &, const class std::list<class utility::tag::XMLSchemaAttribute, class std::allocator<class utility::tag::XMLSchemaAttribute> > &, const std::string &) –> class utility::tag::XMLSchemaSimpleSubelementList &

2. add_simple_subelement(self: pyrosetta.rosetta.utility.tag.XMLSchemaSimpleSubelementList, name: str, : pyrosetta.rosetta.std.list_utility_tag_XMLSchemaAttribute_t, description: str, min_occurs: int) -> pyrosetta.rosetta.utility.tag.XMLSchemaSimpleSubelementList

3. add_simple_subelement(self: pyrosetta.rosetta.utility.tag.XMLSchemaSimpleSubelementList, name: str, : pyrosetta.rosetta.std.list_utility_tag_XMLSchemaAttribute_t, description: str, min_occurs: int, max_occurs: int) -> pyrosetta.rosetta.utility.tag.XMLSchemaSimpleSubelementList

Add a new subelement to the growing list of subelements, but where the minimum and maximum number of

occurrences for this subelement has been set; note: usually, the min and max are set by the XMLSchemaComplexTypeGenerator, and so tension could arise between the generator and your settings. Consider this an advanced function.

C++: utility::tag::XMLSchemaSimpleSubelementList::add_simple_subelement(const std::string &, const class std::list<class utility::tag::XMLSchemaAttribute, class std::allocator<class utility::tag::XMLSchemaAttribute> > &, const std::string &, int, int) –> class utility::tag::XMLSchemaSimpleSubelementList &

add_subelement(self: pyrosetta.rosetta.utility.tag.XMLSchemaSimpleSubelementList, summary: utility::tag::XMLSchemaSimpleSubelementList::ElementSummary) → pyrosetta.rosetta.utility.tag.XMLSchemaSimpleSubelementList

Really only intended to be used by the XMLSchemaRepeatableCTNode

C++: utility::tag::XMLSchemaSimpleSubelementList::add_subelement(const struct utility::tag::XMLSchemaSimpleSubelementList::ElementSummary &) –> class utility::tag::XMLSchemaSimpleSubelementList &

assign(self: pyrosetta.rosetta.utility.tag.XMLSchemaSimpleSubelementList, rhs: pyrosetta.rosetta.utility.tag.XMLSchemaSimpleSubelementList) → pyrosetta.rosetta.utility.tag.XMLSchemaSimpleSubelementList

C++: utility::tag::XMLSchemaSimpleSubelementList::operator=(const class utility::tag::XMLSchemaSimpleSubelementList &) –> class utility::tag::XMLSchemaSimpleSubelementList &

complex_type_naming_func(self: pyrosetta.rosetta.utility.tag.XMLSchemaSimpleSubelementList, naming_function: std::function<std::string (std::string const&)>) → pyrosetta.rosetta.utility.tag.XMLSchemaSimpleSubelementList

the naming function is required if this subelement list is going to be repeatable

C++: utility::tag::XMLSchemaSimpleSubelementList::complex_type_naming_func(const class std::function<std::string (const std::string &)> &) –> class utility::tag::XMLSchemaSimpleSubelementList &

complex_typename_for_element(self: pyrosetta.rosetta.utility.tag.XMLSchemaSimpleSubelementList, element_name: str) → str

C++: utility::tag::XMLSchemaSimpleSubelementList::complex_typename_for_element(const std::string &) const –> std::string

element_list(self: pyrosetta.rosetta.utility.tag.XMLSchemaSimpleSubelementList) → pyrosetta.rosetta.std.list_utility_tag_XMLSchemaSimpleSubelementList_ElementSummary_t

C++: utility::tag::XMLSchemaSimpleSubelementList::element_list() const –> const class std::list<struct utility::tag::XMLSchemaSimpleSubelementList::ElementSummary, class std::allocator<struct utility::tag::XMLSchemaSimpleSubelementList::ElementSummary> > &

static element_summary_as_already_defined_subelement(*args, **kwargs)

Overloaded function.

1. element_summary_as_already_defined_subelement(name: str, ct_naming_function: std::function<std::string (std::string const&)>) -> utility::tag::XMLSchemaSimpleSubelementList::ElementSummary

C++: utility::tag::XMLSchemaSimpleSubelementList::element_summary_as_already_defined_subelement(const std::string &, const class std::function<std::string (const std::string &)> &) –> struct utility::tag::XMLSchemaSimpleSubelementList::ElementSummary

2. element_summary_as_already_defined_subelement(name: str, ct_naming_function: std::function<std::string (std::string const&)>, min_occurs: int, max_occurs: int) -> utility::tag::XMLSchemaSimpleSubelementList::ElementSummary

C++: utility::tag::XMLSchemaSimpleSubelementList::element_summary_as_already_defined_subelement(const std::string &, const class std::function<std::string (const std::string &)> &, int, int) –> struct utility::tag::XMLSchemaSimpleSubelementList::ElementSummary

static element_summary_as_already_defined_subelement_w_alt_element_name(*args, **kwargs)

Overloaded function.

1. element_summary_as_already_defined_subelement_w_alt_element_name(alt_element_name: str, reference_element_name: str, ct_naming_function: std::function<std::string (std::string const&)>) -> utility::tag::XMLSchemaSimpleSubelementList::ElementSummary

C++: utility::tag::XMLSchemaSimpleSubelementList::element_summary_as_already_defined_subelement_w_alt_element_name(const std::string &, const std::string &, const class std::function<std::string (const std::string &)> &) –> struct utility::tag::XMLSchemaSimpleSubelementList::ElementSummary

2. element_summary_as_already_defined_subelement_w_alt_element_name(alt_element_name: str, reference_element_name: str, ct_naming_function: std::function<std::string (std::string const&)>, min_occurs: int, max_occurs: int) -> utility::tag::XMLSchemaSimpleSubelementList::ElementSummary

C++: utility::tag::XMLSchemaSimpleSubelementList::element_summary_as_already_defined_subelement_w_alt_element_name(const std::string &, const std::string &, const class std::function<std::string (const std::string &)> &, int, int) –> struct utility::tag::XMLSchemaSimpleSubelementList::ElementSummary

static element_summary_as_group_subelement(*args, **kwargs)

Overloaded function.

1. element_summary_as_group_subelement(group_name_function: std::function<std::string ()>) -> utility::tag::XMLSchemaSimpleSubelementList::ElementSummary

C++: utility::tag::XMLSchemaSimpleSubelementList::element_summary_as_group_subelement(const class std::function<std::string (void)> &) –> struct utility::tag::XMLSchemaSimpleSubelementList::ElementSummary

2. element_summary_as_group_subelement(group_name_function: std::function<std::string ()>, min_occurs: int, max_occurs: int) -> utility::tag::XMLSchemaSimpleSubelementList::ElementSummary

C++: utility::tag::XMLSchemaSimpleSubelementList::element_summary_as_group_subelement(const class std::function<std::string (void)> &, int, int) –> struct utility::tag::XMLSchemaSimpleSubelementList::ElementSummary

static element_summary_as_simple_subelement(*args, **kwargs)

Overloaded function.

1. element_summary_as_simple_subelement(name: str, attributes: pyrosetta.rosetta.std.list_utility_tag_XMLSchemaAttribute_t, description: str) -> utility::tag::XMLSchemaSimpleSubelementList::ElementSummary

C++: utility::tag::XMLSchemaSimpleSubelementList::element_summary_as_simple_subelement(const std::string &, const class std::list<class utility::tag::XMLSchemaAttribute, class std::allocator<class utility::tag::XMLSchemaAttribute> > &, const std::string &) –> struct utility::tag::XMLSchemaSimpleSubelementList::ElementSummary

2. element_summary_as_simple_subelement(name: str, attributes: pyrosetta.rosetta.std.list_utility_tag_XMLSchemaAttribute_t, description: str, min_occurs: int, max_occurs: int) -> utility::tag::XMLSchemaSimpleSubelementList::ElementSummary

C++: utility::tag::XMLSchemaSimpleSubelementList::element_summary_as_simple_subelement(const std::string &, const class std::list<class utility::tag::XMLSchemaAttribute, class std::allocator<class utility::tag::XMLSchemaAttribute> > &, const std::string &, int, int) –> struct utility::tag::XMLSchemaSimpleSubelementList::ElementSummary

naming_func(self: pyrosetta.rosetta.utility.tag.XMLSchemaSimpleSubelementList) → std::function<std::string (std::string const&)>

C++: utility::tag::XMLSchemaSimpleSubelementList::naming_func() const –> class std::function<std::string (const std::string &)>

simple_element_naming_func_has_been_set(self: pyrosetta.rosetta.utility.tag.XMLSchemaSimpleSubelementList) → bool

C++: utility::tag::XMLSchemaSimpleSubelementList::simple_element_naming_func_has_been_set() const –> bool

class pyrosetta.rosetta.utility.tag.XMLSchemaTopLevelElement

Bases: pybind11_object

The %XMLSchemaTopLevelElement class signifies a class that could be written out as an XML element, with possible sub-elemets, in an XML schema. When generating a schema, the developer will hand an instance of a class derived from an %XMLSchemaTopLevelElement to an XMLSchemaDefinition object.

assign(self: pyrosetta.rosetta.utility.tag.XMLSchemaTopLevelElement, : pyrosetta.rosetta.utility.tag.XMLSchemaTopLevelElement) → pyrosetta.rosetta.utility.tag.XMLSchemaTopLevelElement

C++: utility::tag::XMLSchemaTopLevelElement::operator=(const class utility::tag::XMLSchemaTopLevelElement &) –> class utility::tag::XMLSchemaTopLevelElement &

element_name(self: pyrosetta.rosetta.utility.tag.XMLSchemaTopLevelElement) → str

C++: utility::tag::XMLSchemaTopLevelElement::element_name() const –> const std::string &

prepare_for_output(self: pyrosetta.rosetta.utility.tag.XMLSchemaTopLevelElement, xsd: utility::tag::XMLSchemaDefinition) → None

C++: utility::tag::XMLSchemaTopLevelElement::prepare_for_output(class utility::tag::XMLSchemaDefinition &) const –> void

write_definition(self: pyrosetta.rosetta.utility.tag.XMLSchemaTopLevelElement, indentation: int, os: pyrosetta.rosetta.std.ostream) → None

C++: utility::tag::XMLSchemaTopLevelElement::write_definition(int, std::ostream &) const –> void

class pyrosetta.rosetta.utility.tag.XMLSchemaType

Bases: pybind11_object

class %XMLSchemaType represents the name of a defined type that can be used to describe either an XMLElement or an XMLAttribute. It may refer to either a complex type or to a primative type or to a simple type.

assign(self: pyrosetta.rosetta.utility.tag.XMLSchemaType, : pyrosetta.rosetta.utility.tag.XMLSchemaType) → pyrosetta.rosetta.utility.tag.XMLSchemaType

C++: utility::tag::XMLSchemaType::operator=(const class utility::tag::XMLSchemaType &) –> class utility::tag::XMLSchemaType &

common_type(*args, **kwargs)

Overloaded function.

1. common_type(self: pyrosetta.rosetta.utility.tag.XMLSchemaType, setting: pyrosetta.rosetta.utility.tag.XMLSchemaCommonType) -> None

C++: utility::tag::XMLSchemaType::common_type(enum utility::tag::XMLSchemaCommonType) –> void

2. common_type(self: pyrosetta.rosetta.utility.tag.XMLSchemaType) -> pyrosetta.rosetta.utility.tag.XMLSchemaCommonType

C++: utility::tag::XMLSchemaType::common_type() const –> enum utility::tag::XMLSchemaCommonType

custom_type_name(self: pyrosetta.rosetta.utility.tag.XMLSchemaType, setting: str) → None

C++: utility::tag::XMLSchemaType::custom_type_name(const std::string &) –> void

type(*args, **kwargs)

Overloaded function.

1. type(self: pyrosetta.rosetta.utility.tag.XMLSchemaType, setting: pyrosetta.rosetta.utility.tag.XMLSchemaDataType) -> None

C++: utility::tag::XMLSchemaType::type(enum utility::tag::XMLSchemaDataType) –> void

2. type(self: pyrosetta.rosetta.utility.tag.XMLSchemaType) -> pyrosetta.rosetta.utility.tag.XMLSchemaDataType

C++: utility::tag::XMLSchemaType::type() const –> enum utility::tag::XMLSchemaDataType

type_name(self: pyrosetta.rosetta.utility.tag.XMLSchemaType) → str

C++: utility::tag::XMLSchemaType::type_name() const –> std::string

class pyrosetta.rosetta.utility.tag.XMLValidationOutput

Bases: pybind11_object

add_error(self: pyrosetta.rosetta.utility.tag.XMLValidationOutput, error: str) → None

C++: utility::tag::XMLValidationOutput::add_error(const std::string &) –> void

add_errors(self: pyrosetta.rosetta.utility.tag.XMLValidationOutput, error_list: pyrosetta.rosetta.std.list_std_string_t) → None

C++: utility::tag::XMLValidationOutput::add_errors(const class std::list<std::string, class std::allocator<std::string > > &) –> void

add_warnings(*args, **kwargs)

Overloaded function.

1. add_warnings(self: pyrosetta.rosetta.utility.tag.XMLValidationOutput, warning: str) -> None

C++: utility::tag::XMLValidationOutput::add_warnings(const std::string &) –> void

2. add_warnings(self: pyrosetta.rosetta.utility.tag.XMLValidationOutput, warning_list: pyrosetta.rosetta.std.list_std_string_t) -> None

C++: utility::tag::XMLValidationOutput::add_warnings(const class std::list<std::string, class std::allocator<std::string > > &) –> void

error_messages(self: pyrosetta.rosetta.utility.tag.XMLValidationOutput) → str

C++: utility::tag::XMLValidationOutput::error_messages() const –> std::string

errors(*args, **kwargs)

Overloaded function.

1. errors(self: pyrosetta.rosetta.utility.tag.XMLValidationOutput) -> pyrosetta.rosetta.std.list_std_string_t

C++: utility::tag::XMLValidationOutput::errors() const –> const class std::list<std::string, class std::allocator<std::string > > &

2. errors(self: pyrosetta.rosetta.utility.tag.XMLValidationOutput, error_list: pyrosetta.rosetta.std.list_std_string_t) -> None

C++: utility::tag::XMLValidationOutput::errors(const class std::list<std::string, class std::allocator<std::string > > &) –> void

valid(*args, **kwargs)

Overloaded function.

1. valid(self: pyrosetta.rosetta.utility.tag.XMLValidationOutput, : bool) -> None

C++: utility::tag::XMLValidationOutput::valid(bool) –> void

2. valid(self: pyrosetta.rosetta.utility.tag.XMLValidationOutput) -> bool

C++: utility::tag::XMLValidationOutput::valid() const –> bool

warning_messages(self: pyrosetta.rosetta.utility.tag.XMLValidationOutput) → str

C++: utility::tag::XMLValidationOutput::warning_messages() const –> std::string

warnings(*args, **kwargs)

Overloaded function.

1. warnings(self: pyrosetta.rosetta.utility.tag.XMLValidationOutput) -> pyrosetta.rosetta.std.list_std_string_t

C++: utility::tag::XMLValidationOutput::warnings() const –> const class std::list<std::string, class std::allocator<std::string > > &

2. warnings(self: pyrosetta.rosetta.utility.tag.XMLValidationOutput, warning_list: pyrosetta.rosetta.std.list_std_string_t) -> None

C++: utility::tag::XMLValidationOutput::warnings(const class std::list<std::string, class std::allocator<std::string > > &) –> void

class pyrosetta.rosetta.utility.tag.XMLValidator

Bases: pybind11_object

schema_has_been_set(self: pyrosetta.rosetta.utility.tag.XMLValidator) → bool

C++: utility::tag::XMLValidator::schema_has_been_set() const –> bool

set_schema(self: pyrosetta.rosetta.utility.tag.XMLValidator, schema: str) → utility::tag::XMLValidationOutput

C++: utility::tag::XMLValidator::set_schema(const std::string &) –> class utility::tag::XMLValidationOutput

validate_xml_against_schema(self: pyrosetta.rosetta.utility.tag.XMLValidator, xml: str) → utility::tag::XMLValidationOutput

C++: utility::tag::XMLValidator::validate_xml_against_schema(const std::string &) const –> class utility::tag::XMLValidationOutput

pyrosetta.rosetta.utility.tag.add_schema_restrictions_for_strings(xsd: pyrosetta.rosetta.utility.tag.XMLSchemaDefinition, type_name: str, restrictions: pyrosetta.rosetta.utility.vector1_std_string) → None

Add a SchemaRestriction for a set of strings. Useful for enums.

The type name is then used as the type when adding an attribute.

Example: attlist+ XMLScemaAttribute(tag_name, type_name, description);

C++: utility::tag::add_schema_restrictions_for_strings(class utility::tag::XMLSchemaDefinition &, std::string, const class utility::vector1<std::string, class std::allocator<std::string > > &) –> void

pyrosetta.rosetta.utility.tag.append_name_and_attributes_to_complex_type(attributes: pyrosetta.rosetta.std.list_utility_tag_XMLSchemaAttribute_t, type_definition: pyrosetta.rosetta.utility.tag.XMLSchemaComplexType) → None

append an attribute of “name” with type “xs:string” along with the other attributes

in the input attribute list to the input complex type.

C++: utility::tag::append_name_and_attributes_to_complex_type(const class std::list<class utility::tag::XMLSchemaAttribute, class std::allocator<class utility::tag::XMLSchemaAttribute> > &, class utility::tag::XMLSchemaComplexType &) –> void

pyrosetta.rosetta.utility.tag.append_required_name_and_attributes_to_complex_type(attributes: pyrosetta.rosetta.std.list_utility_tag_XMLSchemaAttribute_t, type_definition: pyrosetta.rosetta.utility.tag.XMLSchemaComplexType) → None

append a required attribute of “name” with type “xs:string” along with the

other attributes in the input attribute list to the input complex type.

C++: utility::tag::append_required_name_and_attributes_to_complex_type(const class std::list<class utility::tag::XMLSchemaAttribute, class std::allocator<class utility::tag::XMLSchemaAttribute> > &, class utility::tag::XMLSchemaComplexType &) –> void

pyrosetta.rosetta.utility.tag.attribute_w_name_in_attribute_list(attname: str, attlist: pyrosetta.rosetta.std.list_utility_tag_XMLSchemaAttribute_t) → bool

check whether an attribute with name attname already exists in AttributeList attlist to avoid collisions

C++: utility::tag::attribute_w_name_in_attribute_list(const std::string &, const class std::list<class utility::tag::XMLSchemaAttribute, class std::allocator<class utility::tag::XMLSchemaAttribute> > &) –> bool

pyrosetta.rosetta.utility.tag.chr_chains_nonrepeated() → str

C++: utility::tag::chr_chains_nonrepeated() –> std::string

pyrosetta.rosetta.utility.tag.handle_structured_xml_error(ctxt: capsule, error: _xmlError) → None

C++: utility::tag::handle_structured_xml_error(void *, struct _xmlError *) –> void

pyrosetta.rosetta.utility.tag.handle_xml_error(ctxt: capsule, message: str) → None

pyrosetta.rosetta.utility.tag.handle_xml_warning(ctxt: capsule, message: str) → None

pyrosetta.rosetta.utility.tag.indent_w_spaces(indentation: int, os: pyrosetta.rosetta.std.ostream) → None

C++: utility::tag::indent_w_spaces(int, std::ostream &) –> void

pyrosetta.rosetta.utility.tag.integer_range_restriction(name: str, lower_inclusive: int, upper_inclusive: int) → pyrosetta.rosetta.utility.tag.XMLSchemaRestriction

Convenience function for defining an inclusive range restriction

C++: utility::tag::integer_range_restriction(const std::string &, int, int) –> class utility::tag::XMLSchemaRestriction

pyrosetta.rosetta.utility.tag.name_for_common_type(common_type: pyrosetta.rosetta.utility.tag.XMLSchemaCommonType) → str

C++: utility::tag::name_for_common_type(enum utility::tag::XMLSchemaCommonType) –> std::string

pyrosetta.rosetta.utility.tag.optional_name_attribute(*args, **kwargs)

Overloaded function.

1. optional_name_attribute() -> pyrosetta.rosetta.utility.tag.XMLSchemaAttribute

2. optional_name_attribute(description: str) -> pyrosetta.rosetta.utility.tag.XMLSchemaAttribute

This function creates an attribute named “name” of type xs_string that is optional;

naming is not always required – it is not even mostly required. This is probably the function you need; very few classes actually need to have a name – the name is often only used by the function reading in the name, but there are reasonable times when a Mover, e.g. could go nameless – for instance, in the fixbb_jd3 application, a PackRotamersMover can be given as a subtag of the <Job> tag. In this case, the PackRotamersMover doesn’t need to be given a name.

C++: utility::tag::optional_name_attribute(const std::string &) –> class utility::tag::XMLSchemaAttribute

pyrosetta.rosetta.utility.tag.real_regex_pattern() → str

C++: utility::tag::real_regex_pattern() –> std::string

pyrosetta.rosetta.utility.tag.refpose_enabled_residue_number_string() → str

C++: utility::tag::refpose_enabled_residue_number_string() –> std::string

pyrosetta.rosetta.utility.tag.required_name_attribute(*args, **kwargs)

Overloaded function.

1. required_name_attribute() -> pyrosetta.rosetta.utility.tag.XMLSchemaAttribute

2. required_name_attribute(description: str) -> pyrosetta.rosetta.utility.tag.XMLSchemaAttribute

This function creates an attribute named “name” of type xs_string that is required;

naming is not always required – it is not even mostly required. This function is probably not what you need. Use with care. See comments for the “optional_name_attribute” function above.

C++: utility::tag::required_name_attribute(const std::string &) –> class utility::tag::XMLSchemaAttribute

pyrosetta.rosetta.utility.tag.residue_number_string() → str

C++: utility::tag::residue_number_string() –> std::string

pyrosetta.rosetta.utility.tag.restriction_type_name(type: pyrosetta.rosetta.utility.tag.XMLSchemaRestrictionType) → str

C++: utility::tag::restriction_type_name(enum utility::tag::XMLSchemaRestrictionType) –> std::string

pyrosetta.rosetta.utility.tag.string_contains_gt_lt_or_ampersand(s: str) → str

Check if given string contain any of ‘<>&’ and if so return found character. If no character is found return 0.

C++: utility::tag::string_contains_gt_lt_or_ampersand(const std::string &) –> char

pyrosetta.rosetta.utility.tag.test_if_schema_is_valid(xsd: str) → pyrosetta.rosetta.utility.tag.XMLValidationOutput

C++: utility::tag::test_if_schema_is_valid(const std::string &) –> class utility::tag::XMLValidationOutput

pyrosetta.rosetta.utility.tag.validate_xml_against_xsd(xml: str, xsd: str) → pyrosetta.rosetta.utility.tag.XMLValidationOutput

C++: utility::tag::validate_xml_against_xsd(const std::string &, const std::string &) –> class utility::tag::XMLValidationOutput

pyrosetta.rosetta.utility.tag.xs_model_group_name(xsmgt: pyrosetta.rosetta.utility.tag.XMLSchemaModelGroupType) → str

C++: utility::tag::xs_model_group_name(enum utility::tag::XMLSchemaModelGroupType) –> std::string