OCR-D / core

# end class BaselineType

class RelationsType(GeneratedsSuper):

    """Container for one-to-one relations between layout

    objects (for example: DropCap - paragraph, caption -

    image)."""

    __hash__ = GeneratedsSuper.__hash__

    member_data_items_ = [

        MemberSpec_('Relation', 'RelationType', 1, 0, {'maxOccurs': 'unbounded', 'minOccurs': '1', 'name': 'Relation', 'type': 'RelationType'}, None),

    ]

    subclass = None

    superclass = None

    def __init__(self, Relation=None, gds_collector_=None, **kwargs_):

        self.gds_collector_ = gds_collector_

        self.gds_elementtree_node_ = None

        self.original_tagname_ = None

        self.parent_object_ = kwargs_.get('parent_object_')

        self.ns_prefix_ = None

        if Relation is None:

            self.Relation = []

        else:

            self.Relation = Relation

        self.Relation_nsprefix_ = "pc"

    def factory(*args_, **kwargs_):

        if CurrentSubclassModule_ is not None:

            subclass = getSubclassFromModule_(

                CurrentSubclassModule_, RelationsType)

            if subclass is not None:

                return subclass(*args_, **kwargs_)

        if RelationsType.subclass:

            return RelationsType.subclass(*args_, **kwargs_)

        else:

            return RelationsType(*args_, **kwargs_)

    factory = staticmethod(factory)

    def get_ns_prefix_(self):

        return self.ns_prefix_

    def set_ns_prefix_(self, ns_prefix):

        self.ns_prefix_ = ns_prefix

    def get_Relation(self):

        return self.Relation

    def set_Relation(self, Relation):

        self.Relation = Relation

    def add_Relation(self, value):

        self.Relation.append(value)

    def insert_Relation_at(self, index, value):

        self.Relation.insert(index, value)

    def replace_Relation_at(self, index, value):

        self.Relation[index] = value

    def hasContent_(self):

        if (

            self.Relation

        ):

            return True

        else:

            return False

    def export(self, outfile, level, namespaceprefix_='', namespacedef_='xmlns:pc="http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15"', name_='RelationsType', pretty_print=True):

        imported_ns_def_ = GenerateDSNamespaceDefs_.get('RelationsType')

        if imported_ns_def_ is not None:

            namespacedef_ = imported_ns_def_

        if pretty_print:

            eol_ = '\n'

        else:

            eol_ = ''

        if self.original_tagname_ is not None and name_ == 'RelationsType':

            name_ = self.original_tagname_

        if UseCapturedNS_ and self.ns_prefix_:

            namespaceprefix_ = self.ns_prefix_ + ':'

        showIndent(outfile, level, pretty_print)

        outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', ))

        already_processed = set()

        self.exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='RelationsType')

        if self.hasContent_():

            outfile.write('>%s' % (eol_, ))

            self.exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='RelationsType', pretty_print=pretty_print)

            showIndent(outfile, level, pretty_print)

            outfile.write('</%s%s>%s' % (namespaceprefix_, name_, eol_))

        else:

            outfile.write('/>%s' % (eol_, ))

    def exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='RelationsType'):

        pass

    def exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='xmlns:pc="http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15"', name_='RelationsType', fromsubclass_=False, pretty_print=True):

        if pretty_print:

            eol_ = '\n'

        else:

            eol_ = ''

        for Relation_ in self.Relation:

            namespaceprefix_ = self.Relation_nsprefix_ + ':' if (UseCapturedNS_ and self.Relation_nsprefix_) else ''

            Relation_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Relation', pretty_print=pretty_print)

    def to_etree(self, parent_element=None, name_='RelationsType', mapping_=None, nsmap_=None):

        if parent_element is None:

            element = etree_.Element('{http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15}' + name_, nsmap=nsmap_)

        else:

            element = etree_.SubElement(parent_element, '{http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15}' + name_, nsmap=nsmap_)

        for Relation_ in self.Relation:

            Relation_.to_etree(element, name_='Relation', mapping_=mapping_, nsmap_=nsmap_)

        if mapping_ is not None:

            mapping_[id(self)] = element

        return element

    def build(self, node, gds_collector_=None):

        self.gds_collector_ = gds_collector_

        if SaveElementTreeNode:

            self.gds_elementtree_node_ = node

        already_processed = set()

        self.ns_prefix_ = node.prefix

        self.buildAttributes(node, node.attrib, already_processed)

        for child in node:

            nodeName_ = Tag_pattern_.match(child.tag).groups()[-1]

            self.buildChildren(child, node, nodeName_, gds_collector_=gds_collector_)

        return self

    def buildAttributes(self, node, attrs, already_processed):

        pass

    def buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):

        if nodeName_ == 'Relation':

            obj_ = RelationType.factory(parent_object_=self)

            obj_.build(child_, gds_collector_=gds_collector_)

            self.Relation.append(obj_)

            obj_.original_tagname_ = 'Relation'

    def __hash__(self):

        return hash(self.id)

