tag

Bindings for utility::tag namespace

class pyrosetta.rosetta.utility.tag.XMLSchemaAttribute

Bases: pyrosetta.rosetta.utility.tag.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.

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: pyrosetta.rosetta.utility.tag.XMLSchemaAttribute) -> None
2. __init__(self: pyrosetta.rosetta.utility.tag.XMLSchemaAttribute, name: str, type: pyrosetta.rosetta.utility.tag.XMLSchemaType, desc: str) -> None
3. __init__(self: pyrosetta.rosetta.utility.tag.XMLSchemaAttribute, arg0: pyrosetta.rosetta.utility.tag.XMLSchemaAttribute) -> None

__init_subclass__()

This method is called when a class is subclassed.

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

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

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

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

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

assign(self: pyrosetta.rosetta.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 &

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 class std::basic_string<char> &, class utility::tag::XMLSchemaType, const class std::basic_string<char> &, const class std::basic_string<char> &) –> 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 class std::basic_string<char> &) –> class utility::tag::XMLSchemaAttribute &

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

C++: utility::tag::XMLSchemaAttribute::description(const class std::basic_string<char> &) –> 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 class std::basic_string<char> &) –> 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

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

C++: utility::tag::XMLSchemaAttribute::required_attribute(const class std::basic_string<char> &, class utility::tag::XMLSchemaType, const class std::basic_string<char> &) –> 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, class std::basic_ostream<char> &) const –> void

class pyrosetta.rosetta.utility.tag.XMLSchemaCommonType

Bases: pybind11_builtins.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

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__(*args, **kwargs)

Overloaded function.

1. __eq__(self: pyrosetta.rosetta.utility.tag.XMLSchemaCommonType, arg0: pyrosetta.rosetta.utility.tag.XMLSchemaCommonType) -> bool
2. __eq__(self: pyrosetta.rosetta.utility.tag.XMLSchemaCommonType, arg0: int) -> bool

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__getstate__(self: pyrosetta.rosetta.utility.tag.XMLSchemaCommonType) → tuple

__gt__

Return self>value.

__hash__(self: pyrosetta.rosetta.utility.tag.XMLSchemaCommonType) → int

__init__(self: pyrosetta.rosetta.utility.tag.XMLSchemaCommonType, arg0: int) → None

__init_subclass__()

This method is called when a class is subclassed.

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

__int__(self: pyrosetta.rosetta.utility.tag.XMLSchemaCommonType) → int

__le__

Return self<=value.

__lt__

Return self<value.

__ne__(*args, **kwargs)

Overloaded function.

1. __ne__(self: pyrosetta.rosetta.utility.tag.XMLSchemaCommonType, arg0: pyrosetta.rosetta.utility.tag.XMLSchemaCommonType) -> bool
2. __ne__(self: pyrosetta.rosetta.utility.tag.XMLSchemaCommonType, arg0: int) -> bool

__new__()

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

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__(self: pyrosetta.rosetta.utility.tag.XMLSchemaCommonType) → str

__setattr__

Implement setattr(self, name, value).

__setstate__(self: pyrosetta.rosetta.utility.tag.XMLSchemaCommonType, arg0: tuple) → None

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

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

class pyrosetta.rosetta.utility.tag.XMLSchemaComplexType

Bases: pyrosetta.rosetta.utility.tag.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.

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: pyrosetta.rosetta.utility.tag.XMLSchemaComplexType) -> None
2. __init__(self: pyrosetta.rosetta.utility.tag.XMLSchemaComplexType, arg0: pyrosetta.rosetta.utility.tag.XMLSchemaComplexType) -> None

__init_subclass__()

This method is called when a class is subclassed.

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

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

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

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

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

add_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 class std::basic_string<char> &) –> 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 class std::basic_string<char> &) –> 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, class std::basic_ostream<char> &) const –> void

class pyrosetta.rosetta.utility.tag.XMLSchemaComplexTypeGenerator

Bases: pybind11_builtins.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).

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(self: pyrosetta.rosetta.utility.tag.XMLSchemaComplexTypeGenerator) → None

__init_subclass__()

This method is called when a class is subclassed.

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

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

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

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

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

add_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 class std::basic_string<char> &) –> 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 class std::basic_string<char> &) –> 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 class std::basic_string<char> &) –> 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 class std::basic_string<char> &) –> 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_builtins.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.

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__(*args, **kwargs)

Overloaded function.