# end class RelationsType

# end class BorderType

class LayersType(GeneratedsSuper):

    """Can be used to express the z-index of overlapping

    regions. An element with a greater z-index is always in

    front of another element with lower z-index."""

    __hash__ = GeneratedsSuper.__hash__

    member_data_items_ = [

        MemberSpec_('Layer', 'LayerType', 1, 0, {'maxOccurs': 'unbounded', 'minOccurs': '1', 'name': 'Layer', 'type': 'LayerType'}, None),

    ]

    subclass = None

    superclass = None

    def __init__(self, Layer=None, gds_collector_=None, **kwargs_):

        self.gds_collector_ = gds_collector_

        self.gds_elementtree_node_ = None

        self.original_tagname_ = None

        self.parent_object_ = kwargs_.get('parent_object_')

        self.ns_prefix_ = None

        if Layer is None:

            self.Layer = []

        else:

            self.Layer = Layer

        self.Layer_nsprefix_ = "pc"

    def factory(*args_, **kwargs_):

        if CurrentSubclassModule_ is not None:

            subclass = getSubclassFromModule_(

                CurrentSubclassModule_, LayersType)

            if subclass is not None:

                return subclass(*args_, **kwargs_)

        if LayersType.subclass:

            return LayersType.subclass(*args_, **kwargs_)

        else:

            return LayersType(*args_, **kwargs_)

    factory = staticmethod(factory)

    def get_ns_prefix_(self):

        return self.ns_prefix_

    def set_ns_prefix_(self, ns_prefix):

        self.ns_prefix_ = ns_prefix

    def get_Layer(self):

        return self.Layer

    def set_Layer(self, Layer):

        self.Layer = Layer

    def add_Layer(self, value):

        self.Layer.append(value)

    def insert_Layer_at(self, index, value):

        self.Layer.insert(index, value)

    def replace_Layer_at(self, index, value):

        self.Layer[index] = value

    def hasContent_(self):

        if (

            self.Layer

        ):

            return True

        else:

            return False

    def export(self, outfile, level, namespaceprefix_='', namespacedef_='xmlns:pc="http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15"', name_='LayersType', pretty_print=True):

        imported_ns_def_ = GenerateDSNamespaceDefs_.get('LayersType')

        if imported_ns_def_ is not None:

            namespacedef_ = imported_ns_def_

        if pretty_print:

            eol_ = '\n'

        else:

            eol_ = ''

        if self.original_tagname_ is not None and name_ == 'LayersType':

            name_ = self.original_tagname_

        if UseCapturedNS_ and self.ns_prefix_:

            namespaceprefix_ = self.ns_prefix_ + ':'

        showIndent(outfile, level, pretty_print)

        outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', ))

        already_processed = set()

        self.exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='LayersType')

        if self.hasContent_():

            outfile.write('>%s' % (eol_, ))

            self.exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='LayersType', pretty_print=pretty_print)

            showIndent(outfile, level, pretty_print)

            outfile.write('</%s%s>%s' % (namespaceprefix_, name_, eol_))

        else:

            outfile.write('/>%s' % (eol_, ))

    def exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='LayersType'):

        pass

    def exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='xmlns:pc="http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15"', name_='LayersType', fromsubclass_=False, pretty_print=True):

        if pretty_print:

            eol_ = '\n'

        else:

            eol_ = ''

        for Layer_ in self.Layer:

            namespaceprefix_ = self.Layer_nsprefix_ + ':' if (UseCapturedNS_ and self.Layer_nsprefix_) else ''

            Layer_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Layer', pretty_print=pretty_print)

    def to_etree(self, parent_element=None, name_='LayersType', mapping_=None, nsmap_=None):

        if parent_element is None:

            element = etree_.Element('{http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15}' + name_, nsmap=nsmap_)

        else:

            element = etree_.SubElement(parent_element, '{http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15}' + name_, nsmap=nsmap_)

        for Layer_ in self.Layer:

            Layer_.to_etree(element, name_='Layer', mapping_=mapping_, nsmap_=nsmap_)

        if mapping_ is not None:

            mapping_[id(self)] = element

        return element

    def build(self, node, gds_collector_=None):

        self.gds_collector_ = gds_collector_

        if SaveElementTreeNode:

            self.gds_elementtree_node_ = node

        already_processed = set()

        self.ns_prefix_ = node.prefix

        self.buildAttributes(node, node.attrib, already_processed)

        for child in node:

            nodeName_ = Tag_pattern_.match(child.tag).groups()[-1]

            self.buildChildren(child, node, nodeName_, gds_collector_=gds_collector_)

        return self

    def buildAttributes(self, node, attrs, already_processed):

        pass

    def buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):

        if nodeName_ == 'Layer':

            obj_ = LayerType.factory(parent_object_=self)

            obj_.build(child_, gds_collector_=gds_collector_)

            self.Layer.append(obj_)

            obj_.original_tagname_ = 'Layer'

    def __hash__(self):

        return hash(self.id)

# end class LayersType

# end class GraphemeGroupType

class UserDefinedType(GeneratedsSuper):

    """Container for user-defined attributes"""

    __hash__ = GeneratedsSuper.__hash__

    member_data_items_ = [

        MemberSpec_('UserAttribute', 'UserAttributeType', 1, 0, {'maxOccurs': 'unbounded', 'minOccurs': '1', 'name': 'UserAttribute', 'type': 'UserAttributeType'}, None),

    ]

    subclass = None

    superclass = None

    def __init__(self, UserAttribute=None, gds_collector_=None, **kwargs_):

        self.gds_collector_ = gds_collector_

        self.gds_elementtree_node_ = None

        self.original_tagname_ = None

        self.parent_object_ = kwargs_.get('parent_object_')

        self.ns_prefix_ = None

        if UserAttribute is None:

            self.UserAttribute = []

        else:

            self.UserAttribute = UserAttribute

        self.UserAttribute_nsprefix_ = "pc"

    def factory(*args_, **kwargs_):

        if CurrentSubclassModule_ is not None:

            subclass = getSubclassFromModule_(

                CurrentSubclassModule_, UserDefinedType)

            if subclass is not None:

                return subclass(*args_, **kwargs_)

        if UserDefinedType.subclass:

            return UserDefinedType.subclass(*args_, **kwargs_)

        else:

            return UserDefinedType(*args_, **kwargs_)

    factory = staticmethod(factory)

    def get_ns_prefix_(self):

        return self.ns_prefix_

    def set_ns_prefix_(self, ns_prefix):

        self.ns_prefix_ = ns_prefix

    def get_UserAttribute(self):

        return self.UserAttribute

    def set_UserAttribute(self, UserAttribute):

        self.UserAttribute = UserAttribute

    def add_UserAttribute(self, value):

        self.UserAttribute.append(value)

    def insert_UserAttribute_at(self, index, value):

        self.UserAttribute.insert(index, value)

    def replace_UserAttribute_at(self, index, value):

        self.UserAttribute[index] = value

    def hasContent_(self):

        if (

            self.UserAttribute

        ):

            return True

        else:

            return False

    def export(self, outfile, level, namespaceprefix_='', namespacedef_='xmlns:pc="http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15"', name_='UserDefinedType', pretty_print=True):

        imported_ns_def_ = GenerateDSNamespaceDefs_.get('UserDefinedType')

        if imported_ns_def_ is not None:

            namespacedef_ = imported_ns_def_

        if pretty_print:

            eol_ = '\n'

        else:

            eol_ = ''

        if self.original_tagname_ is not None and name_ == 'UserDefinedType':

            name_ = self.original_tagname_

        if UseCapturedNS_ and self.ns_prefix_:

            namespaceprefix_ = self.ns_prefix_ + ':'

        showIndent(outfile, level, pretty_print)

        outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', ))

        already_processed = set()

        self.exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='UserDefinedType')

        if self.hasContent_():

            outfile.write('>%s' % (eol_, ))

            self.exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='UserDefinedType', pretty_print=pretty_print)

            showIndent(outfile, level, pretty_print)

            outfile.write('</%s%s>%s' % (namespaceprefix_, name_, eol_))

        else:

            outfile.write('/>%s' % (eol_, ))

    def exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='UserDefinedType'):

        pass

    def exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='xmlns:pc="http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15"', name_='UserDefinedType', fromsubclass_=False, pretty_print=True):

        if pretty_print:

            eol_ = '\n'

        else:

            eol_ = ''

        for UserAttribute_ in self.UserAttribute:

            namespaceprefix_ = self.UserAttribute_nsprefix_ + ':' if (UseCapturedNS_ and self.UserAttribute_nsprefix_) else ''

            UserAttribute_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='UserAttribute', pretty_print=pretty_print)

    def to_etree(self, parent_element=None, name_='UserDefinedType', mapping_=None, nsmap_=None):

        if parent_element is None:

            element = etree_.Element('{http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15}' + name_, nsmap=nsmap_)

        else:

            element = etree_.SubElement(parent_element, '{http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15}' + name_, nsmap=nsmap_)

        for UserAttribute_ in self.UserAttribute:

            UserAttribute_.to_etree(element, name_='UserAttribute', mapping_=mapping_, nsmap_=nsmap_)

        if mapping_ is not None:

            mapping_[id(self)] = element

        return element

    def build(self, node, gds_collector_=None):

        self.gds_collector_ = gds_collector_

        if SaveElementTreeNode:

            self.gds_elementtree_node_ = node

        already_processed = set()

        self.ns_prefix_ = node.prefix

        self.buildAttributes(node, node.attrib, already_processed)

        for child in node:

            nodeName_ = Tag_pattern_.match(child.tag).groups()[-1]

            self.buildChildren(child, node, nodeName_, gds_collector_=gds_collector_)

        return self

    def buildAttributes(self, node, attrs, already_processed):

        pass

    def buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):

        if nodeName_ == 'UserAttribute':

            obj_ = UserAttributeType.factory(parent_object_=self)

            obj_.build(child_, gds_collector_=gds_collector_)

            self.UserAttribute.append(obj_)

            obj_.original_tagname_ = 'UserAttribute'

    def __hash__(self):

        return hash(self.id)