1. __eq__(self: pyrosetta.rosetta.utility.tag.XMLSchemaDataType, arg0: pyrosetta.rosetta.utility.tag.XMLSchemaDataType) -> bool
2. __eq__(self: pyrosetta.rosetta.utility.tag.XMLSchemaDataType, arg0: int) -> bool

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__getstate__(self: pyrosetta.rosetta.utility.tag.XMLSchemaDataType) → tuple

__gt__

Return self>value.

__hash__(self: pyrosetta.rosetta.utility.tag.XMLSchemaDataType) → int

__init__(self: pyrosetta.rosetta.utility.tag.XMLSchemaDataType, arg0: int) → None

__init_subclass__()

This method is called when a class is subclassed.

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

__int__(self: pyrosetta.rosetta.utility.tag.XMLSchemaDataType) → int

__le__

Return self<=value.

__lt__

Return self<value.

__ne__(*args, **kwargs)

Overloaded function.

1. __ne__(self: pyrosetta.rosetta.utility.tag.XMLSchemaDataType, arg0: pyrosetta.rosetta.utility.tag.XMLSchemaDataType) -> bool
2. __ne__(self: pyrosetta.rosetta.utility.tag.XMLSchemaDataType, arg0: int) -> bool

__new__()

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

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__(self: pyrosetta.rosetta.utility.tag.XMLSchemaDataType) → str

__setattr__

Implement setattr(self, name, value).

__setstate__(self: pyrosetta.rosetta.utility.tag.XMLSchemaDataType, arg0: tuple) → None

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

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

class pyrosetta.rosetta.utility.tag.XMLSchemaDefinition

Bases: pybind11_builtins.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.

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(self: pyrosetta.rosetta.utility.tag.XMLSchemaDefinition) → None

__init_subclass__()

This method is called when a class is subclassed.

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

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

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

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

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

add_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 class std::basic_string<char> &) 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

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 class std::basic_string<char> &, const class std::basic_string<char> &) const –> std::string

class pyrosetta.rosetta.utility.tag.XMLSchemaElement

Bases: pyrosetta.rosetta.utility.tag.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.

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: pyrosetta.rosetta.utility.tag.XMLSchemaElement) -> None
2. __init__(self: pyrosetta.rosetta.utility.tag.XMLSchemaElement, arg0: pyrosetta.rosetta.utility.tag.XMLSchemaElement) -> None

__init_subclass__()

This method is called when a class is subclassed.

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

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

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

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

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

assign(self: pyrosetta.rosetta.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 class std::basic_string<char> &) –> 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 class std::basic_string<char> &) –> 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 class std::basic_string<char> &) –> 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, class std::basic_ostream<char> &) const –> void

class pyrosetta.rosetta.utility.tag.XMLSchemaModelGroup

Bases: pyrosetta.rosetta.utility.tag.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.

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: pyrosetta.rosetta.utility.tag.XMLSchemaModelGroup) -> None
2. __init__(self: pyrosetta.rosetta.utility.tag.XMLSchemaModelGroup, type: pyrosetta.rosetta.utility.tag.XMLSchemaModelGroupType) -> None
3. __init__(self: pyrosetta.rosetta.utility.tag.XMLSchemaModelGroup, type: pyrosetta.rosetta.utility.tag.XMLSchemaModelGroupType, particles: pyrosetta.rosetta.std.list_std_shared_ptr_const_utility_tag_XMLSchemaParticle_std_allocator_std_shared_ptr_const_utility_tag_XMLSchemaParticle_t) -> None
4. __init__(self: pyrosetta.rosetta.utility.tag.XMLSchemaModelGroup, group_name: str) -> None
5. __init__(self: pyrosetta.rosetta.utility.tag.XMLSchemaModelGroup, arg0: pyrosetta.rosetta.utility.tag.XMLSchemaModelGroup) -> None

__init_subclass__()

This method is called when a class is subclassed.

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

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

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

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

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

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_std_allocator_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 class std::basic_string<char> &) –> 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, class std::basic_ostream<char> &) const –> void

class pyrosetta.rosetta.utility.tag.XMLSchemaParticle

Bases: pyrosetta.rosetta.utility.tag.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.

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: pyrosetta.rosetta.utility.tag.XMLSchemaParticle) -> None
2. __init__(self: pyrosetta.rosetta.utility.tag.XMLSchemaParticle, arg0: pyrosetta.rosetta.utility.tag.XMLSchemaParticle) -> None

__init_subclass__()

This method is called when a class is subclassed.

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

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

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

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

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

assign(self: pyrosetta.rosetta.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, class std::basic_ostream<char> &) const –> void

class pyrosetta.rosetta.utility.tag.XMLSchemaRestriction