# end class UserDefinedType

# end class TextEquivType

class GridType(GeneratedsSuper):

    """Matrix of grid points defining the table grid on the page."""

    __hash__ = GeneratedsSuper.__hash__

    member_data_items_ = [

        MemberSpec_('GridPoints', 'GridPointsType', 1, 0, {'maxOccurs': 'unbounded', 'minOccurs': '2', 'name': 'GridPoints', 'type': 'GridPointsType'}, None),

    ]

    subclass = None

    superclass = None

    def __init__(self, GridPoints=None, gds_collector_=None, **kwargs_):

        self.gds_collector_ = gds_collector_

        self.gds_elementtree_node_ = None

        self.original_tagname_ = None

        self.parent_object_ = kwargs_.get('parent_object_')

        self.ns_prefix_ = None

        if GridPoints is None:

            self.GridPoints = []

        else:

            self.GridPoints = GridPoints

        self.GridPoints_nsprefix_ = "pc"

    def factory(*args_, **kwargs_):

        if CurrentSubclassModule_ is not None:

            subclass = getSubclassFromModule_(

                CurrentSubclassModule_, GridType)

            if subclass is not None:

                return subclass(*args_, **kwargs_)

        if GridType.subclass:

            return GridType.subclass(*args_, **kwargs_)

        else:

            return GridType(*args_, **kwargs_)

    factory = staticmethod(factory)

    def get_ns_prefix_(self):

        return self.ns_prefix_

    def set_ns_prefix_(self, ns_prefix):

        self.ns_prefix_ = ns_prefix

    def get_GridPoints(self):

        return self.GridPoints

    def set_GridPoints(self, GridPoints):

        self.GridPoints = GridPoints

    def add_GridPoints(self, value):

        self.GridPoints.append(value)

    def insert_GridPoints_at(self, index, value):

        self.GridPoints.insert(index, value)

    def replace_GridPoints_at(self, index, value):

        self.GridPoints[index] = value

    def hasContent_(self):

        if (

            self.GridPoints

        ):

            return True

        else:

            return False

    def export(self, outfile, level, namespaceprefix_='', namespacedef_='xmlns:pc="http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15"', name_='GridType', pretty_print=True):

        imported_ns_def_ = GenerateDSNamespaceDefs_.get('GridType')

        if imported_ns_def_ is not None:

            namespacedef_ = imported_ns_def_

        if pretty_print:

            eol_ = '\n'

        else:

            eol_ = ''

        if self.original_tagname_ is not None and name_ == 'GridType':

            name_ = self.original_tagname_

        if UseCapturedNS_ and self.ns_prefix_:

            namespaceprefix_ = self.ns_prefix_ + ':'

        showIndent(outfile, level, pretty_print)

        outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', ))

        already_processed = set()

        self.exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='GridType')

        if self.hasContent_():

            outfile.write('>%s' % (eol_, ))

            self.exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='GridType', pretty_print=pretty_print)

            showIndent(outfile, level, pretty_print)

            outfile.write('</%s%s>%s' % (namespaceprefix_, name_, eol_))

        else:

            outfile.write('/>%s' % (eol_, ))

    def exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='GridType'):

        pass

    def exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='xmlns:pc="http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15"', name_='GridType', fromsubclass_=False, pretty_print=True):

        if pretty_print:

            eol_ = '\n'

        else:

            eol_ = ''

        for GridPoints_ in self.GridPoints:

            namespaceprefix_ = self.GridPoints_nsprefix_ + ':' if (UseCapturedNS_ and self.GridPoints_nsprefix_) else ''

            GridPoints_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='GridPoints', pretty_print=pretty_print)

    def to_etree(self, parent_element=None, name_='GridType', mapping_=None, nsmap_=None):

        if parent_element is None:

            element = etree_.Element('{http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15}' + name_, nsmap=nsmap_)

        else:

            element = etree_.SubElement(parent_element, '{http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15}' + name_, nsmap=nsmap_)

        for GridPoints_ in self.GridPoints:

            GridPoints_.to_etree(element, name_='GridPoints', mapping_=mapping_, nsmap_=nsmap_)

        if mapping_ is not None:

            mapping_[id(self)] = element

        return element

    def build(self, node, gds_collector_=None):

        self.gds_collector_ = gds_collector_

        if SaveElementTreeNode:

            self.gds_elementtree_node_ = node

        already_processed = set()

        self.ns_prefix_ = node.prefix

        self.buildAttributes(node, node.attrib, already_processed)

        for child in node:

            nodeName_ = Tag_pattern_.match(child.tag).groups()[-1]

            self.buildChildren(child, node, nodeName_, gds_collector_=gds_collector_)

        return self

    def buildAttributes(self, node, attrs, already_processed):

        pass

    def buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):

        if nodeName_ == 'GridPoints':

            obj_ = GridPointsType.factory(parent_object_=self)

            obj_.build(child_, gds_collector_=gds_collector_)

            self.GridPoints.append(obj_)

            obj_.original_tagname_ = 'GridPoints'

    def __hash__(self):

        return hash(self.id)

# end class GridType