Bases: pyrosetta.rosetta.utility.tag.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:

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: pyrosetta.rosetta.utility.tag.XMLSchemaRestriction) -> None
2. __init__(self: pyrosetta.rosetta.utility.tag.XMLSchemaRestriction, arg0: pyrosetta.rosetta.utility.tag.XMLSchemaRestriction) -> None

__init_subclass__()

This method is called when a class is subclassed.

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

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

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

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

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

add_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 class std::basic_string<char> &) –> 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 class std::basic_string<char> &) –> 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, class std::basic_ostream<char> &) const –> void

class pyrosetta.rosetta.utility.tag.XMLSchemaSimpleSubelementList

Bases: pybind11_builtins.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.

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: pyrosetta.rosetta.utility.tag.XMLSchemaSimpleSubelementList) -> None
2. __init__(self: pyrosetta.rosetta.utility.tag.XMLSchemaSimpleSubelementList, arg0: pyrosetta.rosetta.utility.tag.XMLSchemaSimpleSubelementList) -> None

__init_subclass__()

This method is called when a class is subclassed.

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

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

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

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

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

add_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 class std::basic_string<char> &, const class std::list<class utility::tag::XMLSchemaAttribute, class std::allocator<class utility::tag::XMLSchemaAttribute> > &, const class std::basic_string<char> &) –> 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 class std::basic_string<char> &, const class std::list<class utility::tag::XMLSchemaAttribute, class std::allocator<class utility::tag::XMLSchemaAttribute> > &, const class std::basic_string<char> &, 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_typename_for_element(self: pyrosetta.rosetta.utility.tag.XMLSchemaSimpleSubelementList, element_name: str) → str

C++: utility::tag::XMLSchemaSimpleSubelementList::complex_typename_for_element(const class std::basic_string<char> &) 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> > &

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 class std::basic_string<char> &, const class std::list<class utility::tag::XMLSchemaAttribute, class std::allocator<class utility::tag::XMLSchemaAttribute> > &, const class std::basic_string<char> &) –> 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 class std::basic_string<char> &, const class std::list<class utility::tag::XMLSchemaAttribute, class std::allocator<class utility::tag::XMLSchemaAttribute> > &, const class std::basic_string<char> &, int, int) –> struct utility::tag::XMLSchemaSimpleSubelementList::ElementSummary

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_builtins.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.

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: pyrosetta.rosetta.utility.tag.XMLSchemaTopLevelElement) -> None
2. __init__(self: pyrosetta.rosetta.utility.tag.XMLSchemaTopLevelElement, arg0: pyrosetta.rosetta.utility.tag.XMLSchemaTopLevelElement) -> None

__init_subclass__()

This method is called when a class is subclassed.

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

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

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

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

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

assign(self: pyrosetta.rosetta.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, class std::basic_ostream<char> &) const –> void

class pyrosetta.rosetta.utility.tag.XMLSchemaType

Bases: pybind11_builtins.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.

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: pyrosetta.rosetta.utility.tag.XMLSchemaType) -> None
2. __init__(self: pyrosetta.rosetta.utility.tag.XMLSchemaType, setting: pyrosetta.rosetta.utility.tag.XMLSchemaDataType) -> None
3. __init__(self: pyrosetta.rosetta.utility.tag.XMLSchemaType, setting: pyrosetta.rosetta.utility.tag.XMLSchemaCommonType) -> None
4. __init__(self: pyrosetta.rosetta.utility.tag.XMLSchemaType, custom_type: str) -> None
5. __init__(self: pyrosetta.rosetta.utility.tag.XMLSchemaType, custom_type: str) -> None
6. __init__(self: pyrosetta.rosetta.utility.tag.XMLSchemaType, arg0: pyrosetta.rosetta.utility.tag.XMLSchemaType) -> None

__init_subclass__()

This method is called when a class is subclassed.

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

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

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

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

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

assign(self: pyrosetta.rosetta.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 class std::basic_string<char> &) –> 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

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 class std::basic_string<char> &, 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

C++: utility::tag::handle_xml_error(void *, const char *) –> void

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

C++: utility::tag::handle_xml_warning(void *, const char *) –> void

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

C++: utility::tag::indent_w_spaces(int, class std::basic_ostream<char> &) –> 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 class std::basic_string<char> &, 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 class std::basic_string<char> &) –> 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 class std::basic_string<char> &) –> 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.test_if_schema_is_valid(xsd: str) → pyrosetta.rosetta.utility.tag.XMLValidationOutput

C++: utility::tag::test_if_schema_is_valid(const class std::basic_string<char> &) –> 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 class std::basic_string<char> &, const class std::basic_string<char> &) –> 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