OCR-D /
core
| Total Complexity | 4896 |
| Total Lines | 14270 |
| Duplicated Lines | 26.64 % |
| Changes | 0 | ||
Duplicate code is one of the most pungent code smells. A rule that is often used is to re-structure code once it is duplicated in three or more places.
Common duplication problems, and corresponding solutions are:
Complex classes like ocrd_models.ocrd_page_generateds often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes.
Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.
| 1 | #!/usr/bin/env python |
||
| 2 | # -*- coding: utf-8 -*- |
||
| 3 | |||
| 4 | # |
||
| 5 | # Generated Wed Nov 3 12:30:32 2021 by generateDS.py version 2.35.20. |
||
| 6 | # Python 3.6.9 (default, Jan 26 2021, 15:33:00) [GCC 8.4.0] |
||
| 7 | # |
||
| 8 | # Command line options: |
||
| 9 | # ('-f', '') |
||
| 10 | # ('--root-element', 'PcGts') |
||
| 11 | # ('-o', 'ocrd_models/ocrd_models/ocrd_page_generateds.py') |
||
| 12 | # ('--silence', '') |
||
| 13 | # ('--export', 'write etree') |
||
| 14 | # ('--disable-generatedssuper-lookup', '') |
||
| 15 | # ('--user-methods', 'ocrd_models/ocrd_page_user_methods.py') |
||
| 16 | # |
||
| 17 | # Command line arguments: |
||
| 18 | # ocrd_validators/ocrd_validators/page.xsd |
||
| 19 | # |
||
| 20 | # Command line: |
||
| 21 | # /home/kba/monorepo/ocrd_all/venv/bin/generateDS -f --root-element="PcGts" -o "ocrd_models/ocrd_models/ocrd_page_generateds.py" --silence --export="write etree" --disable-generatedssuper-lookup --user-methods="ocrd_models/ocrd_page_user_methods.py" ocrd_validators/ocrd_validators/page.xsd |
||
| 22 | # |
||
| 23 | # Current working directory (os.getcwd()): |
||
| 24 | # core |
||
| 25 | # |
||
| 26 | |||
| 27 | from itertools import zip_longest |
||
| 28 | import os |
||
| 29 | import sys |
||
| 30 | import re as re_ |
||
| 31 | import base64 |
||
| 32 | import datetime as datetime_ |
||
| 33 | import decimal as decimal_ |
||
| 34 | try: |
||
| 35 | from lxml import etree as etree_ |
||
| 36 | except ImportError: |
||
| 37 | from xml.etree import ElementTree as etree_ |
||
| 38 | |||
| 39 | |||
| 40 | Validate_simpletypes_ = True |
||
| 41 | SaveElementTreeNode = True |
||
| 42 | if sys.version_info.major == 2: |
||
| 43 | BaseStrType_ = basestring |
||
|
Comprehensibility
Best Practice
introduced
by
|
|||
| 44 | else: |
||
| 45 | BaseStrType_ = str |
||
| 46 | |||
| 47 | |||
| 48 | def parsexml_(infile, parser=None, **kwargs): |
||
| 49 | if parser is None: |
||
| 50 | # Use the lxml ElementTree compatible parser so that, e.g., |
||
| 51 | # we ignore comments. |
||
| 52 | try: |
||
| 53 | parser = etree_.ETCompatXMLParser() |
||
| 54 | except AttributeError: |
||
| 55 | # fallback to xml.etree |
||
| 56 | parser = etree_.XMLParser() |
||
| 57 | try: |
||
| 58 | if isinstance(infile, os.PathLike): |
||
| 59 | infile = os.path.join(infile) |
||
| 60 | except AttributeError: |
||
| 61 | pass |
||
| 62 | doc = etree_.parse(infile, parser=parser, **kwargs) |
||
| 63 | return doc |
||
| 64 | |||
| 65 | def parsexmlstring_(instring, parser=None, **kwargs): |
||
| 66 | if parser is None: |
||
| 67 | # Use the lxml ElementTree compatible parser so that, e.g., |
||
| 68 | # we ignore comments. |
||
| 69 | try: |
||
| 70 | parser = etree_.ETCompatXMLParser() |
||
| 71 | except AttributeError: |
||
| 72 | # fallback to xml.etree |
||
| 73 | parser = etree_.XMLParser() |
||
| 74 | element = etree_.fromstring(instring, parser=parser, **kwargs) |
||
| 75 | return element |
||
| 76 | |||
| 77 | # |
||
| 78 | # Namespace prefix definition table (and other attributes, too) |
||
| 79 | # |
||
| 80 | # The module generatedsnamespaces, if it is importable, must contain |
||
| 81 | # a dictionary named GeneratedsNamespaceDefs. This Python dictionary |
||
| 82 | # should map element type names (strings) to XML schema namespace prefix |
||
| 83 | # definitions. The export method for any class for which there is |
||
| 84 | # a namespace prefix definition, will export that definition in the |
||
| 85 | # XML representation of that element. See the export method of |
||
| 86 | # any generated element type class for an example of the use of this |
||
| 87 | # table. |
||
| 88 | # A sample table is: |
||
| 89 | # |
||
| 90 | # # File: generatedsnamespaces.py |
||
| 91 | # |
||
| 92 | # GenerateDSNamespaceDefs = { |
||
| 93 | # "ElementtypeA": "http://www.xxx.com/namespaceA", |
||
| 94 | # "ElementtypeB": "http://www.xxx.com/namespaceB", |
||
| 95 | # } |
||
| 96 | # |
||
| 97 | # Additionally, the generatedsnamespaces module can contain a python |
||
| 98 | # dictionary named GenerateDSNamespaceTypePrefixes that associates element |
||
| 99 | # types with the namespace prefixes that are to be added to the |
||
| 100 | # "xsi:type" attribute value. See the exportAttributes method of |
||
| 101 | # any generated element type and the generation of "xsi:type" for an |
||
| 102 | # example of the use of this table. |
||
| 103 | # An example table: |
||
| 104 | # |
||
| 105 | # # File: generatedsnamespaces.py |
||
| 106 | # |
||
| 107 | # GenerateDSNamespaceTypePrefixes = { |
||
| 108 | # "ElementtypeC": "aaa:", |
||
| 109 | # "ElementtypeD": "bbb:", |
||
| 110 | # } |
||
| 111 | # |
||
| 112 | |||
| 113 | try: |
||
| 114 | from generatedsnamespaces import GenerateDSNamespaceDefs as GenerateDSNamespaceDefs_ |
||
| 115 | except ImportError: |
||
| 116 | GenerateDSNamespaceDefs_ = {} |
||
| 117 | try: |
||
| 118 | from generatedsnamespaces import GenerateDSNamespaceTypePrefixes as GenerateDSNamespaceTypePrefixes_ |
||
| 119 | except ImportError: |
||
| 120 | GenerateDSNamespaceTypePrefixes_ = {} |
||
| 121 | |||
| 122 | # |
||
| 123 | # You can replace the following class definition by defining an |
||
| 124 | # importable module named "generatedscollector" containing a class |
||
| 125 | # named "GdsCollector". See the default class definition below for |
||
| 126 | # clues about the possible content of that class. |
||
| 127 | # |
||
| 128 | try: |
||
| 129 | from generatedscollector import GdsCollector as GdsCollector_ |
||
| 130 | except ImportError: |
||
| 131 | |||
| 132 | class GdsCollector_(object): |
||
| 133 | |||
| 134 | def __init__(self, messages=None): |
||
| 135 | if messages is None: |
||
| 136 | self.messages = [] |
||
| 137 | else: |
||
| 138 | self.messages = messages |
||
| 139 | |||
| 140 | def add_message(self, msg): |
||
| 141 | self.messages.append(msg) |
||
| 142 | |||
| 143 | def get_messages(self): |
||
| 144 | return self.messages |
||
| 145 | |||
| 146 | def clear_messages(self): |
||
| 147 | self.messages = [] |
||
| 148 | |||
| 149 | def print_messages(self): |
||
| 150 | for msg in self.messages: |
||
| 151 | print("Warning: {}".format(msg)) |
||
| 152 | |||
| 153 | def write_messages(self, outstream): |
||
| 154 | for msg in self.messages: |
||
| 155 | outstream.write("Warning: {}\n".format(msg)) |
||
| 156 | |||
| 157 | |||
| 158 | # |
||
| 159 | # The super-class for enum types |
||
| 160 | # |
||
| 161 | |||
| 162 | try: |
||
| 163 | from enum import Enum |
||
| 164 | except ImportError: |
||
| 165 | Enum = object |
||
| 166 | |||
| 167 | # |
||
| 168 | # The root super-class for element type classes |
||
| 169 | # |
||
| 170 | # Calls to the methods in these classes are generated by generateDS.py. |
||
| 171 | # You can replace these methods by re-implementing the following class |
||
| 172 | # in a module named generatedssuper.py. |
||
| 173 | |||
| 174 | |||
| 175 | class GeneratedsSuper(object): |
||
| 176 | __hash__ = object.__hash__ |
||
| 177 | tzoff_pattern = re_.compile(r'(\+|-)((0\d|1[0-3]):[0-5]\d|14:00)$') |
||
| 178 | class _FixedOffsetTZ(datetime_.tzinfo): |
||
| 179 | def __init__(self, offset, name): |
||
| 180 | self.__offset = datetime_.timedelta(minutes=offset) |
||
| 181 | self.__name = name |
||
| 182 | def utcoffset(self, dt): |
||
| 183 | return self.__offset |
||
| 184 | def tzname(self, dt): |
||
| 185 | return self.__name |
||
| 186 | def dst(self, dt): |
||
| 187 | return None |
||
| 188 | def gds_format_string(self, input_data, input_name=''): |
||
| 189 | return input_data |
||
| 190 | def gds_parse_string(self, input_data, node=None, input_name=''): |
||
| 191 | return input_data |
||
| 192 | def gds_validate_string(self, input_data, node=None, input_name=''): |
||
| 193 | if not input_data: |
||
| 194 | return '' |
||
| 195 | else: |
||
| 196 | return input_data |
||
| 197 | def gds_format_base64(self, input_data, input_name=''): |
||
| 198 | return base64.b64encode(input_data) |
||
| 199 | def gds_validate_base64(self, input_data, node=None, input_name=''): |
||
| 200 | return input_data |
||
| 201 | def gds_format_integer(self, input_data, input_name=''): |
||
| 202 | return '%d' % input_data |
||
| 203 | def gds_parse_integer(self, input_data, node=None, input_name=''): |
||
| 204 | try: |
||
| 205 | ival = int(input_data) |
||
| 206 | except (TypeError, ValueError) as exp: |
||
| 207 | raise_parse_error(node, 'Requires integer value: %s' % exp) |
||
| 208 | return ival |
||
| 209 | def gds_validate_integer(self, input_data, node=None, input_name=''): |
||
| 210 | try: |
||
| 211 | value = int(input_data) |
||
| 212 | except (TypeError, ValueError): |
||
| 213 | raise_parse_error(node, 'Requires integer value') |
||
| 214 | return value |
||
| 215 | def gds_format_integer_list(self, input_data, input_name=''): |
||
| 216 | return '%s' % ' '.join(input_data) |
||
| 217 | def gds_validate_integer_list( |
||
| 218 | self, input_data, node=None, input_name=''): |
||
| 219 | values = input_data.split() |
||
| 220 | for value in values: |
||
| 221 | try: |
||
| 222 | int(value) |
||
| 223 | except (TypeError, ValueError): |
||
| 224 | raise_parse_error(node, 'Requires sequence of integer valuess') |
||
| 225 | return values |
||
| 226 | def gds_format_float(self, input_data, input_name=''): |
||
| 227 | return ('%.15f' % input_data).rstrip('0') |
||
| 228 | def gds_parse_float(self, input_data, node=None, input_name=''): |
||
| 229 | try: |
||
| 230 | fval_ = float(input_data) |
||
| 231 | except (TypeError, ValueError) as exp: |
||
| 232 | raise_parse_error(node, 'Requires float or double value: %s' % exp) |
||
| 233 | return fval_ |
||
| 234 | def gds_validate_float(self, input_data, node=None, input_name=''): |
||
| 235 | try: |
||
| 236 | value = float(input_data) |
||
| 237 | except (TypeError, ValueError): |
||
| 238 | raise_parse_error(node, 'Requires float value') |
||
| 239 | return value |
||
| 240 | def gds_format_float_list(self, input_data, input_name=''): |
||
| 241 | return '%s' % ' '.join(input_data) |
||
| 242 | def gds_validate_float_list( |
||
| 243 | self, input_data, node=None, input_name=''): |
||
| 244 | values = input_data.split() |
||
| 245 | for value in values: |
||
| 246 | try: |
||
| 247 | float(value) |
||
| 248 | except (TypeError, ValueError): |
||
| 249 | raise_parse_error(node, 'Requires sequence of float values') |
||
| 250 | return values |
||
| 251 | def gds_format_decimal(self, input_data, input_name=''): |
||
| 252 | return ('%s' % input_data).rstrip('0') |
||
| 253 | def gds_parse_decimal(self, input_data, node=None, input_name=''): |
||
| 254 | try: |
||
| 255 | decimal_value = decimal_.Decimal(input_data) |
||
| 256 | except (TypeError, ValueError): |
||
| 257 | raise_parse_error(node, 'Requires decimal value') |
||
| 258 | return decimal_value |
||
| 259 | def gds_validate_decimal(self, input_data, node=None, input_name=''): |
||
| 260 | try: |
||
| 261 | value = decimal_.Decimal(input_data) |
||
| 262 | except (TypeError, ValueError): |
||
| 263 | raise_parse_error(node, 'Requires decimal value') |
||
| 264 | return value |
||
| 265 | def gds_format_decimal_list(self, input_data, input_name=''): |
||
| 266 | return '%s' % ' '.join(input_data) |
||
| 267 | def gds_validate_decimal_list( |
||
| 268 | self, input_data, node=None, input_name=''): |
||
| 269 | values = input_data.split() |
||
| 270 | for value in values: |
||
| 271 | try: |
||
| 272 | decimal_.Decimal(value) |
||
| 273 | except (TypeError, ValueError): |
||
| 274 | raise_parse_error(node, 'Requires sequence of decimal values') |
||
| 275 | return values |
||
| 276 | def gds_format_double(self, input_data, input_name=''): |
||
| 277 | return '%e' % input_data |
||
| 278 | def gds_parse_double(self, input_data, node=None, input_name=''): |
||
| 279 | try: |
||
| 280 | fval_ = float(input_data) |
||
| 281 | except (TypeError, ValueError) as exp: |
||
| 282 | raise_parse_error(node, 'Requires double or float value: %s' % exp) |
||
| 283 | return fval_ |
||
| 284 | def gds_validate_double(self, input_data, node=None, input_name=''): |
||
| 285 | try: |
||
| 286 | value = float(input_data) |
||
| 287 | except (TypeError, ValueError): |
||
| 288 | raise_parse_error(node, 'Requires double or float value') |
||
| 289 | return value |
||
| 290 | def gds_format_double_list(self, input_data, input_name=''): |
||
| 291 | return '%s' % ' '.join(input_data) |
||
| 292 | def gds_validate_double_list( |
||
| 293 | self, input_data, node=None, input_name=''): |
||
| 294 | values = input_data.split() |
||
| 295 | for value in values: |
||
| 296 | try: |
||
| 297 | float(value) |
||
| 298 | except (TypeError, ValueError): |
||
| 299 | raise_parse_error( |
||
| 300 | node, 'Requires sequence of double or float values') |
||
| 301 | return values |
||
| 302 | def gds_format_boolean(self, input_data, input_name=''): |
||
| 303 | return ('%s' % input_data).lower() |
||
| 304 | def gds_parse_boolean(self, input_data, node=None, input_name=''): |
||
| 305 | if input_data in ('true', '1'): |
||
| 306 | bval = True |
||
| 307 | elif input_data in ('false', '0'): |
||
| 308 | bval = False |
||
| 309 | else: |
||
| 310 | raise_parse_error(node, 'Requires boolean value') |
||
| 311 | return bval |
||
| 312 | def gds_validate_boolean(self, input_data, node=None, input_name=''): |
||
| 313 | if input_data not in (True, 1, False, 0, ): |
||
| 314 | raise_parse_error( |
||
| 315 | node, |
||
| 316 | 'Requires boolean value ' |
||
| 317 | '(one of True, 1, False, 0)') |
||
| 318 | return input_data |
||
| 319 | def gds_format_boolean_list(self, input_data, input_name=''): |
||
| 320 | return '%s' % ' '.join(input_data) |
||
| 321 | def gds_validate_boolean_list( |
||
| 322 | self, input_data, node=None, input_name=''): |
||
| 323 | values = input_data.split() |
||
| 324 | for value in values: |
||
| 325 | if value not in (True, 1, False, 0, ): |
||
| 326 | raise_parse_error( |
||
| 327 | node, |
||
| 328 | 'Requires sequence of boolean values ' |
||
| 329 | '(one of True, 1, False, 0)') |
||
| 330 | return values |
||
| 331 | def gds_validate_datetime(self, input_data, node=None, input_name=''): |
||
| 332 | return input_data |
||
| 333 | View Code Duplication | def gds_format_datetime(self, input_data, input_name=''): |
|
| 334 | if input_data.microsecond == 0: |
||
| 335 | _svalue = '%04d-%02d-%02dT%02d:%02d:%02d' % ( |
||
| 336 | input_data.year, |
||
| 337 | input_data.month, |
||
| 338 | input_data.day, |
||
| 339 | input_data.hour, |
||
| 340 | input_data.minute, |
||
| 341 | input_data.second, |
||
| 342 | ) |
||
| 343 | else: |
||
| 344 | _svalue = '%04d-%02d-%02dT%02d:%02d:%02d.%s' % ( |
||
| 345 | input_data.year, |
||
| 346 | input_data.month, |
||
| 347 | input_data.day, |
||
| 348 | input_data.hour, |
||
| 349 | input_data.minute, |
||
| 350 | input_data.second, |
||
| 351 | ('%f' % (float(input_data.microsecond) / 1000000))[2:], |
||
| 352 | ) |
||
| 353 | if input_data.tzinfo is not None: |
||
| 354 | tzoff = input_data.tzinfo.utcoffset(input_data) |
||
| 355 | if tzoff is not None: |
||
| 356 | total_seconds = tzoff.seconds + (86400 * tzoff.days) |
||
| 357 | if total_seconds == 0: |
||
| 358 | _svalue += 'Z' |
||
| 359 | else: |
||
| 360 | if total_seconds < 0: |
||
| 361 | _svalue += '-' |
||
| 362 | total_seconds *= -1 |
||
| 363 | else: |
||
| 364 | _svalue += '+' |
||
| 365 | hours = total_seconds // 3600 |
||
| 366 | minutes = (total_seconds - (hours * 3600)) // 60 |
||
| 367 | _svalue += '{0:02d}:{1:02d}'.format(hours, minutes) |
||
| 368 | return _svalue |
||
| 369 | @classmethod |
||
| 370 | def gds_parse_datetime(cls, input_data): |
||
| 371 | tz = None |
||
| 372 | View Code Duplication | if input_data[-1] == 'Z': |
|
| 373 | tz = GeneratedsSuper._FixedOffsetTZ(0, 'UTC') |
||
| 374 | input_data = input_data[:-1] |
||
| 375 | else: |
||
| 376 | results = GeneratedsSuper.tzoff_pattern.search(input_data) |
||
| 377 | if results is not None: |
||
| 378 | tzoff_parts = results.group(2).split(':') |
||
| 379 | tzoff = int(tzoff_parts[0]) * 60 + int(tzoff_parts[1]) |
||
| 380 | if results.group(1) == '-': |
||
| 381 | tzoff *= -1 |
||
| 382 | tz = GeneratedsSuper._FixedOffsetTZ( |
||
| 383 | tzoff, results.group(0)) |
||
| 384 | input_data = input_data[:-6] |
||
| 385 | time_parts = input_data.split('.') |
||
| 386 | if len(time_parts) > 1: |
||
| 387 | micro_seconds = int(float('0.' + time_parts[1]) * 1000000) |
||
| 388 | input_data = '%s.%s' % ( |
||
| 389 | time_parts[0], "{}".format(micro_seconds).rjust(6, "0"), ) |
||
| 390 | dt = datetime_.datetime.strptime( |
||
| 391 | input_data, '%Y-%m-%dT%H:%M:%S.%f') |
||
| 392 | else: |
||
| 393 | dt = datetime_.datetime.strptime( |
||
| 394 | input_data, '%Y-%m-%dT%H:%M:%S') |
||
| 395 | dt = dt.replace(tzinfo=tz) |
||
| 396 | return dt |
||
| 397 | def gds_validate_date(self, input_data, node=None, input_name=''): |
||
| 398 | return input_data |
||
| 399 | def gds_format_date(self, input_data, input_name=''): |
||
| 400 | _svalue = '%04d-%02d-%02d' % ( |
||
| 401 | input_data.year, |
||
| 402 | input_data.month, |
||
| 403 | input_data.day, |
||
| 404 | ) |
||
| 405 | try: |
||
| 406 | if input_data.tzinfo is not None: |
||
| 407 | tzoff = input_data.tzinfo.utcoffset(input_data) |
||
| 408 | if tzoff is not None: |
||
| 409 | total_seconds = tzoff.seconds + (86400 * tzoff.days) |
||
| 410 | if total_seconds == 0: |
||
| 411 | _svalue += 'Z' |
||
| 412 | else: |
||
| 413 | if total_seconds < 0: |
||
| 414 | _svalue += '-' |
||
| 415 | total_seconds *= -1 |
||
| 416 | else: |
||
| 417 | _svalue += '+' |
||
| 418 | hours = total_seconds // 3600 |
||
| 419 | minutes = (total_seconds - (hours * 3600)) // 60 |
||
| 420 | _svalue += '{0:02d}:{1:02d}'.format( |
||
| 421 | hours, minutes) |
||
| 422 | except AttributeError: |
||
| 423 | pass |
||
| 424 | return _svalue |
||
| 425 | @classmethod |
||
| 426 | def gds_parse_date(cls, input_data): |
||
| 427 | tz = None |
||
| 428 | View Code Duplication | if input_data[-1] == 'Z': |
|
| 429 | tz = GeneratedsSuper._FixedOffsetTZ(0, 'UTC') |
||
| 430 | input_data = input_data[:-1] |
||
| 431 | else: |
||
| 432 | results = GeneratedsSuper.tzoff_pattern.search(input_data) |
||
| 433 | if results is not None: |
||
| 434 | tzoff_parts = results.group(2).split(':') |
||
| 435 | tzoff = int(tzoff_parts[0]) * 60 + int(tzoff_parts[1]) |
||
| 436 | if results.group(1) == '-': |
||
| 437 | tzoff *= -1 |
||
| 438 | tz = GeneratedsSuper._FixedOffsetTZ( |
||
| 439 | tzoff, results.group(0)) |
||
| 440 | input_data = input_data[:-6] |
||
| 441 | dt = datetime_.datetime.strptime(input_data, '%Y-%m-%d') |
||
| 442 | dt = dt.replace(tzinfo=tz) |
||
| 443 | return dt.date() |
||
| 444 | def gds_validate_time(self, input_data, node=None, input_name=''): |
||
| 445 | return input_data |
||
| 446 | View Code Duplication | def gds_format_time(self, input_data, input_name=''): |
|
| 447 | if input_data.microsecond == 0: |
||
| 448 | _svalue = '%02d:%02d:%02d' % ( |
||
| 449 | input_data.hour, |
||
| 450 | input_data.minute, |
||
| 451 | input_data.second, |
||
| 452 | ) |
||
| 453 | else: |
||
| 454 | _svalue = '%02d:%02d:%02d.%s' % ( |
||
| 455 | input_data.hour, |
||
| 456 | input_data.minute, |
||
| 457 | input_data.second, |
||
| 458 | ('%f' % (float(input_data.microsecond) / 1000000))[2:], |
||
| 459 | ) |
||
| 460 | if input_data.tzinfo is not None: |
||
| 461 | tzoff = input_data.tzinfo.utcoffset(input_data) |
||
| 462 | if tzoff is not None: |
||
| 463 | total_seconds = tzoff.seconds + (86400 * tzoff.days) |
||
| 464 | if total_seconds == 0: |
||
| 465 | _svalue += 'Z' |
||
| 466 | else: |
||
| 467 | if total_seconds < 0: |
||
| 468 | _svalue += '-' |
||
| 469 | total_seconds *= -1 |
||
| 470 | else: |
||
| 471 | _svalue += '+' |
||
| 472 | hours = total_seconds // 3600 |
||
| 473 | minutes = (total_seconds - (hours * 3600)) // 60 |
||
| 474 | _svalue += '{0:02d}:{1:02d}'.format(hours, minutes) |
||
| 475 | return _svalue |
||
| 476 | def gds_validate_simple_patterns(self, patterns, target): |
||
| 477 | # pat is a list of lists of strings/patterns. |
||
| 478 | # The target value must match at least one of the patterns |
||
| 479 | # in order for the test to succeed. |
||
| 480 | found1 = True |
||
| 481 | for patterns1 in patterns: |
||
| 482 | found2 = False |
||
| 483 | for patterns2 in patterns1: |
||
| 484 | mo = re_.search(patterns2, target) |
||
| 485 | if mo is not None and len(mo.group(0)) == len(target): |
||
| 486 | found2 = True |
||
| 487 | break |
||
| 488 | if not found2: |
||
| 489 | found1 = False |
||
| 490 | break |
||
| 491 | return found1 |
||
| 492 | @classmethod |
||
| 493 | def gds_parse_time(cls, input_data): |
||
| 494 | tz = None |
||
| 495 | View Code Duplication | if input_data[-1] == 'Z': |
|
| 496 | tz = GeneratedsSuper._FixedOffsetTZ(0, 'UTC') |
||
| 497 | input_data = input_data[:-1] |
||
| 498 | else: |
||
| 499 | results = GeneratedsSuper.tzoff_pattern.search(input_data) |
||
| 500 | if results is not None: |
||
| 501 | tzoff_parts = results.group(2).split(':') |
||
| 502 | tzoff = int(tzoff_parts[0]) * 60 + int(tzoff_parts[1]) |
||
| 503 | if results.group(1) == '-': |
||
| 504 | tzoff *= -1 |
||
| 505 | tz = GeneratedsSuper._FixedOffsetTZ( |
||
| 506 | tzoff, results.group(0)) |
||
| 507 | input_data = input_data[:-6] |
||
| 508 | if len(input_data.split('.')) > 1: |
||
| 509 | dt = datetime_.datetime.strptime(input_data, '%H:%M:%S.%f') |
||
| 510 | else: |
||
| 511 | dt = datetime_.datetime.strptime(input_data, '%H:%M:%S') |
||
| 512 | dt = dt.replace(tzinfo=tz) |
||
| 513 | return dt.time() |
||
| 514 | def gds_check_cardinality_( |
||
| 515 | self, value, input_name, |
||
| 516 | min_occurs=0, max_occurs=1, required=None): |
||
| 517 | if value is None: |
||
| 518 | length = 0 |
||
| 519 | elif isinstance(value, list): |
||
| 520 | length = len(value) |
||
| 521 | else: |
||
| 522 | length = 1 |
||
| 523 | if required is not None : |
||
| 524 | if required and length < 1: |
||
| 525 | self.gds_collector_.add_message( |
||
| 526 | "Required value {}{} is missing".format( |
||
| 527 | input_name, self.gds_get_node_lineno_())) |
||
| 528 | if length < min_occurs: |
||
| 529 | self.gds_collector_.add_message( |
||
| 530 | "Number of values for {}{} is below " |
||
| 531 | "the minimum allowed, " |
||
| 532 | "expected at least {}, found {}".format( |
||
| 533 | input_name, self.gds_get_node_lineno_(), |
||
| 534 | min_occurs, length)) |
||
| 535 | elif length > max_occurs: |
||
| 536 | self.gds_collector_.add_message( |
||
| 537 | "Number of values for {}{} is above " |
||
| 538 | "the maximum allowed, " |
||
| 539 | "expected at most {}, found {}".format( |
||
| 540 | input_name, self.gds_get_node_lineno_(), |
||
| 541 | max_occurs, length)) |
||
| 542 | def gds_validate_builtin_ST_( |
||
| 543 | self, validator, value, input_name, |
||
| 544 | min_occurs=None, max_occurs=None, required=None): |
||
| 545 | if value is not None: |
||
| 546 | try: |
||
| 547 | validator(value, input_name=input_name) |
||
| 548 | except GDSParseError as parse_error: |
||
| 549 | self.gds_collector_.add_message(str(parse_error)) |
||
| 550 | def gds_validate_defined_ST_( |
||
| 551 | self, validator, value, input_name, |
||
| 552 | min_occurs=None, max_occurs=None, required=None): |
||
| 553 | if value is not None: |
||
| 554 | try: |
||
| 555 | validator(value) |
||
| 556 | except GDSParseError as parse_error: |
||
| 557 | self.gds_collector_.add_message(str(parse_error)) |
||
| 558 | def gds_str_lower(self, instring): |
||
| 559 | return instring.lower() |
||
| 560 | def get_path_(self, node): |
||
| 561 | path_list = [] |
||
| 562 | self.get_path_list_(node, path_list) |
||
| 563 | path_list.reverse() |
||
| 564 | path = '/'.join(path_list) |
||
| 565 | return path |
||
| 566 | Tag_strip_pattern_ = re_.compile(r'\{.*\}') |
||
| 567 | def get_path_list_(self, node, path_list): |
||
| 568 | if node is None: |
||
| 569 | return |
||
| 570 | tag = GeneratedsSuper.Tag_strip_pattern_.sub('', node.tag) |
||
| 571 | if tag: |
||
| 572 | path_list.append(tag) |
||
| 573 | self.get_path_list_(node.getparent(), path_list) |
||
| 574 | def get_class_obj_(self, node, default_class=None): |
||
| 575 | class_obj1 = default_class |
||
| 576 | if 'xsi' in node.nsmap: |
||
| 577 | classname = node.get('{%s}type' % node.nsmap['xsi']) |
||
| 578 | if classname is not None: |
||
| 579 | names = classname.split(':') |
||
| 580 | if len(names) == 2: |
||
| 581 | classname = names[1] |
||
| 582 | class_obj2 = globals().get(classname) |
||
| 583 | if class_obj2 is not None: |
||
| 584 | class_obj1 = class_obj2 |
||
| 585 | return class_obj1 |
||
| 586 | def gds_build_any(self, node, type_name=None): |
||
| 587 | # provide default value in case option --disable-xml is used. |
||
| 588 | content = "" |
||
| 589 | content = etree_.tostring(node, encoding="unicode") |
||
| 590 | return content |
||
| 591 | @classmethod |
||
| 592 | def gds_reverse_node_mapping(cls, mapping): |
||
| 593 | return dict(((v, k) for k, v in mapping.items())) |
||
| 594 | @staticmethod |
||
| 595 | def gds_encode(instring): |
||
| 596 | if sys.version_info.major == 2: |
||
| 597 | if ExternalEncoding: |
||
| 598 | encoding = ExternalEncoding |
||
| 599 | else: |
||
| 600 | encoding = 'utf-8' |
||
| 601 | return instring.encode(encoding) |
||
| 602 | else: |
||
| 603 | return instring |
||
| 604 | @staticmethod |
||
| 605 | def convert_unicode(instring): |
||
| 606 | if isinstance(instring, str): |
||
| 607 | result = quote_xml(instring) |
||
| 608 | elif sys.version_info.major == 2 and isinstance(instring, unicode): |
||
| 609 | result = quote_xml(instring).encode('utf8') |
||
| 610 | else: |
||
| 611 | result = GeneratedsSuper.gds_encode(str(instring)) |
||
| 612 | return result |
||
| 613 | def __eq__(self, other): |
||
| 614 | def excl_select_objs_(obj): |
||
| 615 | return (obj[0] != 'parent_object_' and |
||
| 616 | obj[0] != 'gds_collector_') |
||
| 617 | if type(self) != type(other): |
||
| 618 | return False |
||
| 619 | return all(x == y for x, y in zip_longest( |
||
| 620 | filter(excl_select_objs_, self.__dict__.items()), |
||
| 621 | filter(excl_select_objs_, other.__dict__.items()))) |
||
| 622 | def __ne__(self, other): |
||
| 623 | return not self.__eq__(other) |
||
| 624 | # Django ETL transform hooks. |
||
| 625 | def gds_djo_etl_transform(self): |
||
| 626 | pass |
||
| 627 | def gds_djo_etl_transform_db_obj(self, dbobj): |
||
| 628 | pass |
||
| 629 | # SQLAlchemy ETL transform hooks. |
||
| 630 | def gds_sqa_etl_transform(self): |
||
| 631 | return 0, None |
||
| 632 | def gds_sqa_etl_transform_db_obj(self, dbobj): |
||
| 633 | pass |
||
| 634 | def gds_get_node_lineno_(self): |
||
| 635 | if (hasattr(self, "gds_elementtree_node_") and |
||
| 636 | self.gds_elementtree_node_ is not None): |
||
| 637 | return ' near line {}'.format( |
||
| 638 | self.gds_elementtree_node_.sourceline) |
||
| 639 | else: |
||
| 640 | return "" |
||
| 641 | |||
| 642 | |||
| 643 | def getSubclassFromModule_(module, class_): |
||
| 644 | '''Get the subclass of a class from a specific module.''' |
||
| 645 | name = class_.__name__ + 'Sub' |
||
| 646 | if hasattr(module, name): |
||
| 647 | return getattr(module, name) |
||
| 648 | else: |
||
| 649 | return None |
||
| 650 | |||
| 651 | |||
| 652 | # |
||
| 653 | # If you have installed IPython you can uncomment and use the following. |
||
| 654 | # IPython is available from http://ipython.scipy.org/. |
||
| 655 | # |
||
| 656 | |||
| 657 | ## from IPython.Shell import IPShellEmbed |
||
| 658 | ## args = '' |
||
| 659 | ## ipshell = IPShellEmbed(args, |
||
| 660 | ## banner = 'Dropping into IPython', |
||
| 661 | ## exit_msg = 'Leaving Interpreter, back to program.') |
||
| 662 | |||
| 663 | # Then use the following line where and when you want to drop into the |
||
| 664 | # IPython shell: |
||
| 665 | # ipshell('<some message> -- Entering ipshell.\nHit Ctrl-D to exit') |
||
| 666 | |||
| 667 | # |
||
| 668 | # Globals |
||
| 669 | # |
||
| 670 | |||
| 671 | ExternalEncoding = '' |
||
| 672 | # Set this to false in order to deactivate during export, the use of |
||
| 673 | # name space prefixes captured from the input document. |
||
| 674 | UseCapturedNS_ = True |
||
| 675 | CapturedNsmap_ = {} |
||
| 676 | Tag_pattern_ = re_.compile(r'({.*})?(.*)') |
||
| 677 | String_cleanup_pat_ = re_.compile(r"[\n\r\s]+") |
||
| 678 | Namespace_extract_pat_ = re_.compile(r'{(.*)}(.*)') |
||
| 679 | CDATA_pattern_ = re_.compile(r"<!\[CDATA\[.*?\]\]>", re_.DOTALL) |
||
| 680 | |||
| 681 | # Change this to redirect the generated superclass module to use a |
||
| 682 | # specific subclass module. |
||
| 683 | CurrentSubclassModule_ = None |
||
| 684 | |||
| 685 | # |
||
| 686 | # Support/utility functions. |
||
| 687 | # |
||
| 688 | |||
| 689 | |||
| 690 | def showIndent(outfile, level, pretty_print=True): |
||
| 691 | if pretty_print: |
||
| 692 | for idx in range(level): |
||
| 693 | outfile.write(' ') |
||
| 694 | |||
| 695 | |||
| 696 | def quote_xml(inStr): |
||
| 697 | "Escape markup chars, but do not modify CDATA sections." |
||
| 698 | if not inStr: |
||
| 699 | return '' |
||
| 700 | s1 = (isinstance(inStr, BaseStrType_) and inStr or '%s' % inStr) |
||
| 701 | s2 = '' |
||
| 702 | pos = 0 |
||
| 703 | matchobjects = CDATA_pattern_.finditer(s1) |
||
| 704 | for mo in matchobjects: |
||
| 705 | s3 = s1[pos:mo.start()] |
||
| 706 | s2 += quote_xml_aux(s3) |
||
| 707 | s2 += s1[mo.start():mo.end()] |
||
| 708 | pos = mo.end() |
||
| 709 | s3 = s1[pos:] |
||
| 710 | s2 += quote_xml_aux(s3) |
||
| 711 | return s2 |
||
| 712 | |||
| 713 | |||
| 714 | def quote_xml_aux(inStr): |
||
| 715 | s1 = inStr.replace('&', '&') |
||
| 716 | s1 = s1.replace('<', '<') |
||
| 717 | s1 = s1.replace('>', '>') |
||
| 718 | return s1 |
||
| 719 | |||
| 720 | |||
| 721 | def quote_attrib(inStr): |
||
| 722 | s1 = (isinstance(inStr, BaseStrType_) and inStr or '%s' % inStr) |
||
| 723 | s1 = s1.replace('&', '&') |
||
| 724 | s1 = s1.replace('<', '<') |
||
| 725 | s1 = s1.replace('>', '>') |
||
| 726 | if '"' in s1: |
||
| 727 | if "'" in s1: |
||
| 728 | s1 = '"%s"' % s1.replace('"', """) |
||
| 729 | else: |
||
| 730 | s1 = "'%s'" % s1 |
||
| 731 | else: |
||
| 732 | s1 = '"%s"' % s1 |
||
| 733 | return s1 |
||
| 734 | |||
| 735 | |||
| 736 | def quote_python(inStr): |
||
| 737 | s1 = inStr |
||
| 738 | if s1.find("'") == -1: |
||
| 739 | if s1.find('\n') == -1: |
||
| 740 | return "'%s'" % s1 |
||
| 741 | else: |
||
| 742 | return "'''%s'''" % s1 |
||
| 743 | else: |
||
| 744 | if s1.find('"') != -1: |
||
| 745 | s1 = s1.replace('"', '\\"') |
||
| 746 | if s1.find('\n') == -1: |
||
| 747 | return '"%s"' % s1 |
||
| 748 | else: |
||
| 749 | return '"""%s"""' % s1 |
||
| 750 | |||
| 751 | |||
| 752 | def get_all_text_(node): |
||
| 753 | if node.text is not None: |
||
| 754 | text = node.text |
||
| 755 | else: |
||
| 756 | text = '' |
||
| 757 | for child in node: |
||
| 758 | if child.tail is not None: |
||
| 759 | text += child.tail |
||
| 760 | return text |
||
| 761 | |||
| 762 | |||
| 763 | def find_attr_value_(attr_name, node): |
||
| 764 | attrs = node.attrib |
||
| 765 | attr_parts = attr_name.split(':') |
||
| 766 | value = None |
||
| 767 | if len(attr_parts) == 1: |
||
| 768 | value = attrs.get(attr_name) |
||
| 769 | elif len(attr_parts) == 2: |
||
| 770 | prefix, name = attr_parts |
||
| 771 | namespace = node.nsmap.get(prefix) |
||
| 772 | if namespace is not None: |
||
| 773 | value = attrs.get('{%s}%s' % (namespace, name, )) |
||
| 774 | return value |
||
| 775 | |||
| 776 | |||
| 777 | def encode_str_2_3(instr): |
||
| 778 | return instr |
||
| 779 | |||
| 780 | |||
| 781 | class GDSParseError(Exception): |
||
| 782 | pass |
||
| 783 | |||
| 784 | |||
| 785 | def raise_parse_error(node, msg): |
||
| 786 | if node is not None: |
||
| 787 | msg = '%s (element %s/line %d)' % (msg, node.tag, node.sourceline, ) |
||
| 788 | raise GDSParseError(msg) |
||
| 789 | |||
| 790 | |||
| 791 | class MixedContainer: |
||
| 792 | # Constants for category: |
||
| 793 | CategoryNone = 0 |
||
| 794 | CategoryText = 1 |
||
| 795 | CategorySimple = 2 |
||
| 796 | CategoryComplex = 3 |
||
| 797 | # Constants for content_type: |
||
| 798 | TypeNone = 0 |
||
| 799 | TypeText = 1 |
||
| 800 | TypeString = 2 |
||
| 801 | TypeInteger = 3 |
||
| 802 | TypeFloat = 4 |
||
| 803 | TypeDecimal = 5 |
||
| 804 | TypeDouble = 6 |
||
| 805 | TypeBoolean = 7 |
||
| 806 | TypeBase64 = 8 |
||
| 807 | def __init__(self, category, content_type, name, value): |
||
| 808 | self.category = category |
||
| 809 | self.content_type = content_type |
||
| 810 | self.name = name |
||
| 811 | self.value = value |
||
| 812 | def getCategory(self): |
||
| 813 | return self.category |
||
| 814 | def getContenttype(self, content_type): |
||
| 815 | return self.content_type |
||
| 816 | def getValue(self): |
||
| 817 | return self.value |
||
| 818 | def getName(self): |
||
| 819 | return self.name |
||
| 820 | def export(self, outfile, level, name, namespace, |
||
| 821 | pretty_print=True): |
||
| 822 | if self.category == MixedContainer.CategoryText: |
||
| 823 | # Prevent exporting empty content as empty lines. |
||
| 824 | if self.value.strip(): |
||
| 825 | outfile.write(self.value) |
||
| 826 | elif self.category == MixedContainer.CategorySimple: |
||
| 827 | self.exportSimple(outfile, level, name) |
||
| 828 | else: # category == MixedContainer.CategoryComplex |
||
| 829 | self.value.export( |
||
| 830 | outfile, level, namespace, name_=name, |
||
| 831 | pretty_print=pretty_print) |
||
| 832 | def exportSimple(self, outfile, level, name): |
||
| 833 | if self.content_type == MixedContainer.TypeString: |
||
| 834 | outfile.write('<%s>%s</%s>' % ( |
||
| 835 | self.name, self.value, self.name)) |
||
| 836 | elif self.content_type == MixedContainer.TypeInteger or \ |
||
| 837 | self.content_type == MixedContainer.TypeBoolean: |
||
| 838 | outfile.write('<%s>%d</%s>' % ( |
||
| 839 | self.name, self.value, self.name)) |
||
| 840 | elif self.content_type == MixedContainer.TypeFloat or \ |
||
| 841 | self.content_type == MixedContainer.TypeDecimal: |
||
| 842 | outfile.write('<%s>%f</%s>' % ( |
||
| 843 | self.name, self.value, self.name)) |
||
| 844 | elif self.content_type == MixedContainer.TypeDouble: |
||
| 845 | outfile.write('<%s>%g</%s>' % ( |
||
| 846 | self.name, self.value, self.name)) |
||
| 847 | elif self.content_type == MixedContainer.TypeBase64: |
||
| 848 | outfile.write('<%s>%s</%s>' % ( |
||
| 849 | self.name, |
||
| 850 | base64.b64encode(self.value), |
||
| 851 | self.name)) |
||
| 852 | def to_etree(self, element, mapping_=None, nsmap_=None): |
||
| 853 | if self.category == MixedContainer.CategoryText: |
||
| 854 | # Prevent exporting empty content as empty lines. |
||
| 855 | if self.value.strip(): |
||
| 856 | if len(element) > 0: |
||
| 857 | if element[-1].tail is None: |
||
| 858 | element[-1].tail = self.value |
||
| 859 | else: |
||
| 860 | element[-1].tail += self.value |
||
| 861 | else: |
||
| 862 | if element.text is None: |
||
| 863 | element.text = self.value |
||
| 864 | else: |
||
| 865 | element.text += self.value |
||
| 866 | elif self.category == MixedContainer.CategorySimple: |
||
| 867 | subelement = etree_.SubElement( |
||
| 868 | element, '%s' % self.name) |
||
| 869 | subelement.text = self.to_etree_simple() |
||
| 870 | else: # category == MixedContainer.CategoryComplex |
||
| 871 | self.value.to_etree(element) |
||
| 872 | def to_etree_simple(self, mapping_=None, nsmap_=None): |
||
| 873 | if self.content_type == MixedContainer.TypeString: |
||
| 874 | text = self.value |
||
| 875 | elif (self.content_type == MixedContainer.TypeInteger or |
||
| 876 | self.content_type == MixedContainer.TypeBoolean): |
||
| 877 | text = '%d' % self.value |
||
| 878 | elif (self.content_type == MixedContainer.TypeFloat or |
||
| 879 | self.content_type == MixedContainer.TypeDecimal): |
||
| 880 | text = '%f' % self.value |
||
| 881 | elif self.content_type == MixedContainer.TypeDouble: |
||
| 882 | text = '%g' % self.value |
||
| 883 | elif self.content_type == MixedContainer.TypeBase64: |
||
| 884 | text = '%s' % base64.b64encode(self.value) |
||
| 885 | return text |
||
| 886 | def exportLiteral(self, outfile, level, name): |
||
| 887 | if self.category == MixedContainer.CategoryText: |
||
| 888 | showIndent(outfile, level) |
||
| 889 | outfile.write( |
||
| 890 | 'model_.MixedContainer(%d, %d, "%s", "%s"),\n' % ( |
||
| 891 | self.category, self.content_type, |
||
| 892 | self.name, self.value)) |
||
| 893 | elif self.category == MixedContainer.CategorySimple: |
||
| 894 | showIndent(outfile, level) |
||
| 895 | outfile.write( |
||
| 896 | 'model_.MixedContainer(%d, %d, "%s", "%s"),\n' % ( |
||
| 897 | self.category, self.content_type, |
||
| 898 | self.name, self.value)) |
||
| 899 | else: # category == MixedContainer.CategoryComplex |
||
| 900 | showIndent(outfile, level) |
||
| 901 | outfile.write( |
||
| 902 | 'model_.MixedContainer(%d, %d, "%s",\n' % ( |
||
| 903 | self.category, self.content_type, self.name,)) |
||
| 904 | self.value.exportLiteral(outfile, level + 1) |
||
| 905 | showIndent(outfile, level) |
||
| 906 | outfile.write(')\n') |
||
| 907 | |||
| 908 | |||
| 909 | class MemberSpec_(object): |
||
| 910 | def __init__(self, name='', data_type='', container=0, |
||
| 911 | optional=0, child_attrs=None, choice=None): |
||
| 912 | self.name = name |
||
| 913 | self.data_type = data_type |
||
| 914 | self.container = container |
||
| 915 | self.child_attrs = child_attrs |
||
| 916 | self.choice = choice |
||
| 917 | self.optional = optional |
||
| 918 | def set_name(self, name): self.name = name |
||
| 919 | def get_name(self): return self.name |
||
| 920 | def set_data_type(self, data_type): self.data_type = data_type |
||
| 921 | def get_data_type_chain(self): return self.data_type |
||
| 922 | def get_data_type(self): |
||
| 923 | if isinstance(self.data_type, list): |
||
| 924 | if len(self.data_type) > 0: |
||
| 925 | return self.data_type[-1] |
||
| 926 | else: |
||
| 927 | return 'xs:string' |
||
| 928 | else: |
||
| 929 | return self.data_type |
||
| 930 | def set_container(self, container): self.container = container |
||
| 931 | def get_container(self): return self.container |
||
| 932 | def set_child_attrs(self, child_attrs): self.child_attrs = child_attrs |
||
| 933 | def get_child_attrs(self): return self.child_attrs |
||
| 934 | def set_choice(self, choice): self.choice = choice |
||
| 935 | def get_choice(self): return self.choice |
||
| 936 | def set_optional(self, optional): self.optional = optional |
||
| 937 | def get_optional(self): return self.optional |
||
| 938 | |||
| 939 | |||
| 940 | def _cast(typ, value): |
||
| 941 | if typ is None or value is None: |
||
| 942 | return value |
||
| 943 | return typ(value) |
||
| 944 | |||
| 945 | # |
||
| 946 | # Data representation classes. |
||
| 947 | # |
||
| 948 | |||
| 949 | |||
| 950 | class AlignSimpleType(str, Enum): |
||
| 951 | LEFT='left' |
||
| 952 | CENTRE='centre' |
||
| 953 | RIGHT='right' |
||
| 954 | JUSTIFY='justify' |
||
| 955 | |||
| 956 | |||
| 957 | class ChartTypeSimpleType(str, Enum): |
||
| 958 | BAR='bar' |
||
| 959 | LINE='line' |
||
| 960 | PIE='pie' |
||
| 961 | SCATTER='scatter' |
||
| 962 | SURFACE='surface' |
||
| 963 | OTHER='other' |
||
| 964 | |||
| 965 | |||
| 966 | class ColourDepthSimpleType(str, Enum): |
||
| 967 | BILEVEL='bilevel' |
||
| 968 | GREYSCALE='greyscale' |
||
| 969 | COLOUR='colour' |
||
| 970 | OTHER='other' |
||
| 971 | |||
| 972 | |||
| 973 | class ColourSimpleType(str, Enum): |
||
| 974 | BLACK='black' |
||
| 975 | BLUE='blue' |
||
| 976 | BROWN='brown' |
||
| 977 | CYAN='cyan' |
||
| 978 | GREEN='green' |
||
| 979 | GREY='grey' |
||
| 980 | INDIGO='indigo' |
||
| 981 | MAGENTA='magenta' |
||
| 982 | ORANGE='orange' |
||
| 983 | PINK='pink' |
||
| 984 | RED='red' |
||
| 985 | TURQUOISE='turquoise' |
||
| 986 | VIOLET='violet' |
||
| 987 | WHITE='white' |
||
| 988 | YELLOW='yellow' |
||
| 989 | OTHER='other' |
||
| 990 | |||
| 991 | |||
| 992 | class GraphicsTypeSimpleType(str, Enum): |
||
| 993 | LOGO='logo' |
||
| 994 | LETTERHEAD='letterhead' |
||
| 995 | DECORATION='decoration' |
||
| 996 | FRAME='frame' |
||
| 997 | HANDWRITTENANNOTATION='handwritten-annotation' |
||
| 998 | STAMP='stamp' |
||
| 999 | SIGNATURE='signature' |
||
| 1000 | BARCODE='barcode' |
||
| 1001 | PAPERGROW='paper-grow' |
||
| 1002 | PUNCHHOLE='punch-hole' |
||
| 1003 | OTHER='other' |
||
| 1004 | |||
| 1005 | |||
| 1006 | class GroupTypeSimpleType(str, Enum): |
||
| 1007 | PARAGRAPH='paragraph' |
||
| 1008 | LIST='list' |
||
| 1009 | LISTITEM='list-item' |
||
| 1010 | FIGURE='figure' |
||
| 1011 | ARTICLE='article' |
||
| 1012 | DIV='div' |
||
| 1013 | OTHER='other' |
||
| 1014 | |||
| 1015 | |||
| 1016 | class PageTypeSimpleType(str, Enum): |
||
| 1017 | FRONTCOVER='front-cover' |
||
| 1018 | BACKCOVER='back-cover' |
||
| 1019 | TITLE='title' |
||
| 1020 | TABLEOFCONTENTS='table-of-contents' |
||
| 1021 | INDEX='index' |
||
| 1022 | CONTENT='content' |
||
| 1023 | BLANK='blank' |
||
| 1024 | OTHER='other' |
||
| 1025 | |||
| 1026 | |||
| 1027 | class ProductionSimpleType(str, Enum): |
||
| 1028 | """Text production type""" |
||
| 1029 | PRINTED='printed' |
||
| 1030 | TYPEWRITTEN='typewritten' |
||
| 1031 | HANDWRITTENCURSIVE='handwritten-cursive' |
||
| 1032 | HANDWRITTENPRINTSCRIPT='handwritten-printscript' |
||
| 1033 | MEDIEVALMANUSCRIPT='medieval-manuscript' |
||
| 1034 | OTHER='other' |
||
| 1035 | |||
| 1036 | |||
| 1037 | class ReadingDirectionSimpleType(str, Enum): |
||
| 1038 | LEFTTORIGHT='left-to-right' |
||
| 1039 | RIGHTTOLEFT='right-to-left' |
||
| 1040 | TOPTOBOTTOM='top-to-bottom' |
||
| 1041 | BOTTOMTOTOP='bottom-to-top' |
||
| 1042 | |||
| 1043 | |||
| 1044 | class TextDataTypeSimpleType(str, Enum): |
||
| 1045 | XSDDECIMAL='xsd:decimal' # Examples: "123.456", "+1234.456", "-1234.456", "-.456", "-456" |
||
| 1046 | XSDFLOAT='xsd:float' # Examples: "123.456", "+1234.456", "-1.2344e56", "-.45E-6", "INF", "-INF", "NaN" |
||
| 1047 | XSDINTEGER='xsd:integer' # Examples: "123456", "+00000012", "-1", "-456" |
||
| 1048 | XSDBOOLEAN='xsd:boolean' # Examples: "true", "false", "1", "0" |
||
| 1049 | XSDDATE='xsd:date' # Examples: "2001-10-26", "2001-10-26+02:00", "2001-10-26Z", "2001-10-26+00:00", "-2001-10-26", "-20000-04-01" |
||
| 1050 | XSDTIME='xsd:time' # Examples: "21:32:52", "21:32:52+02:00", "19:32:52Z", "19:32:52+00:00", "21:32:52.12679" |
||
| 1051 | XSDDATE_TIME='xsd:dateTime' # Examples: "2001-10-26T21:32:52", "2001-10-26T21:32:52+02:00", "2001-10-26T19:32:52Z", "2001-10-26T19:32:52+00:00", "-2001-10-26T21:32:52", "2001-10-26T21:32:52.12679" |
||
| 1052 | XSDSTRING='xsd:string' # Generic text string |
||
| 1053 | OTHER='other' # An XSD type that is not listed or a custom type (use dataTypeDetails attribute). |
||
| 1054 | |||
| 1055 | |||
| 1056 | class TextLineOrderSimpleType(str, Enum): |
||
| 1057 | TOPTOBOTTOM='top-to-bottom' |
||
| 1058 | BOTTOMTOTOP='bottom-to-top' |
||
| 1059 | LEFTTORIGHT='left-to-right' |
||
| 1060 | RIGHTTOLEFT='right-to-left' |
||
| 1061 | |||
| 1062 | |||
| 1063 | class TextTypeSimpleType(str, Enum): |
||
| 1064 | PARAGRAPH='paragraph' |
||
| 1065 | HEADING='heading' |
||
| 1066 | CAPTION='caption' |
||
| 1067 | HEADER='header' |
||
| 1068 | FOOTER='footer' |
||
| 1069 | PAGENUMBER='page-number' |
||
| 1070 | DROPCAPITAL='drop-capital' |
||
| 1071 | CREDIT='credit' |
||
| 1072 | FLOATING='floating' |
||
| 1073 | SIGNATUREMARK='signature-mark' |
||
| 1074 | CATCHWORD='catch-word' |
||
| 1075 | MARGINALIA='marginalia' |
||
| 1076 | FOOTNOTE='footnote' |
||
| 1077 | FOOTNOTECONTINUED='footnote-continued' |
||
| 1078 | ENDNOTE='endnote' |
||
| 1079 | TOCENTRY='TOC-entry' |
||
| 1080 | LISTLABEL='list-label' |
||
| 1081 | OTHER='other' |
||
| 1082 | |||
| 1083 | |||
| 1084 | class UnderlineStyleSimpleType(str, Enum): |
||
| 1085 | SINGLE_LINE='singleLine' |
||
| 1086 | DOUBLE_LINE='doubleLine' |
||
| 1087 | OTHER='other' |
||
| 1088 | |||
| 1089 | |||
| 1090 | class PcGtsType(GeneratedsSuper): |
||
| 1091 | __hash__ = GeneratedsSuper.__hash__ |
||
| 1092 | member_data_items_ = [ |
||
| 1093 | MemberSpec_('pcGtsId', 'string', 0, 1, {'use': 'optional'}), |
||
| 1094 | MemberSpec_('Metadata', 'MetadataType', 0, 0, {'name': 'Metadata', 'type': 'MetadataType'}, None), |
||
| 1095 | MemberSpec_('Page', 'PageType', 0, 0, {'name': 'Page', 'type': 'PageType'}, None), |
||
| 1096 | ] |
||
| 1097 | subclass = None |
||
| 1098 | superclass = None |
||
| 1099 | def __init__(self, pcGtsId=None, Metadata=None, Page=None, gds_collector_=None, **kwargs_): |
||
| 1100 | self.gds_collector_ = gds_collector_ |
||
| 1101 | self.gds_elementtree_node_ = None |
||
| 1102 | self.original_tagname_ = None |
||
| 1103 | self.parent_object_ = kwargs_.get('parent_object_') |
||
| 1104 | self.ns_prefix_ = None |
||
| 1105 | self.pcGtsId = _cast(None, pcGtsId) |
||
| 1106 | self.pcGtsId_nsprefix_ = "pc" |
||
| 1107 | self.Metadata = Metadata |
||
| 1108 | self.Metadata_nsprefix_ = "pc" |
||
| 1109 | self.Page = Page |
||
| 1110 | self.Page_nsprefix_ = "pc" |
||
| 1111 | def factory(*args_, **kwargs_): |
||
| 1112 | if CurrentSubclassModule_ is not None: |
||
| 1113 | subclass = getSubclassFromModule_( |
||
| 1114 | CurrentSubclassModule_, PcGtsType) |
||
| 1115 | if subclass is not None: |
||
| 1116 | return subclass(*args_, **kwargs_) |
||
| 1117 | if PcGtsType.subclass: |
||
| 1118 | return PcGtsType.subclass(*args_, **kwargs_) |
||
| 1119 | else: |
||
| 1120 | return PcGtsType(*args_, **kwargs_) |
||
| 1121 | factory = staticmethod(factory) |
||
| 1122 | def get_ns_prefix_(self): |
||
| 1123 | return self.ns_prefix_ |
||
| 1124 | def set_ns_prefix_(self, ns_prefix): |
||
| 1125 | self.ns_prefix_ = ns_prefix |
||
| 1126 | def get_Metadata(self): |
||
| 1127 | return self.Metadata |
||
| 1128 | def set_Metadata(self, Metadata): |
||
| 1129 | self.Metadata = Metadata |
||
| 1130 | def get_Page(self): |
||
| 1131 | return self.Page |
||
| 1132 | def set_Page(self, Page): |
||
| 1133 | self.Page = Page |
||
| 1134 | def get_pcGtsId(self): |
||
| 1135 | return self.pcGtsId |
||
| 1136 | def set_pcGtsId(self, pcGtsId): |
||
| 1137 | self.pcGtsId = pcGtsId |
||
| 1138 | def hasContent_(self): |
||
| 1139 | if ( |
||
| 1140 | self.Metadata is not None or |
||
| 1141 | self.Page is not None |
||
| 1142 | ): |
||
| 1143 | return True |
||
| 1144 | else: |
||
| 1145 | return False |
||
| 1146 | def export(self, outfile, level, namespaceprefix_='', namespacedef_='xmlns:pc="http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15"', name_='PcGtsType', pretty_print=True): |
||
| 1147 | imported_ns_def_ = GenerateDSNamespaceDefs_.get('PcGtsType') |
||
| 1148 | if imported_ns_def_ is not None: |
||
| 1149 | namespacedef_ = imported_ns_def_ |
||
| 1150 | if pretty_print: |
||
| 1151 | eol_ = '\n' |
||
| 1152 | else: |
||
| 1153 | eol_ = '' |
||
| 1154 | if self.original_tagname_ is not None and name_ == 'PcGtsType': |
||
| 1155 | name_ = self.original_tagname_ |
||
| 1156 | if UseCapturedNS_ and self.ns_prefix_: |
||
| 1157 | namespaceprefix_ = self.ns_prefix_ + ':' |
||
| 1158 | showIndent(outfile, level, pretty_print) |
||
| 1159 | outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) |
||
| 1160 | already_processed = set() |
||
| 1161 | self.exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='PcGtsType') |
||
| 1162 | if self.hasContent_(): |
||
| 1163 | outfile.write('>%s' % (eol_, )) |
||
| 1164 | self.exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='PcGtsType', pretty_print=pretty_print) |
||
| 1165 | showIndent(outfile, level, pretty_print) |
||
| 1166 | outfile.write('</%s%s>%s' % (namespaceprefix_, name_, eol_)) |
||
| 1167 | else: |
||
| 1168 | outfile.write('/>%s' % (eol_, )) |
||
| 1169 | def exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='PcGtsType'): |
||
| 1170 | if self.pcGtsId is not None and 'pcGtsId' not in already_processed: |
||
| 1171 | already_processed.add('pcGtsId') |
||
| 1172 | outfile.write(' pcGtsId=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.pcGtsId), input_name='pcGtsId')), )) |
||
| 1173 | def exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='xmlns:pc="http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15"', name_='PcGtsType', fromsubclass_=False, pretty_print=True): |
||
| 1174 | if pretty_print: |
||
| 1175 | eol_ = '\n' |
||
| 1176 | else: |
||
| 1177 | eol_ = '' |
||
| 1178 | if self.Metadata is not None: |
||
| 1179 | namespaceprefix_ = self.Metadata_nsprefix_ + ':' if (UseCapturedNS_ and self.Metadata_nsprefix_) else '' |
||
| 1180 | self.Metadata.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Metadata', pretty_print=pretty_print) |
||
| 1181 | if self.Page is not None: |
||
| 1182 | namespaceprefix_ = self.Page_nsprefix_ + ':' if (UseCapturedNS_ and self.Page_nsprefix_) else '' |
||
| 1183 | self.Page.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Page', pretty_print=pretty_print) |
||
| 1184 | def to_etree(self, parent_element=None, name_='PcGtsType', mapping_=None, nsmap_=None): |
||
| 1185 | if parent_element is None: |
||
| 1186 | element = etree_.Element('{http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15}' + name_, nsmap=nsmap_) |
||
| 1187 | else: |
||
| 1188 | element = etree_.SubElement(parent_element, '{http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15}' + name_, nsmap=nsmap_) |
||
| 1189 | if self.pcGtsId is not None: |
||
| 1190 | element.set('pcGtsId', self.gds_format_string(self.pcGtsId)) |
||
| 1191 | if self.Metadata is not None: |
||
| 1192 | Metadata_ = self.Metadata |
||
| 1193 | Metadata_.to_etree(element, name_='Metadata', mapping_=mapping_, nsmap_=nsmap_) |
||
| 1194 | if self.Page is not None: |
||
| 1195 | Page_ = self.Page |
||
| 1196 | Page_.to_etree(element, name_='Page', mapping_=mapping_, nsmap_=nsmap_) |
||
| 1197 | if mapping_ is not None: |
||
| 1198 | mapping_[id(self)] = element |
||
| 1199 | return element |
||
| 1200 | def build(self, node, gds_collector_=None): |
||
| 1201 | self.gds_collector_ = gds_collector_ |
||
| 1202 | if SaveElementTreeNode: |
||
| 1203 | self.gds_elementtree_node_ = node |
||
| 1204 | already_processed = set() |
||
| 1205 | self.ns_prefix_ = node.prefix |
||
| 1206 | self.buildAttributes(node, node.attrib, already_processed) |
||
| 1207 | for child in node: |
||
| 1208 | nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] |
||
| 1209 | self.buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) |
||
| 1210 | return self |
||
| 1211 | def buildAttributes(self, node, attrs, already_processed): |
||
| 1212 | value = find_attr_value_('pcGtsId', node) |
||
| 1213 | if value is not None and 'pcGtsId' not in already_processed: |
||
| 1214 | already_processed.add('pcGtsId') |
||
| 1215 | self.pcGtsId = value |
||
| 1216 | def buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None): |
||
| 1217 | if nodeName_ == 'Metadata': |
||
| 1218 | obj_ = MetadataType.factory(parent_object_=self) |
||
| 1219 | obj_.build(child_, gds_collector_=gds_collector_) |
||
| 1220 | self.Metadata = obj_ |
||
| 1221 | obj_.original_tagname_ = 'Metadata' |
||
| 1222 | elif nodeName_ == 'Page': |
||
| 1223 | obj_ = PageType.factory(parent_object_=self) |
||
| 1224 | obj_.build(child_, gds_collector_=gds_collector_) |
||
| 1225 | self.Page = obj_ |
||
| 1226 | obj_.original_tagname_ = 'Page' |
||
| 1227 | def __hash__(self): |
||
| 1228 | return hash(self.id) |
||
| 1229 | @property |
||
| 1230 | def id(self): |
||
| 1231 | if hasattr(self, 'pcGtsId'): |
||
| 1232 | return self.pcGtsId or '' |
||
| 1233 | return self.imageFilename |
||
| 1234 | View Code Duplication | def get_AllAlternativeImagePaths(self, page=True, region=True, line=True, word=True, glyph=True): |
|
| 1235 | """ |
||
| 1236 | Get all the ``pc:AlternativeImage/@filename`` paths referenced in the PAGE-XML document. |
||
| 1237 | |||
| 1238 | Arguments: |
||
| 1239 | page (boolean): Get images on ``pc:Page`` level |
||
| 1240 | region (boolean): Get images on ``pc:*Region`` level |
||
| 1241 | line (boolean): Get images on ``pc:TextLine`` level |
||
| 1242 | word (boolean): Get images on ``pc:Word`` level |
||
| 1243 | glyph (boolean): Get images on ``pc:Glyph`` level |
||
| 1244 | |||
| 1245 | Returns: |
||
| 1246 | a list of image filename strings |
||
| 1247 | """ |
||
| 1248 | from .constants import NAMESPACES, PAGE_REGION_TYPES # pylint: disable=relative-beyond-top-level,import-outside-toplevel |
||
| 1249 | from io import StringIO # pylint: disable=import-outside-toplevel |
||
| 1250 | ret = [] |
||
| 1251 | # XXX Since we're only interested in the **paths** of the images, |
||
| 1252 | # export, parse and xpath are less convoluted than traversing |
||
| 1253 | # the generateDS API. Quite possibly not as efficient as could be. |
||
| 1254 | sio = StringIO() |
||
| 1255 | self.export( |
||
| 1256 | outfile=sio, |
||
| 1257 | level=0, |
||
| 1258 | name_='PcGts', |
||
| 1259 | namespaceprefix_='pc:', |
||
| 1260 | namespacedef_='xmlns:pc="%s" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="%s %s/pagecontent.xsd"' % ( |
||
| 1261 | NAMESPACES['page'], |
||
| 1262 | NAMESPACES['page'], |
||
| 1263 | NAMESPACES['page'] |
||
| 1264 | )) |
||
| 1265 | doc = parsexmlstring_(sio.getvalue()) # pylint: disable=undefined-variable |
||
| 1266 | # shortcut |
||
| 1267 | if page and region and line and word and glyph: |
||
| 1268 | ret += doc.xpath('//page:AlternativeImage/@filename', namespaces=NAMESPACES) |
||
| 1269 | else: |
||
| 1270 | if page: |
||
| 1271 | ret += doc.xpath('/page:PcGts/page:Page/page:AlternativeImage/@filename', namespaces=NAMESPACES) |
||
| 1272 | if region: |
||
| 1273 | for class_ in PAGE_REGION_TYPES: |
||
| 1274 | ret += doc.xpath('//page:%sRegion/page:AlternativeImage/@filename' % class_, namespaces=NAMESPACES) |
||
| 1275 | if line: |
||
| 1276 | ret += doc.xpath('//page:TextLine/page:AlternativeImage/@filename', namespaces=NAMESPACES) |
||
| 1277 | if word: |
||
| 1278 | ret += doc.xpath('//page:Word/page:AlternativeImage/@filename', namespaces=NAMESPACES) |
||
| 1279 | if glyph: |
||
| 1280 | ret += doc.xpath('//page:Glyph/page:AlternativeImage/@filename', namespaces=NAMESPACES) |
||
| 1281 | |||
| 1282 | return ret |
||
| 1283 | View Code Duplication | def prune_ReadingOrder(self): |
|
| 1284 | """ |
||
| 1285 | Remove any empty ReadingOrder elements |
||
| 1286 | """ |
||
| 1287 | ro = self.get_Page().get_ReadingOrder() |
||
| 1288 | if ro: |
||
| 1289 | og = ro.get_OrderedGroup() |
||
| 1290 | if og and (not og.get_RegionRefIndexed() and |
||
| 1291 | not og.get_OrderedGroupIndexed() and |
||
| 1292 | not og.get_UnorderedGroupIndexed()): |
||
| 1293 | og = None |
||
| 1294 | ug = ro.get_UnorderedGroup() |
||
| 1295 | if ug and (not ug.get_RegionRef() and |
||
| 1296 | not ug.get_OrderedGroup() and |
||
| 1297 | not ug.get_UnorderedGroup()): |
||
| 1298 | ug = None |
||
| 1299 | if not og and not ug: |
||
| 1300 | self.get_Page().set_ReadingOrder(None) |
||
| 1301 | # end class PcGtsType |
||
| 1302 | |||
| 1303 | |||
| 1304 | class MetadataType(GeneratedsSuper): |
||
| 1305 | """External reference of any kind""" |
||
| 1306 | __hash__ = GeneratedsSuper.__hash__ |
||
| 1307 | member_data_items_ = [ |
||
| 1308 | MemberSpec_('externalRef', 'string', 0, 1, {'use': 'optional'}), |
||
| 1309 | MemberSpec_('Creator', 'string', 0, 0, {'name': 'Creator', 'type': 'string'}, None), |
||
| 1310 | MemberSpec_('Created', 'dateTime', 0, 0, {'name': 'Created', 'type': 'dateTime'}, None), |
||
| 1311 | MemberSpec_('LastChange', 'dateTime', 0, 0, {'name': 'LastChange', 'type': 'dateTime'}, None), |
||
| 1312 | MemberSpec_('Comments', 'string', 0, 1, {'maxOccurs': '1', 'minOccurs': '0', 'name': 'Comments', 'type': 'string'}, None), |
||
| 1313 | MemberSpec_('UserDefined', 'UserDefinedType', 0, 1, {'maxOccurs': '1', 'minOccurs': '0', 'name': 'UserDefined', 'type': 'UserDefinedType'}, None), |
||
| 1314 | MemberSpec_('MetadataItem', 'MetadataItemType', 1, 1, {'maxOccurs': 'unbounded', 'minOccurs': '0', 'name': 'MetadataItem', 'type': 'MetadataItemType'}, None), |
||
| 1315 | ] |
||
| 1316 | subclass = None |
||
| 1317 | superclass = None |
||
| 1318 | def __init__(self, externalRef=None, Creator=None, Created=None, LastChange=None, Comments=None, UserDefined=None, MetadataItem=None, gds_collector_=None, **kwargs_): |
||
| 1319 | self.gds_collector_ = gds_collector_ |
||
| 1320 | self.gds_elementtree_node_ = None |
||
| 1321 | self.original_tagname_ = None |
||
| 1322 | self.parent_object_ = kwargs_.get('parent_object_') |
||
| 1323 | self.ns_prefix_ = None |
||
| 1324 | self.externalRef = _cast(None, externalRef) |
||
| 1325 | self.externalRef_nsprefix_ = "pc" |
||
| 1326 | self.Creator = Creator |
||
| 1327 | self.Creator_nsprefix_ = "pc" |
||
| 1328 | if isinstance(Created, BaseStrType_): |
||
| 1329 | initvalue_ = datetime_.datetime.strptime(Created, '%Y-%m-%dT%H:%M:%S') |
||
| 1330 | else: |
||
| 1331 | initvalue_ = Created |
||
| 1332 | self.Created = initvalue_ |
||
| 1333 | self.Created_nsprefix_ = "pc" |
||
| 1334 | if isinstance(LastChange, BaseStrType_): |
||
| 1335 | initvalue_ = datetime_.datetime.strptime(LastChange, '%Y-%m-%dT%H:%M:%S') |
||
| 1336 | else: |
||
| 1337 | initvalue_ = LastChange |
||
| 1338 | self.LastChange = initvalue_ |
||
| 1339 | self.LastChange_nsprefix_ = "pc" |
||
| 1340 | self.Comments = Comments |
||
| 1341 | self.Comments_nsprefix_ = "pc" |
||
| 1342 | self.UserDefined = UserDefined |
||
| 1343 | self.UserDefined_nsprefix_ = "pc" |
||
| 1344 | if MetadataItem is None: |
||
| 1345 | self.MetadataItem = [] |
||
| 1346 | else: |
||
| 1347 | self.MetadataItem = MetadataItem |
||
| 1348 | self.MetadataItem_nsprefix_ = "pc" |
||
| 1349 | def factory(*args_, **kwargs_): |
||
| 1350 | if CurrentSubclassModule_ is not None: |
||
| 1351 | subclass = getSubclassFromModule_( |
||
| 1352 | CurrentSubclassModule_, MetadataType) |
||
| 1353 | if subclass is not None: |
||
| 1354 | return subclass(*args_, **kwargs_) |
||
| 1355 | if MetadataType.subclass: |
||
| 1356 | return MetadataType.subclass(*args_, **kwargs_) |
||
| 1357 | else: |
||
| 1358 | return MetadataType(*args_, **kwargs_) |
||
| 1359 | factory = staticmethod(factory) |
||
| 1360 | def get_ns_prefix_(self): |
||
| 1361 | return self.ns_prefix_ |
||
| 1362 | def set_ns_prefix_(self, ns_prefix): |
||
| 1363 | self.ns_prefix_ = ns_prefix |
||
| 1364 | def get_Creator(self): |
||
| 1365 | return self.Creator |
||
| 1366 | def set_Creator(self, Creator): |
||
| 1367 | self.Creator = Creator |
||
| 1368 | def get_Created(self): |
||
| 1369 | return self.Created |
||
| 1370 | def set_Created(self, Created): |
||
| 1371 | self.Created = Created |
||
| 1372 | def get_LastChange(self): |
||
| 1373 | return self.LastChange |
||
| 1374 | def set_LastChange(self, LastChange): |
||
| 1375 | self.LastChange = LastChange |
||
| 1376 | def get_Comments(self): |
||
| 1377 | return self.Comments |
||
| 1378 | def set_Comments(self, Comments): |
||
| 1379 | self.Comments = Comments |
||
| 1380 | def get_UserDefined(self): |
||
| 1381 | return self.UserDefined |
||
| 1382 | def set_UserDefined(self, UserDefined): |
||
| 1383 | self.UserDefined = UserDefined |
||
| 1384 | def get_MetadataItem(self): |
||
| 1385 | return self.MetadataItem |
||
| 1386 | def set_MetadataItem(self, MetadataItem): |
||
| 1387 | self.MetadataItem = MetadataItem |
||
| 1388 | def add_MetadataItem(self, value): |
||
| 1389 | self.MetadataItem.append(value) |
||
| 1390 | def insert_MetadataItem_at(self, index, value): |
||
| 1391 | self.MetadataItem.insert(index, value) |
||
| 1392 | def replace_MetadataItem_at(self, index, value): |
||
| 1393 | self.MetadataItem[index] = value |
||
| 1394 | def get_externalRef(self): |
||
| 1395 | return self.externalRef |
||
| 1396 | def set_externalRef(self, externalRef): |
||
| 1397 | self.externalRef = externalRef |
||
| 1398 | def hasContent_(self): |
||
| 1399 | if ( |
||
| 1400 | self.Creator is not None or |
||
| 1401 | self.Created is not None or |
||
| 1402 | self.LastChange is not None or |
||
| 1403 | self.Comments is not None or |
||
| 1404 | self.UserDefined is not None or |
||
| 1405 | self.MetadataItem |
||
| 1406 | ): |
||
| 1407 | return True |
||
| 1408 | else: |
||
| 1409 | return False |
||
| 1410 | def export(self, outfile, level, namespaceprefix_='', namespacedef_='xmlns:pc="http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15" xmlns:None="http://www.w3.org/2001/XMLSchema" ', name_='MetadataType', pretty_print=True): |
||
| 1411 | imported_ns_def_ = GenerateDSNamespaceDefs_.get('MetadataType') |
||
| 1412 | if imported_ns_def_ is not None: |
||
| 1413 | namespacedef_ = imported_ns_def_ |
||
| 1414 | if pretty_print: |
||
| 1415 | eol_ = '\n' |
||
| 1416 | else: |
||
| 1417 | eol_ = '' |
||
| 1418 | if self.original_tagname_ is not None and name_ == 'MetadataType': |
||
| 1419 | name_ = self.original_tagname_ |
||
| 1420 | if UseCapturedNS_ and self.ns_prefix_: |
||
| 1421 | namespaceprefix_ = self.ns_prefix_ + ':' |
||
| 1422 | showIndent(outfile, level, pretty_print) |
||
| 1423 | outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) |
||
| 1424 | already_processed = set() |
||
| 1425 | self.exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='MetadataType') |
||
| 1426 | if self.hasContent_(): |
||
| 1427 | outfile.write('>%s' % (eol_, )) |
||
| 1428 | self.exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='MetadataType', pretty_print=pretty_print) |
||
| 1429 | showIndent(outfile, level, pretty_print) |
||
| 1430 | outfile.write('</%s%s>%s' % (namespaceprefix_, name_, eol_)) |
||
| 1431 | else: |
||
| 1432 | outfile.write('/>%s' % (eol_, )) |
||
| 1433 | def exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='MetadataType'): |
||
| 1434 | if self.externalRef is not None and 'externalRef' not in already_processed: |
||
| 1435 | already_processed.add('externalRef') |
||
| 1436 | outfile.write(' externalRef=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.externalRef), input_name='externalRef')), )) |
||
| 1437 | def exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='xmlns:pc="http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15" xmlns:None="http://www.w3.org/2001/XMLSchema" ', name_='MetadataType', fromsubclass_=False, pretty_print=True): |
||
| 1438 | if pretty_print: |
||
| 1439 | eol_ = '\n' |
||
| 1440 | else: |
||
| 1441 | eol_ = '' |
||
| 1442 | if self.Creator is not None: |
||
| 1443 | namespaceprefix_ = self.Creator_nsprefix_ + ':' if (UseCapturedNS_ and self.Creator_nsprefix_) else '' |
||
| 1444 | showIndent(outfile, level, pretty_print) |
||
| 1445 | outfile.write('<%sCreator>%s</%sCreator>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.Creator), input_name='Creator')), namespaceprefix_ , eol_)) |
||
| 1446 | if self.Created is not None: |
||
| 1447 | namespaceprefix_ = self.Created_nsprefix_ + ':' if (UseCapturedNS_ and self.Created_nsprefix_) else '' |
||
| 1448 | showIndent(outfile, level, pretty_print) |
||
| 1449 | outfile.write('<%sCreated>%s</%sCreated>%s' % (namespaceprefix_ , self.gds_format_datetime(self.Created, input_name='Created'), namespaceprefix_ , eol_)) |
||
| 1450 | if self.LastChange is not None: |
||
| 1451 | namespaceprefix_ = self.LastChange_nsprefix_ + ':' if (UseCapturedNS_ and self.LastChange_nsprefix_) else '' |
||
| 1452 | showIndent(outfile, level, pretty_print) |
||
| 1453 | outfile.write('<%sLastChange>%s</%sLastChange>%s' % (namespaceprefix_ , self.gds_format_datetime(self.LastChange, input_name='LastChange'), namespaceprefix_ , eol_)) |
||
| 1454 | if self.Comments is not None: |
||
| 1455 | namespaceprefix_ = self.Comments_nsprefix_ + ':' if (UseCapturedNS_ and self.Comments_nsprefix_) else '' |
||
| 1456 | showIndent(outfile, level, pretty_print) |
||
| 1457 | outfile.write('<%sComments>%s</%sComments>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.Comments), input_name='Comments')), namespaceprefix_ , eol_)) |
||
| 1458 | if self.UserDefined is not None: |
||
| 1459 | namespaceprefix_ = self.UserDefined_nsprefix_ + ':' if (UseCapturedNS_ and self.UserDefined_nsprefix_) else '' |
||
| 1460 | self.UserDefined.export(outfile, level, namespaceprefix_, namespacedef_='', name_='UserDefined', pretty_print=pretty_print) |
||
| 1461 | for MetadataItem_ in self.MetadataItem: |
||
| 1462 | namespaceprefix_ = self.MetadataItem_nsprefix_ + ':' if (UseCapturedNS_ and self.MetadataItem_nsprefix_) else '' |
||
| 1463 | MetadataItem_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='MetadataItem', pretty_print=pretty_print) |
||
| 1464 | def to_etree(self, parent_element=None, name_='MetadataType', mapping_=None, nsmap_=None): |
||
| 1465 | if parent_element is None: |
||
| 1466 | element = etree_.Element('{http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15}' + name_, nsmap=nsmap_) |
||
| 1467 | else: |
||
| 1468 | element = etree_.SubElement(parent_element, '{http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15}' + name_, nsmap=nsmap_) |
||
| 1469 | if self.externalRef is not None: |
||
| 1470 | element.set('externalRef', self.gds_format_string(self.externalRef)) |
||
| 1471 | if self.Creator is not None: |
||
| 1472 | Creator_ = self.Creator |
||
| 1473 | etree_.SubElement(element, '{http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15}Creator').text = self.gds_format_string(Creator_) |
||
| 1474 | if self.Created is not None: |
||
| 1475 | Created_ = self.Created |
||
| 1476 | etree_.SubElement(element, '{http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15}Created').text = self.gds_format_datetime(Created_) |
||
| 1477 | if self.LastChange is not None: |
||
| 1478 | LastChange_ = self.LastChange |
||
| 1479 | etree_.SubElement(element, '{http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15}LastChange').text = self.gds_format_datetime(LastChange_) |
||
| 1480 | if self.Comments is not None: |
||
| 1481 | Comments_ = self.Comments |
||
| 1482 | etree_.SubElement(element, '{http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15}Comments').text = self.gds_format_string(Comments_) |
||
| 1483 | if self.UserDefined is not None: |
||
| 1484 | UserDefined_ = self.UserDefined |
||
| 1485 | UserDefined_.to_etree(element, name_='UserDefined', mapping_=mapping_, nsmap_=nsmap_) |
||
| 1486 | for MetadataItem_ in self.MetadataItem: |
||
| 1487 | MetadataItem_.to_etree(element, name_='MetadataItem', mapping_=mapping_, nsmap_=nsmap_) |
||
| 1488 | if mapping_ is not None: |
||
| 1489 | mapping_[id(self)] = element |
||
| 1490 | return element |
||
| 1491 | def build(self, node, gds_collector_=None): |
||
| 1492 | self.gds_collector_ = gds_collector_ |
||
| 1493 | if SaveElementTreeNode: |
||
| 1494 | self.gds_elementtree_node_ = node |
||
| 1495 | already_processed = set() |
||
| 1496 | self.ns_prefix_ = node.prefix |
||
| 1497 | self.buildAttributes(node, node.attrib, already_processed) |
||
| 1498 | for child in node: |
||
| 1499 | nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] |
||
| 1500 | self.buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) |
||
| 1501 | return self |
||
| 1502 | def buildAttributes(self, node, attrs, already_processed): |
||
| 1503 | value = find_attr_value_('externalRef', node) |
||
| 1504 | if value is not None and 'externalRef' not in already_processed: |
||
| 1505 | already_processed.add('externalRef') |
||
| 1506 | self.externalRef = value |
||
| 1507 | def buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None): |
||
| 1508 | if nodeName_ == 'Creator': |
||
| 1509 | value_ = child_.text |
||
| 1510 | value_ = self.gds_parse_string(value_, node, 'Creator') |
||
| 1511 | value_ = self.gds_validate_string(value_, node, 'Creator') |
||
| 1512 | self.Creator = value_ |
||
| 1513 | |||
| 1514 | elif nodeName_ == 'Created': |
||
| 1515 | sval_ = child_.text |
||
| 1516 | dval_ = self.gds_parse_datetime(sval_) |
||
| 1517 | self.Created = dval_ |
||
| 1518 | |||
| 1519 | elif nodeName_ == 'LastChange': |
||
| 1520 | sval_ = child_.text |
||
| 1521 | dval_ = self.gds_parse_datetime(sval_) |
||
| 1522 | self.LastChange = dval_ |
||
| 1523 | |||
| 1524 | elif nodeName_ == 'Comments': |
||
| 1525 | value_ = child_.text |
||
| 1526 | value_ = self.gds_parse_string(value_, node, 'Comments') |
||
| 1527 | value_ = self.gds_validate_string(value_, node, 'Comments') |
||
| 1528 | self.Comments = value_ |
||
| 1529 | |||
| 1530 | elif nodeName_ == 'UserDefined': |
||
| 1531 | obj_ = UserDefinedType.factory(parent_object_=self) |
||
| 1532 | obj_.build(child_, gds_collector_=gds_collector_) |
||
| 1533 | self.UserDefined = obj_ |
||
| 1534 | obj_.original_tagname_ = 'UserDefined' |
||
| 1535 | elif nodeName_ == 'MetadataItem': |
||
| 1536 | obj_ = MetadataItemType.factory(parent_object_=self) |
||
| 1537 | obj_.build(child_, gds_collector_=gds_collector_) |
||
| 1538 | self.MetadataItem.append(obj_) |
||
| 1539 | obj_.original_tagname_ = 'MetadataItem' |
||
| 1540 | def __hash__(self): |
||
| 1541 | return hash(self.id) |
||
| 1542 | # end class MetadataType |
||
| 1543 | |||
| 1544 | |||
| 1545 | class MetadataItemType(GeneratedsSuper): |
||
| 1546 | """Type of metadata (e.g. author) |
||
| 1547 | E.g. imagePhotometricInterpretation |
||
| 1548 | E.g. RGB""" |
||
| 1549 | __hash__ = GeneratedsSuper.__hash__ |
||
| 1550 | member_data_items_ = [ |
||
| 1551 | MemberSpec_('type_', 'string', 0, 1, {'use': 'optional'}), |
||
| 1552 | MemberSpec_('name', 'string', 0, 1, {'use': 'optional'}), |
||
| 1553 | MemberSpec_('value', 'string', 0, 0, {'use': 'required'}), |
||
| 1554 | MemberSpec_('date', 'dateTime', 0, 1, {'use': 'optional'}), |
||
| 1555 | MemberSpec_('Labels', 'LabelsType', 1, 1, {'maxOccurs': 'unbounded', 'minOccurs': '0', 'name': 'Labels', 'type': 'LabelsType'}, None), |
||
| 1556 | ] |
||
| 1557 | subclass = None |
||
| 1558 | superclass = None |
||
| 1559 | def __init__(self, type_=None, name=None, value=None, date=None, Labels=None, gds_collector_=None, **kwargs_): |
||
| 1560 | self.gds_collector_ = gds_collector_ |
||
| 1561 | self.gds_elementtree_node_ = None |
||
| 1562 | self.original_tagname_ = None |
||
| 1563 | self.parent_object_ = kwargs_.get('parent_object_') |
||
| 1564 | self.ns_prefix_ = None |
||
| 1565 | self.type_ = _cast(None, type_) |
||
| 1566 | self.type__nsprefix_ = "pc" |
||
| 1567 | self.name = _cast(None, name) |
||
| 1568 | self.name_nsprefix_ = "pc" |
||
| 1569 | self.value = _cast(None, value) |
||
| 1570 | self.value_nsprefix_ = "pc" |
||
| 1571 | if isinstance(date, BaseStrType_): |
||
| 1572 | initvalue_ = datetime_.datetime.strptime(date, '%Y-%m-%dT%H:%M:%S') |
||
| 1573 | else: |
||
| 1574 | initvalue_ = date |
||
| 1575 | self.date = initvalue_ |
||
| 1576 | if Labels is None: |
||
| 1577 | self.Labels = [] |
||
| 1578 | else: |
||
| 1579 | self.Labels = Labels |
||
| 1580 | self.Labels_nsprefix_ = "pc" |
||
| 1581 | def factory(*args_, **kwargs_): |
||
| 1582 | if CurrentSubclassModule_ is not None: |
||
| 1583 | subclass = getSubclassFromModule_( |
||
| 1584 | CurrentSubclassModule_, MetadataItemType) |
||
| 1585 | if subclass is not None: |
||
| 1586 | return subclass(*args_, **kwargs_) |
||
| 1587 | if MetadataItemType.subclass: |
||
| 1588 | return MetadataItemType.subclass(*args_, **kwargs_) |
||
| 1589 | else: |
||
| 1590 | return MetadataItemType(*args_, **kwargs_) |
||
| 1591 | factory = staticmethod(factory) |
||
| 1592 | def get_ns_prefix_(self): |
||
| 1593 | return self.ns_prefix_ |
||
| 1594 | def set_ns_prefix_(self, ns_prefix): |
||
| 1595 | self.ns_prefix_ = ns_prefix |
||
| 1596 | def get_Labels(self): |
||
| 1597 | return self.Labels |
||
| 1598 | def set_Labels(self, Labels): |
||
| 1599 | self.Labels = Labels |
||
| 1600 | def add_Labels(self, value): |
||
| 1601 | self.Labels.append(value) |
||
| 1602 | def insert_Labels_at(self, index, value): |
||
| 1603 | self.Labels.insert(index, value) |
||
| 1604 | def replace_Labels_at(self, index, value): |
||
| 1605 | self.Labels[index] = value |
||
| 1606 | def get_type(self): |
||
| 1607 | return self.type_ |
||
| 1608 | def set_type(self, type_): |
||
| 1609 | self.type_ = type_ |
||
| 1610 | def get_name(self): |
||
| 1611 | return self.name |
||
| 1612 | def set_name(self, name): |
||
| 1613 | self.name = name |
||
| 1614 | def get_value(self): |
||
| 1615 | return self.value |
||
| 1616 | def set_value(self, value): |
||
| 1617 | self.value = value |
||
| 1618 | def get_date(self): |
||
| 1619 | return self.date |
||
| 1620 | def set_date(self, date): |
||
| 1621 | self.date = date |
||
| 1622 | def hasContent_(self): |
||
| 1623 | if ( |
||
| 1624 | self.Labels |
||
| 1625 | ): |
||
| 1626 | return True |
||
| 1627 | else: |
||
| 1628 | return False |
||
| 1629 | def export(self, outfile, level, namespaceprefix_='', namespacedef_='xmlns:pc="http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15"', name_='MetadataItemType', pretty_print=True): |
||
| 1630 | imported_ns_def_ = GenerateDSNamespaceDefs_.get('MetadataItemType') |
||
| 1631 | if imported_ns_def_ is not None: |
||
| 1632 | namespacedef_ = imported_ns_def_ |
||
| 1633 | if pretty_print: |
||
| 1634 | eol_ = '\n' |
||
| 1635 | else: |
||
| 1636 | eol_ = '' |
||
| 1637 | if self.original_tagname_ is not None and name_ == 'MetadataItemType': |
||
| 1638 | name_ = self.original_tagname_ |
||
| 1639 | if UseCapturedNS_ and self.ns_prefix_: |
||
| 1640 | namespaceprefix_ = self.ns_prefix_ + ':' |
||
| 1641 | showIndent(outfile, level, pretty_print) |
||
| 1642 | outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) |
||
| 1643 | already_processed = set() |
||
| 1644 | self.exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='MetadataItemType') |
||
| 1645 | if self.hasContent_(): |
||
| 1646 | outfile.write('>%s' % (eol_, )) |
||
| 1647 | self.exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='MetadataItemType', pretty_print=pretty_print) |
||
| 1648 | showIndent(outfile, level, pretty_print) |
||
| 1649 | outfile.write('</%s%s>%s' % (namespaceprefix_, name_, eol_)) |
||
| 1650 | else: |
||
| 1651 | outfile.write('/>%s' % (eol_, )) |
||
| 1652 | View Code Duplication | def exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='MetadataItemType'): |
|
| 1653 | if self.type_ is not None and 'type_' not in already_processed: |
||
| 1654 | already_processed.add('type_') |
||
| 1655 | outfile.write(' type=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.type_), input_name='type')), )) |
||
| 1656 | if self.name is not None and 'name' not in already_processed: |
||
| 1657 | already_processed.add('name') |
||
| 1658 | outfile.write(' name=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.name), input_name='name')), )) |
||
| 1659 | if self.value is not None and 'value' not in already_processed: |
||
| 1660 | already_processed.add('value') |
||
| 1661 | outfile.write(' value=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.value), input_name='value')), )) |
||
| 1662 | if self.date is not None and 'date' not in already_processed: |
||
| 1663 | already_processed.add('date') |
||
| 1664 | outfile.write(' date="%s"' % self.gds_format_datetime(self.date, input_name='date')) |
||
| 1665 | def exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='xmlns:pc="http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15"', name_='MetadataItemType', fromsubclass_=False, pretty_print=True): |
||
| 1666 | if pretty_print: |
||
| 1667 | eol_ = '\n' |
||
| 1668 | else: |
||
| 1669 | eol_ = '' |
||
| 1670 | for Labels_ in self.Labels: |
||
| 1671 | namespaceprefix_ = self.Labels_nsprefix_ + ':' if (UseCapturedNS_ and self.Labels_nsprefix_) else '' |
||
| 1672 | Labels_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Labels', pretty_print=pretty_print) |
||
| 1673 | def to_etree(self, parent_element=None, name_='MetadataItemType', mapping_=None, nsmap_=None): |
||
| 1674 | if parent_element is None: |
||
| 1675 | element = etree_.Element('{http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15}' + name_, nsmap=nsmap_) |
||
| 1676 | else: |
||
| 1677 | element = etree_.SubElement(parent_element, '{http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15}' + name_, nsmap=nsmap_) |
||
| 1678 | if self.type_ is not None: |
||
| 1679 | element.set('type', self.gds_format_string(self.type_)) |
||
| 1680 | if self.name is not None: |
||
| 1681 | element.set('name', self.gds_format_string(self.name)) |
||
| 1682 | if self.value is not None: |
||
| 1683 | element.set('value', self.gds_format_string(self.value)) |
||
| 1684 | if self.date is not None: |
||
| 1685 | element.set('date', self.gds_format_datetime(self.date)) |
||
| 1686 | for Labels_ in self.Labels: |
||
| 1687 | Labels_.to_etree(element, name_='Labels', mapping_=mapping_, nsmap_=nsmap_) |
||
| 1688 | if mapping_ is not None: |
||
| 1689 | mapping_[id(self)] = element |
||
| 1690 | return element |
||
| 1691 | def build(self, node, gds_collector_=None): |
||
| 1692 | self.gds_collector_ = gds_collector_ |
||
| 1693 | if SaveElementTreeNode: |
||
| 1694 | self.gds_elementtree_node_ = node |
||
| 1695 | already_processed = set() |
||
| 1696 | self.ns_prefix_ = node.prefix |
||
| 1697 | self.buildAttributes(node, node.attrib, already_processed) |
||
| 1698 | for child in node: |
||
| 1699 | nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] |
||
| 1700 | self.buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) |
||
| 1701 | return self |
||
| 1702 | def buildAttributes(self, node, attrs, already_processed): |
||
| 1703 | value = find_attr_value_('type', node) |
||
| 1704 | if value is not None and 'type' not in already_processed: |
||
| 1705 | already_processed.add('type') |
||
| 1706 | self.type_ = value |
||
| 1707 | value = find_attr_value_('name', node) |
||
| 1708 | if value is not None and 'name' not in already_processed: |
||
| 1709 | already_processed.add('name') |
||
| 1710 | self.name = value |
||
| 1711 | value = find_attr_value_('value', node) |
||
| 1712 | if value is not None and 'value' not in already_processed: |
||
| 1713 | already_processed.add('value') |
||
| 1714 | self.value = value |
||
| 1715 | value = find_attr_value_('date', node) |
||
| 1716 | if value is not None and 'date' not in already_processed: |
||
| 1717 | already_processed.add('date') |
||
| 1718 | try: |
||
| 1719 | self.date = self.gds_parse_datetime(value) |
||
| 1720 | except ValueError as exp: |
||
| 1721 | raise ValueError('Bad date-time attribute (date): %s' % exp) |
||
| 1722 | def buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None): |
||
| 1723 | if nodeName_ == 'Labels': |
||
| 1724 | obj_ = LabelsType.factory(parent_object_=self) |
||
| 1725 | obj_.build(child_, gds_collector_=gds_collector_) |
||
| 1726 | self.Labels.append(obj_) |
||
| 1727 | obj_.original_tagname_ = 'Labels' |
||
| 1728 | def __hash__(self): |
||
| 1729 | return hash(self.id) |
||
| 1730 | # end class MetadataItemType |
||
| 1731 | |||
| 1732 | |||
| 1733 | class LabelsType(GeneratedsSuper): |
||
| 1734 | """Reference to external model / ontology / schema |
||
| 1735 | E.g. an RDF resource identifier |
||
| 1736 | (to be used as subject or object of an RDF triple) |
||
| 1737 | Prefix for all labels (e.g. first part of an URI)""" |
||
| 1738 | __hash__ = GeneratedsSuper.__hash__ |
||
| 1739 | member_data_items_ = [ |
||
| 1740 | MemberSpec_('externalModel', 'string', 0, 1, {'use': 'optional'}), |
||
| 1741 | MemberSpec_('externalId', 'string', 0, 1, {'use': 'optional'}), |
||
| 1742 | MemberSpec_('prefix', 'string', 0, 1, {'use': 'optional'}), |
||
| 1743 | MemberSpec_('comments', 'string', 0, 1, {'use': 'optional'}), |
||
| 1744 | MemberSpec_('Label', 'LabelType', 1, 1, {'maxOccurs': 'unbounded', 'minOccurs': '0', 'name': 'Label', 'type': 'LabelType'}, None), |
||
| 1745 | ] |
||
| 1746 | subclass = None |
||
| 1747 | superclass = None |
||
| 1748 | def __init__(self, externalModel=None, externalId=None, prefix=None, comments=None, Label=None, gds_collector_=None, **kwargs_): |
||
| 1749 | self.gds_collector_ = gds_collector_ |
||
| 1750 | self.gds_elementtree_node_ = None |
||
| 1751 | self.original_tagname_ = None |
||
| 1752 | self.parent_object_ = kwargs_.get('parent_object_') |
||
| 1753 | self.ns_prefix_ = None |
||
| 1754 | self.externalModel = _cast(None, externalModel) |
||
| 1755 | self.externalModel_nsprefix_ = "pc" |
||
| 1756 | self.externalId = _cast(None, externalId) |
||
| 1757 | self.externalId_nsprefix_ = "pc" |
||
| 1758 | self.prefix = _cast(None, prefix) |
||
| 1759 | self.prefix_nsprefix_ = "pc" |
||
| 1760 | self.comments = _cast(None, comments) |
||
| 1761 | self.comments_nsprefix_ = "pc" |
||
| 1762 | if Label is None: |
||
| 1763 | self.Label = [] |
||
| 1764 | else: |
||
| 1765 | self.Label = Label |
||
| 1766 | self.Label_nsprefix_ = "pc" |
||
| 1767 | def factory(*args_, **kwargs_): |
||
| 1768 | if CurrentSubclassModule_ is not None: |
||
| 1769 | subclass = getSubclassFromModule_( |
||
| 1770 | CurrentSubclassModule_, LabelsType) |
||
| 1771 | if subclass is not None: |
||
| 1772 | return subclass(*args_, **kwargs_) |
||
| 1773 | if LabelsType.subclass: |
||
| 1774 | return LabelsType.subclass(*args_, **kwargs_) |
||
| 1775 | else: |
||
| 1776 | return LabelsType(*args_, **kwargs_) |
||
| 1777 | factory = staticmethod(factory) |
||
| 1778 | def get_ns_prefix_(self): |
||
| 1779 | return self.ns_prefix_ |
||
| 1780 | def set_ns_prefix_(self, ns_prefix): |
||
| 1781 | self.ns_prefix_ = ns_prefix |
||
| 1782 | def get_Label(self): |
||
| 1783 | return self.Label |
||
| 1784 | def set_Label(self, Label): |
||
| 1785 | self.Label = Label |
||
| 1786 | def add_Label(self, value): |
||
| 1787 | self.Label.append(value) |
||
| 1788 | def insert_Label_at(self, index, value): |
||
| 1789 | self.Label.insert(index, value) |
||
| 1790 | def replace_Label_at(self, index, value): |
||
| 1791 | self.Label[index] = value |
||
| 1792 | def get_externalModel(self): |
||
| 1793 | return self.externalModel |
||
| 1794 | def set_externalModel(self, externalModel): |
||
| 1795 | self.externalModel = externalModel |
||
| 1796 | def get_externalId(self): |
||
| 1797 | return self.externalId |
||
| 1798 | def set_externalId(self, externalId): |
||
| 1799 | self.externalId = externalId |
||
| 1800 | def get_prefix(self): |
||
| 1801 | return self.prefix |
||
| 1802 | def set_prefix(self, prefix): |
||
| 1803 | self.prefix = prefix |
||
| 1804 | def get_comments(self): |
||
| 1805 | return self.comments |
||
| 1806 | def set_comments(self, comments): |
||
| 1807 | self.comments = comments |
||
| 1808 | def hasContent_(self): |
||
| 1809 | if ( |
||
| 1810 | self.Label |
||
| 1811 | ): |
||
| 1812 | return True |
||
| 1813 | else: |
||
| 1814 | return False |
||
| 1815 | def export(self, outfile, level, namespaceprefix_='', namespacedef_='xmlns:pc="http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15"', name_='LabelsType', pretty_print=True): |
||
| 1816 | imported_ns_def_ = GenerateDSNamespaceDefs_.get('LabelsType') |
||
| 1817 | if imported_ns_def_ is not None: |
||
| 1818 | namespacedef_ = imported_ns_def_ |
||
| 1819 | if pretty_print: |
||
| 1820 | eol_ = '\n' |
||
| 1821 | else: |
||
| 1822 | eol_ = '' |
||
| 1823 | if self.original_tagname_ is not None and name_ == 'LabelsType': |
||
| 1824 | name_ = self.original_tagname_ |
||
| 1825 | if UseCapturedNS_ and self.ns_prefix_: |
||
| 1826 | namespaceprefix_ = self.ns_prefix_ + ':' |
||
| 1827 | showIndent(outfile, level, pretty_print) |
||
| 1828 | outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) |
||
| 1829 | already_processed = set() |
||
| 1830 | self.exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='LabelsType') |
||
| 1831 | if self.hasContent_(): |
||
| 1832 | outfile.write('>%s' % (eol_, )) |
||
| 1833 | self.exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='LabelsType', pretty_print=pretty_print) |
||
| 1834 | showIndent(outfile, level, pretty_print) |
||
| 1835 | outfile.write('</%s%s>%s' % (namespaceprefix_, name_, eol_)) |
||
| 1836 | else: |
||
| 1837 | outfile.write('/>%s' % (eol_, )) |
||
| 1838 | def exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='LabelsType'): |
||
| 1839 | if self.externalModel is not None and 'externalModel' not in already_processed: |
||
| 1840 | already_processed.add('externalModel') |
||
| 1841 | outfile.write(' externalModel=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.externalModel), input_name='externalModel')), )) |
||
| 1842 | if self.externalId is not None and 'externalId' not in already_processed: |
||
| 1843 | already_processed.add('externalId') |
||
| 1844 | outfile.write(' externalId=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.externalId), input_name='externalId')), )) |
||
| 1845 | if self.prefix is not None and 'prefix' not in already_processed: |
||
| 1846 | already_processed.add('prefix') |
||
| 1847 | outfile.write(' prefix=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.prefix), input_name='prefix')), )) |
||
| 1848 | if self.comments is not None and 'comments' not in already_processed: |
||
| 1849 | already_processed.add('comments') |
||
| 1850 | outfile.write(' comments=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.comments), input_name='comments')), )) |
||
| 1851 | def exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='xmlns:pc="http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15"', name_='LabelsType', fromsubclass_=False, pretty_print=True): |
||
| 1852 | if pretty_print: |
||
| 1853 | eol_ = '\n' |
||
| 1854 | else: |
||
| 1855 | eol_ = '' |
||
| 1856 | for Label_ in self.Label: |
||
| 1857 | namespaceprefix_ = self.Label_nsprefix_ + ':' if (UseCapturedNS_ and self.Label_nsprefix_) else '' |
||
| 1858 | Label_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Label', pretty_print=pretty_print) |
||
| 1859 | def to_etree(self, parent_element=None, name_='LabelsType', mapping_=None, nsmap_=None): |
||
| 1860 | if parent_element is None: |
||
| 1861 | element = etree_.Element('{http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15}' + name_, nsmap=nsmap_) |
||
| 1862 | else: |
||
| 1863 | element = etree_.SubElement(parent_element, '{http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15}' + name_, nsmap=nsmap_) |
||
| 1864 | if self.externalModel is not None: |
||
| 1865 | element.set('externalModel', self.gds_format_string(self.externalModel)) |
||
| 1866 | if self.externalId is not None: |
||
| 1867 | element.set('externalId', self.gds_format_string(self.externalId)) |
||
| 1868 | if self.prefix is not None: |
||
| 1869 | element.set('prefix', self.gds_format_string(self.prefix)) |
||
| 1870 | if self.comments is not None: |
||
| 1871 | element.set('comments', self.gds_format_string(self.comments)) |
||
| 1872 | for Label_ in self.Label: |
||
| 1873 | Label_.to_etree(element, name_='Label', mapping_=mapping_, nsmap_=nsmap_) |
||
| 1874 | if mapping_ is not None: |
||
| 1875 | mapping_[id(self)] = element |
||
| 1876 | return element |
||
| 1877 | def build(self, node, gds_collector_=None): |
||
| 1878 | self.gds_collector_ = gds_collector_ |
||
| 1879 | if SaveElementTreeNode: |
||
| 1880 | self.gds_elementtree_node_ = node |
||
| 1881 | already_processed = set() |
||
| 1882 | self.ns_prefix_ = node.prefix |
||
| 1883 | self.buildAttributes(node, node.attrib, already_processed) |
||
| 1884 | for child in node: |
||
| 1885 | nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] |
||
| 1886 | self.buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) |
||
| 1887 | return self |
||
| 1888 | def buildAttributes(self, node, attrs, already_processed): |
||
| 1889 | value = find_attr_value_('externalModel', node) |
||
| 1890 | if value is not None and 'externalModel' not in already_processed: |
||
| 1891 | already_processed.add('externalModel') |
||
| 1892 | self.externalModel = value |
||
| 1893 | value = find_attr_value_('externalId', node) |
||
| 1894 | if value is not None and 'externalId' not in already_processed: |
||
| 1895 | already_processed.add('externalId') |
||
| 1896 | self.externalId = value |
||
| 1897 | value = find_attr_value_('prefix', node) |
||
| 1898 | if value is not None and 'prefix' not in already_processed: |
||
| 1899 | already_processed.add('prefix') |
||
| 1900 | self.prefix = value |
||
| 1901 | value = find_attr_value_('comments', node) |
||
| 1902 | if value is not None and 'comments' not in already_processed: |
||
| 1903 | already_processed.add('comments') |
||
| 1904 | self.comments = value |
||
| 1905 | def buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None): |
||
| 1906 | if nodeName_ == 'Label': |
||
| 1907 | obj_ = LabelType.factory(parent_object_=self) |
||
| 1908 | obj_.build(child_, gds_collector_=gds_collector_) |
||
| 1909 | self.Label.append(obj_) |
||
| 1910 | obj_.original_tagname_ = 'Label' |
||
| 1911 | def __hash__(self): |
||
| 1912 | return hash(self.id) |
||
| 1913 | # end class LabelsType |
||
| 1914 | |||
| 1915 | |||
| 1916 | class LabelType(GeneratedsSuper): |
||
| 1917 | """Semantic label |
||
| 1918 | The label / tag (e.g. 'person'). |
||
| 1919 | Can be an RDF resource identifier |
||
| 1920 | (e.g. object of an RDF triple). |
||
| 1921 | Additional information on the label |
||
| 1922 | (e.g. 'YYYY-mm-dd' for a date label). |
||
| 1923 | Can be used as predicate of an RDF triple.""" |
||
| 1924 | __hash__ = GeneratedsSuper.__hash__ |
||
| 1925 | member_data_items_ = [ |
||
| 1926 | MemberSpec_('value', 'string', 0, 0, {'use': 'required'}), |
||
| 1927 | MemberSpec_('type_', 'string', 0, 1, {'use': 'optional'}), |
||
| 1928 | MemberSpec_('comments', 'string', 0, 1, {'use': 'optional'}), |
||
| 1929 | ] |
||
| 1930 | subclass = None |
||
| 1931 | superclass = None |
||
| 1932 | def __init__(self, value=None, type_=None, comments=None, gds_collector_=None, **kwargs_): |
||
| 1933 | self.gds_collector_ = gds_collector_ |
||
| 1934 | self.gds_elementtree_node_ = None |
||
| 1935 | self.original_tagname_ = None |
||
| 1936 | self.parent_object_ = kwargs_.get('parent_object_') |
||
| 1937 | self.ns_prefix_ = None |
||
| 1938 | self.value = _cast(None, value) |
||
| 1939 | self.value_nsprefix_ = "pc" |
||
| 1940 | self.type_ = _cast(None, type_) |
||
| 1941 | self.type__nsprefix_ = "pc" |
||
| 1942 | self.comments = _cast(None, comments) |
||
| 1943 | self.comments_nsprefix_ = "pc" |
||
| 1944 | def factory(*args_, **kwargs_): |
||
| 1945 | if CurrentSubclassModule_ is not None: |
||
| 1946 | subclass = getSubclassFromModule_( |
||
| 1947 | CurrentSubclassModule_, LabelType) |
||
| 1948 | if subclass is not None: |
||
| 1949 | return subclass(*args_, **kwargs_) |
||
| 1950 | if LabelType.subclass: |
||
| 1951 | return LabelType.subclass(*args_, **kwargs_) |
||
| 1952 | else: |
||
| 1953 | return LabelType(*args_, **kwargs_) |
||
| 1954 | factory = staticmethod(factory) |
||
| 1955 | def get_ns_prefix_(self): |
||
| 1956 | return self.ns_prefix_ |
||
| 1957 | def set_ns_prefix_(self, ns_prefix): |
||
| 1958 | self.ns_prefix_ = ns_prefix |
||
| 1959 | def get_value(self): |
||
| 1960 | return self.value |
||
| 1961 | def set_value(self, value): |
||
| 1962 | self.value = value |
||
| 1963 | def get_type(self): |
||
| 1964 | return self.type_ |
||
| 1965 | def set_type(self, type_): |
||
| 1966 | self.type_ = type_ |
||
| 1967 | def get_comments(self): |
||
| 1968 | return self.comments |
||
| 1969 | def set_comments(self, comments): |
||
| 1970 | self.comments = comments |
||
| 1971 | def hasContent_(self): |
||
| 1972 | if ( |
||
| 1973 | |||
| 1974 | ): |
||
| 1975 | return True |
||
| 1976 | else: |
||
| 1977 | return False |
||
| 1978 | def export(self, outfile, level, namespaceprefix_='', namespacedef_='xmlns:pc="http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15"', name_='LabelType', pretty_print=True): |
||
| 1979 | imported_ns_def_ = GenerateDSNamespaceDefs_.get('LabelType') |
||
| 1980 | if imported_ns_def_ is not None: |
||
| 1981 | namespacedef_ = imported_ns_def_ |
||
| 1982 | if pretty_print: |
||
| 1983 | eol_ = '\n' |
||
| 1984 | else: |
||
| 1985 | eol_ = '' |
||
| 1986 | if self.original_tagname_ is not None and name_ == 'LabelType': |
||
| 1987 | name_ = self.original_tagname_ |
||
| 1988 | if UseCapturedNS_ and self.ns_prefix_: |
||
| 1989 | namespaceprefix_ = self.ns_prefix_ + ':' |
||
| 1990 | showIndent(outfile, level, pretty_print) |
||
| 1991 | outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) |
||
| 1992 | already_processed = set() |
||
| 1993 | self.exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='LabelType') |
||
| 1994 | if self.hasContent_(): |
||
| 1995 | outfile.write('>%s' % (eol_, )) |
||
| 1996 | self.exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='LabelType', pretty_print=pretty_print) |
||
| 1997 | outfile.write('</%s%s>%s' % (namespaceprefix_, name_, eol_)) |
||
| 1998 | else: |
||
| 1999 | outfile.write('/>%s' % (eol_, )) |
||
| 2000 | View Code Duplication | def exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='LabelType'): |
|
| 2001 | if self.value is not None and 'value' not in already_processed: |
||
| 2002 | already_processed.add('value') |
||
| 2003 | outfile.write(' value=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.value), input_name='value')), )) |
||
| 2004 | if self.type_ is not None and 'type_' not in already_processed: |
||
| 2005 | already_processed.add('type_') |
||
| 2006 | outfile.write(' type=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.type_), input_name='type')), )) |
||
| 2007 | if self.comments is not None and 'comments' not in already_processed: |
||
| 2008 | already_processed.add('comments') |
||
| 2009 | outfile.write(' comments=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.comments), input_name='comments')), )) |
||
| 2010 | def exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='xmlns:pc="http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15"', name_='LabelType', fromsubclass_=False, pretty_print=True): |
||
| 2011 | pass |
||
| 2012 | View Code Duplication | def to_etree(self, parent_element=None, name_='LabelType', mapping_=None, nsmap_=None): |
|
| 2013 | if parent_element is None: |
||
| 2014 | element = etree_.Element('{http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15}' + name_, nsmap=nsmap_) |
||
| 2015 | else: |
||
| 2016 | element = etree_.SubElement(parent_element, '{http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15}' + name_, nsmap=nsmap_) |
||
| 2017 | if self.value is not None: |
||
| 2018 | element.set('value', self.gds_format_string(self.value)) |
||
| 2019 | if self.type_ is not None: |
||
| 2020 | element.set('type', self.gds_format_string(self.type_)) |
||
| 2021 | if self.comments is not None: |
||
| 2022 | element.set('comments', self.gds_format_string(self.comments)) |
||
| 2023 | if mapping_ is not None: |
||
| 2024 | mapping_[id(self)] = element |
||
| 2025 | return element |
||
| 2026 | def build(self, node, gds_collector_=None): |
||
| 2027 | self.gds_collector_ = gds_collector_ |
||
| 2028 | if SaveElementTreeNode: |
||
| 2029 | self.gds_elementtree_node_ = node |
||
| 2030 | already_processed = set() |
||
| 2031 | self.ns_prefix_ = node.prefix |
||
| 2032 | self.buildAttributes(node, node.attrib, already_processed) |
||
| 2033 | for child in node: |
||
| 2034 | nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] |
||
| 2035 | self.buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) |
||
| 2036 | return self |
||
| 2037 | def buildAttributes(self, node, attrs, already_processed): |
||
| 2038 | value = find_attr_value_('value', node) |
||
| 2039 | if value is not None and 'value' not in already_processed: |
||
| 2040 | already_processed.add('value') |
||
| 2041 | self.value = value |
||
| 2042 | value = find_attr_value_('type', node) |
||
| 2043 | if value is not None and 'type' not in already_processed: |
||
| 2044 | already_processed.add('type') |
||
| 2045 | self.type_ = value |
||
| 2046 | value = find_attr_value_('comments', node) |
||
| 2047 | if value is not None and 'comments' not in already_processed: |
||
| 2048 | already_processed.add('comments') |
||
| 2049 | self.comments = value |
||
| 2050 | def buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None): |
||
| 2051 | pass |
||
| 2052 | def __hash__(self): |
||
| 2053 | return hash(self.id) |
||
| 2054 | # end class LabelType |
||
| 2055 | |||
| 2056 | |||
| 2057 | class PageType(GeneratedsSuper): |
||
| 2058 | """Contains the image file name including the file extension. |
||
| 2059 | Specifies the width of the image.Specifies the height of the |
||
| 2060 | image.Specifies the image resolution in width.Specifies the image |
||
| 2061 | resolution in height. |
||
| 2062 | Specifies the unit of the resolution information |
||
| 2063 | referring to a standardised unit of measurement |
||
| 2064 | (pixels per inch, pixels per centimeter or other). |
||
| 2065 | For generic use |
||
| 2066 | The angle the rectangle encapsulating the page |
||
| 2067 | (or its Border) has to be rotated in clockwise direction |
||
| 2068 | in order to correct the present skew |
||
| 2069 | (negative values indicate anti-clockwise rotation). |
||
| 2070 | (The rotated image can be further referenced |
||
| 2071 | via “AlternativeImage”.) |
||
| 2072 | Range: -179.999,180 |
||
| 2073 | The type of the page within the document |
||
| 2074 | (e.g. cover page). |
||
| 2075 | The primary language used in the page |
||
| 2076 | (lower-level definitions override the page-level definition). |
||
| 2077 | The secondary language used in the page |
||
| 2078 | (lower-level definitions override the page-level definition). |
||
| 2079 | The primary script used in the page |
||
| 2080 | (lower-level definitions override the page-level definition). |
||
| 2081 | The secondary script used in the page |
||
| 2082 | (lower-level definitions override the page-level definition). |
||
| 2083 | The direction in which text within lines |
||
| 2084 | should be read (order of words and characters), |
||
| 2085 | in addition to “textLineOrder” |
||
| 2086 | (lower-level definitions override the page-level definition). |
||
| 2087 | The order of text lines within a block, |
||
| 2088 | in addition to “readingDirection” |
||
| 2089 | (lower-level definitions override the page-level definition). |
||
| 2090 | Confidence value for whole page (between 0 and 1)""" |
||
| 2091 | __hash__ = GeneratedsSuper.__hash__ |
||
| 2092 | member_data_items_ = [ |
||
| 2093 | MemberSpec_('imageFilename', 'string', 0, 0, {'use': 'required'}), |
||
| 2094 | MemberSpec_('imageWidth', 'int', 0, 0, {'use': 'required'}), |
||
| 2095 | MemberSpec_('imageHeight', 'int', 0, 0, {'use': 'required'}), |
||
| 2096 | MemberSpec_('imageXResolution', 'float', 0, 1, {'use': 'optional'}), |
||
| 2097 | MemberSpec_('imageYResolution', 'float', 0, 1, {'use': 'optional'}), |
||
| 2098 | MemberSpec_('imageResolutionUnit', 'string', 0, 1, {'use': 'optional'}), |
||
| 2099 | MemberSpec_('custom', 'string', 0, 1, {'use': 'optional'}), |
||
| 2100 | MemberSpec_('orientation', 'float', 0, 1, {'use': 'optional'}), |
||
| 2101 | MemberSpec_('type_', 'pc:PageTypeSimpleType', 0, 1, {'use': 'optional'}), |
||
| 2102 | MemberSpec_('primaryLanguage', 'pc:LanguageSimpleType', 0, 1, {'use': 'optional'}), |
||
| 2103 | MemberSpec_('secondaryLanguage', 'pc:LanguageSimpleType', 0, 1, {'use': 'optional'}), |
||
| 2104 | MemberSpec_('primaryScript', 'pc:ScriptSimpleType', 0, 1, {'use': 'optional'}), |
||
| 2105 | MemberSpec_('secondaryScript', 'pc:ScriptSimpleType', 0, 1, {'use': 'optional'}), |
||
| 2106 | MemberSpec_('readingDirection', 'pc:ReadingDirectionSimpleType', 0, 1, {'use': 'optional'}), |
||
| 2107 | MemberSpec_('textLineOrder', 'pc:TextLineOrderSimpleType', 0, 1, {'use': 'optional'}), |
||
| 2108 | MemberSpec_('conf', 'pc:ConfSimpleType', 0, 1, {'use': 'optional'}), |
||
| 2109 | MemberSpec_('AlternativeImage', 'AlternativeImageType', 1, 1, {'maxOccurs': 'unbounded', 'minOccurs': '0', 'name': 'AlternativeImage', 'type': 'AlternativeImageType'}, None), |
||
| 2110 | MemberSpec_('Border', 'BorderType', 0, 1, {'maxOccurs': '1', 'minOccurs': '0', 'name': 'Border', 'type': 'BorderType'}, None), |
||
| 2111 | MemberSpec_('PrintSpace', 'PrintSpaceType', 0, 1, {'maxOccurs': '1', 'minOccurs': '0', 'name': 'PrintSpace', 'type': 'PrintSpaceType'}, None), |
||
| 2112 | MemberSpec_('ReadingOrder', 'ReadingOrderType', 0, 1, {'maxOccurs': '1', 'minOccurs': '0', 'name': 'ReadingOrder', 'type': 'ReadingOrderType'}, None), |
||
| 2113 | MemberSpec_('Layers', 'LayersType', 0, 1, {'maxOccurs': '1', 'minOccurs': '0', 'name': 'Layers', 'type': 'LayersType'}, None), |
||
| 2114 | MemberSpec_('Relations', 'RelationsType', 0, 1, {'minOccurs': '0', 'name': 'Relations', 'type': 'RelationsType'}, None), |
||
| 2115 | MemberSpec_('TextStyle', 'TextStyleType', 0, 1, {'maxOccurs': '1', 'minOccurs': '0', 'name': 'TextStyle', 'type': 'TextStyleType'}, None), |
||
| 2116 | MemberSpec_('UserDefined', 'UserDefinedType', 0, 1, {'maxOccurs': '1', 'minOccurs': '0', 'name': 'UserDefined', 'type': 'UserDefinedType'}, None), |
||
| 2117 | MemberSpec_('Labels', 'LabelsType', 1, 1, {'maxOccurs': 'unbounded', 'minOccurs': '0', 'name': 'Labels', 'type': 'LabelsType'}, None), |
||
| 2118 | MemberSpec_('TextRegion', 'TextRegionType', 1, 1, {'name': 'TextRegion', 'type': 'TextRegionType'}, 1), |
||
| 2119 | MemberSpec_('ImageRegion', 'ImageRegionType', 1, 1, {'name': 'ImageRegion', 'type': 'ImageRegionType'}, 1), |
||
| 2120 | MemberSpec_('LineDrawingRegion', 'LineDrawingRegionType', 1, 1, {'name': 'LineDrawingRegion', 'type': 'LineDrawingRegionType'}, 1), |
||
| 2121 | MemberSpec_('GraphicRegion', 'GraphicRegionType', 1, 1, {'name': 'GraphicRegion', 'type': 'GraphicRegionType'}, 1), |
||
| 2122 | MemberSpec_('TableRegion', 'TableRegionType', 1, 1, {'name': 'TableRegion', 'type': 'TableRegionType'}, 1), |
||
| 2123 | MemberSpec_('ChartRegion', 'ChartRegionType', 1, 1, {'name': 'ChartRegion', 'type': 'ChartRegionType'}, 1), |
||
| 2124 | MemberSpec_('MapRegion', 'MapRegionType', 1, 1, {'name': 'MapRegion', 'type': 'MapRegionType'}, 1), |
||
| 2125 | MemberSpec_('SeparatorRegion', 'SeparatorRegionType', 1, 1, {'name': 'SeparatorRegion', 'type': 'SeparatorRegionType'}, 1), |
||
| 2126 | MemberSpec_('MathsRegion', 'MathsRegionType', 1, 1, {'name': 'MathsRegion', 'type': 'MathsRegionType'}, 1), |
||
| 2127 | MemberSpec_('ChemRegion', 'ChemRegionType', 1, 1, {'name': 'ChemRegion', 'type': 'ChemRegionType'}, 1), |
||
| 2128 | MemberSpec_('MusicRegion', 'MusicRegionType', 1, 1, {'name': 'MusicRegion', 'type': 'MusicRegionType'}, 1), |
||
| 2129 | MemberSpec_('AdvertRegion', 'AdvertRegionType', 1, 1, {'name': 'AdvertRegion', 'type': 'AdvertRegionType'}, 1), |
||
| 2130 | MemberSpec_('NoiseRegion', 'NoiseRegionType', 1, 1, {'name': 'NoiseRegion', 'type': 'NoiseRegionType'}, 1), |
||
| 2131 | MemberSpec_('UnknownRegion', 'UnknownRegionType', 1, 1, {'name': 'UnknownRegion', 'type': 'UnknownRegionType'}, 1), |
||
| 2132 | MemberSpec_('CustomRegion', 'CustomRegionType', 1, 1, {'name': 'CustomRegion', 'type': 'CustomRegionType'}, 1), |
||
| 2133 | ] |
||
| 2134 | subclass = None |
||
| 2135 | superclass = None |
||
| 2136 | def __init__(self, imageFilename=None, imageWidth=None, imageHeight=None, imageXResolution=None, imageYResolution=None, imageResolutionUnit=None, custom=None, orientation=None, type_=None, primaryLanguage=None, secondaryLanguage=None, primaryScript=None, secondaryScript=None, readingDirection=None, textLineOrder=None, conf=None, AlternativeImage=None, Border=None, PrintSpace=None, ReadingOrder=None, Layers=None, Relations=None, TextStyle=None, UserDefined=None, Labels=None, TextRegion=None, ImageRegion=None, LineDrawingRegion=None, GraphicRegion=None, TableRegion=None, ChartRegion=None, MapRegion=None, SeparatorRegion=None, MathsRegion=None, ChemRegion=None, MusicRegion=None, AdvertRegion=None, NoiseRegion=None, UnknownRegion=None, CustomRegion=None, gds_collector_=None, **kwargs_): |
||
| 2137 | self.gds_collector_ = gds_collector_ |
||
| 2138 | self.gds_elementtree_node_ = None |
||
| 2139 | self.original_tagname_ = None |
||
| 2140 | self.parent_object_ = kwargs_.get('parent_object_') |
||
| 2141 | self.ns_prefix_ = None |
||
| 2142 | self.imageFilename = _cast(None, imageFilename) |
||
| 2143 | self.imageFilename_nsprefix_ = "pc" |
||
| 2144 | self.imageWidth = _cast(int, imageWidth) |
||
| 2145 | self.imageWidth_nsprefix_ = "pc" |
||
| 2146 | self.imageHeight = _cast(int, imageHeight) |
||
| 2147 | self.imageHeight_nsprefix_ = "pc" |
||
| 2148 | self.imageXResolution = _cast(float, imageXResolution) |
||
| 2149 | self.imageXResolution_nsprefix_ = "pc" |
||
| 2150 | self.imageYResolution = _cast(float, imageYResolution) |
||
| 2151 | self.imageYResolution_nsprefix_ = "pc" |
||
| 2152 | self.imageResolutionUnit = _cast(None, imageResolutionUnit) |
||
| 2153 | self.imageResolutionUnit_nsprefix_ = "pc" |
||
| 2154 | self.custom = _cast(None, custom) |
||
| 2155 | self.custom_nsprefix_ = "pc" |
||
| 2156 | self.orientation = _cast(float, orientation) |
||
| 2157 | self.orientation_nsprefix_ = "pc" |
||
| 2158 | self.type_ = _cast(None, type_) |
||
| 2159 | self.type__nsprefix_ = "pc" |
||
| 2160 | self.primaryLanguage = _cast(None, primaryLanguage) |
||
| 2161 | self.primaryLanguage_nsprefix_ = "pc" |
||
| 2162 | self.secondaryLanguage = _cast(None, secondaryLanguage) |
||
| 2163 | self.secondaryLanguage_nsprefix_ = "pc" |
||
| 2164 | self.primaryScript = _cast(None, primaryScript) |
||
| 2165 | self.primaryScript_nsprefix_ = "pc" |
||
| 2166 | self.secondaryScript = _cast(None, secondaryScript) |
||
| 2167 | self.secondaryScript_nsprefix_ = "pc" |
||
| 2168 | self.readingDirection = _cast(None, readingDirection) |
||
| 2169 | self.readingDirection_nsprefix_ = "pc" |
||
| 2170 | self.textLineOrder = _cast(None, textLineOrder) |
||
| 2171 | self.textLineOrder_nsprefix_ = "pc" |
||
| 2172 | self.conf = _cast(float, conf) |
||
| 2173 | self.conf_nsprefix_ = "pc" |
||
| 2174 | if AlternativeImage is None: |
||
| 2175 | self.AlternativeImage = [] |
||
| 2176 | else: |
||
| 2177 | self.AlternativeImage = AlternativeImage |
||
| 2178 | self.AlternativeImage_nsprefix_ = "pc" |
||
| 2179 | self.Border = Border |
||
| 2180 | self.Border_nsprefix_ = "pc" |
||
| 2181 | self.PrintSpace = PrintSpace |
||
| 2182 | self.PrintSpace_nsprefix_ = "pc" |
||
| 2183 | self.ReadingOrder = ReadingOrder |
||
| 2184 | self.ReadingOrder_nsprefix_ = "pc" |
||
| 2185 | self.Layers = Layers |
||
| 2186 | self.Layers_nsprefix_ = "pc" |
||
| 2187 | self.Relations = Relations |
||
| 2188 | self.Relations_nsprefix_ = "pc" |
||
| 2189 | self.TextStyle = TextStyle |
||
| 2190 | self.TextStyle_nsprefix_ = "pc" |
||
| 2191 | self.UserDefined = UserDefined |
||
| 2192 | self.UserDefined_nsprefix_ = "pc" |
||
| 2193 | if Labels is None: |
||
| 2194 | self.Labels = [] |
||
| 2195 | else: |
||
| 2196 | self.Labels = Labels |
||
| 2197 | self.Labels_nsprefix_ = "pc" |
||
| 2198 | if TextRegion is None: |
||
| 2199 | self.TextRegion = [] |
||
| 2200 | else: |
||
| 2201 | self.TextRegion = TextRegion |
||
| 2202 | self.TextRegion_nsprefix_ = "pc" |
||
| 2203 | if ImageRegion is None: |
||
| 2204 | self.ImageRegion = [] |
||
| 2205 | else: |
||
| 2206 | self.ImageRegion = ImageRegion |
||
| 2207 | self.ImageRegion_nsprefix_ = "pc" |
||
| 2208 | if LineDrawingRegion is None: |
||
| 2209 | self.LineDrawingRegion = [] |
||
| 2210 | else: |
||
| 2211 | self.LineDrawingRegion = LineDrawingRegion |
||
| 2212 | self.LineDrawingRegion_nsprefix_ = "pc" |
||
| 2213 | if GraphicRegion is None: |
||
| 2214 | self.GraphicRegion = [] |
||
| 2215 | else: |
||
| 2216 | self.GraphicRegion = GraphicRegion |
||
| 2217 | self.GraphicRegion_nsprefix_ = "pc" |
||
| 2218 | if TableRegion is None: |
||
| 2219 | self.TableRegion = [] |
||
| 2220 | else: |
||
| 2221 | self.TableRegion = TableRegion |
||
| 2222 | self.TableRegion_nsprefix_ = "pc" |
||
| 2223 | if ChartRegion is None: |
||
| 2224 | self.ChartRegion = [] |
||
| 2225 | else: |
||
| 2226 | self.ChartRegion = ChartRegion |
||
| 2227 | self.ChartRegion_nsprefix_ = "pc" |
||
| 2228 | if MapRegion is None: |
||
| 2229 | self.MapRegion = [] |
||
| 2230 | else: |
||
| 2231 | self.MapRegion = MapRegion |
||
| 2232 | self.MapRegion_nsprefix_ = "pc" |
||
| 2233 | if SeparatorRegion is None: |
||
| 2234 | self.SeparatorRegion = [] |
||
| 2235 | else: |
||
| 2236 | self.SeparatorRegion = SeparatorRegion |
||
| 2237 | self.SeparatorRegion_nsprefix_ = "pc" |
||
| 2238 | if MathsRegion is None: |
||
| 2239 | self.MathsRegion = [] |
||
| 2240 | else: |
||
| 2241 | self.MathsRegion = MathsRegion |
||
| 2242 | self.MathsRegion_nsprefix_ = "pc" |
||
| 2243 | if ChemRegion is None: |
||
| 2244 | self.ChemRegion = [] |
||
| 2245 | else: |
||
| 2246 | self.ChemRegion = ChemRegion |
||
| 2247 | self.ChemRegion_nsprefix_ = "pc" |
||
| 2248 | if MusicRegion is None: |
||
| 2249 | self.MusicRegion = [] |
||
| 2250 | else: |
||
| 2251 | self.MusicRegion = MusicRegion |
||
| 2252 | self.MusicRegion_nsprefix_ = "pc" |
||
| 2253 | if AdvertRegion is None: |
||
| 2254 | self.AdvertRegion = [] |
||
| 2255 | else: |
||
| 2256 | self.AdvertRegion = AdvertRegion |
||
| 2257 | self.AdvertRegion_nsprefix_ = "pc" |
||
| 2258 | if NoiseRegion is None: |
||
| 2259 | self.NoiseRegion = [] |
||
| 2260 | else: |
||
| 2261 | self.NoiseRegion = NoiseRegion |
||
| 2262 | self.NoiseRegion_nsprefix_ = "pc" |
||
| 2263 | if UnknownRegion is None: |
||
| 2264 | self.UnknownRegion = [] |
||
| 2265 | else: |
||
| 2266 | self.UnknownRegion = UnknownRegion |
||
| 2267 | self.UnknownRegion_nsprefix_ = "pc" |
||
| 2268 | if CustomRegion is None: |
||
| 2269 | self.CustomRegion = [] |
||
| 2270 | else: |
||
| 2271 | self.CustomRegion = CustomRegion |
||
| 2272 | self.CustomRegion_nsprefix_ = "pc" |
||
| 2273 | def factory(*args_, **kwargs_): |
||
| 2274 | if CurrentSubclassModule_ is not None: |
||
| 2275 | subclass = getSubclassFromModule_( |
||
| 2276 | CurrentSubclassModule_, PageType) |
||
| 2277 | if subclass is not None: |
||
| 2278 | return subclass(*args_, **kwargs_) |
||
| 2279 | if PageType.subclass: |
||
| 2280 | return PageType.subclass(*args_, **kwargs_) |
||
| 2281 | else: |
||
| 2282 | return PageType(*args_, **kwargs_) |
||
| 2283 | factory = staticmethod(factory) |
||
| 2284 | def get_ns_prefix_(self): |
||
| 2285 | return self.ns_prefix_ |
||
| 2286 | def set_ns_prefix_(self, ns_prefix): |
||
| 2287 | self.ns_prefix_ = ns_prefix |
||
| 2288 | def get_AlternativeImage(self): |
||
| 2289 | return self.AlternativeImage |
||
| 2290 | def set_AlternativeImage(self, AlternativeImage): |
||
| 2291 | self.AlternativeImage = AlternativeImage |
||
| 2292 | def add_AlternativeImage(self, value): |
||
| 2293 | self.AlternativeImage.append(value) |
||
| 2294 | def insert_AlternativeImage_at(self, index, value): |
||
| 2295 | self.AlternativeImage.insert(index, value) |
||
| 2296 | def replace_AlternativeImage_at(self, index, value): |
||
| 2297 | self.AlternativeImage[index] = value |
||
| 2298 | def get_Border(self): |
||
| 2299 | return self.Border |
||
| 2300 | def set_Border(self, Border): |
||
| 2301 | self.Border = Border |
||
| 2302 | def get_PrintSpace(self): |
||
| 2303 | return self.PrintSpace |
||
| 2304 | def set_PrintSpace(self, PrintSpace): |
||
| 2305 | self.PrintSpace = PrintSpace |
||
| 2306 | def get_ReadingOrder(self): |
||
| 2307 | return self.ReadingOrder |
||
| 2308 | def set_ReadingOrder(self, ReadingOrder): |
||
| 2309 | self.ReadingOrder = ReadingOrder |
||
| 2310 | def get_Layers(self): |
||
| 2311 | return self.Layers |
||
| 2312 | def set_Layers(self, Layers): |
||
| 2313 | self.Layers = Layers |
||
| 2314 | def get_Relations(self): |
||
| 2315 | return self.Relations |
||
| 2316 | def set_Relations(self, Relations): |
||
| 2317 | self.Relations = Relations |
||
| 2318 | def get_TextStyle(self): |
||
| 2319 | return self.TextStyle |
||
| 2320 | def set_TextStyle(self, TextStyle): |
||
| 2321 | self.TextStyle = TextStyle |
||
| 2322 | def get_UserDefined(self): |
||
| 2323 | return self.UserDefined |
||
| 2324 | def set_UserDefined(self, UserDefined): |
||
| 2325 | self.UserDefined = UserDefined |
||
| 2326 | def get_Labels(self): |
||
| 2327 | return self.Labels |
||
| 2328 | def set_Labels(self, Labels): |
||
| 2329 | self.Labels = Labels |
||
| 2330 | def add_Labels(self, value): |
||
| 2331 | self.Labels.append(value) |
||
| 2332 | def insert_Labels_at(self, index, value): |
||
| 2333 | self.Labels.insert(index, value) |
||
| 2334 | def replace_Labels_at(self, index, value): |
||
| 2335 | self.Labels[index] = value |
||
| 2336 | def get_TextRegion(self): |
||
| 2337 | return self.TextRegion |
||
| 2338 | def set_TextRegion(self, TextRegion): |
||
| 2339 | self.TextRegion = TextRegion |
||
| 2340 | def add_TextRegion(self, value): |
||
| 2341 | self.TextRegion.append(value) |
||
| 2342 | def insert_TextRegion_at(self, index, value): |
||
| 2343 | self.TextRegion.insert(index, value) |
||
| 2344 | def replace_TextRegion_at(self, index, value): |
||
| 2345 | self.TextRegion[index] = value |
||
| 2346 | def get_ImageRegion(self): |
||
| 2347 | return self.ImageRegion |
||
| 2348 | def set_ImageRegion(self, ImageRegion): |
||
| 2349 | self.ImageRegion = ImageRegion |
||
| 2350 | def add_ImageRegion(self, value): |
||
| 2351 | self.ImageRegion.append(value) |
||
| 2352 | def insert_ImageRegion_at(self, index, value): |
||
| 2353 | self.ImageRegion.insert(index, value) |
||
| 2354 | def replace_ImageRegion_at(self, index, value): |
||
| 2355 | self.ImageRegion[index] = value |
||
| 2356 | def get_LineDrawingRegion(self): |
||
| 2357 | return self.LineDrawingRegion |
||
| 2358 | def set_LineDrawingRegion(self, LineDrawingRegion): |
||
| 2359 | self.LineDrawingRegion = LineDrawingRegion |
||
| 2360 | def add_LineDrawingRegion(self, value): |
||
| 2361 | self.LineDrawingRegion.append(value) |
||
| 2362 | def insert_LineDrawingRegion_at(self, index, value): |
||
| 2363 | self.LineDrawingRegion.insert(index, value) |
||
| 2364 | def replace_LineDrawingRegion_at(self, index, value): |
||
| 2365 | self.LineDrawingRegion[index] = value |
||
| 2366 | def get_GraphicRegion(self): |
||
| 2367 | return self.GraphicRegion |
||
| 2368 | def set_GraphicRegion(self, GraphicRegion): |
||
| 2369 | self.GraphicRegion = GraphicRegion |
||
| 2370 | def add_GraphicRegion(self, value): |
||
| 2371 | self.GraphicRegion.append(value) |
||
| 2372 | def insert_GraphicRegion_at(self, index, value): |
||
| 2373 | self.GraphicRegion.insert(index, value) |
||
| 2374 | def replace_GraphicRegion_at(self, index, value): |
||
| 2375 | self.GraphicRegion[index] = value |
||
| 2376 | def get_TableRegion(self): |
||
| 2377 | return self.TableRegion |
||
| 2378 | def set_TableRegion(self, TableRegion): |
||
| 2379 | self.TableRegion = TableRegion |
||
| 2380 | def add_TableRegion(self, value): |
||
| 2381 | self.TableRegion.append(value) |
||
| 2382 | def insert_TableRegion_at(self, index, value): |
||
| 2383 | self.TableRegion.insert(index, value) |
||
| 2384 | def replace_TableRegion_at(self, index, value): |
||
| 2385 | self.TableRegion[index] = value |
||
| 2386 | def get_ChartRegion(self): |
||
| 2387 | return self.ChartRegion |
||
| 2388 | def set_ChartRegion(self, ChartRegion): |
||
| 2389 | self.ChartRegion = ChartRegion |
||
| 2390 | def add_ChartRegion(self, value): |
||
| 2391 | self.ChartRegion.append(value) |
||
| 2392 | def insert_ChartRegion_at(self, index, value): |
||
| 2393 | self.ChartRegion.insert(index, value) |
||
| 2394 | def replace_ChartRegion_at(self, index, value): |
||
| 2395 | self.ChartRegion[index] = value |
||
| 2396 | def get_MapRegion(self): |
||
| 2397 | return self.MapRegion |
||
| 2398 | def set_MapRegion(self, MapRegion): |
||
| 2399 | self.MapRegion = MapRegion |
||
| 2400 | def add_MapRegion(self, value): |
||
| 2401 | self.MapRegion.append(value) |
||
| 2402 | def insert_MapRegion_at(self, index, value): |
||
| 2403 | self.MapRegion.insert(index, value) |
||
| 2404 | def replace_MapRegion_at(self, index, value): |
||
| 2405 | self.MapRegion[index] = value |
||
| 2406 | def get_SeparatorRegion(self): |
||
| 2407 | return self.SeparatorRegion |
||
| 2408 | def set_SeparatorRegion(self, SeparatorRegion): |
||
| 2409 | self.SeparatorRegion = SeparatorRegion |
||
| 2410 | def add_SeparatorRegion(self, value): |
||
| 2411 | self.SeparatorRegion.append(value) |
||
| 2412 | def insert_SeparatorRegion_at(self, index, value): |
||
| 2413 | self.SeparatorRegion.insert(index, value) |
||
| 2414 | def replace_SeparatorRegion_at(self, index, value): |
||
| 2415 | self.SeparatorRegion[index] = value |
||
| 2416 | def get_MathsRegion(self): |
||
| 2417 | return self.MathsRegion |
||
| 2418 | def set_MathsRegion(self, MathsRegion): |
||
| 2419 | self.MathsRegion = MathsRegion |
||
| 2420 | def add_MathsRegion(self, value): |
||
| 2421 | self.MathsRegion.append(value) |
||
| 2422 | def insert_MathsRegion_at(self, index, value): |
||
| 2423 | self.MathsRegion.insert(index, value) |
||
| 2424 | def replace_MathsRegion_at(self, index, value): |
||
| 2425 | self.MathsRegion[index] = value |
||
| 2426 | def get_ChemRegion(self): |
||
| 2427 | return self.ChemRegion |
||
| 2428 | def set_ChemRegion(self, ChemRegion): |
||
| 2429 | self.ChemRegion = ChemRegion |
||
| 2430 | def add_ChemRegion(self, value): |
||
| 2431 | self.ChemRegion.append(value) |
||
| 2432 | def insert_ChemRegion_at(self, index, value): |
||
| 2433 | self.ChemRegion.insert(index, value) |
||
| 2434 | def replace_ChemRegion_at(self, index, value): |
||
| 2435 | self.ChemRegion[index] = value |
||
| 2436 | def get_MusicRegion(self): |
||
| 2437 | return self.MusicRegion |
||
| 2438 | def set_MusicRegion(self, MusicRegion): |
||
| 2439 | self.MusicRegion = MusicRegion |
||
| 2440 | def add_MusicRegion(self, value): |
||
| 2441 | self.MusicRegion.append(value) |
||
| 2442 | def insert_MusicRegion_at(self, index, value): |
||
| 2443 | self.MusicRegion.insert(index, value) |
||
| 2444 | def replace_MusicRegion_at(self, index, value): |
||
| 2445 | self.MusicRegion[index] = value |
||
| 2446 | def get_AdvertRegion(self): |
||
| 2447 | return self.AdvertRegion |
||
| 2448 | def set_AdvertRegion(self, AdvertRegion): |
||
| 2449 | self.AdvertRegion = AdvertRegion |
||
| 2450 | def add_AdvertRegion(self, value): |
||
| 2451 | self.AdvertRegion.append(value) |
||
| 2452 | def insert_AdvertRegion_at(self, index, value): |
||
| 2453 | self.AdvertRegion.insert(index, value) |
||
| 2454 | def replace_AdvertRegion_at(self, index, value): |
||
| 2455 | self.AdvertRegion[index] = value |
||
| 2456 | def get_NoiseRegion(self): |
||
| 2457 | return self.NoiseRegion |
||
| 2458 | def set_NoiseRegion(self, NoiseRegion): |
||
| 2459 | self.NoiseRegion = NoiseRegion |
||
| 2460 | def add_NoiseRegion(self, value): |
||
| 2461 | self.NoiseRegion.append(value) |
||
| 2462 | def insert_NoiseRegion_at(self, index, value): |
||
| 2463 | self.NoiseRegion.insert(index, value) |
||
| 2464 | def replace_NoiseRegion_at(self, index, value): |
||
| 2465 | self.NoiseRegion[index] = value |
||
| 2466 | def get_UnknownRegion(self): |
||
| 2467 | return self.UnknownRegion |
||
| 2468 | def set_UnknownRegion(self, UnknownRegion): |
||
| 2469 | self.UnknownRegion = UnknownRegion |
||
| 2470 | def add_UnknownRegion(self, value): |
||
| 2471 | self.UnknownRegion.append(value) |
||
| 2472 | def insert_UnknownRegion_at(self, index, value): |
||
| 2473 | self.UnknownRegion.insert(index, value) |
||
| 2474 | def replace_UnknownRegion_at(self, index, value): |
||
| 2475 | self.UnknownRegion[index] = value |
||
| 2476 | def get_CustomRegion(self): |
||
| 2477 | return self.CustomRegion |
||
| 2478 | def set_CustomRegion(self, CustomRegion): |
||
| 2479 | self.CustomRegion = CustomRegion |
||
| 2480 | def add_CustomRegion(self, value): |
||
| 2481 | self.CustomRegion.append(value) |
||
| 2482 | def insert_CustomRegion_at(self, index, value): |
||
| 2483 | self.CustomRegion.insert(index, value) |
||
| 2484 | def replace_CustomRegion_at(self, index, value): |
||
| 2485 | self.CustomRegion[index] = value |
||
| 2486 | def get_imageFilename(self): |
||
| 2487 | return self.imageFilename |
||
| 2488 | def set_imageFilename(self, imageFilename): |
||
| 2489 | self.imageFilename = imageFilename |
||
| 2490 | def get_imageWidth(self): |
||
| 2491 | return self.imageWidth |
||
| 2492 | def set_imageWidth(self, imageWidth): |
||
| 2493 | self.imageWidth = imageWidth |
||
| 2494 | def get_imageHeight(self): |
||
| 2495 | return self.imageHeight |
||
| 2496 | def set_imageHeight(self, imageHeight): |
||
| 2497 | self.imageHeight = imageHeight |
||
| 2498 | def get_imageXResolution(self): |
||
| 2499 | return self.imageXResolution |
||
| 2500 | def set_imageXResolution(self, imageXResolution): |
||
| 2501 | self.imageXResolution = imageXResolution |
||
| 2502 | def get_imageYResolution(self): |
||
| 2503 | return self.imageYResolution |
||
| 2504 | def set_imageYResolution(self, imageYResolution): |
||
| 2505 | self.imageYResolution = imageYResolution |
||
| 2506 | def get_imageResolutionUnit(self): |
||
| 2507 | return self.imageResolutionUnit |
||
| 2508 | def set_imageResolutionUnit(self, imageResolutionUnit): |
||
| 2509 | self.imageResolutionUnit = imageResolutionUnit |
||
| 2510 | def get_custom(self): |
||
| 2511 | return self.custom |
||
| 2512 | def set_custom(self, custom): |
||
| 2513 | self.custom = custom |
||
| 2514 | def get_orientation(self): |
||
| 2515 | return self.orientation |
||
| 2516 | def set_orientation(self, orientation): |
||
| 2517 | self.orientation = orientation |
||
| 2518 | def get_type(self): |
||
| 2519 | return self.type_ |
||
| 2520 | def set_type(self, type_): |
||
| 2521 | self.type_ = type_ |
||
| 2522 | def get_primaryLanguage(self): |
||
| 2523 | return self.primaryLanguage |
||
| 2524 | def set_primaryLanguage(self, primaryLanguage): |
||
| 2525 | self.primaryLanguage = primaryLanguage |
||
| 2526 | def get_secondaryLanguage(self): |
||
| 2527 | return self.secondaryLanguage |
||
| 2528 | def set_secondaryLanguage(self, secondaryLanguage): |
||
| 2529 | self.secondaryLanguage = secondaryLanguage |
||
| 2530 | def get_primaryScript(self): |
||
| 2531 | return self.primaryScript |
||
| 2532 | def set_primaryScript(self, primaryScript): |
||
| 2533 | self.primaryScript = primaryScript |
||
| 2534 | def get_secondaryScript(self): |
||
| 2535 | return self.secondaryScript |
||
| 2536 | def set_secondaryScript(self, secondaryScript): |
||
| 2537 | self.secondaryScript = secondaryScript |
||
| 2538 | def get_readingDirection(self): |
||
| 2539 | return self.readingDirection |
||
| 2540 | def set_readingDirection(self, readingDirection): |
||
| 2541 | self.readingDirection = readingDirection |
||
| 2542 | def get_textLineOrder(self): |
||
| 2543 | return self.textLineOrder |
||
| 2544 | def set_textLineOrder(self, textLineOrder): |
||
| 2545 | self.textLineOrder = textLineOrder |
||
| 2546 | def get_conf(self): |
||
| 2547 | return self.conf |
||
| 2548 | def set_conf(self, conf): |
||
| 2549 | self.conf = conf |
||
| 2550 | def validate_PageTypeSimpleType(self, value): |
||
| 2551 | # Validate type pc:PageTypeSimpleType, a restriction on string. |
||
| 2552 | if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None: |
||
| 2553 | if not isinstance(value, str): |
||
| 2554 | lineno = self.gds_get_node_lineno_() |
||
| 2555 | self.gds_collector_.add_message('Value "%(value)s"%(lineno)s is not of the correct base simple type (str)' % {"value": value, "lineno": lineno, }) |
||
| 2556 | return False |
||
| 2557 | value = value |
||
| 2558 | enumerations = ['front-cover', 'back-cover', 'title', 'table-of-contents', 'index', 'content', 'blank', 'other'] |
||
| 2559 | if value not in enumerations: |
||
| 2560 | lineno = self.gds_get_node_lineno_() |
||
| 2561 | self.gds_collector_.add_message('Value "%(value)s"%(lineno)s does not match xsd enumeration restriction on PageTypeSimpleType' % {"value" : encode_str_2_3(value), "lineno": lineno} ) |
||
| 2562 | result = False |
||
| 2563 | def validate_LanguageSimpleType(self, value): |
||
| 2564 | # Validate type pc:LanguageSimpleType, a restriction on string. |
||
| 2565 | if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None: |
||
| 2566 | if not isinstance(value, str): |
||
| 2567 | lineno = self.gds_get_node_lineno_() |
||
| 2568 | self.gds_collector_.add_message('Value "%(value)s"%(lineno)s is not of the correct base simple type (str)' % {"value": value, "lineno": lineno, }) |
||
| 2569 | return False |
||
| 2570 | value = value |
||
| 2571 | enumerations = ['Abkhaz', 'Afar', 'Afrikaans', 'Akan', 'Albanian', 'Amharic', 'Arabic', 'Aragonese', 'Armenian', 'Assamese', 'Avaric', 'Avestan', 'Aymara', 'Azerbaijani', 'Bambara', 'Bashkir', 'Basque', 'Belarusian', 'Bengali', 'Bihari', 'Bislama', 'Bosnian', 'Breton', 'Bulgarian', 'Burmese', 'Cambodian', 'Cantonese', 'Catalan', 'Chamorro', 'Chechen', 'Chichewa', 'Chinese', 'Chuvash', 'Cornish', 'Corsican', 'Cree', 'Croatian', 'Czech', 'Danish', 'Divehi', 'Dutch', 'Dzongkha', 'English', 'Esperanto', 'Estonian', 'Ewe', 'Faroese', 'Fijian', 'Finnish', 'French', 'Fula', 'Gaelic', 'Galician', 'Ganda', 'Georgian', 'German', 'Greek', 'Guaraní', 'Gujarati', 'Haitian', 'Hausa', 'Hebrew', 'Herero', 'Hindi', 'Hiri Motu', 'Hungarian', 'Icelandic', 'Ido', 'Igbo', 'Indonesian', 'Interlingua', 'Interlingue', 'Inuktitut', 'Inupiaq', 'Irish', 'Italian', 'Japanese', 'Javanese', 'Kalaallisut', 'Kannada', 'Kanuri', 'Kashmiri', 'Kazakh', 'Khmer', 'Kikuyu', 'Kinyarwanda', 'Kirundi', 'Komi', 'Kongo', 'Korean', 'Kurdish', 'Kwanyama', 'Kyrgyz', 'Lao', 'Latin', 'Latvian', 'Limburgish', 'Lingala', 'Lithuanian', 'Luba-Katanga', 'Luxembourgish', 'Macedonian', 'Malagasy', 'Malay', 'Malayalam', 'Maltese', 'Manx', 'Māori', 'Marathi', 'Marshallese', 'Mongolian', 'Nauru', 'Navajo', 'Ndonga', 'Nepali', 'North Ndebele', 'Northern Sami', 'Norwegian', 'Norwegian Bokmål', 'Norwegian Nynorsk', 'Nuosu', 'Occitan', 'Ojibwe', 'Old Church Slavonic', 'Oriya', 'Oromo', 'Ossetian', 'Pāli', 'Panjabi', 'Pashto', 'Persian', 'Polish', 'Portuguese', 'Punjabi', 'Quechua', 'Romanian', 'Romansh', 'Russian', 'Samoan', 'Sango', 'Sanskrit', 'Sardinian', 'Serbian', 'Shona', 'Sindhi', 'Sinhala', 'Slovak', 'Slovene', 'Somali', 'South Ndebele', 'Southern Sotho', 'Spanish', 'Sundanese', 'Swahili', 'Swati', 'Swedish', 'Tagalog', 'Tahitian', 'Tajik', 'Tamil', 'Tatar', 'Telugu', 'Thai', 'Tibetan', 'Tigrinya', 'Tonga', 'Tsonga', 'Tswana', 'Turkish', 'Turkmen', 'Twi', 'Uighur', 'Ukrainian', 'Urdu', 'Uzbek', 'Venda', 'Vietnamese', 'Volapük', 'Walloon', 'Welsh', 'Western Frisian', 'Wolof', 'Xhosa', 'Yiddish', 'Yoruba', 'Zhuang', 'Zulu', 'other'] |
||
| 2572 | if value not in enumerations: |
||
| 2573 | lineno = self.gds_get_node_lineno_() |
||
| 2574 | self.gds_collector_.add_message('Value "%(value)s"%(lineno)s does not match xsd enumeration restriction on LanguageSimpleType' % {"value" : encode_str_2_3(value), "lineno": lineno} ) |
||
| 2575 | result = False |
||
| 2576 | def validate_ScriptSimpleType(self, value): |
||
| 2577 | # Validate type pc:ScriptSimpleType, a restriction on string. |
||
| 2578 | if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None: |
||
| 2579 | if not isinstance(value, str): |
||
| 2580 | lineno = self.gds_get_node_lineno_() |
||
| 2581 | self.gds_collector_.add_message('Value "%(value)s"%(lineno)s is not of the correct base simple type (str)' % {"value": value, "lineno": lineno, }) |
||
| 2582 | return False |
||
| 2583 | value = value |
||
| 2584 | enumerations = ['Adlm - Adlam', 'Afak - Afaka', 'Aghb - Caucasian Albanian', 'Ahom - Ahom, Tai Ahom', 'Arab - Arabic', 'Aran - Arabic (Nastaliq variant)', 'Armi - Imperial Aramaic', 'Armn - Armenian', 'Avst - Avestan', 'Bali - Balinese', 'Bamu - Bamum', 'Bass - Bassa Vah', 'Batk - Batak', 'Beng - Bengali', 'Bhks - Bhaiksuki', 'Blis - Blissymbols', 'Bopo - Bopomofo', 'Brah - Brahmi', 'Brai - Braille', 'Bugi - Buginese', 'Buhd - Buhid', 'Cakm - Chakma', 'Cans - Unified Canadian Aboriginal Syllabics', 'Cari - Carian', 'Cham - Cham', 'Cher - Cherokee', 'Cirt - Cirth', 'Copt - Coptic', 'Cprt - Cypriot', 'Cyrl - Cyrillic', 'Cyrs - Cyrillic (Old Church Slavonic variant)', 'Deva - Devanagari (Nagari)', 'Dsrt - Deseret (Mormon)', 'Dupl - Duployan shorthand, Duployan stenography', 'Egyd - Egyptian demotic', 'Egyh - Egyptian hieratic', 'Egyp - Egyptian hieroglyphs', 'Elba - Elbasan', 'Ethi - Ethiopic', 'Geok - Khutsuri (Asomtavruli and Nuskhuri)', 'Geor - Georgian (Mkhedruli)', 'Glag - Glagolitic', 'Goth - Gothic', 'Gran - Grantha', 'Grek - Greek', 'Gujr - Gujarati', 'Guru - Gurmukhi', 'Hanb - Han with Bopomofo', 'Hang - Hangul', 'Hani - Han (Hanzi, Kanji, Hanja)', 'Hano - Hanunoo (Hanunóo)', 'Hans - Han (Simplified variant)', 'Hant - Han (Traditional variant)', 'Hatr - Hatran', 'Hebr - Hebrew', 'Hira - Hiragana', 'Hluw - Anatolian Hieroglyphs', 'Hmng - Pahawh Hmong', 'Hrkt - Japanese syllabaries', 'Hung - Old Hungarian (Hungarian Runic)', 'Inds - Indus (Harappan)', 'Ital - Old Italic (Etruscan, Oscan etc.)', 'Jamo - Jamo', 'Java - Javanese', 'Jpan - Japanese', 'Jurc - Jurchen', 'Kali - Kayah Li', 'Kana - Katakana', 'Khar - Kharoshthi', 'Khmr - Khmer', 'Khoj - Khojki', 'Kitl - Khitan large script', 'Kits - Khitan small script', 'Knda - Kannada', 'Kore - Korean (alias for Hangul + Han)', 'Kpel - Kpelle', 'Kthi - Kaithi', 'Lana - Tai Tham (Lanna)', 'Laoo - Lao', 'Latf - Latin (Fraktur variant)', 'Latg - Latin (Gaelic variant)', 'Latn - Latin', 'Leke - Leke', 'Lepc - Lepcha (Róng)', 'Limb - Limbu', 'Lina - Linear A', 'Linb - Linear B', 'Lisu - Lisu (Fraser)', 'Loma - Loma', 'Lyci - Lycian', 'Lydi - Lydian', 'Mahj - Mahajani', 'Mand - Mandaic, Mandaean', 'Mani - Manichaean', 'Marc - Marchen', 'Maya - Mayan hieroglyphs', 'Mend - Mende Kikakui', 'Merc - Meroitic Cursive', 'Mero - Meroitic Hieroglyphs', 'Mlym - Malayalam', 'Modi - Modi, Moḍī', 'Mong - Mongolian', 'Moon - Moon (Moon code, Moon script, Moon type)', 'Mroo - Mro, Mru', 'Mtei - Meitei Mayek (Meithei, Meetei)', 'Mult - Multani', 'Mymr - Myanmar (Burmese)', 'Narb - Old North Arabian (Ancient North Arabian)', 'Nbat - Nabataean', 'Newa - Newa, Newar, Newari', 'Nkgb - Nakhi Geba', 'Nkoo - N’Ko', 'Nshu - Nüshu', 'Ogam - Ogham', 'Olck - Ol Chiki (Ol Cemet’, Ol, Santali)', 'Orkh - Old Turkic, Orkhon Runic', 'Orya - Oriya', 'Osge - Osage', 'Osma - Osmanya', 'Palm - Palmyrene', 'Pauc - Pau Cin Hau', 'Perm - Old Permic', 'Phag - Phags-pa', 'Phli - Inscriptional Pahlavi', 'Phlp - Psalter Pahlavi', 'Phlv - Book Pahlavi', 'Phnx - Phoenician', 'Piqd - Klingon (KLI pIqaD)', 'Plrd - Miao (Pollard)', 'Prti - Inscriptional Parthian', 'Rjng - Rejang (Redjang, Kaganga)', 'Roro - Rongorongo', 'Runr - Runic', 'Samr - Samaritan', 'Sara - Sarati', 'Sarb - Old South Arabian', 'Saur - Saurashtra', 'Sgnw - SignWriting', 'Shaw - Shavian (Shaw)', 'Shrd - Sharada, Śāradā', 'Sidd - Siddham', 'Sind - Khudawadi, Sindhi', 'Sinh - Sinhala', 'Sora - Sora Sompeng', 'Sund - Sundanese', 'Sylo - Syloti Nagri', 'Syrc - Syriac', 'Syre - Syriac (Estrangelo variant)', 'Syrj - Syriac (Western variant)', 'Syrn - Syriac (Eastern variant)', 'Tagb - Tagbanwa', 'Takr - Takri', 'Tale - Tai Le', 'Talu - New Tai Lue', 'Taml - Tamil', 'Tang - Tangut', 'Tavt - Tai Viet', 'Telu - Telugu', 'Teng - Tengwar', 'Tfng - Tifinagh (Berber)', 'Tglg - Tagalog (Baybayin, Alibata)', 'Thaa - Thaana', 'Thai - Thai', 'Tibt - Tibetan', 'Tirh - Tirhuta', 'Ugar - Ugaritic', 'Vaii - Vai', 'Visp - Visible Speech', 'Wara - Warang Citi (Varang Kshiti)', 'Wole - Woleai', 'Xpeo - Old Persian', 'Xsux - Cuneiform, Sumero-Akkadian', 'Yiii - Yi', 'Zinh - Code for inherited script', 'Zmth - Mathematical notation', 'Zsye - Symbols (Emoji variant)', 'Zsym - Symbols', 'Zxxx - Code for unwritten documents', 'Zyyy - Code for undetermined script', 'Zzzz - Code for uncoded script', 'other'] |
||
| 2585 | if value not in enumerations: |
||
| 2586 | lineno = self.gds_get_node_lineno_() |
||
| 2587 | self.gds_collector_.add_message('Value "%(value)s"%(lineno)s does not match xsd enumeration restriction on ScriptSimpleType' % {"value" : encode_str_2_3(value), "lineno": lineno} ) |
||
| 2588 | result = False |
||
| 2589 | def validate_ReadingDirectionSimpleType(self, value): |
||
| 2590 | # Validate type pc:ReadingDirectionSimpleType, a restriction on string. |
||
| 2591 | if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None: |
||
| 2592 | if not isinstance(value, str): |
||
| 2593 | lineno = self.gds_get_node_lineno_() |
||
| 2594 | self.gds_collector_.add_message('Value "%(value)s"%(lineno)s is not of the correct base simple type (str)' % {"value": value, "lineno": lineno, }) |
||
| 2595 | return False |
||
| 2596 | value = value |
||
| 2597 | enumerations = ['left-to-right', 'right-to-left', 'top-to-bottom', 'bottom-to-top'] |
||
| 2598 | if value not in enumerations: |
||
| 2599 | lineno = self.gds_get_node_lineno_() |
||
| 2600 | self.gds_collector_.add_message('Value "%(value)s"%(lineno)s does not match xsd enumeration restriction on ReadingDirectionSimpleType' % {"value" : encode_str_2_3(value), "lineno": lineno} ) |
||
| 2601 | result = False |
||
| 2602 | def validate_TextLineOrderSimpleType(self, value): |
||
| 2603 | # Validate type pc:TextLineOrderSimpleType, a restriction on string. |
||
| 2604 | if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None: |
||
| 2605 | if not isinstance(value, str): |
||
| 2606 | lineno = self.gds_get_node_lineno_() |
||
| 2607 | self.gds_collector_.add_message('Value "%(value)s"%(lineno)s is not of the correct base simple type (str)' % {"value": value, "lineno": lineno, }) |
||
| 2608 | return False |
||
| 2609 | value = value |
||
| 2610 | enumerations = ['top-to-bottom', 'bottom-to-top', 'left-to-right', 'right-to-left'] |
||
| 2611 | if value not in enumerations: |
||
| 2612 | lineno = self.gds_get_node_lineno_() |
||
| 2613 | self.gds_collector_.add_message('Value "%(value)s"%(lineno)s does not match xsd enumeration restriction on TextLineOrderSimpleType' % {"value" : encode_str_2_3(value), "lineno": lineno} ) |
||
| 2614 | result = False |
||
| 2615 | View Code Duplication | def validate_ConfSimpleType(self, value): |
|
| 2616 | # Validate type pc:ConfSimpleType, a restriction on float. |
||
| 2617 | if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None: |
||
| 2618 | if not isinstance(value, float): |
||
| 2619 | lineno = self.gds_get_node_lineno_() |
||
| 2620 | self.gds_collector_.add_message('Value "%(value)s"%(lineno)s is not of the correct base simple type (float)' % {"value": value, "lineno": lineno, }) |
||
| 2621 | return False |
||
| 2622 | if value < 0: |
||
| 2623 | lineno = self.gds_get_node_lineno_() |
||
| 2624 | self.gds_collector_.add_message('Value "%(value)s"%(lineno)s does not match xsd minInclusive restriction on ConfSimpleType' % {"value": value, "lineno": lineno} ) |
||
| 2625 | result = False |
||
| 2626 | if value > 1: |
||
| 2627 | lineno = self.gds_get_node_lineno_() |
||
| 2628 | self.gds_collector_.add_message('Value "%(value)s"%(lineno)s does not match xsd maxInclusive restriction on ConfSimpleType' % {"value": value, "lineno": lineno} ) |
||
| 2629 | result = False |
||
| 2630 | def hasContent_(self): |
||
| 2631 | if ( |
||
| 2632 | self.AlternativeImage or |
||
| 2633 | self.Border is not None or |
||
| 2634 | self.PrintSpace is not None or |
||
| 2635 | self.ReadingOrder is not None or |
||
| 2636 | self.Layers is not None or |
||
| 2637 | self.Relations is not None or |
||
| 2638 | self.TextStyle is not None or |
||
| 2639 | self.UserDefined is not None or |
||
| 2640 | self.Labels or |
||
| 2641 | self.TextRegion or |
||
| 2642 | self.ImageRegion or |
||
| 2643 | self.LineDrawingRegion or |
||
| 2644 | self.GraphicRegion or |
||
| 2645 | self.TableRegion or |
||
| 2646 | self.ChartRegion or |
||
| 2647 | self.MapRegion or |
||
| 2648 | self.SeparatorRegion or |
||
| 2649 | self.MathsRegion or |
||
| 2650 | self.ChemRegion or |
||
| 2651 | self.MusicRegion or |
||
| 2652 | self.AdvertRegion or |
||
| 2653 | self.NoiseRegion or |
||
| 2654 | self.UnknownRegion or |
||
| 2655 | self.CustomRegion |
||
| 2656 | ): |
||
| 2657 | return True |
||
| 2658 | else: |
||
| 2659 | return False |
||
| 2660 | def export(self, outfile, level, namespaceprefix_='', namespacedef_='xmlns:pc="http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15"', name_='PageType', pretty_print=True): |
||
| 2661 | imported_ns_def_ = GenerateDSNamespaceDefs_.get('PageType') |
||
| 2662 | if imported_ns_def_ is not None: |
||
| 2663 | namespacedef_ = imported_ns_def_ |
||
| 2664 | if pretty_print: |
||
| 2665 | eol_ = '\n' |
||
| 2666 | else: |
||
| 2667 | eol_ = '' |
||
| 2668 | if self.original_tagname_ is not None and name_ == 'PageType': |
||
| 2669 | name_ = self.original_tagname_ |
||
| 2670 | if UseCapturedNS_ and self.ns_prefix_: |
||
| 2671 | namespaceprefix_ = self.ns_prefix_ + ':' |
||
| 2672 | showIndent(outfile, level, pretty_print) |
||
| 2673 | outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) |
||
| 2674 | already_processed = set() |
||
| 2675 | self.exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='PageType') |
||
| 2676 | if self.hasContent_(): |
||
| 2677 | outfile.write('>%s' % (eol_, )) |
||
| 2678 | self.exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='PageType', pretty_print=pretty_print) |
||
| 2679 | showIndent(outfile, level, pretty_print) |
||
| 2680 | outfile.write('</%s%s>%s' % (namespaceprefix_, name_, eol_)) |
||
| 2681 | else: |
||
| 2682 | outfile.write('/>%s' % (eol_, )) |
||
| 2683 | def exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='PageType'): |
||
| 2684 | if self.imageFilename is not None and 'imageFilename' not in already_processed: |
||
| 2685 | already_processed.add('imageFilename') |
||
| 2686 | outfile.write(' imageFilename=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.imageFilename), input_name='imageFilename')), )) |
||
| 2687 | if self.imageWidth is not None and 'imageWidth' not in already_processed: |
||
| 2688 | already_processed.add('imageWidth') |
||
| 2689 | outfile.write(' imageWidth="%s"' % self.gds_format_integer(self.imageWidth, input_name='imageWidth')) |
||
| 2690 | if self.imageHeight is not None and 'imageHeight' not in already_processed: |
||
| 2691 | already_processed.add('imageHeight') |
||
| 2692 | outfile.write(' imageHeight="%s"' % self.gds_format_integer(self.imageHeight, input_name='imageHeight')) |
||
| 2693 | if self.imageXResolution is not None and 'imageXResolution' not in already_processed: |
||
| 2694 | already_processed.add('imageXResolution') |
||
| 2695 | outfile.write(' imageXResolution="%s"' % self.gds_format_float(self.imageXResolution, input_name='imageXResolution')) |
||
| 2696 | if self.imageYResolution is not None and 'imageYResolution' not in already_processed: |
||
| 2697 | already_processed.add('imageYResolution') |
||
| 2698 | outfile.write(' imageYResolution="%s"' % self.gds_format_float(self.imageYResolution, input_name='imageYResolution')) |
||
| 2699 | if self.imageResolutionUnit is not None and 'imageResolutionUnit' not in already_processed: |
||
| 2700 | already_processed.add('imageResolutionUnit') |
||
| 2701 | outfile.write(' imageResolutionUnit=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.imageResolutionUnit), input_name='imageResolutionUnit')), )) |
||
| 2702 | if self.custom is not None and 'custom' not in already_processed: |
||
| 2703 | already_processed.add('custom') |
||
| 2704 | outfile.write(' custom=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.custom), input_name='custom')), )) |
||
| 2705 | if self.orientation is not None and 'orientation' not in already_processed: |
||
| 2706 | already_processed.add('orientation') |
||
| 2707 | outfile.write(' orientation="%s"' % self.gds_format_float(self.orientation, input_name='orientation')) |
||
| 2708 | if self.type_ is not None and 'type_' not in already_processed: |
||
| 2709 | already_processed.add('type_') |
||
| 2710 | outfile.write(' type=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.type_), input_name='type')), )) |
||
| 2711 | if self.primaryLanguage is not None and 'primaryLanguage' not in already_processed: |
||
| 2712 | already_processed.add('primaryLanguage') |
||
| 2713 | outfile.write(' primaryLanguage=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.primaryLanguage), input_name='primaryLanguage')), )) |
||
| 2714 | if self.secondaryLanguage is not None and 'secondaryLanguage' not in already_processed: |
||
| 2715 | already_processed.add('secondaryLanguage') |
||
| 2716 | outfile.write(' secondaryLanguage=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.secondaryLanguage), input_name='secondaryLanguage')), )) |
||
| 2717 | if self.primaryScript is not None and 'primaryScript' not in already_processed: |
||
| 2718 | already_processed.add('primaryScript') |
||
| 2719 | outfile.write(' primaryScript=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.primaryScript), input_name='primaryScript')), )) |
||
| 2720 | if self.secondaryScript is not None and 'secondaryScript' not in already_processed: |
||
| 2721 | already_processed.add('secondaryScript') |
||
| 2722 | outfile.write(' secondaryScript=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.secondaryScript), input_name='secondaryScript')), )) |
||
| 2723 | if self.readingDirection is not None and 'readingDirection' not in already_processed: |
||
| 2724 | already_processed.add('readingDirection') |
||
| 2725 | outfile.write(' readingDirection=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.readingDirection), input_name='readingDirection')), )) |
||
| 2726 | if self.textLineOrder is not None and 'textLineOrder' not in already_processed: |
||
| 2727 | already_processed.add('textLineOrder') |
||
| 2728 | outfile.write(' textLineOrder=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.textLineOrder), input_name='textLineOrder')), )) |
||
| 2729 | if self.conf is not None and 'conf' not in already_processed: |
||
| 2730 | already_processed.add('conf') |
||
| 2731 | outfile.write(' conf="%s"' % self.gds_format_float(self.conf, input_name='conf')) |
||
| 2732 | def exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='xmlns:pc="http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15"', name_='PageType', fromsubclass_=False, pretty_print=True): |
||
| 2733 | if pretty_print: |
||
| 2734 | eol_ = '\n' |
||
| 2735 | else: |
||
| 2736 | eol_ = '' |
||
| 2737 | for AlternativeImage_ in self.AlternativeImage: |
||
| 2738 | namespaceprefix_ = self.AlternativeImage_nsprefix_ + ':' if (UseCapturedNS_ and self.AlternativeImage_nsprefix_) else '' |
||
| 2739 | AlternativeImage_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='AlternativeImage', pretty_print=pretty_print) |
||
| 2740 | if self.Border is not None: |
||
| 2741 | namespaceprefix_ = self.Border_nsprefix_ + ':' if (UseCapturedNS_ and self.Border_nsprefix_) else '' |
||
| 2742 | self.Border.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Border', pretty_print=pretty_print) |
||
| 2743 | if self.PrintSpace is not None: |
||
| 2744 | namespaceprefix_ = self.PrintSpace_nsprefix_ + ':' if (UseCapturedNS_ and self.PrintSpace_nsprefix_) else '' |
||
| 2745 | self.PrintSpace.export(outfile, level, namespaceprefix_, namespacedef_='', name_='PrintSpace', pretty_print=pretty_print) |
||
| 2746 | if self.ReadingOrder is not None: |
||
| 2747 | namespaceprefix_ = self.ReadingOrder_nsprefix_ + ':' if (UseCapturedNS_ and self.ReadingOrder_nsprefix_) else '' |
||
| 2748 | self.ReadingOrder.export(outfile, level, namespaceprefix_, namespacedef_='', name_='ReadingOrder', pretty_print=pretty_print) |
||
| 2749 | if self.Layers is not None: |
||
| 2750 | namespaceprefix_ = self.Layers_nsprefix_ + ':' if (UseCapturedNS_ and self.Layers_nsprefix_) else '' |
||
| 2751 | self.Layers.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Layers', pretty_print=pretty_print) |
||
| 2752 | if self.Relations is not None: |
||
| 2753 | namespaceprefix_ = self.Relations_nsprefix_ + ':' if (UseCapturedNS_ and self.Relations_nsprefix_) else '' |
||
| 2754 | self.Relations.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Relations', pretty_print=pretty_print) |
||
| 2755 | if self.TextStyle is not None: |
||
| 2756 | namespaceprefix_ = self.TextStyle_nsprefix_ + ':' if (UseCapturedNS_ and self.TextStyle_nsprefix_) else '' |
||
| 2757 | self.TextStyle.export(outfile, level, namespaceprefix_, namespacedef_='', name_='TextStyle', pretty_print=pretty_print) |
||
| 2758 | if self.UserDefined is not None: |
||
| 2759 | namespaceprefix_ = self.UserDefined_nsprefix_ + ':' if (UseCapturedNS_ and self.UserDefined_nsprefix_) else '' |
||
| 2760 | self.UserDefined.export(outfile, level, namespaceprefix_, namespacedef_='', name_='UserDefined', pretty_print=pretty_print) |
||
| 2761 | for Labels_ in self.Labels: |
||
| 2762 | namespaceprefix_ = self.Labels_nsprefix_ + ':' if (UseCapturedNS_ and self.Labels_nsprefix_) else '' |
||
| 2763 | Labels_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Labels', pretty_print=pretty_print) |
||
| 2764 | for TextRegion_ in self.TextRegion: |
||
| 2765 | namespaceprefix_ = self.TextRegion_nsprefix_ + ':' if (UseCapturedNS_ and self.TextRegion_nsprefix_) else '' |
||
| 2766 | TextRegion_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='TextRegion', pretty_print=pretty_print) |
||
| 2767 | for ImageRegion_ in self.ImageRegion: |
||
| 2768 | namespaceprefix_ = self.ImageRegion_nsprefix_ + ':' if (UseCapturedNS_ and self.ImageRegion_nsprefix_) else '' |
||
| 2769 | ImageRegion_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='ImageRegion', pretty_print=pretty_print) |
||
| 2770 | for LineDrawingRegion_ in self.LineDrawingRegion: |
||
| 2771 | namespaceprefix_ = self.LineDrawingRegion_nsprefix_ + ':' if (UseCapturedNS_ and self.LineDrawingRegion_nsprefix_) else '' |
||
| 2772 | LineDrawingRegion_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='LineDrawingRegion', pretty_print=pretty_print) |
||
| 2773 | for GraphicRegion_ in self.GraphicRegion: |
||
| 2774 | namespaceprefix_ = self.GraphicRegion_nsprefix_ + ':' if (UseCapturedNS_ and self.GraphicRegion_nsprefix_) else '' |
||
| 2775 | GraphicRegion_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='GraphicRegion', pretty_print=pretty_print) |
||
| 2776 | for TableRegion_ in self.TableRegion: |
||
| 2777 | namespaceprefix_ = self.TableRegion_nsprefix_ + ':' if (UseCapturedNS_ and self.TableRegion_nsprefix_) else '' |
||
| 2778 | TableRegion_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='TableRegion', pretty_print=pretty_print) |
||
| 2779 | for ChartRegion_ in self.ChartRegion: |
||
| 2780 | namespaceprefix_ = self.ChartRegion_nsprefix_ + ':' if (UseCapturedNS_ and self.ChartRegion_nsprefix_) else '' |
||
| 2781 | ChartRegion_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='ChartRegion', pretty_print=pretty_print) |
||
| 2782 | for MapRegion_ in self.MapRegion: |
||
| 2783 | namespaceprefix_ = self.MapRegion_nsprefix_ + ':' if (UseCapturedNS_ and self.MapRegion_nsprefix_) else '' |
||
| 2784 | MapRegion_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='MapRegion', pretty_print=pretty_print) |
||
| 2785 | for SeparatorRegion_ in self.SeparatorRegion: |
||
| 2786 | namespaceprefix_ = self.SeparatorRegion_nsprefix_ + ':' if (UseCapturedNS_ and self.SeparatorRegion_nsprefix_) else '' |
||
| 2787 | SeparatorRegion_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='SeparatorRegion', pretty_print=pretty_print) |
||
| 2788 | for MathsRegion_ in self.MathsRegion: |
||
| 2789 | namespaceprefix_ = self.MathsRegion_nsprefix_ + ':' if (UseCapturedNS_ and self.MathsRegion_nsprefix_) else '' |
||
| 2790 | MathsRegion_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='MathsRegion', pretty_print=pretty_print) |
||
| 2791 | for ChemRegion_ in self.ChemRegion: |
||
| 2792 | namespaceprefix_ = self.ChemRegion_nsprefix_ + ':' if (UseCapturedNS_ and self.ChemRegion_nsprefix_) else '' |
||
| 2793 | ChemRegion_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='ChemRegion', pretty_print=pretty_print) |
||
| 2794 | for MusicRegion_ in self.MusicRegion: |
||
| 2795 | namespaceprefix_ = self.MusicRegion_nsprefix_ + ':' if (UseCapturedNS_ and self.MusicRegion_nsprefix_) else '' |
||
| 2796 | MusicRegion_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='MusicRegion', pretty_print=pretty_print) |
||
| 2797 | for AdvertRegion_ in self.AdvertRegion: |
||
| 2798 | namespaceprefix_ = self.AdvertRegion_nsprefix_ + ':' if (UseCapturedNS_ and self.AdvertRegion_nsprefix_) else '' |
||
| 2799 | AdvertRegion_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='AdvertRegion', pretty_print=pretty_print) |
||
| 2800 | for NoiseRegion_ in self.NoiseRegion: |
||
| 2801 | namespaceprefix_ = self.NoiseRegion_nsprefix_ + ':' if (UseCapturedNS_ and self.NoiseRegion_nsprefix_) else '' |
||
| 2802 | NoiseRegion_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='NoiseRegion', pretty_print=pretty_print) |
||
| 2803 | for UnknownRegion_ in self.UnknownRegion: |
||
| 2804 | namespaceprefix_ = self.UnknownRegion_nsprefix_ + ':' if (UseCapturedNS_ and self.UnknownRegion_nsprefix_) else '' |
||
| 2805 | UnknownRegion_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='UnknownRegion', pretty_print=pretty_print) |
||
| 2806 | for CustomRegion_ in self.CustomRegion: |
||
| 2807 | namespaceprefix_ = self.CustomRegion_nsprefix_ + ':' if (UseCapturedNS_ and self.CustomRegion_nsprefix_) else '' |
||
| 2808 | CustomRegion_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='CustomRegion', pretty_print=pretty_print) |
||
| 2809 | def to_etree(self, parent_element=None, name_='PageType', mapping_=None, nsmap_=None): |
||
| 2810 | if parent_element is None: |
||
| 2811 | element = etree_.Element('{http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15}' + name_, nsmap=nsmap_) |
||
| 2812 | else: |
||
| 2813 | element = etree_.SubElement(parent_element, '{http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15}' + name_, nsmap=nsmap_) |
||
| 2814 | if self.imageFilename is not None: |
||
| 2815 | element.set('imageFilename', self.gds_format_string(self.imageFilename)) |
||
| 2816 | if self.imageWidth is not None: |
||
| 2817 | element.set('imageWidth', self.gds_format_integer(self.imageWidth)) |
||
| 2818 | if self.imageHeight is not None: |
||
| 2819 | element.set('imageHeight', self.gds_format_integer(self.imageHeight)) |
||
| 2820 | if self.imageXResolution is not None: |
||
| 2821 | element.set('imageXResolution', self.gds_format_float(self.imageXResolution)) |
||
| 2822 | if self.imageYResolution is not None: |
||
| 2823 | element.set('imageYResolution', self.gds_format_float(self.imageYResolution)) |
||
| 2824 | if self.imageResolutionUnit is not None: |
||
| 2825 | element.set('imageResolutionUnit', self.gds_format_string(self.imageResolutionUnit)) |
||
| 2826 | if self.custom is not None: |
||
| 2827 | element.set('custom', self.gds_format_string(self.custom)) |
||
| 2828 | if self.orientation is not None: |
||
| 2829 | element.set('orientation', self.gds_format_float(self.orientation)) |
||
| 2830 | if self.type_ is not None: |
||
| 2831 | element.set('type', self.gds_format_string(self.type_)) |
||
| 2832 | if self.primaryLanguage is not None: |
||
| 2833 | element.set('primaryLanguage', self.gds_format_string(self.primaryLanguage)) |
||
| 2834 | if self.secondaryLanguage is not None: |
||
| 2835 | element.set('secondaryLanguage', self.gds_format_string(self.secondaryLanguage)) |
||
| 2836 | if self.primaryScript is not None: |
||
| 2837 | element.set('primaryScript', self.gds_format_string(self.primaryScript)) |
||
| 2838 | if self.secondaryScript is not None: |
||
| 2839 | element.set('secondaryScript', self.gds_format_string(self.secondaryScript)) |
||
| 2840 | if self.readingDirection is not None: |
||
| 2841 | element.set('readingDirection', self.gds_format_string(self.readingDirection)) |
||
| 2842 | if self.textLineOrder is not None: |
||
| 2843 | element.set('textLineOrder', self.gds_format_string(self.textLineOrder)) |
||
| 2844 | if self.conf is not None: |
||
| 2845 | element.set('conf', self.gds_format_float(self.conf)) |
||
| 2846 | for AlternativeImage_ in self.AlternativeImage: |
||
| 2847 | AlternativeImage_.to_etree(element, name_='AlternativeImage', mapping_=mapping_, nsmap_=nsmap_) |
||
| 2848 | if self.Border is not None: |
||
| 2849 | Border_ = self.Border |
||
| 2850 | Border_.to_etree(element, name_='Border', mapping_=mapping_, nsmap_=nsmap_) |
||
| 2851 | if self.PrintSpace is not None: |
||
| 2852 | PrintSpace_ = self.PrintSpace |
||
| 2853 | PrintSpace_.to_etree(element, name_='PrintSpace', mapping_=mapping_, nsmap_=nsmap_) |
||
| 2854 | if self.ReadingOrder is not None: |
||
| 2855 | ReadingOrder_ = self.ReadingOrder |
||
| 2856 | ReadingOrder_.to_etree(element, name_='ReadingOrder', mapping_=mapping_, nsmap_=nsmap_) |
||
| 2857 | if self.Layers is not None: |
||
| 2858 | Layers_ = self.Layers |
||
| 2859 | Layers_.to_etree(element, name_='Layers', mapping_=mapping_, nsmap_=nsmap_) |
||
| 2860 | if self.Relations is not None: |
||
| 2861 | Relations_ = self.Relations |
||
| 2862 | Relations_.to_etree(element, name_='Relations', mapping_=mapping_, nsmap_=nsmap_) |
||
| 2863 | if self.TextStyle is not None: |
||
| 2864 | TextStyle_ = self.TextStyle |
||
| 2865 | TextStyle_.to_etree(element, name_='TextStyle', mapping_=mapping_, nsmap_=nsmap_) |
||
| 2866 | if self.UserDefined is not None: |
||
| 2867 | UserDefined_ = self.UserDefined |
||
| 2868 | UserDefined_.to_etree(element, name_='UserDefined', mapping_=mapping_, nsmap_=nsmap_) |
||
| 2869 | for Labels_ in self.Labels: |
||
| 2870 | Labels_.to_etree(element, name_='Labels', mapping_=mapping_, nsmap_=nsmap_) |
||
| 2871 | for TextRegion_ in self.TextRegion: |
||
| 2872 | TextRegion_.to_etree(element, name_='TextRegion', mapping_=mapping_, nsmap_=nsmap_) |
||
| 2873 | for ImageRegion_ in self.ImageRegion: |
||
| 2874 | ImageRegion_.to_etree(element, name_='ImageRegion', mapping_=mapping_, nsmap_=nsmap_) |
||
| 2875 | for LineDrawingRegion_ in self.LineDrawingRegion: |
||
| 2876 | LineDrawingRegion_.to_etree(element, name_='LineDrawingRegion', mapping_=mapping_, nsmap_=nsmap_) |
||
| 2877 | for GraphicRegion_ in self.GraphicRegion: |
||
| 2878 | GraphicRegion_.to_etree(element, name_='GraphicRegion', mapping_=mapping_, nsmap_=nsmap_) |
||
| 2879 | for TableRegion_ in self.TableRegion: |
||
| 2880 | TableRegion_.to_etree(element, name_='TableRegion', mapping_=mapping_, nsmap_=nsmap_) |
||
| 2881 | for ChartRegion_ in self.ChartRegion: |
||
| 2882 | ChartRegion_.to_etree(element, name_='ChartRegion', mapping_=mapping_, nsmap_=nsmap_) |
||
| 2883 | for MapRegion_ in self.MapRegion: |
||
| 2884 | MapRegion_.to_etree(element, name_='MapRegion', mapping_=mapping_, nsmap_=nsmap_) |
||
| 2885 | for SeparatorRegion_ in self.SeparatorRegion: |
||
| 2886 | SeparatorRegion_.to_etree(element, name_='SeparatorRegion', mapping_=mapping_, nsmap_=nsmap_) |
||
| 2887 | for MathsRegion_ in self.MathsRegion: |
||
| 2888 | MathsRegion_.to_etree(element, name_='MathsRegion', mapping_=mapping_, nsmap_=nsmap_) |
||
| 2889 | for ChemRegion_ in self.ChemRegion: |
||
| 2890 | ChemRegion_.to_etree(element, name_='ChemRegion', mapping_=mapping_, nsmap_=nsmap_) |
||
| 2891 | for MusicRegion_ in self.MusicRegion: |
||
| 2892 | MusicRegion_.to_etree(element, name_='MusicRegion', mapping_=mapping_, nsmap_=nsmap_) |
||
| 2893 | for AdvertRegion_ in self.AdvertRegion: |
||
| 2894 | AdvertRegion_.to_etree(element, name_='AdvertRegion', mapping_=mapping_, nsmap_=nsmap_) |
||
| 2895 | for NoiseRegion_ in self.NoiseRegion: |
||
| 2896 | NoiseRegion_.to_etree(element, name_='NoiseRegion', mapping_=mapping_, nsmap_=nsmap_) |
||
| 2897 | for UnknownRegion_ in self.UnknownRegion: |
||
| 2898 | UnknownRegion_.to_etree(element, name_='UnknownRegion', mapping_=mapping_, nsmap_=nsmap_) |
||
| 2899 | for CustomRegion_ in self.CustomRegion: |
||
| 2900 | CustomRegion_.to_etree(element, name_='CustomRegion', mapping_=mapping_, nsmap_=nsmap_) |
||
| 2901 | if mapping_ is not None: |
||
| 2902 | mapping_[id(self)] = element |
||
| 2903 | return element |
||
| 2904 | def build(self, node, gds_collector_=None): |
||
| 2905 | self.gds_collector_ = gds_collector_ |
||
| 2906 | if SaveElementTreeNode: |
||
| 2907 | self.gds_elementtree_node_ = node |
||
| 2908 | already_processed = set() |
||
| 2909 | self.ns_prefix_ = node.prefix |
||
| 2910 | self.buildAttributes(node, node.attrib, already_processed) |
||
| 2911 | for child in node: |
||
| 2912 | nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] |
||
| 2913 | self.buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) |
||
| 2914 | return self |
||
| 2915 | def buildAttributes(self, node, attrs, already_processed): |
||
| 2916 | value = find_attr_value_('imageFilename', node) |
||
| 2917 | if value is not None and 'imageFilename' not in already_processed: |
||
| 2918 | already_processed.add('imageFilename') |
||
| 2919 | self.imageFilename = value |
||
| 2920 | value = find_attr_value_('imageWidth', node) |
||
| 2921 | if value is not None and 'imageWidth' not in already_processed: |
||
| 2922 | already_processed.add('imageWidth') |
||
| 2923 | self.imageWidth = self.gds_parse_integer(value, node, 'imageWidth') |
||
| 2924 | value = find_attr_value_('imageHeight', node) |
||
| 2925 | if value is not None and 'imageHeight' not in already_processed: |
||
| 2926 | already_processed.add('imageHeight') |
||
| 2927 | self.imageHeight = self.gds_parse_integer(value, node, 'imageHeight') |
||
| 2928 | value = find_attr_value_('imageXResolution', node) |
||
| 2929 | if value is not None and 'imageXResolution' not in already_processed: |
||
| 2930 | already_processed.add('imageXResolution') |
||
| 2931 | value = self.gds_parse_float(value, node, 'imageXResolution') |
||
| 2932 | self.imageXResolution = value |
||
| 2933 | value = find_attr_value_('imageYResolution', node) |
||
| 2934 | if value is not None and 'imageYResolution' not in already_processed: |
||
| 2935 | already_processed.add('imageYResolution') |
||
| 2936 | value = self.gds_parse_float(value, node, 'imageYResolution') |
||
| 2937 | self.imageYResolution = value |
||
| 2938 | value = find_attr_value_('imageResolutionUnit', node) |
||
| 2939 | if value is not None and 'imageResolutionUnit' not in already_processed: |
||
| 2940 | already_processed.add('imageResolutionUnit') |
||
| 2941 | self.imageResolutionUnit = value |
||
| 2942 | value = find_attr_value_('custom', node) |
||
| 2943 | if value is not None and 'custom' not in already_processed: |
||
| 2944 | already_processed.add('custom') |
||
| 2945 | self.custom = value |
||
| 2946 | value = find_attr_value_('orientation', node) |
||
| 2947 | if value is not None and 'orientation' not in already_processed: |
||
| 2948 | already_processed.add('orientation') |
||
| 2949 | value = self.gds_parse_float(value, node, 'orientation') |
||
| 2950 | self.orientation = value |
||
| 2951 | value = find_attr_value_('type', node) |
||
| 2952 | if value is not None and 'type' not in already_processed: |
||
| 2953 | already_processed.add('type') |
||
| 2954 | self.type_ = value |
||
| 2955 | self.validate_PageTypeSimpleType(self.type_) # validate type PageTypeSimpleType |
||
| 2956 | value = find_attr_value_('primaryLanguage', node) |
||
| 2957 | if value is not None and 'primaryLanguage' not in already_processed: |
||
| 2958 | already_processed.add('primaryLanguage') |
||
| 2959 | self.primaryLanguage = value |
||
| 2960 | self.validate_LanguageSimpleType(self.primaryLanguage) # validate type LanguageSimpleType |
||
| 2961 | value = find_attr_value_('secondaryLanguage', node) |
||
| 2962 | if value is not None and 'secondaryLanguage' not in already_processed: |
||
| 2963 | already_processed.add('secondaryLanguage') |
||
| 2964 | self.secondaryLanguage = value |
||
| 2965 | self.validate_LanguageSimpleType(self.secondaryLanguage) # validate type LanguageSimpleType |
||
| 2966 | value = find_attr_value_('primaryScript', node) |
||
| 2967 | if value is not None and 'primaryScript' not in already_processed: |
||
| 2968 | already_processed.add('primaryScript') |
||
| 2969 | self.primaryScript = value |
||
| 2970 | self.validate_ScriptSimpleType(self.primaryScript) # validate type ScriptSimpleType |
||
| 2971 | value = find_attr_value_('secondaryScript', node) |
||
| 2972 | if value is not None and 'secondaryScript' not in already_processed: |
||
| 2973 | already_processed.add('secondaryScript') |
||
| 2974 | self.secondaryScript = value |
||
| 2975 | self.validate_ScriptSimpleType(self.secondaryScript) # validate type ScriptSimpleType |
||
| 2976 | value = find_attr_value_('readingDirection', node) |
||
| 2977 | if value is not None and 'readingDirection' not in already_processed: |
||
| 2978 | already_processed.add('readingDirection') |
||
| 2979 | self.readingDirection = value |
||
| 2980 | self.validate_ReadingDirectionSimpleType(self.readingDirection) # validate type ReadingDirectionSimpleType |
||
| 2981 | value = find_attr_value_('textLineOrder', node) |
||
| 2982 | if value is not None and 'textLineOrder' not in already_processed: |
||
| 2983 | already_processed.add('textLineOrder') |
||
| 2984 | self.textLineOrder = value |
||
| 2985 | self.validate_TextLineOrderSimpleType(self.textLineOrder) # validate type TextLineOrderSimpleType |
||
| 2986 | value = find_attr_value_('conf', node) |
||
| 2987 | if value is not None and 'conf' not in already_processed: |
||
| 2988 | already_processed.add('conf') |
||
| 2989 | value = self.gds_parse_float(value, node, 'conf') |
||
| 2990 | self.conf = value |
||
| 2991 | self.validate_ConfSimpleType(self.conf) # validate type ConfSimpleType |
||
| 2992 | def buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None): |
||
| 2993 | if nodeName_ == 'AlternativeImage': |
||
| 2994 | obj_ = AlternativeImageType.factory(parent_object_=self) |
||
| 2995 | obj_.build(child_, gds_collector_=gds_collector_) |
||
| 2996 | self.AlternativeImage.append(obj_) |
||
| 2997 | obj_.original_tagname_ = 'AlternativeImage' |
||
| 2998 | elif nodeName_ == 'Border': |
||
| 2999 | obj_ = BorderType.factory(parent_object_=self) |
||
| 3000 | obj_.build(child_, gds_collector_=gds_collector_) |
||
| 3001 | self.Border = obj_ |
||
| 3002 | obj_.original_tagname_ = 'Border' |
||
| 3003 | elif nodeName_ == 'PrintSpace': |
||
| 3004 | obj_ = PrintSpaceType.factory(parent_object_=self) |
||
| 3005 | obj_.build(child_, gds_collector_=gds_collector_) |
||
| 3006 | self.PrintSpace = obj_ |
||
| 3007 | obj_.original_tagname_ = 'PrintSpace' |
||
| 3008 | elif nodeName_ == 'ReadingOrder': |
||
| 3009 | obj_ = ReadingOrderType.factory(parent_object_=self) |
||
| 3010 | obj_.build(child_, gds_collector_=gds_collector_) |
||
| 3011 | self.ReadingOrder = obj_ |
||
| 3012 | obj_.original_tagname_ = 'ReadingOrder' |
||
| 3013 | elif nodeName_ == 'Layers': |
||
| 3014 | obj_ = LayersType.factory(parent_object_=self) |
||
| 3015 | obj_.build(child_, gds_collector_=gds_collector_) |
||
| 3016 | self.Layers = obj_ |
||
| 3017 | obj_.original_tagname_ = 'Layers' |
||
| 3018 | elif nodeName_ == 'Relations': |
||
| 3019 | obj_ = RelationsType.factory(parent_object_=self) |
||
| 3020 | obj_.build(child_, gds_collector_=gds_collector_) |
||
| 3021 | self.Relations = obj_ |
||
| 3022 | obj_.original_tagname_ = 'Relations' |
||
| 3023 | elif nodeName_ == 'TextStyle': |
||
| 3024 | obj_ = TextStyleType.factory(parent_object_=self) |
||
| 3025 | obj_.build(child_, gds_collector_=gds_collector_) |
||
| 3026 | self.TextStyle = obj_ |
||
| 3027 | obj_.original_tagname_ = 'TextStyle' |
||
| 3028 | elif nodeName_ == 'UserDefined': |
||
| 3029 | obj_ = UserDefinedType.factory(parent_object_=self) |
||
| 3030 | obj_.build(child_, gds_collector_=gds_collector_) |
||
| 3031 | self.UserDefined = obj_ |
||
| 3032 | obj_.original_tagname_ = 'UserDefined' |
||
| 3033 | elif nodeName_ == 'Labels': |
||
| 3034 | obj_ = LabelsType.factory(parent_object_=self) |
||
| 3035 | obj_.build(child_, gds_collector_=gds_collector_) |
||
| 3036 | self.Labels.append(obj_) |
||
| 3037 | obj_.original_tagname_ = 'Labels' |
||
| 3038 | elif nodeName_ == 'TextRegion': |
||
| 3039 | obj_ = TextRegionType.factory(parent_object_=self) |
||
| 3040 | obj_.build(child_, gds_collector_=gds_collector_) |
||
| 3041 | self.TextRegion.append(obj_) |
||
| 3042 | obj_.original_tagname_ = 'TextRegion' |
||
| 3043 | elif nodeName_ == 'ImageRegion': |
||
| 3044 | obj_ = ImageRegionType.factory(parent_object_=self) |
||
| 3045 | obj_.build(child_, gds_collector_=gds_collector_) |
||
| 3046 | self.ImageRegion.append(obj_) |
||
| 3047 | obj_.original_tagname_ = 'ImageRegion' |
||
| 3048 | elif nodeName_ == 'LineDrawingRegion': |
||
| 3049 | obj_ = LineDrawingRegionType.factory(parent_object_=self) |
||
| 3050 | obj_.build(child_, gds_collector_=gds_collector_) |
||
| 3051 | self.LineDrawingRegion.append(obj_) |
||
| 3052 | obj_.original_tagname_ = 'LineDrawingRegion' |
||
| 3053 | elif nodeName_ == 'GraphicRegion': |
||
| 3054 | obj_ = GraphicRegionType.factory(parent_object_=self) |
||
| 3055 | obj_.build(child_, gds_collector_=gds_collector_) |
||
| 3056 | self.GraphicRegion.append(obj_) |
||
| 3057 | obj_.original_tagname_ = 'GraphicRegion' |
||
| 3058 | elif nodeName_ == 'TableRegion': |
||
| 3059 | obj_ = TableRegionType.factory(parent_object_=self) |
||
| 3060 | obj_.build(child_, gds_collector_=gds_collector_) |
||
| 3061 | self.TableRegion.append(obj_) |
||
| 3062 | obj_.original_tagname_ = 'TableRegion' |
||
| 3063 | elif nodeName_ == 'ChartRegion': |
||
| 3064 | obj_ = ChartRegionType.factory(parent_object_=self) |
||
| 3065 | obj_.build(child_, gds_collector_=gds_collector_) |
||
| 3066 | self.ChartRegion.append(obj_) |
||
| 3067 | obj_.original_tagname_ = 'ChartRegion' |
||
| 3068 | elif nodeName_ == 'MapRegion': |
||
| 3069 | obj_ = MapRegionType.factory(parent_object_=self) |
||
| 3070 | obj_.build(child_, gds_collector_=gds_collector_) |
||
| 3071 | self.MapRegion.append(obj_) |
||
| 3072 | obj_.original_tagname_ = 'MapRegion' |
||
| 3073 | elif nodeName_ == 'SeparatorRegion': |
||
| 3074 | obj_ = SeparatorRegionType.factory(parent_object_=self) |
||
| 3075 | obj_.build(child_, gds_collector_=gds_collector_) |
||
| 3076 | self.SeparatorRegion.append(obj_) |
||
| 3077 | obj_.original_tagname_ = 'SeparatorRegion' |
||
| 3078 | elif nodeName_ == 'MathsRegion': |
||
| 3079 | obj_ = MathsRegionType.factory(parent_object_=self) |
||
| 3080 | obj_.build(child_, gds_collector_=gds_collector_) |
||
| 3081 | self.MathsRegion.append(obj_) |
||
| 3082 | obj_.original_tagname_ = 'MathsRegion' |
||
| 3083 | elif nodeName_ == 'ChemRegion': |
||
| 3084 | obj_ = ChemRegionType.factory(parent_object_=self) |
||
| 3085 | obj_.build(child_, gds_collector_=gds_collector_) |
||
| 3086 | self.ChemRegion.append(obj_) |
||
| 3087 | obj_.original_tagname_ = 'ChemRegion' |
||
| 3088 | elif nodeName_ == 'MusicRegion': |
||
| 3089 | obj_ = MusicRegionType.factory(parent_object_=self) |
||
| 3090 | obj_.build(child_, gds_collector_=gds_collector_) |
||
| 3091 | self.MusicRegion.append(obj_) |
||
| 3092 | obj_.original_tagname_ = 'MusicRegion' |
||
| 3093 | elif nodeName_ == 'AdvertRegion': |
||
| 3094 | obj_ = AdvertRegionType.factory(parent_object_=self) |
||
| 3095 | obj_.build(child_, gds_collector_=gds_collector_) |
||
| 3096 | self.AdvertRegion.append(obj_) |
||
| 3097 | obj_.original_tagname_ = 'AdvertRegion' |
||
| 3098 | elif nodeName_ == 'NoiseRegion': |
||
| 3099 | obj_ = NoiseRegionType.factory(parent_object_=self) |
||
| 3100 | obj_.build(child_, gds_collector_=gds_collector_) |
||
| 3101 | self.NoiseRegion.append(obj_) |
||
| 3102 | obj_.original_tagname_ = 'NoiseRegion' |
||
| 3103 | elif nodeName_ == 'UnknownRegion': |
||
| 3104 | obj_ = UnknownRegionType.factory(parent_object_=self) |
||
| 3105 | obj_.build(child_, gds_collector_=gds_collector_) |
||
| 3106 | self.UnknownRegion.append(obj_) |
||
| 3107 | obj_.original_tagname_ = 'UnknownRegion' |
||
| 3108 | elif nodeName_ == 'CustomRegion': |
||
| 3109 | obj_ = CustomRegionType.factory(parent_object_=self) |
||
| 3110 | obj_.build(child_, gds_collector_=gds_collector_) |
||
| 3111 | self.CustomRegion.append(obj_) |
||
| 3112 | obj_.original_tagname_ = 'CustomRegion' |
||
| 3113 | def __hash__(self): |
||
| 3114 | return hash(self.id) |
||
| 3115 | @property |
||
| 3116 | def id(self): |
||
| 3117 | if hasattr(self, 'pcGtsId'): |
||
| 3118 | return self.pcGtsId or '' |
||
| 3119 | return self.imageFilename |
||
| 3120 | # pylint: disable=line-too-long,invalid-name,protected-access,missing-module-docstring |
||
| 3121 | def _region_class(self, x): # pylint: disable=unused-argument |
||
| 3122 | return x.__class__.__name__.replace('RegionType', '') |
||
| 3123 | |||
| 3124 | View Code Duplication | def _get_recursive_regions(self, regions, level, classes=None): |
|
| 3125 | from .constants import PAGE_REGION_TYPES # pylint: disable=relative-beyond-top-level,import-outside-toplevel |
||
| 3126 | if level == 1: |
||
| 3127 | # stop recursion, filter classes |
||
| 3128 | if classes: |
||
| 3129 | return [r for r in regions if self._region_class(r) in classes] |
||
| 3130 | if regions and regions[0].__class__.__name__ == 'PageType': |
||
| 3131 | regions = regions[1:] |
||
| 3132 | return regions |
||
| 3133 | # find more regions recursively |
||
| 3134 | more_regions = [] |
||
| 3135 | for region in regions: |
||
| 3136 | more_regions.append([]) |
||
| 3137 | for class_ in PAGE_REGION_TYPES: |
||
| 3138 | if class_ == 'Map' and not isinstance(region, PageType): # pylint: disable=undefined-variable |
||
| 3139 | # 'Map' is not recursive in 2019 schema |
||
| 3140 | continue |
||
| 3141 | more_regions[-1] += getattr(region, 'get_{}Region'.format(class_))() |
||
| 3142 | if not any(more_regions): |
||
| 3143 | return self._get_recursive_regions(regions, 1, classes) |
||
| 3144 | ret = [] |
||
| 3145 | for r, more in zip(regions, more_regions): |
||
| 3146 | ret.append(r) |
||
| 3147 | ret += self._get_recursive_regions(more, level - 1 if level else 0, classes) |
||
| 3148 | return self._get_recursive_regions(ret, 1, classes) |
||
| 3149 | |||
| 3150 | View Code Duplication | def _get_recursive_reading_order(self, rogroup): |
|
| 3151 | if isinstance(rogroup, (OrderedGroupType, OrderedGroupIndexedType)): # pylint: disable=undefined-variable |
||
| 3152 | elements = rogroup.get_AllIndexed() |
||
| 3153 | if isinstance(rogroup, (UnorderedGroupType, UnorderedGroupIndexedType)): # pylint: disable=undefined-variable |
||
| 3154 | elements = (rogroup.get_RegionRef() + rogroup.get_OrderedGroup() + rogroup.get_UnorderedGroup()) |
||
| 3155 | regionrefs = list() |
||
| 3156 | for elem in elements: |
||
| 3157 | regionrefs.append(elem.get_regionRef()) |
||
| 3158 | if not isinstance(elem, (RegionRefType, RegionRefIndexedType)): # pylint: disable=undefined-variable |
||
| 3159 | regionrefs.extend(self._get_recursive_reading_order(elem)) |
||
| 3160 | return regionrefs |
||
| 3161 | |||
| 3162 | View Code Duplication | def get_AllRegions(self, classes=None, order='document', depth=0): |
|
| 3163 | """ |
||
| 3164 | Get all the ``*Region`` elements, or only those provided by `classes`. |
||
| 3165 | Return in document order, unless `order` is ``reading-order``. |
||
| 3166 | |||
| 3167 | Arguments: |
||
| 3168 | classes (list): Classes of regions that shall be returned, \ |
||
| 3169 | e.g. ``['Text', 'Image']`` |
||
| 3170 | order ("document"|"reading-order"|"reading-order-only"): Whether to \ |
||
| 3171 | return regions sorted by document order (``document``, default) or by |
||
| 3172 | reading order with regions not in the reading order at the end of the |
||
| 3173 | returned list (``reading-order``) or regions not in the reading order |
||
| 3174 | omitted (``reading-order-only``) |
||
| 3175 | depth (int): Recursive depth to look for regions at, set to `0` for \ |
||
| 3176 | all regions at any depth. Default: 0 |
||
| 3177 | |||
| 3178 | Returns: |
||
| 3179 | a list of :py:class:`TextRegionType`, :py:class:`ImageRegionType`, \ |
||
| 3180 | :py:class:`LineDrawingRegionType`, :py:class:`GraphicRegionType`, \ |
||
| 3181 | :py:class:`TableRegionType`, :py:class:`ChartRegionType`, \ |
||
| 3182 | :py:class:`MapRegionType`, :py:class:`SeparatorRegionType`, \ |
||
| 3183 | :py:class:`MathsRegionType`, :py:class:`ChemRegionType`, \ |
||
| 3184 | :py:class:`MusicRegionType`, :py:class:`AdvertRegionType`, \ |
||
| 3185 | :py:class:`NoiseRegionType`, :py:class:`UnknownRegionType`, \ |
||
| 3186 | and/or :py:class:`CustomRegionType` |
||
| 3187 | |||
| 3188 | For example, to get all text anywhere on the page in reading order, use: |
||
| 3189 | :: |
||
| 3190 | '\\n'.join(line.get_TextEquiv()[0].Unicode |
||
| 3191 | for region in page.get_AllRegions(classes=['Text'], depth=0, order='reading-order') |
||
| 3192 | for line in region.get_TextLine()) |
||
| 3193 | """ |
||
| 3194 | if order not in ['document', 'reading-order', 'reading-order-only']: |
||
| 3195 | raise Exception("Argument 'order' must be either 'document', 'reading-order' or 'reading-order-only', not '{}'".format(order)) |
||
| 3196 | if depth < 0: |
||
| 3197 | raise Exception("Argument 'depth' must be an integer greater-or-equal 0, not '{}'".format(depth)) |
||
| 3198 | ret = self._get_recursive_regions([self], depth + 1 if depth else 0, classes) |
||
| 3199 | if order.startswith('reading-order'): |
||
| 3200 | reading_order = self.get_ReadingOrder() |
||
| 3201 | if reading_order: |
||
| 3202 | reading_order = reading_order.get_OrderedGroup() or reading_order.get_UnorderedGroup() |
||
| 3203 | if reading_order: |
||
| 3204 | reading_order = self._get_recursive_reading_order(reading_order) |
||
| 3205 | if reading_order: |
||
| 3206 | id2region = {region.id: region for region in ret} |
||
| 3207 | in_reading_order = [id2region[region_id] for region_id in reading_order if region_id in id2region] |
||
| 3208 | # print("ret: {} / in_ro: {} / not-in-ro: {}".format( |
||
| 3209 | # len(ret), |
||
| 3210 | # len([id2region[region_id] for region_id in reading_order if region_id in id2region]), |
||
| 3211 | # len([r for r in ret if r not in in_reading_order]) |
||
| 3212 | # )) |
||
| 3213 | if order == 'reading-order-only': |
||
| 3214 | ret = in_reading_order |
||
| 3215 | else: |
||
| 3216 | ret = in_reading_order + [r for r in ret if r not in in_reading_order] |
||
| 3217 | return ret |
||
| 3218 | View Code Duplication | def get_AllAlternativeImages(self, page=True, region=True, line=True, word=True, glyph=True): |
|
| 3219 | """ |
||
| 3220 | Get all the ``pc:AlternativeImage`` in a document |
||
| 3221 | |||
| 3222 | Arguments: |
||
| 3223 | page (boolean): Get images on ``pc:Page`` level |
||
| 3224 | region (boolean): Get images on ``pc:*Region`` level |
||
| 3225 | line (boolean): Get images on ``pc:TextLine`` level |
||
| 3226 | word (boolean): Get images on ``pc:Word`` level |
||
| 3227 | glyph (boolean): Get images on ``pc:Glyph`` level |
||
| 3228 | |||
| 3229 | Returns: |
||
| 3230 | a list of :py:class:`AlternativeImageType` |
||
| 3231 | """ |
||
| 3232 | ret = [] |
||
| 3233 | if page: |
||
| 3234 | ret += self.get_AlternativeImage() |
||
| 3235 | for this_region in self.get_AllRegions(['Text']): |
||
| 3236 | if region: |
||
| 3237 | ret += this_region.get_AlternativeImage() |
||
| 3238 | for this_line in this_region.get_TextLine(): |
||
| 3239 | if line: |
||
| 3240 | ret += this_line.get_AlternativeImage() |
||
| 3241 | for this_word in this_line.get_Word(): |
||
| 3242 | if word: |
||
| 3243 | ret += this_word.get_AlternativeImage() |
||
| 3244 | for this_glyph in this_word.get_Glyph(): |
||
| 3245 | if glyph: |
||
| 3246 | ret += this_glyph.get_AlternativeImage() |
||
| 3247 | return ret |
||
| 3248 | |||
| 3249 | View Code Duplication | def invalidate_AlternativeImage(self, feature_selector=None): |
|
| 3250 | """ |
||
| 3251 | Remove derived images from this segment (due to changed coordinates). |
||
| 3252 | |||
| 3253 | If `feature_selector` is not none, remove only images with |
||
| 3254 | matching ``@comments``, e.g. ``feature_selector=cropped,deskewed``. |
||
| 3255 | """ |
||
| 3256 | existing_images = self.AlternativeImage or [] |
||
| 3257 | removed_images = [] |
||
| 3258 | if feature_selector: |
||
| 3259 | new_images = [] |
||
| 3260 | for image in existing_images: |
||
| 3261 | features = image.get_comments() or '' |
||
| 3262 | if any(feature in features.split(',') |
||
| 3263 | for feature in feature_selector.split(',') if feature): |
||
| 3264 | removed_images.append(image) |
||
| 3265 | else: |
||
| 3266 | new_images.append(image) |
||
| 3267 | self.AlternativeImage = new_images |
||
| 3268 | else: |
||
| 3269 | removed_images = existing_images |
||
| 3270 | self.AlternativeImage = [] |
||
| 3271 | if hasattr(self, 'id'): |
||
| 3272 | name = self.id |
||
| 3273 | elif hasattr(self, 'parent_object_') and hasattr(self.parent_object_, 'pcGtsId'): |
||
| 3274 | name = self.parent_object_.pcGtsId |
||
| 3275 | else: |
||
| 3276 | name = '' |
||
| 3277 | for image in removed_images: |
||
| 3278 | self.gds_collector_.add_message('Removing AlternativeImage %s from "%s"' % ( |
||
| 3279 | image.get_comments() or '', name)) |
||
| 3280 | def set_Border(self, Border): |
||
| 3281 | """ |
||
| 3282 | Set coordinate polygon by given :py:class:`BorderType` object. |
||
| 3283 | Moreover, invalidate self's ``pc:AlternativeImage``s |
||
| 3284 | (because they will have been cropped with a bbox |
||
| 3285 | of the previous polygon). |
||
| 3286 | """ |
||
| 3287 | self.invalidate_AlternativeImage(feature_selector='cropped') |
||
| 3288 | self.Border = Border |
||
| 3289 | View Code Duplication | def get_AllTextLines(self, region_order='document', respect_textline_order=True): |
|
| 3290 | """ |
||
| 3291 | Return all the TextLine in the document |
||
| 3292 | |||
| 3293 | Arguments: |
||
| 3294 | region_order ("document"|"reading-order"|"reading-order-only"): Whether to \ |
||
| 3295 | return regions sorted by document order (``document``, default) or by \ |
||
| 3296 | reading order with regions not in the reading order at the end of the \ |
||
| 3297 | returned list (``reading-order``) or regions not in the reading order \ |
||
| 3298 | omitted (``reading-order-only``) |
||
| 3299 | respect_textline_order (boolean): Whether to respect `@textLineOrder` attribute |
||
| 3300 | |||
| 3301 | Returns: |
||
| 3302 | a list of :py:class:`TextLineType` |
||
| 3303 | """ |
||
| 3304 | # TODO handle textLineOrder according to https://github.com/PRImA-Research-Lab/PAGE-XML/issues/26 |
||
| 3305 | ret = [] |
||
| 3306 | for reg in self.get_AllRegions(['Text'], order=region_order): |
||
| 3307 | lines = reg.get_TextLine() |
||
| 3308 | if not respect_textline_order: |
||
| 3309 | ret += lines |
||
| 3310 | else: |
||
| 3311 | lo = reg.get_textLineOrder() or self.get_textLineOrder() or 'top-to-bottom' |
||
| 3312 | ret += lines if lo in ['top-to-bottom', 'left-to-right'] else list(reversed(lines)) |
||
| 3313 | return ret |
||
| 3314 | |||
| 3315 | def set_orientation(self, orientation): |
||
| 3316 | """ |
||
| 3317 | Set deskewing angle to given `orientation` number. |
||
| 3318 | Moreover, invalidate self's ``pc:AlternativeImage``s |
||
| 3319 | (because they will have been rotated and enlarged |
||
| 3320 | with the angle of the previous value). |
||
| 3321 | """ |
||
| 3322 | if hasattr(self, 'invalidate_AlternativeImage'): |
||
| 3323 | # PageType, RegionType: |
||
| 3324 | self.invalidate_AlternativeImage(feature_selector='deskewed') |
||
| 3325 | self.orientation = orientation |
||
| 3326 | # end class PageType |
||
| 3327 | |||
| 3328 | |||
| 3329 | class CoordsType(GeneratedsSuper): |
||
| 3330 | """Polygon outline of the element as a path of points. |
||
| 3331 | No points may lie outside the outline of its parent, |
||
| 3332 | which in the case of Border is the bounding rectangle |
||
| 3333 | of the root image. Paths are closed by convention, |
||
| 3334 | i.e. the last point logically connects with the first |
||
| 3335 | (and at least 3 points are required to span an area). |
||
| 3336 | Paths must be planar (i.e. must not self-intersect). |
||
| 3337 | Confidence value (between 0 and 1)""" |
||
| 3338 | __hash__ = GeneratedsSuper.__hash__ |
||
| 3339 | member_data_items_ = [ |
||
| 3340 | MemberSpec_('points', 'pc:PointsType', 0, 0, {'use': 'required'}), |
||
| 3341 | MemberSpec_('conf', 'pc:ConfSimpleType', 0, 1, {'use': 'optional'}), |
||
| 3342 | ] |
||
| 3343 | subclass = None |
||
| 3344 | superclass = None |
||
| 3345 | View Code Duplication | def __init__(self, points=None, conf=None, gds_collector_=None, **kwargs_): |
|
| 3346 | self.gds_collector_ = gds_collector_ |
||
| 3347 | self.gds_elementtree_node_ = None |
||
| 3348 | self.original_tagname_ = None |
||
| 3349 | self.parent_object_ = kwargs_.get('parent_object_') |
||
| 3350 | self.ns_prefix_ = None |
||
| 3351 | self.points = _cast(None, points) |
||
| 3352 | self.points_nsprefix_ = "pc" |
||
| 3353 | self.conf = _cast(float, conf) |
||
| 3354 | self.conf_nsprefix_ = "pc" |
||
| 3355 | def factory(*args_, **kwargs_): |
||
| 3356 | if CurrentSubclassModule_ is not None: |
||
| 3357 | subclass = getSubclassFromModule_( |
||
| 3358 | CurrentSubclassModule_, CoordsType) |
||
| 3359 | if subclass is not None: |
||
| 3360 | return subclass(*args_, **kwargs_) |
||
| 3361 | if CoordsType.subclass: |
||
| 3362 | return CoordsType.subclass(*args_, **kwargs_) |
||
| 3363 | else: |
||
| 3364 | return CoordsType(*args_, **kwargs_) |
||
| 3365 | factory = staticmethod(factory) |
||
| 3366 | def get_ns_prefix_(self): |
||
| 3367 | return self.ns_prefix_ |
||
| 3368 | def set_ns_prefix_(self, ns_prefix): |
||
| 3369 | self.ns_prefix_ = ns_prefix |
||
| 3370 | def get_points(self): |
||
| 3371 | return self.points |
||
| 3372 | def set_points(self, points): |
||
| 3373 | self.points = points |
||
| 3374 | def get_conf(self): |
||
| 3375 | return self.conf |
||
| 3376 | def set_conf(self, conf): |
||
| 3377 | self.conf = conf |
||
| 3378 | View Code Duplication | def validate_PointsType(self, value): |
|
| 3379 | # Validate type pc:PointsType, a restriction on string. |
||
| 3380 | if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None: |
||
| 3381 | if not isinstance(value, str): |
||
| 3382 | lineno = self.gds_get_node_lineno_() |
||
| 3383 | self.gds_collector_.add_message('Value "%(value)s"%(lineno)s is not of the correct base simple type (str)' % {"value": value, "lineno": lineno, }) |
||
| 3384 | return False |
||
| 3385 | if not self.gds_validate_simple_patterns( |
||
| 3386 | self.validate_PointsType_patterns_, value): |
||
| 3387 | self.gds_collector_.add_message('Value "%s" does not match xsd pattern restrictions: %s' % (encode_str_2_3(value), self.validate_PointsType_patterns_, )) |
||
| 3388 | validate_PointsType_patterns_ = [['^(([0-9]+,[0-9]+ )+([0-9]+,[0-9]+))$']] |
||
| 3389 | View Code Duplication | def validate_ConfSimpleType(self, value): |
|
| 3390 | # Validate type pc:ConfSimpleType, a restriction on float. |
||
| 3391 | if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None: |
||
| 3392 | if not isinstance(value, float): |
||
| 3393 | lineno = self.gds_get_node_lineno_() |
||
| 3394 | self.gds_collector_.add_message('Value "%(value)s"%(lineno)s is not of the correct base simple type (float)' % {"value": value, "lineno": lineno, }) |
||
| 3395 | return False |
||
| 3396 | if value < 0: |
||
| 3397 | lineno = self.gds_get_node_lineno_() |
||
| 3398 | self.gds_collector_.add_message('Value "%(value)s"%(lineno)s does not match xsd minInclusive restriction on ConfSimpleType' % {"value": value, "lineno": lineno} ) |
||
| 3399 | result = False |
||
| 3400 | if value > 1: |
||
| 3401 | lineno = self.gds_get_node_lineno_() |
||
| 3402 | self.gds_collector_.add_message('Value "%(value)s"%(lineno)s does not match xsd maxInclusive restriction on ConfSimpleType' % {"value": value, "lineno": lineno} ) |
||
| 3403 | result = False |
||
| 3404 | def hasContent_(self): |
||
| 3405 | if ( |
||
| 3406 | |||
| 3407 | ): |
||
| 3408 | return True |
||
| 3409 | else: |
||
| 3410 | return False |
||
| 3411 | def export(self, outfile, level, namespaceprefix_='', namespacedef_='xmlns:pc="http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15"', name_='CoordsType', pretty_print=True): |
||
| 3412 | imported_ns_def_ = GenerateDSNamespaceDefs_.get('CoordsType') |
||
| 3413 | if imported_ns_def_ is not None: |
||
| 3414 | namespacedef_ = imported_ns_def_ |
||
| 3415 | if pretty_print: |
||
| 3416 | eol_ = '\n' |
||
| 3417 | else: |
||
| 3418 | eol_ = '' |
||
| 3419 | if self.original_tagname_ is not None and name_ == 'CoordsType': |
||
| 3420 | name_ = self.original_tagname_ |
||
| 3421 | if UseCapturedNS_ and self.ns_prefix_: |
||
| 3422 | namespaceprefix_ = self.ns_prefix_ + ':' |
||
| 3423 | showIndent(outfile, level, pretty_print) |
||
| 3424 | outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) |
||
| 3425 | already_processed = set() |
||
| 3426 | self.exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='CoordsType') |
||
| 3427 | if self.hasContent_(): |
||
| 3428 | outfile.write('>%s' % (eol_, )) |
||
| 3429 | self.exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='CoordsType', pretty_print=pretty_print) |
||
| 3430 | outfile.write('</%s%s>%s' % (namespaceprefix_, name_, eol_)) |
||
| 3431 | else: |
||
| 3432 | outfile.write('/>%s' % (eol_, )) |
||
| 3433 | def exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='CoordsType'): |
||
| 3434 | if self.points is not None and 'points' not in already_processed: |
||
| 3435 | already_processed.add('points') |
||
| 3436 | outfile.write(' points=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.points), input_name='points')), )) |
||
| 3437 | if self.conf is not None and 'conf' not in already_processed: |
||
| 3438 | already_processed.add('conf') |
||
| 3439 | outfile.write(' conf="%s"' % self.gds_format_float(self.conf, input_name='conf')) |
||
| 3440 | def exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='xmlns:pc="http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15"', name_='CoordsType', fromsubclass_=False, pretty_print=True): |
||
| 3441 | pass |
||
| 3442 | View Code Duplication | def to_etree(self, parent_element=None, name_='CoordsType', mapping_=None, nsmap_=None): |
|
| 3443 | if parent_element is None: |
||
| 3444 | element = etree_.Element('{http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15}' + name_, nsmap=nsmap_) |
||
| 3445 | else: |
||
| 3446 | element = etree_.SubElement(parent_element, '{http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15}' + name_, nsmap=nsmap_) |
||
| 3447 | if self.points is not None: |
||
| 3448 | element.set('points', self.gds_format_string(self.points)) |
||
| 3449 | if self.conf is not None: |
||
| 3450 | element.set('conf', self.gds_format_float(self.conf)) |
||
| 3451 | if mapping_ is not None: |
||
| 3452 | mapping_[id(self)] = element |
||
| 3453 | return element |
||
| 3454 | def build(self, node, gds_collector_=None): |
||
| 3455 | self.gds_collector_ = gds_collector_ |
||
| 3456 | if SaveElementTreeNode: |
||
| 3457 | self.gds_elementtree_node_ = node |
||
| 3458 | already_processed = set() |
||
| 3459 | self.ns_prefix_ = node.prefix |
||
| 3460 | self.buildAttributes(node, node.attrib, already_processed) |
||
| 3461 | for child in node: |
||
| 3462 | nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] |
||
| 3463 | self.buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) |
||
| 3464 | return self |
||
| 3465 | View Code Duplication | def buildAttributes(self, node, attrs, already_processed): |
|
| 3466 | value = find_attr_value_('points', node) |
||
| 3467 | if value is not None and 'points' not in already_processed: |
||
| 3468 | already_processed.add('points') |
||
| 3469 | self.points = value |
||
| 3470 | self.validate_PointsType(self.points) # validate type PointsType |
||
| 3471 | value = find_attr_value_('conf', node) |
||
| 3472 | if value is not None and 'conf' not in already_processed: |
||
| 3473 | already_processed.add('conf') |
||
| 3474 | value = self.gds_parse_float(value, node, 'conf') |
||
| 3475 | self.conf = value |
||
| 3476 | self.validate_ConfSimpleType(self.conf) # validate type ConfSimpleType |
||
| 3477 | def buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None): |
||
| 3478 | pass |
||
| 3479 | def __hash__(self): |
||
| 3480 | return hash(self.id) |
||
| 3481 | View Code Duplication | def set_points(self, points): |
|
| 3482 | """ |
||
| 3483 | Set coordinate polygon by given string. |
||
| 3484 | Moreover, invalidate the parent's ``pc:AlternativeImage``s |
||
| 3485 | (because they will have been cropped with a bbox |
||
| 3486 | of the previous polygon). |
||
| 3487 | """ |
||
| 3488 | if hasattr(self, 'parent_object_'): |
||
| 3489 | parent = self.parent_object_ |
||
| 3490 | if hasattr(parent, 'invalidate_AlternativeImage'): |
||
| 3491 | # RegionType, TextLineType, WordType, GlyphType: |
||
| 3492 | parent.invalidate_AlternativeImage() |
||
| 3493 | elif hasattr(parent, 'parent_object_') and hasattr(parent.parent_object_, 'invalidate_AlternativeImage'): |
||
| 3494 | # BorderType: |
||
| 3495 | parent.parent_object_.invalidate_AlternativeImage(feature_selector='cropped') |
||
| 3496 | self.points = points |
||
| 3497 | # end class CoordsType |
||
| 3498 | |||
| 3499 | |||
| 3500 | class TextLineType(GeneratedsSuper): |
||
| 3501 | """Overrides primaryLanguage attribute of parent text |
||
| 3502 | region |
||
| 3503 | The primary script used in the text line |
||
| 3504 | The secondary script used in the text line |
||
| 3505 | The direction in which text within the line |
||
| 3506 | should be read (order of words and characters). |
||
| 3507 | Overrides the production attribute of the parent |
||
| 3508 | text region |
||
| 3509 | For generic use |
||
| 3510 | Position (order number) of this text line within the |
||
| 3511 | parent text region.""" |
||
| 3512 | __hash__ = GeneratedsSuper.__hash__ |
||
| 3513 | member_data_items_ = [ |
||
| 3514 | MemberSpec_('id', 'string', 0, 0, {'use': 'required'}), |
||
| 3515 | MemberSpec_('primaryLanguage', 'pc:LanguageSimpleType', 0, 1, {'use': 'optional'}), |
||
| 3516 | MemberSpec_('primaryScript', 'pc:ScriptSimpleType', 0, 1, {'use': 'optional'}), |
||
| 3517 | MemberSpec_('secondaryScript', 'pc:ScriptSimpleType', 0, 1, {'use': 'optional'}), |
||
| 3518 | MemberSpec_('readingDirection', 'pc:ReadingDirectionSimpleType', 0, 1, {'use': 'optional'}), |
||
| 3519 | MemberSpec_('production', 'pc:ProductionSimpleType', 0, 1, {'use': 'optional'}), |
||
| 3520 | MemberSpec_('custom', 'string', 0, 1, {'use': 'optional'}), |
||
| 3521 | MemberSpec_('comments', 'string', 0, 1, {'use': 'optional'}), |
||
| 3522 | MemberSpec_('index', 'int', 0, 1, {'use': 'optional'}), |
||
| 3523 | MemberSpec_('AlternativeImage', 'AlternativeImageType', 1, 1, {'maxOccurs': 'unbounded', 'minOccurs': '0', 'name': 'AlternativeImage', 'type': 'AlternativeImageType'}, None), |
||
| 3524 | MemberSpec_('Coords', 'CoordsType', 0, 0, {'name': 'Coords', 'type': 'CoordsType'}, None), |
||
| 3525 | MemberSpec_('Baseline', 'BaselineType', 0, 1, {'minOccurs': '0', 'name': 'Baseline', 'type': 'BaselineType'}, None), |
||
| 3526 | MemberSpec_('Word', 'WordType', 1, 1, {'maxOccurs': 'unbounded', 'minOccurs': '0', 'name': 'Word', 'type': 'WordType'}, None), |
||
| 3527 | MemberSpec_('TextEquiv', 'TextEquivType', 1, 1, {'maxOccurs': 'unbounded', 'minOccurs': '0', 'name': 'TextEquiv', 'type': 'TextEquivType'}, None), |
||
| 3528 | MemberSpec_('TextStyle', 'TextStyleType', 0, 1, {'minOccurs': '0', 'name': 'TextStyle', 'type': 'TextStyleType'}, None), |
||
| 3529 | MemberSpec_('UserDefined', 'UserDefinedType', 0, 1, {'maxOccurs': '1', 'minOccurs': '0', 'name': 'UserDefined', 'type': 'UserDefinedType'}, None), |
||
| 3530 | MemberSpec_('Labels', 'LabelsType', 1, 1, {'maxOccurs': 'unbounded', 'minOccurs': '0', 'name': 'Labels', 'type': 'LabelsType'}, None), |
||
| 3531 | ] |
||
| 3532 | subclass = None |
||
| 3533 | superclass = None |
||
| 3534 | def __init__(self, id=None, primaryLanguage=None, primaryScript=None, secondaryScript=None, readingDirection=None, production=None, custom=None, comments=None, index=None, AlternativeImage=None, Coords=None, Baseline=None, Word=None, TextEquiv=None, TextStyle=None, UserDefined=None, Labels=None, gds_collector_=None, **kwargs_): |
||
| 3535 | self.gds_collector_ = gds_collector_ |
||
| 3536 | self.gds_elementtree_node_ = None |
||
| 3537 | self.original_tagname_ = None |
||
| 3538 | self.parent_object_ = kwargs_.get('parent_object_') |
||
| 3539 | self.ns_prefix_ = None |
||
| 3540 | self.id = _cast(None, id) |
||
| 3541 | self.id_nsprefix_ = "pc" |
||
| 3542 | self.primaryLanguage = _cast(None, primaryLanguage) |
||
| 3543 | self.primaryLanguage_nsprefix_ = "pc" |
||
| 3544 | self.primaryScript = _cast(None, primaryScript) |
||
| 3545 | self.primaryScript_nsprefix_ = "pc" |
||
| 3546 | self.secondaryScript = _cast(None, secondaryScript) |
||
| 3547 | self.secondaryScript_nsprefix_ = "pc" |
||
| 3548 | self.readingDirection = _cast(None, readingDirection) |
||
| 3549 | self.readingDirection_nsprefix_ = "pc" |
||
| 3550 | self.production = _cast(None, production) |
||
| 3551 | self.production_nsprefix_ = "pc" |
||
| 3552 | self.custom = _cast(None, custom) |
||
| 3553 | self.custom_nsprefix_ = "pc" |
||
| 3554 | self.comments = _cast(None, comments) |
||
| 3555 | self.comments_nsprefix_ = "pc" |
||
| 3556 | self.index = _cast(int, index) |
||
| 3557 | self.index_nsprefix_ = "pc" |
||
| 3558 | if AlternativeImage is None: |
||
| 3559 | self.AlternativeImage = [] |
||
| 3560 | else: |
||
| 3561 | self.AlternativeImage = AlternativeImage |
||
| 3562 | self.AlternativeImage_nsprefix_ = "pc" |
||
| 3563 | self.Coords = Coords |
||
| 3564 | self.Coords_nsprefix_ = "pc" |
||
| 3565 | self.Baseline = Baseline |
||
| 3566 | self.Baseline_nsprefix_ = "pc" |
||
| 3567 | if Word is None: |
||
| 3568 | self.Word = [] |
||
| 3569 | else: |
||
| 3570 | self.Word = Word |
||
| 3571 | self.Word_nsprefix_ = "pc" |
||
| 3572 | if TextEquiv is None: |
||
| 3573 | self.TextEquiv = [] |
||
| 3574 | else: |
||
| 3575 | self.TextEquiv = TextEquiv |
||
| 3576 | self.TextEquiv_nsprefix_ = "pc" |
||
| 3577 | self.TextStyle = TextStyle |
||
| 3578 | self.TextStyle_nsprefix_ = "pc" |
||
| 3579 | self.UserDefined = UserDefined |
||
| 3580 | self.UserDefined_nsprefix_ = "pc" |
||
| 3581 | if Labels is None: |
||
| 3582 | self.Labels = [] |
||
| 3583 | else: |
||
| 3584 | self.Labels = Labels |
||
| 3585 | self.Labels_nsprefix_ = "pc" |
||
| 3586 | def factory(*args_, **kwargs_): |
||
| 3587 | if CurrentSubclassModule_ is not None: |
||
| 3588 | subclass = getSubclassFromModule_( |
||
| 3589 | CurrentSubclassModule_, TextLineType) |
||
| 3590 | if subclass is not None: |
||
| 3591 | return subclass(*args_, **kwargs_) |
||
| 3592 | if TextLineType.subclass: |
||
| 3593 | return TextLineType.subclass(*args_, **kwargs_) |
||
| 3594 | else: |
||
| 3595 | return TextLineType(*args_, **kwargs_) |
||
| 3596 | factory = staticmethod(factory) |
||
| 3597 | def get_ns_prefix_(self): |
||
| 3598 | return self.ns_prefix_ |
||
| 3599 | def set_ns_prefix_(self, ns_prefix): |
||
| 3600 | self.ns_prefix_ = ns_prefix |
||
| 3601 | def get_AlternativeImage(self): |
||
| 3602 | return self.AlternativeImage |
||
| 3603 | def set_AlternativeImage(self, AlternativeImage): |
||
| 3604 | self.AlternativeImage = AlternativeImage |
||
| 3605 | def add_AlternativeImage(self, value): |
||
| 3606 | self.AlternativeImage.append(value) |
||
| 3607 | def insert_AlternativeImage_at(self, index, value): |
||
| 3608 | self.AlternativeImage.insert(index, value) |
||
| 3609 | def replace_AlternativeImage_at(self, index, value): |
||
| 3610 | self.AlternativeImage[index] = value |
||
| 3611 | def get_Coords(self): |
||
| 3612 | return self.Coords |
||
| 3613 | def set_Coords(self, Coords): |
||
| 3614 | self.Coords = Coords |
||
| 3615 | def get_Baseline(self): |
||
| 3616 | return self.Baseline |
||
| 3617 | def set_Baseline(self, Baseline): |
||
| 3618 | self.Baseline = Baseline |
||
| 3619 | def get_Word(self): |
||
| 3620 | return self.Word |
||
| 3621 | def set_Word(self, Word): |
||
| 3622 | self.Word = Word |
||
| 3623 | def add_Word(self, value): |
||
| 3624 | self.Word.append(value) |
||
| 3625 | def insert_Word_at(self, index, value): |
||
| 3626 | self.Word.insert(index, value) |
||
| 3627 | def replace_Word_at(self, index, value): |
||
| 3628 | self.Word[index] = value |
||
| 3629 | def get_TextEquiv(self): |
||
| 3630 | return self.TextEquiv |
||
| 3631 | def set_TextEquiv(self, TextEquiv): |
||
| 3632 | self.TextEquiv = TextEquiv |
||
| 3633 | def add_TextEquiv(self, value): |
||
| 3634 | self.TextEquiv.append(value) |
||
| 3635 | def insert_TextEquiv_at(self, index, value): |
||
| 3636 | self.TextEquiv.insert(index, value) |
||
| 3637 | def replace_TextEquiv_at(self, index, value): |
||
| 3638 | self.TextEquiv[index] = value |
||
| 3639 | def get_TextStyle(self): |
||
| 3640 | return self.TextStyle |
||
| 3641 | def set_TextStyle(self, TextStyle): |
||
| 3642 | self.TextStyle = TextStyle |
||
| 3643 | def get_UserDefined(self): |
||
| 3644 | return self.UserDefined |
||
| 3645 | def set_UserDefined(self, UserDefined): |
||
| 3646 | self.UserDefined = UserDefined |
||
| 3647 | def get_Labels(self): |
||
| 3648 | return self.Labels |
||
| 3649 | def set_Labels(self, Labels): |
||
| 3650 | self.Labels = Labels |
||
| 3651 | def add_Labels(self, value): |
||
| 3652 | self.Labels.append(value) |
||
| 3653 | def insert_Labels_at(self, index, value): |
||
| 3654 | self.Labels.insert(index, value) |
||
| 3655 | def replace_Labels_at(self, index, value): |
||
| 3656 | self.Labels[index] = value |
||
| 3657 | def get_id(self): |
||
| 3658 | return self.id |
||
| 3659 | def set_id(self, id): |
||
| 3660 | self.id = id |
||
| 3661 | def get_primaryLanguage(self): |
||
| 3662 | return self.primaryLanguage |
||
| 3663 | def set_primaryLanguage(self, primaryLanguage): |
||
| 3664 | self.primaryLanguage = primaryLanguage |
||
| 3665 | def get_primaryScript(self): |
||
| 3666 | return self.primaryScript |
||
| 3667 | def set_primaryScript(self, primaryScript): |
||
| 3668 | self.primaryScript = primaryScript |
||
| 3669 | def get_secondaryScript(self): |
||
| 3670 | return self.secondaryScript |
||
| 3671 | def set_secondaryScript(self, secondaryScript): |
||
| 3672 | self.secondaryScript = secondaryScript |
||
| 3673 | def get_readingDirection(self): |
||
| 3674 | return self.readingDirection |
||
| 3675 | def set_readingDirection(self, readingDirection): |
||
| 3676 | self.readingDirection = readingDirection |
||
| 3677 | def get_production(self): |
||
| 3678 | return self.production |
||
| 3679 | def set_production(self, production): |
||
| 3680 | self.production = production |
||
| 3681 | def get_custom(self): |
||
| 3682 | return self.custom |
||
| 3683 | def set_custom(self, custom): |
||
| 3684 | self.custom = custom |
||
| 3685 | def get_comments(self): |
||
| 3686 | return self.comments |
||
| 3687 | def set_comments(self, comments): |
||
| 3688 | self.comments = comments |
||
| 3689 | def get_index(self): |
||
| 3690 | return self.index |
||
| 3691 | def set_index(self, index): |
||
| 3692 | self.index = index |
||
| 3693 | def validate_LanguageSimpleType(self, value): |
||
| 3694 | # Validate type pc:LanguageSimpleType, a restriction on string. |
||
| 3695 | if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None: |
||
| 3696 | if not isinstance(value, str): |
||
| 3697 | lineno = self.gds_get_node_lineno_() |
||
| 3698 | self.gds_collector_.add_message('Value "%(value)s"%(lineno)s is not of the correct base simple type (str)' % {"value": value, "lineno": lineno, }) |
||
| 3699 | return False |
||
| 3700 | value = value |
||
| 3701 | enumerations = ['Abkhaz', 'Afar', 'Afrikaans', 'Akan', 'Albanian', 'Amharic', 'Arabic', 'Aragonese', 'Armenian', 'Assamese', 'Avaric', 'Avestan', 'Aymara', 'Azerbaijani', 'Bambara', 'Bashkir', 'Basque', 'Belarusian', 'Bengali', 'Bihari', 'Bislama', 'Bosnian', 'Breton', 'Bulgarian', 'Burmese', 'Cambodian', 'Cantonese', 'Catalan', 'Chamorro', 'Chechen', 'Chichewa', 'Chinese', 'Chuvash', 'Cornish', 'Corsican', 'Cree', 'Croatian', 'Czech', 'Danish', 'Divehi', 'Dutch', 'Dzongkha', 'English', 'Esperanto', 'Estonian', 'Ewe', 'Faroese', 'Fijian', 'Finnish', 'French', 'Fula', 'Gaelic', 'Galician', 'Ganda', 'Georgian', 'German', 'Greek', 'Guaraní', 'Gujarati', 'Haitian', 'Hausa', 'Hebrew', 'Herero', 'Hindi', 'Hiri Motu', 'Hungarian', 'Icelandic', 'Ido', 'Igbo', 'Indonesian', 'Interlingua', 'Interlingue', 'Inuktitut', 'Inupiaq', 'Irish', 'Italian', 'Japanese', 'Javanese', 'Kalaallisut', 'Kannada', 'Kanuri', 'Kashmiri', 'Kazakh', 'Khmer', 'Kikuyu', 'Kinyarwanda', 'Kirundi', 'Komi', 'Kongo', 'Korean', 'Kurdish', 'Kwanyama', 'Kyrgyz', 'Lao', 'Latin', 'Latvian', 'Limburgish', 'Lingala', 'Lithuanian', 'Luba-Katanga', 'Luxembourgish', 'Macedonian', 'Malagasy', 'Malay', 'Malayalam', 'Maltese', 'Manx', 'Māori', 'Marathi', 'Marshallese', 'Mongolian', 'Nauru', 'Navajo', 'Ndonga', 'Nepali', 'North Ndebele', 'Northern Sami', 'Norwegian', 'Norwegian Bokmål', 'Norwegian Nynorsk', 'Nuosu', 'Occitan', 'Ojibwe', 'Old Church Slavonic', 'Oriya', 'Oromo', 'Ossetian', 'Pāli', 'Panjabi', 'Pashto', 'Persian', 'Polish', 'Portuguese', 'Punjabi', 'Quechua', 'Romanian', 'Romansh', 'Russian', 'Samoan', 'Sango', 'Sanskrit', 'Sardinian', 'Serbian', 'Shona', 'Sindhi', 'Sinhala', 'Slovak', 'Slovene', 'Somali', 'South Ndebele', 'Southern Sotho', 'Spanish', 'Sundanese', 'Swahili', 'Swati', 'Swedish', 'Tagalog', 'Tahitian', 'Tajik', 'Tamil', 'Tatar', 'Telugu', 'Thai', 'Tibetan', 'Tigrinya', 'Tonga', 'Tsonga', 'Tswana', 'Turkish', 'Turkmen', 'Twi', 'Uighur', 'Ukrainian', 'Urdu', 'Uzbek', 'Venda', 'Vietnamese', 'Volapük', 'Walloon', 'Welsh', 'Western Frisian', 'Wolof', 'Xhosa', 'Yiddish', 'Yoruba', 'Zhuang', 'Zulu', 'other'] |
||
| 3702 | if value not in enumerations: |
||
| 3703 | lineno = self.gds_get_node_lineno_() |
||
| 3704 | self.gds_collector_.add_message('Value "%(value)s"%(lineno)s does not match xsd enumeration restriction on LanguageSimpleType' % {"value" : encode_str_2_3(value), "lineno": lineno} ) |
||
| 3705 | result = False |
||
| 3706 | def validate_ScriptSimpleType(self, value): |
||
| 3707 | # Validate type pc:ScriptSimpleType, a restriction on string. |
||
| 3708 | if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None: |
||
| 3709 | if not isinstance(value, str): |
||
| 3710 | lineno = self.gds_get_node_lineno_() |
||
| 3711 | self.gds_collector_.add_message('Value "%(value)s"%(lineno)s is not of the correct base simple type (str)' % {"value": value, "lineno": lineno, }) |
||
| 3712 | return False |
||
| 3713 | value = value |
||
| 3714 | enumerations = ['Adlm - Adlam', 'Afak - Afaka', 'Aghb - Caucasian Albanian', 'Ahom - Ahom, Tai Ahom', 'Arab - Arabic', 'Aran - Arabic (Nastaliq variant)', 'Armi - Imperial Aramaic', 'Armn - Armenian', 'Avst - Avestan', 'Bali - Balinese', 'Bamu - Bamum', 'Bass - Bassa Vah', 'Batk - Batak', 'Beng - Bengali', 'Bhks - Bhaiksuki', 'Blis - Blissymbols', 'Bopo - Bopomofo', 'Brah - Brahmi', 'Brai - Braille', 'Bugi - Buginese', 'Buhd - Buhid', 'Cakm - Chakma', 'Cans - Unified Canadian Aboriginal Syllabics', 'Cari - Carian', 'Cham - Cham', 'Cher - Cherokee', 'Cirt - Cirth', 'Copt - Coptic', 'Cprt - Cypriot', 'Cyrl - Cyrillic', 'Cyrs - Cyrillic (Old Church Slavonic variant)', 'Deva - Devanagari (Nagari)', 'Dsrt - Deseret (Mormon)', 'Dupl - Duployan shorthand, Duployan stenography', 'Egyd - Egyptian demotic', 'Egyh - Egyptian hieratic', 'Egyp - Egyptian hieroglyphs', 'Elba - Elbasan', 'Ethi - Ethiopic', 'Geok - Khutsuri (Asomtavruli and Nuskhuri)', 'Geor - Georgian (Mkhedruli)', 'Glag - Glagolitic', 'Goth - Gothic', 'Gran - Grantha', 'Grek - Greek', 'Gujr - Gujarati', 'Guru - Gurmukhi', 'Hanb - Han with Bopomofo', 'Hang - Hangul', 'Hani - Han (Hanzi, Kanji, Hanja)', 'Hano - Hanunoo (Hanunóo)', 'Hans - Han (Simplified variant)', 'Hant - Han (Traditional variant)', 'Hatr - Hatran', 'Hebr - Hebrew', 'Hira - Hiragana', 'Hluw - Anatolian Hieroglyphs', 'Hmng - Pahawh Hmong', 'Hrkt - Japanese syllabaries', 'Hung - Old Hungarian (Hungarian Runic)', 'Inds - Indus (Harappan)', 'Ital - Old Italic (Etruscan, Oscan etc.)', 'Jamo - Jamo', 'Java - Javanese', 'Jpan - Japanese', 'Jurc - Jurchen', 'Kali - Kayah Li', 'Kana - Katakana', 'Khar - Kharoshthi', 'Khmr - Khmer', 'Khoj - Khojki', 'Kitl - Khitan large script', 'Kits - Khitan small script', 'Knda - Kannada', 'Kore - Korean (alias for Hangul + Han)', 'Kpel - Kpelle', 'Kthi - Kaithi', 'Lana - Tai Tham (Lanna)', 'Laoo - Lao', 'Latf - Latin (Fraktur variant)', 'Latg - Latin (Gaelic variant)', 'Latn - Latin', 'Leke - Leke', 'Lepc - Lepcha (Róng)', 'Limb - Limbu', 'Lina - Linear A', 'Linb - Linear B', 'Lisu - Lisu (Fraser)', 'Loma - Loma', 'Lyci - Lycian', 'Lydi - Lydian', 'Mahj - Mahajani', 'Mand - Mandaic, Mandaean', 'Mani - Manichaean', 'Marc - Marchen', 'Maya - Mayan hieroglyphs', 'Mend - Mende Kikakui', 'Merc - Meroitic Cursive', 'Mero - Meroitic Hieroglyphs', 'Mlym - Malayalam', 'Modi - Modi, Moḍī', 'Mong - Mongolian', 'Moon - Moon (Moon code, Moon script, Moon type)', 'Mroo - Mro, Mru', 'Mtei - Meitei Mayek (Meithei, Meetei)', 'Mult - Multani', 'Mymr - Myanmar (Burmese)', 'Narb - Old North Arabian (Ancient North Arabian)', 'Nbat - Nabataean', 'Newa - Newa, Newar, Newari', 'Nkgb - Nakhi Geba', 'Nkoo - N’Ko', 'Nshu - Nüshu', 'Ogam - Ogham', 'Olck - Ol Chiki (Ol Cemet’, Ol, Santali)', 'Orkh - Old Turkic, Orkhon Runic', 'Orya - Oriya', 'Osge - Osage', 'Osma - Osmanya', 'Palm - Palmyrene', 'Pauc - Pau Cin Hau', 'Perm - Old Permic', 'Phag - Phags-pa', 'Phli - Inscriptional Pahlavi', 'Phlp - Psalter Pahlavi', 'Phlv - Book Pahlavi', 'Phnx - Phoenician', 'Piqd - Klingon (KLI pIqaD)', 'Plrd - Miao (Pollard)', 'Prti - Inscriptional Parthian', 'Rjng - Rejang (Redjang, Kaganga)', 'Roro - Rongorongo', 'Runr - Runic', 'Samr - Samaritan', 'Sara - Sarati', 'Sarb - Old South Arabian', 'Saur - Saurashtra', 'Sgnw - SignWriting', 'Shaw - Shavian (Shaw)', 'Shrd - Sharada, Śāradā', 'Sidd - Siddham', 'Sind - Khudawadi, Sindhi', 'Sinh - Sinhala', 'Sora - Sora Sompeng', 'Sund - Sundanese', 'Sylo - Syloti Nagri', 'Syrc - Syriac', 'Syre - Syriac (Estrangelo variant)', 'Syrj - Syriac (Western variant)', 'Syrn - Syriac (Eastern variant)', 'Tagb - Tagbanwa', 'Takr - Takri', 'Tale - Tai Le', 'Talu - New Tai Lue', 'Taml - Tamil', 'Tang - Tangut', 'Tavt - Tai Viet', 'Telu - Telugu', 'Teng - Tengwar', 'Tfng - Tifinagh (Berber)', 'Tglg - Tagalog (Baybayin, Alibata)', 'Thaa - Thaana', 'Thai - Thai', 'Tibt - Tibetan', 'Tirh - Tirhuta', 'Ugar - Ugaritic', 'Vaii - Vai', 'Visp - Visible Speech', 'Wara - Warang Citi (Varang Kshiti)', 'Wole - Woleai', 'Xpeo - Old Persian', 'Xsux - Cuneiform, Sumero-Akkadian', 'Yiii - Yi', 'Zinh - Code for inherited script', 'Zmth - Mathematical notation', 'Zsye - Symbols (Emoji variant)', 'Zsym - Symbols', 'Zxxx - Code for unwritten documents', 'Zyyy - Code for undetermined script', 'Zzzz - Code for uncoded script', 'other'] |
||
| 3715 | if value not in enumerations: |
||
| 3716 | lineno = self.gds_get_node_lineno_() |
||
| 3717 | self.gds_collector_.add_message('Value "%(value)s"%(lineno)s does not match xsd enumeration restriction on ScriptSimpleType' % {"value" : encode_str_2_3(value), "lineno": lineno} ) |
||
| 3718 | result = False |
||
| 3719 | def validate_ReadingDirectionSimpleType(self, value): |
||
| 3720 | # Validate type pc:ReadingDirectionSimpleType, a restriction on string. |
||
| 3721 | if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None: |
||
| 3722 | if not isinstance(value, str): |
||
| 3723 | lineno = self.gds_get_node_lineno_() |
||
| 3724 | self.gds_collector_.add_message('Value "%(value)s"%(lineno)s is not of the correct base simple type (str)' % {"value": value, "lineno": lineno, }) |
||
| 3725 | return False |
||
| 3726 | value = value |
||
| 3727 | enumerations = ['left-to-right', 'right-to-left', 'top-to-bottom', 'bottom-to-top'] |
||
| 3728 | if value not in enumerations: |
||
| 3729 | lineno = self.gds_get_node_lineno_() |
||
| 3730 | self.gds_collector_.add_message('Value "%(value)s"%(lineno)s does not match xsd enumeration restriction on ReadingDirectionSimpleType' % {"value" : encode_str_2_3(value), "lineno": lineno} ) |
||
| 3731 | result = False |
||
| 3732 | def validate_ProductionSimpleType(self, value): |
||
| 3733 | # Validate type pc:ProductionSimpleType, a restriction on string. |
||
| 3734 | if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None: |
||
| 3735 | if not isinstance(value, str): |
||
| 3736 | lineno = self.gds_get_node_lineno_() |
||
| 3737 | self.gds_collector_.add_message('Value "%(value)s"%(lineno)s is not of the correct base simple type (str)' % {"value": value, "lineno": lineno, }) |
||
| 3738 | return False |
||
| 3739 | value = value |
||
| 3740 | enumerations = ['printed', 'typewritten', 'handwritten-cursive', 'handwritten-printscript', 'medieval-manuscript', 'other'] |
||
| 3741 | if value not in enumerations: |
||
| 3742 | lineno = self.gds_get_node_lineno_() |
||
| 3743 | self.gds_collector_.add_message('Value "%(value)s"%(lineno)s does not match xsd enumeration restriction on ProductionSimpleType' % {"value" : encode_str_2_3(value), "lineno": lineno} ) |
||
| 3744 | result = False |
||
| 3745 | def hasContent_(self): |
||
| 3746 | if ( |
||
| 3747 | self.AlternativeImage or |
||
| 3748 | self.Coords is not None or |
||
| 3749 | self.Baseline is not None or |
||
| 3750 | self.Word or |
||
| 3751 | self.TextEquiv or |
||
| 3752 | self.TextStyle is not None or |
||
| 3753 | self.UserDefined is not None or |
||
| 3754 | self.Labels |
||
| 3755 | ): |
||
| 3756 | return True |
||
| 3757 | else: |
||
| 3758 | return False |
||
| 3759 | def export(self, outfile, level, namespaceprefix_='', namespacedef_='xmlns:pc="http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15"', name_='TextLineType', pretty_print=True): |
||
| 3760 | imported_ns_def_ = GenerateDSNamespaceDefs_.get('TextLineType') |
||
| 3761 | if imported_ns_def_ is not None: |
||
| 3762 | namespacedef_ = imported_ns_def_ |
||
| 3763 | if pretty_print: |
||
| 3764 | eol_ = '\n' |
||
| 3765 | else: |
||
| 3766 | eol_ = '' |
||
| 3767 | if self.original_tagname_ is not None and name_ == 'TextLineType': |
||
| 3768 | name_ = self.original_tagname_ |
||
| 3769 | if UseCapturedNS_ and self.ns_prefix_: |
||
| 3770 | namespaceprefix_ = self.ns_prefix_ + ':' |
||
| 3771 | showIndent(outfile, level, pretty_print) |
||
| 3772 | outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) |
||
| 3773 | already_processed = set() |
||
| 3774 | self.exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='TextLineType') |
||
| 3775 | if self.hasContent_(): |
||
| 3776 | outfile.write('>%s' % (eol_, )) |
||
| 3777 | self.exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='TextLineType', pretty_print=pretty_print) |
||
| 3778 | showIndent(outfile, level, pretty_print) |
||
| 3779 | outfile.write('</%s%s>%s' % (namespaceprefix_, name_, eol_)) |
||
| 3780 | else: |
||
| 3781 | outfile.write('/>%s' % (eol_, )) |
||
| 3782 | def exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='TextLineType'): |
||
| 3783 | if self.id is not None and 'id' not in already_processed: |
||
| 3784 | already_processed.add('id') |
||
| 3785 | outfile.write(' id=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.id), input_name='id')), )) |
||
| 3786 | if self.primaryLanguage is not None and 'primaryLanguage' not in already_processed: |
||
| 3787 | already_processed.add('primaryLanguage') |
||
| 3788 | outfile.write(' primaryLanguage=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.primaryLanguage), input_name='primaryLanguage')), )) |
||
| 3789 | if self.primaryScript is not None and 'primaryScript' not in already_processed: |
||
| 3790 | already_processed.add('primaryScript') |
||
| 3791 | outfile.write(' primaryScript=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.primaryScript), input_name='primaryScript')), )) |
||
| 3792 | if self.secondaryScript is not None and 'secondaryScript' not in already_processed: |
||
| 3793 | already_processed.add('secondaryScript') |
||
| 3794 | outfile.write(' secondaryScript=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.secondaryScript), input_name='secondaryScript')), )) |
||
| 3795 | if self.readingDirection is not None and 'readingDirection' not in already_processed: |
||
| 3796 | already_processed.add('readingDirection') |
||
| 3797 | outfile.write(' readingDirection=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.readingDirection), input_name='readingDirection')), )) |
||
| 3798 | if self.production is not None and 'production' not in already_processed: |
||
| 3799 | already_processed.add('production') |
||
| 3800 | outfile.write(' production=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.production), input_name='production')), )) |
||
| 3801 | if self.custom is not None and 'custom' not in already_processed: |
||
| 3802 | already_processed.add('custom') |
||
| 3803 | outfile.write(' custom=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.custom), input_name='custom')), )) |
||
| 3804 | if self.comments is not None and 'comments' not in already_processed: |
||
| 3805 | already_processed.add('comments') |
||
| 3806 | outfile.write(' comments=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.comments), input_name='comments')), )) |
||
| 3807 | if self.index is not None and 'index' not in already_processed: |
||
| 3808 | already_processed.add('index') |
||
| 3809 | outfile.write(' index="%s"' % self.gds_format_integer(self.index, input_name='index')) |
||
| 3810 | def exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='xmlns:pc="http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15"', name_='TextLineType', fromsubclass_=False, pretty_print=True): |
||
| 3811 | if pretty_print: |
||
| 3812 | eol_ = '\n' |
||
| 3813 | else: |
||
| 3814 | eol_ = '' |
||
| 3815 | for AlternativeImage_ in self.AlternativeImage: |
||
| 3816 | namespaceprefix_ = self.AlternativeImage_nsprefix_ + ':' if (UseCapturedNS_ and self.AlternativeImage_nsprefix_) else '' |
||
| 3817 | AlternativeImage_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='AlternativeImage', pretty_print=pretty_print) |
||
| 3818 | if self.Coords is not None: |
||
| 3819 | namespaceprefix_ = self.Coords_nsprefix_ + ':' if (UseCapturedNS_ and self.Coords_nsprefix_) else '' |
||
| 3820 | self.Coords.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Coords', pretty_print=pretty_print) |
||
| 3821 | if self.Baseline is not None: |
||
| 3822 | namespaceprefix_ = self.Baseline_nsprefix_ + ':' if (UseCapturedNS_ and self.Baseline_nsprefix_) else '' |
||
| 3823 | self.Baseline.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Baseline', pretty_print=pretty_print) |
||
| 3824 | for Word_ in self.Word: |
||
| 3825 | namespaceprefix_ = self.Word_nsprefix_ + ':' if (UseCapturedNS_ and self.Word_nsprefix_) else '' |
||
| 3826 | Word_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Word', pretty_print=pretty_print) |
||
| 3827 | for TextEquiv_ in self.TextEquiv: |
||
| 3828 | namespaceprefix_ = self.TextEquiv_nsprefix_ + ':' if (UseCapturedNS_ and self.TextEquiv_nsprefix_) else '' |
||
| 3829 | TextEquiv_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='TextEquiv', pretty_print=pretty_print) |
||
| 3830 | if self.TextStyle is not None: |
||
| 3831 | namespaceprefix_ = self.TextStyle_nsprefix_ + ':' if (UseCapturedNS_ and self.TextStyle_nsprefix_) else '' |
||
| 3832 | self.TextStyle.export(outfile, level, namespaceprefix_, namespacedef_='', name_='TextStyle', pretty_print=pretty_print) |
||
| 3833 | if self.UserDefined is not None: |
||
| 3834 | namespaceprefix_ = self.UserDefined_nsprefix_ + ':' if (UseCapturedNS_ and self.UserDefined_nsprefix_) else '' |
||
| 3835 | self.UserDefined.export(outfile, level, namespaceprefix_, namespacedef_='', name_='UserDefined', pretty_print=pretty_print) |
||
| 3836 | for Labels_ in self.Labels: |
||
| 3837 | namespaceprefix_ = self.Labels_nsprefix_ + ':' if (UseCapturedNS_ and self.Labels_nsprefix_) else '' |
||
| 3838 | Labels_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Labels', pretty_print=pretty_print) |
||
| 3839 | def to_etree(self, parent_element=None, name_='TextLineType', mapping_=None, nsmap_=None): |
||
| 3840 | if parent_element is None: |
||
| 3841 | element = etree_.Element('{http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15}' + name_, nsmap=nsmap_) |
||
| 3842 | else: |
||
| 3843 | element = etree_.SubElement(parent_element, '{http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15}' + name_, nsmap=nsmap_) |
||
| 3844 | if self.id is not None: |
||
| 3845 | element.set('id', self.gds_format_string(self.id)) |
||
| 3846 | if self.primaryLanguage is not None: |
||
| 3847 | element.set('primaryLanguage', self.gds_format_string(self.primaryLanguage)) |
||
| 3848 | if self.primaryScript is not None: |
||
| 3849 | element.set('primaryScript', self.gds_format_string(self.primaryScript)) |
||
| 3850 | if self.secondaryScript is not None: |
||
| 3851 | element.set('secondaryScript', self.gds_format_string(self.secondaryScript)) |
||
| 3852 | if self.readingDirection is not None: |
||
| 3853 | element.set('readingDirection', self.gds_format_string(self.readingDirection)) |
||
| 3854 | if self.production is not None: |
||
| 3855 | element.set('production', self.gds_format_string(self.production)) |
||
| 3856 | if self.custom is not None: |
||
| 3857 | element.set('custom', self.gds_format_string(self.custom)) |
||
| 3858 | if self.comments is not None: |
||
| 3859 | element.set('comments', self.gds_format_string(self.comments)) |
||
| 3860 | if self.index is not None: |
||
| 3861 | element.set('index', self.gds_format_integer(self.index)) |
||
| 3862 | for AlternativeImage_ in self.AlternativeImage: |
||
| 3863 | AlternativeImage_.to_etree(element, name_='AlternativeImage', mapping_=mapping_, nsmap_=nsmap_) |
||
| 3864 | if self.Coords is not None: |
||
| 3865 | Coords_ = self.Coords |
||
| 3866 | Coords_.to_etree(element, name_='Coords', mapping_=mapping_, nsmap_=nsmap_) |
||
| 3867 | if self.Baseline is not None: |
||
| 3868 | Baseline_ = self.Baseline |
||
| 3869 | Baseline_.to_etree(element, name_='Baseline', mapping_=mapping_, nsmap_=nsmap_) |
||
| 3870 | for Word_ in self.Word: |
||
| 3871 | Word_.to_etree(element, name_='Word', mapping_=mapping_, nsmap_=nsmap_) |
||
| 3872 | for TextEquiv_ in self.TextEquiv: |
||
| 3873 | TextEquiv_.to_etree(element, name_='TextEquiv', mapping_=mapping_, nsmap_=nsmap_) |
||
| 3874 | if self.TextStyle is not None: |
||
| 3875 | TextStyle_ = self.TextStyle |
||
| 3876 | TextStyle_.to_etree(element, name_='TextStyle', mapping_=mapping_, nsmap_=nsmap_) |
||
| 3877 | if self.UserDefined is not None: |
||
| 3878 | UserDefined_ = self.UserDefined |
||
| 3879 | UserDefined_.to_etree(element, name_='UserDefined', mapping_=mapping_, nsmap_=nsmap_) |
||
| 3880 | for Labels_ in self.Labels: |
||
| 3881 | Labels_.to_etree(element, name_='Labels', mapping_=mapping_, nsmap_=nsmap_) |
||
| 3882 | if mapping_ is not None: |
||
| 3883 | mapping_[id(self)] = element |
||
| 3884 | return element |
||
| 3885 | def build(self, node, gds_collector_=None): |
||
| 3886 | self.gds_collector_ = gds_collector_ |
||
| 3887 | if SaveElementTreeNode: |
||
| 3888 | self.gds_elementtree_node_ = node |
||
| 3889 | already_processed = set() |
||
| 3890 | self.ns_prefix_ = node.prefix |
||
| 3891 | self.buildAttributes(node, node.attrib, already_processed) |
||
| 3892 | for child in node: |
||
| 3893 | nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] |
||
| 3894 | self.buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) |
||
| 3895 | return self |
||
| 3896 | def buildAttributes(self, node, attrs, already_processed): |
||
| 3897 | value = find_attr_value_('id', node) |
||
| 3898 | if value is not None and 'id' not in already_processed: |
||
| 3899 | already_processed.add('id') |
||
| 3900 | self.id = value |
||
| 3901 | value = find_attr_value_('primaryLanguage', node) |
||
| 3902 | if value is not None and 'primaryLanguage' not in already_processed: |
||
| 3903 | already_processed.add('primaryLanguage') |
||
| 3904 | self.primaryLanguage = value |
||
| 3905 | self.validate_LanguageSimpleType(self.primaryLanguage) # validate type LanguageSimpleType |
||
| 3906 | value = find_attr_value_('primaryScript', node) |
||
| 3907 | if value is not None and 'primaryScript' not in already_processed: |
||
| 3908 | already_processed.add('primaryScript') |
||
| 3909 | self.primaryScript = value |
||
| 3910 | self.validate_ScriptSimpleType(self.primaryScript) # validate type ScriptSimpleType |
||
| 3911 | value = find_attr_value_('secondaryScript', node) |
||
| 3912 | if value is not None and 'secondaryScript' not in already_processed: |
||
| 3913 | already_processed.add('secondaryScript') |
||
| 3914 | self.secondaryScript = value |
||
| 3915 | self.validate_ScriptSimpleType(self.secondaryScript) # validate type ScriptSimpleType |
||
| 3916 | value = find_attr_value_('readingDirection', node) |
||
| 3917 | if value is not None and 'readingDirection' not in already_processed: |
||
| 3918 | already_processed.add('readingDirection') |
||
| 3919 | self.readingDirection = value |
||
| 3920 | self.validate_ReadingDirectionSimpleType(self.readingDirection) # validate type ReadingDirectionSimpleType |
||
| 3921 | value = find_attr_value_('production', node) |
||
| 3922 | if value is not None and 'production' not in already_processed: |
||
| 3923 | already_processed.add('production') |
||
| 3924 | self.production = value |
||
| 3925 | self.validate_ProductionSimpleType(self.production) # validate type ProductionSimpleType |
||
| 3926 | value = find_attr_value_('custom', node) |
||
| 3927 | if value is not None and 'custom' not in already_processed: |
||
| 3928 | already_processed.add('custom') |
||
| 3929 | self.custom = value |
||
| 3930 | value = find_attr_value_('comments', node) |
||
| 3931 | if value is not None and 'comments' not in already_processed: |
||
| 3932 | already_processed.add('comments') |
||
| 3933 | self.comments = value |
||
| 3934 | value = find_attr_value_('index', node) |
||
| 3935 | if value is not None and 'index' not in already_processed: |
||
| 3936 | already_processed.add('index') |
||
| 3937 | self.index = self.gds_parse_integer(value, node, 'index') |
||
| 3938 | def buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None): |
||
| 3939 | if nodeName_ == 'AlternativeImage': |
||
| 3940 | obj_ = AlternativeImageType.factory(parent_object_=self) |
||
| 3941 | obj_.build(child_, gds_collector_=gds_collector_) |
||
| 3942 | self.AlternativeImage.append(obj_) |
||
| 3943 | obj_.original_tagname_ = 'AlternativeImage' |
||
| 3944 | elif nodeName_ == 'Coords': |
||
| 3945 | obj_ = CoordsType.factory(parent_object_=self) |
||
| 3946 | obj_.build(child_, gds_collector_=gds_collector_) |
||
| 3947 | self.Coords = obj_ |
||
| 3948 | obj_.original_tagname_ = 'Coords' |
||
| 3949 | elif nodeName_ == 'Baseline': |
||
| 3950 | obj_ = BaselineType.factory(parent_object_=self) |
||
| 3951 | obj_.build(child_, gds_collector_=gds_collector_) |
||
| 3952 | self.Baseline = obj_ |
||
| 3953 | obj_.original_tagname_ = 'Baseline' |
||
| 3954 | elif nodeName_ == 'Word': |
||
| 3955 | obj_ = WordType.factory(parent_object_=self) |
||
| 3956 | obj_.build(child_, gds_collector_=gds_collector_) |
||
| 3957 | self.Word.append(obj_) |
||
| 3958 | obj_.original_tagname_ = 'Word' |
||
| 3959 | elif nodeName_ == 'TextEquiv': |
||
| 3960 | obj_ = TextEquivType.factory(parent_object_=self) |
||
| 3961 | obj_.build(child_, gds_collector_=gds_collector_) |
||
| 3962 | self.TextEquiv.append(obj_) |
||
| 3963 | obj_.original_tagname_ = 'TextEquiv' |
||
| 3964 | elif nodeName_ == 'TextStyle': |
||
| 3965 | obj_ = TextStyleType.factory(parent_object_=self) |
||
| 3966 | obj_.build(child_, gds_collector_=gds_collector_) |
||
| 3967 | self.TextStyle = obj_ |
||
| 3968 | obj_.original_tagname_ = 'TextStyle' |
||
| 3969 | elif nodeName_ == 'UserDefined': |
||
| 3970 | obj_ = UserDefinedType.factory(parent_object_=self) |
||
| 3971 | obj_.build(child_, gds_collector_=gds_collector_) |
||
| 3972 | self.UserDefined = obj_ |
||
| 3973 | obj_.original_tagname_ = 'UserDefined' |
||
| 3974 | elif nodeName_ == 'Labels': |
||
| 3975 | obj_ = LabelsType.factory(parent_object_=self) |
||
| 3976 | obj_.build(child_, gds_collector_=gds_collector_) |
||
| 3977 | self.Labels.append(obj_) |
||
| 3978 | obj_.original_tagname_ = 'Labels' |
||
| 3979 | def __hash__(self): |
||
| 3980 | return hash(self.id) |
||
| 3981 | View Code Duplication | def invalidate_AlternativeImage(self, feature_selector=None): |
|
| 3982 | """ |
||
| 3983 | Remove derived images from this segment (due to changed coordinates). |
||
| 3984 | |||
| 3985 | If `feature_selector` is not none, remove only images with |
||
| 3986 | matching ``@comments``, e.g. ``feature_selector=cropped,deskewed``. |
||
| 3987 | """ |
||
| 3988 | existing_images = self.AlternativeImage or [] |
||
| 3989 | removed_images = [] |
||
| 3990 | if feature_selector: |
||
| 3991 | new_images = [] |
||
| 3992 | for image in existing_images: |
||
| 3993 | features = image.get_comments() or '' |
||
| 3994 | if any(feature in features.split(',') |
||
| 3995 | for feature in feature_selector.split(',') if feature): |
||
| 3996 | removed_images.append(image) |
||
| 3997 | else: |
||
| 3998 | new_images.append(image) |
||
| 3999 | self.AlternativeImage = new_images |
||
| 4000 | else: |
||
| 4001 | removed_images = existing_images |
||
| 4002 | self.AlternativeImage = [] |
||
| 4003 | if hasattr(self, 'id'): |
||
| 4004 | name = self.id |
||
| 4005 | elif hasattr(self, 'parent_object_') and hasattr(self.parent_object_, 'pcGtsId'): |
||
| 4006 | name = self.parent_object_.pcGtsId |
||
| 4007 | else: |
||
| 4008 | name = '' |
||
| 4009 | for image in removed_images: |
||
| 4010 | self.gds_collector_.add_message('Removing AlternativeImage %s from "%s"' % ( |
||
| 4011 | image.get_comments() or '', name)) |
||
| 4012 | def set_Coords(self, Coords): |
||
| 4013 | """ |
||
| 4014 | Set coordinate polygon by given :py:class:`CoordsType` object. |
||
| 4015 | Moreover, invalidate self's ``pc:AlternativeImage``s |
||
| 4016 | (because they will have been cropped with a bbox |
||
| 4017 | of the previous polygon). |
||
| 4018 | """ |
||
| 4019 | if hasattr(self, 'invalidate_AlternativeImage'): |
||
| 4020 | # RegionType, TextLineType, WordType, GlyphType: |
||
| 4021 | self.invalidate_AlternativeImage() |
||
| 4022 | elif hasattr(self, 'parent_object_') and hasattr(self.parent_object_, 'invalidate_AlternativeImage'): |
||
| 4023 | # BorderType: |
||
| 4024 | self.parent_object_.invalidate_AlternativeImage(feature_selector='cropped') |
||
| 4025 | self.Coords = Coords |
||
| 4026 | # end class TextLineType |
||
| 4027 | |||
| 4028 | |||
| 4029 | class WordType(GeneratedsSuper): |
||
| 4030 | """Overrides primaryLanguage attribute of parent line |
||
| 4031 | and/or text region |
||
| 4032 | The primary script used in the word |
||
| 4033 | The secondary script used in the word |
||
| 4034 | The direction in which text within the word |
||
| 4035 | should be read (order of characters). |
||
| 4036 | Overrides the production attribute of the parent |
||
| 4037 | text line and/or text region. |
||
| 4038 | For generic use""" |
||
| 4039 | __hash__ = GeneratedsSuper.__hash__ |
||
| 4040 | member_data_items_ = [ |
||
| 4041 | MemberSpec_('id', 'string', 0, 0, {'use': 'required'}), |
||
| 4042 | MemberSpec_('language', 'pc:LanguageSimpleType', 0, 1, {'use': 'optional'}), |
||
| 4043 | MemberSpec_('primaryScript', 'pc:ScriptSimpleType', 0, 1, {'use': 'optional'}), |
||
| 4044 | MemberSpec_('secondaryScript', 'pc:ScriptSimpleType', 0, 1, {'use': 'optional'}), |
||
| 4045 | MemberSpec_('readingDirection', 'pc:ReadingDirectionSimpleType', 0, 1, {'use': 'optional'}), |
||
| 4046 | MemberSpec_('production', 'pc:ProductionSimpleType', 0, 1, {'use': 'optional'}), |
||
| 4047 | MemberSpec_('custom', 'string', 0, 1, {'use': 'optional'}), |
||
| 4048 | MemberSpec_('comments', 'string', 0, 1, {'use': 'optional'}), |
||
| 4049 | MemberSpec_('AlternativeImage', 'AlternativeImageType', 1, 1, {'maxOccurs': 'unbounded', 'minOccurs': '0', 'name': 'AlternativeImage', 'type': 'AlternativeImageType'}, None), |
||
| 4050 | MemberSpec_('Coords', 'CoordsType', 0, 0, {'name': 'Coords', 'type': 'CoordsType'}, None), |
||
| 4051 | MemberSpec_('Glyph', 'GlyphType', 1, 1, {'maxOccurs': 'unbounded', 'minOccurs': '0', 'name': 'Glyph', 'type': 'GlyphType'}, None), |
||
| 4052 | MemberSpec_('TextEquiv', 'TextEquivType', 1, 1, {'maxOccurs': 'unbounded', 'minOccurs': '0', 'name': 'TextEquiv', 'type': 'TextEquivType'}, None), |
||
| 4053 | MemberSpec_('TextStyle', 'TextStyleType', 0, 1, {'minOccurs': '0', 'name': 'TextStyle', 'type': 'TextStyleType'}, None), |
||
| 4054 | MemberSpec_('UserDefined', 'UserDefinedType', 0, 1, {'maxOccurs': '1', 'minOccurs': '0', 'name': 'UserDefined', 'type': 'UserDefinedType'}, None), |
||
| 4055 | MemberSpec_('Labels', 'LabelsType', 1, 1, {'maxOccurs': 'unbounded', 'minOccurs': '0', 'name': 'Labels', 'type': 'LabelsType'}, None), |
||
| 4056 | ] |
||
| 4057 | subclass = None |
||
| 4058 | superclass = None |
||
| 4059 | def __init__(self, id=None, language=None, primaryScript=None, secondaryScript=None, readingDirection=None, production=None, custom=None, comments=None, AlternativeImage=None, Coords=None, Glyph=None, TextEquiv=None, TextStyle=None, UserDefined=None, Labels=None, gds_collector_=None, **kwargs_): |
||
| 4060 | self.gds_collector_ = gds_collector_ |
||
| 4061 | self.gds_elementtree_node_ = None |
||
| 4062 | self.original_tagname_ = None |
||
| 4063 | self.parent_object_ = kwargs_.get('parent_object_') |
||
| 4064 | self.ns_prefix_ = None |
||
| 4065 | self.id = _cast(None, id) |
||
| 4066 | self.id_nsprefix_ = "pc" |
||
| 4067 | self.language = _cast(None, language) |
||
| 4068 | self.language_nsprefix_ = "pc" |
||
| 4069 | self.primaryScript = _cast(None, primaryScript) |
||
| 4070 | self.primaryScript_nsprefix_ = "pc" |
||
| 4071 | self.secondaryScript = _cast(None, secondaryScript) |
||
| 4072 | self.secondaryScript_nsprefix_ = "pc" |
||
| 4073 | self.readingDirection = _cast(None, readingDirection) |
||
| 4074 | self.readingDirection_nsprefix_ = "pc" |
||
| 4075 | self.production = _cast(None, production) |
||
| 4076 | self.production_nsprefix_ = "pc" |
||
| 4077 | self.custom = _cast(None, custom) |
||
| 4078 | self.custom_nsprefix_ = "pc" |
||
| 4079 | self.comments = _cast(None, comments) |
||
| 4080 | self.comments_nsprefix_ = "pc" |
||
| 4081 | if AlternativeImage is None: |
||
| 4082 | self.AlternativeImage = [] |
||
| 4083 | else: |
||
| 4084 | self.AlternativeImage = AlternativeImage |
||
| 4085 | self.AlternativeImage_nsprefix_ = "pc" |
||
| 4086 | self.Coords = Coords |
||
| 4087 | self.Coords_nsprefix_ = "pc" |
||
| 4088 | if Glyph is None: |
||
| 4089 | self.Glyph = [] |
||
| 4090 | else: |
||
| 4091 | self.Glyph = Glyph |
||
| 4092 | self.Glyph_nsprefix_ = "pc" |
||
| 4093 | if TextEquiv is None: |
||
| 4094 | self.TextEquiv = [] |
||
| 4095 | else: |
||
| 4096 | self.TextEquiv = TextEquiv |
||
| 4097 | self.TextEquiv_nsprefix_ = "pc" |
||
| 4098 | self.TextStyle = TextStyle |
||
| 4099 | self.TextStyle_nsprefix_ = "pc" |
||
| 4100 | self.UserDefined = UserDefined |
||
| 4101 | self.UserDefined_nsprefix_ = "pc" |
||
| 4102 | if Labels is None: |
||
| 4103 | self.Labels = [] |
||
| 4104 | else: |
||
| 4105 | self.Labels = Labels |
||
| 4106 | self.Labels_nsprefix_ = "pc" |
||
| 4107 | def factory(*args_, **kwargs_): |
||
| 4108 | if CurrentSubclassModule_ is not None: |
||
| 4109 | subclass = getSubclassFromModule_( |
||
| 4110 | CurrentSubclassModule_, WordType) |
||
| 4111 | if subclass is not None: |
||
| 4112 | return subclass(*args_, **kwargs_) |
||
| 4113 | if WordType.subclass: |
||
| 4114 | return WordType.subclass(*args_, **kwargs_) |
||
| 4115 | else: |
||
| 4116 | return WordType(*args_, **kwargs_) |
||
| 4117 | factory = staticmethod(factory) |
||
| 4118 | def get_ns_prefix_(self): |
||
| 4119 | return self.ns_prefix_ |
||
| 4120 | def set_ns_prefix_(self, ns_prefix): |
||
| 4121 | self.ns_prefix_ = ns_prefix |
||
| 4122 | def get_AlternativeImage(self): |
||
| 4123 | return self.AlternativeImage |
||
| 4124 | def set_AlternativeImage(self, AlternativeImage): |
||
| 4125 | self.AlternativeImage = AlternativeImage |
||
| 4126 | def add_AlternativeImage(self, value): |
||
| 4127 | self.AlternativeImage.append(value) |
||
| 4128 | def insert_AlternativeImage_at(self, index, value): |
||
| 4129 | self.AlternativeImage.insert(index, value) |
||
| 4130 | def replace_AlternativeImage_at(self, index, value): |
||
| 4131 | self.AlternativeImage[index] = value |
||
| 4132 | def get_Coords(self): |
||
| 4133 | return self.Coords |
||
| 4134 | def set_Coords(self, Coords): |
||
| 4135 | self.Coords = Coords |
||
| 4136 | def get_Glyph(self): |
||
| 4137 | return self.Glyph |
||
| 4138 | def set_Glyph(self, Glyph): |
||
| 4139 | self.Glyph = Glyph |
||
| 4140 | def add_Glyph(self, value): |
||
| 4141 | self.Glyph.append(value) |
||
| 4142 | def insert_Glyph_at(self, index, value): |
||
| 4143 | self.Glyph.insert(index, value) |
||
| 4144 | def replace_Glyph_at(self, index, value): |
||
| 4145 | self.Glyph[index] = value |
||
| 4146 | def get_TextEquiv(self): |
||
| 4147 | return self.TextEquiv |
||
| 4148 | def set_TextEquiv(self, TextEquiv): |
||
| 4149 | self.TextEquiv = TextEquiv |
||
| 4150 | def add_TextEquiv(self, value): |
||
| 4151 | self.TextEquiv.append(value) |
||
| 4152 | def insert_TextEquiv_at(self, index, value): |
||
| 4153 | self.TextEquiv.insert(index, value) |
||
| 4154 | def replace_TextEquiv_at(self, index, value): |
||
| 4155 | self.TextEquiv[index] = value |
||
| 4156 | def get_TextStyle(self): |
||
| 4157 | return self.TextStyle |
||
| 4158 | def set_TextStyle(self, TextStyle): |
||
| 4159 | self.TextStyle = TextStyle |
||
| 4160 | def get_UserDefined(self): |
||
| 4161 | return self.UserDefined |
||
| 4162 | def set_UserDefined(self, UserDefined): |
||
| 4163 | self.UserDefined = UserDefined |
||
| 4164 | def get_Labels(self): |
||
| 4165 | return self.Labels |
||
| 4166 | def set_Labels(self, Labels): |
||
| 4167 | self.Labels = Labels |
||
| 4168 | def add_Labels(self, value): |
||
| 4169 | self.Labels.append(value) |
||
| 4170 | def insert_Labels_at(self, index, value): |
||
| 4171 | self.Labels.insert(index, value) |
||
| 4172 | def replace_Labels_at(self, index, value): |
||
| 4173 | self.Labels[index] = value |
||
| 4174 | def get_id(self): |
||
| 4175 | return self.id |
||
| 4176 | def set_id(self, id): |
||
| 4177 | self.id = id |
||
| 4178 | def get_language(self): |
||
| 4179 | return self.language |
||
| 4180 | def set_language(self, language): |
||
| 4181 | self.language = language |
||
| 4182 | def get_primaryScript(self): |
||
| 4183 | return self.primaryScript |
||
| 4184 | def set_primaryScript(self, primaryScript): |
||
| 4185 | self.primaryScript = primaryScript |
||
| 4186 | def get_secondaryScript(self): |
||
| 4187 | return self.secondaryScript |
||
| 4188 | def set_secondaryScript(self, secondaryScript): |
||
| 4189 | self.secondaryScript = secondaryScript |
||
| 4190 | def get_readingDirection(self): |
||
| 4191 | return self.readingDirection |
||
| 4192 | def set_readingDirection(self, readingDirection): |
||
| 4193 | self.readingDirection = readingDirection |
||
| 4194 | def get_production(self): |
||
| 4195 | return self.production |
||
| 4196 | def set_production(self, production): |
||
| 4197 | self.production = production |
||
| 4198 | def get_custom(self): |
||
| 4199 | return self.custom |
||
| 4200 | def set_custom(self, custom): |
||
| 4201 | self.custom = custom |
||
| 4202 | def get_comments(self): |
||
| 4203 | return self.comments |
||
| 4204 | def set_comments(self, comments): |
||
| 4205 | self.comments = comments |
||
| 4206 | def validate_LanguageSimpleType(self, value): |
||
| 4207 | # Validate type pc:LanguageSimpleType, a restriction on string. |
||
| 4208 | if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None: |
||
| 4209 | if not isinstance(value, str): |
||
| 4210 | lineno = self.gds_get_node_lineno_() |
||
| 4211 | self.gds_collector_.add_message('Value "%(value)s"%(lineno)s is not of the correct base simple type (str)' % {"value": value, "lineno": lineno, }) |
||
| 4212 | return False |
||
| 4213 | value = value |
||
| 4214 | enumerations = ['Abkhaz', 'Afar', 'Afrikaans', 'Akan', 'Albanian', 'Amharic', 'Arabic', 'Aragonese', 'Armenian', 'Assamese', 'Avaric', 'Avestan', 'Aymara', 'Azerbaijani', 'Bambara', 'Bashkir', 'Basque', 'Belarusian', 'Bengali', 'Bihari', 'Bislama', 'Bosnian', 'Breton', 'Bulgarian', 'Burmese', 'Cambodian', 'Cantonese', 'Catalan', 'Chamorro', 'Chechen', 'Chichewa', 'Chinese', 'Chuvash', 'Cornish', 'Corsican', 'Cree', 'Croatian', 'Czech', 'Danish', 'Divehi', 'Dutch', 'Dzongkha', 'English', 'Esperanto', 'Estonian', 'Ewe', 'Faroese', 'Fijian', 'Finnish', 'French', 'Fula', 'Gaelic', 'Galician', 'Ganda', 'Georgian', 'German', 'Greek', 'Guaraní', 'Gujarati', 'Haitian', 'Hausa', 'Hebrew', 'Herero', 'Hindi', 'Hiri Motu', 'Hungarian', 'Icelandic', 'Ido', 'Igbo', 'Indonesian', 'Interlingua', 'Interlingue', 'Inuktitut', 'Inupiaq', 'Irish', 'Italian', 'Japanese', 'Javanese', 'Kalaallisut', 'Kannada', 'Kanuri', 'Kashmiri', 'Kazakh', 'Khmer', 'Kikuyu', 'Kinyarwanda', 'Kirundi', 'Komi', 'Kongo', 'Korean', 'Kurdish', 'Kwanyama', 'Kyrgyz', 'Lao', 'Latin', 'Latvian', 'Limburgish', 'Lingala', 'Lithuanian', 'Luba-Katanga', 'Luxembourgish', 'Macedonian', 'Malagasy', 'Malay', 'Malayalam', 'Maltese', 'Manx', 'Māori', 'Marathi', 'Marshallese', 'Mongolian', 'Nauru', 'Navajo', 'Ndonga', 'Nepali', 'North Ndebele', 'Northern Sami', 'Norwegian', 'Norwegian Bokmål', 'Norwegian Nynorsk', 'Nuosu', 'Occitan', 'Ojibwe', 'Old Church Slavonic', 'Oriya', 'Oromo', 'Ossetian', 'Pāli', 'Panjabi', 'Pashto', 'Persian', 'Polish', 'Portuguese', 'Punjabi', 'Quechua', 'Romanian', 'Romansh', 'Russian', 'Samoan', 'Sango', 'Sanskrit', 'Sardinian', 'Serbian', 'Shona', 'Sindhi', 'Sinhala', 'Slovak', 'Slovene', 'Somali', 'South Ndebele', 'Southern Sotho', 'Spanish', 'Sundanese', 'Swahili', 'Swati', 'Swedish', 'Tagalog', 'Tahitian', 'Tajik', 'Tamil', 'Tatar', 'Telugu', 'Thai', 'Tibetan', 'Tigrinya', 'Tonga', 'Tsonga', 'Tswana', 'Turkish', 'Turkmen', 'Twi', 'Uighur', 'Ukrainian', 'Urdu', 'Uzbek', 'Venda', 'Vietnamese', 'Volapük', 'Walloon', 'Welsh', 'Western Frisian', 'Wolof', 'Xhosa', 'Yiddish', 'Yoruba', 'Zhuang', 'Zulu', 'other'] |
||
| 4215 | if value not in enumerations: |
||
| 4216 | lineno = self.gds_get_node_lineno_() |
||
| 4217 | self.gds_collector_.add_message('Value "%(value)s"%(lineno)s does not match xsd enumeration restriction on LanguageSimpleType' % {"value" : encode_str_2_3(value), "lineno": lineno} ) |
||
| 4218 | result = False |
||
| 4219 | def validate_ScriptSimpleType(self, value): |
||
| 4220 | # Validate type pc:ScriptSimpleType, a restriction on string. |
||
| 4221 | if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None: |
||
| 4222 | if not isinstance(value, str): |
||
| 4223 | lineno = self.gds_get_node_lineno_() |
||
| 4224 | self.gds_collector_.add_message('Value "%(value)s"%(lineno)s is not of the correct base simple type (str)' % {"value": value, "lineno": lineno, }) |
||
| 4225 | return False |
||
| 4226 | value = value |
||
| 4227 | enumerations = ['Adlm - Adlam', 'Afak - Afaka', 'Aghb - Caucasian Albanian', 'Ahom - Ahom, Tai Ahom', 'Arab - Arabic', 'Aran - Arabic (Nastaliq variant)', 'Armi - Imperial Aramaic', 'Armn - Armenian', 'Avst - Avestan', 'Bali - Balinese', 'Bamu - Bamum', 'Bass - Bassa Vah', 'Batk - Batak', 'Beng - Bengali', 'Bhks - Bhaiksuki', 'Blis - Blissymbols', 'Bopo - Bopomofo', 'Brah - Brahmi', 'Brai - Braille', 'Bugi - Buginese', 'Buhd - Buhid', 'Cakm - Chakma', 'Cans - Unified Canadian Aboriginal Syllabics', 'Cari - Carian', 'Cham - Cham', 'Cher - Cherokee', 'Cirt - Cirth', 'Copt - Coptic', 'Cprt - Cypriot', 'Cyrl - Cyrillic', 'Cyrs - Cyrillic (Old Church Slavonic variant)', 'Deva - Devanagari (Nagari)', 'Dsrt - Deseret (Mormon)', 'Dupl - Duployan shorthand, Duployan stenography', 'Egyd - Egyptian demotic', 'Egyh - Egyptian hieratic', 'Egyp - Egyptian hieroglyphs', 'Elba - Elbasan', 'Ethi - Ethiopic', 'Geok - Khutsuri (Asomtavruli and Nuskhuri)', 'Geor - Georgian (Mkhedruli)', 'Glag - Glagolitic', 'Goth - Gothic', 'Gran - Grantha', 'Grek - Greek', 'Gujr - Gujarati', 'Guru - Gurmukhi', 'Hanb - Han with Bopomofo', 'Hang - Hangul', 'Hani - Han (Hanzi, Kanji, Hanja)', 'Hano - Hanunoo (Hanunóo)', 'Hans - Han (Simplified variant)', 'Hant - Han (Traditional variant)', 'Hatr - Hatran', 'Hebr - Hebrew', 'Hira - Hiragana', 'Hluw - Anatolian Hieroglyphs', 'Hmng - Pahawh Hmong', 'Hrkt - Japanese syllabaries', 'Hung - Old Hungarian (Hungarian Runic)', 'Inds - Indus (Harappan)', 'Ital - Old Italic (Etruscan, Oscan etc.)', 'Jamo - Jamo', 'Java - Javanese', 'Jpan - Japanese', 'Jurc - Jurchen', 'Kali - Kayah Li', 'Kana - Katakana', 'Khar - Kharoshthi', 'Khmr - Khmer', 'Khoj - Khojki', 'Kitl - Khitan large script', 'Kits - Khitan small script', 'Knda - Kannada', 'Kore - Korean (alias for Hangul + Han)', 'Kpel - Kpelle', 'Kthi - Kaithi', 'Lana - Tai Tham (Lanna)', 'Laoo - Lao', 'Latf - Latin (Fraktur variant)', 'Latg - Latin (Gaelic variant)', 'Latn - Latin', 'Leke - Leke', 'Lepc - Lepcha (Róng)', 'Limb - Limbu', 'Lina - Linear A', 'Linb - Linear B', 'Lisu - Lisu (Fraser)', 'Loma - Loma', 'Lyci - Lycian', 'Lydi - Lydian', 'Mahj - Mahajani', 'Mand - Mandaic, Mandaean', 'Mani - Manichaean', 'Marc - Marchen', 'Maya - Mayan hieroglyphs', 'Mend - Mende Kikakui', 'Merc - Meroitic Cursive', 'Mero - Meroitic Hieroglyphs', 'Mlym - Malayalam', 'Modi - Modi, Moḍī', 'Mong - Mongolian', 'Moon - Moon (Moon code, Moon script, Moon type)', 'Mroo - Mro, Mru', 'Mtei - Meitei Mayek (Meithei, Meetei)', 'Mult - Multani', 'Mymr - Myanmar (Burmese)', 'Narb - Old North Arabian (Ancient North Arabian)', 'Nbat - Nabataean', 'Newa - Newa, Newar, Newari', 'Nkgb - Nakhi Geba', 'Nkoo - N’Ko', 'Nshu - Nüshu', 'Ogam - Ogham', 'Olck - Ol Chiki (Ol Cemet’, Ol, Santali)', 'Orkh - Old Turkic, Orkhon Runic', 'Orya - Oriya', 'Osge - Osage', 'Osma - Osmanya', 'Palm - Palmyrene', 'Pauc - Pau Cin Hau', 'Perm - Old Permic', 'Phag - Phags-pa', 'Phli - Inscriptional Pahlavi', 'Phlp - Psalter Pahlavi', 'Phlv - Book Pahlavi', 'Phnx - Phoenician', 'Piqd - Klingon (KLI pIqaD)', 'Plrd - Miao (Pollard)', 'Prti - Inscriptional Parthian', 'Rjng - Rejang (Redjang, Kaganga)', 'Roro - Rongorongo', 'Runr - Runic', 'Samr - Samaritan', 'Sara - Sarati', 'Sarb - Old South Arabian', 'Saur - Saurashtra', 'Sgnw - SignWriting', 'Shaw - Shavian (Shaw)', 'Shrd - Sharada, Śāradā', 'Sidd - Siddham', 'Sind - Khudawadi, Sindhi', 'Sinh - Sinhala', 'Sora - Sora Sompeng', 'Sund - Sundanese', 'Sylo - Syloti Nagri', 'Syrc - Syriac', 'Syre - Syriac (Estrangelo variant)', 'Syrj - Syriac (Western variant)', 'Syrn - Syriac (Eastern variant)', 'Tagb - Tagbanwa', 'Takr - Takri', 'Tale - Tai Le', 'Talu - New Tai Lue', 'Taml - Tamil', 'Tang - Tangut', 'Tavt - Tai Viet', 'Telu - Telugu', 'Teng - Tengwar', 'Tfng - Tifinagh (Berber)', 'Tglg - Tagalog (Baybayin, Alibata)', 'Thaa - Thaana', 'Thai - Thai', 'Tibt - Tibetan', 'Tirh - Tirhuta', 'Ugar - Ugaritic', 'Vaii - Vai', 'Visp - Visible Speech', 'Wara - Warang Citi (Varang Kshiti)', 'Wole - Woleai', 'Xpeo - Old Persian', 'Xsux - Cuneiform, Sumero-Akkadian', 'Yiii - Yi', 'Zinh - Code for inherited script', 'Zmth - Mathematical notation', 'Zsye - Symbols (Emoji variant)', 'Zsym - Symbols', 'Zxxx - Code for unwritten documents', 'Zyyy - Code for undetermined script', 'Zzzz - Code for uncoded script', 'other'] |
||
| 4228 | if value not in enumerations: |
||
| 4229 | lineno = self.gds_get_node_lineno_() |
||
| 4230 | self.gds_collector_.add_message('Value "%(value)s"%(lineno)s does not match xsd enumeration restriction on ScriptSimpleType' % {"value" : encode_str_2_3(value), "lineno": lineno} ) |
||
| 4231 | result = False |
||
| 4232 | def validate_ReadingDirectionSimpleType(self, value): |
||
| 4233 | # Validate type pc:ReadingDirectionSimpleType, a restriction on string. |
||
| 4234 | if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None: |
||
| 4235 | if not isinstance(value, str): |
||
| 4236 | lineno = self.gds_get_node_lineno_() |
||
| 4237 | self.gds_collector_.add_message('Value "%(value)s"%(lineno)s is not of the correct base simple type (str)' % {"value": value, "lineno": lineno, }) |
||
| 4238 | return False |
||
| 4239 | value = value |
||
| 4240 | enumerations = ['left-to-right', 'right-to-left', 'top-to-bottom', 'bottom-to-top'] |
||
| 4241 | if value not in enumerations: |
||
| 4242 | lineno = self.gds_get_node_lineno_() |
||
| 4243 | self.gds_collector_.add_message('Value "%(value)s"%(lineno)s does not match xsd enumeration restriction on ReadingDirectionSimpleType' % {"value" : encode_str_2_3(value), "lineno": lineno} ) |
||
| 4244 | result = False |
||
| 4245 | def validate_ProductionSimpleType(self, value): |
||
| 4246 | # Validate type pc:ProductionSimpleType, a restriction on string. |
||
| 4247 | if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None: |
||
| 4248 | if not isinstance(value, str): |
||
| 4249 | lineno = self.gds_get_node_lineno_() |
||
| 4250 | self.gds_collector_.add_message('Value "%(value)s"%(lineno)s is not of the correct base simple type (str)' % {"value": value, "lineno": lineno, }) |
||
| 4251 | return False |
||
| 4252 | value = value |
||
| 4253 | enumerations = ['printed', 'typewritten', 'handwritten-cursive', 'handwritten-printscript', 'medieval-manuscript', 'other'] |
||
| 4254 | if value not in enumerations: |
||
| 4255 | lineno = self.gds_get_node_lineno_() |
||
| 4256 | self.gds_collector_.add_message('Value "%(value)s"%(lineno)s does not match xsd enumeration restriction on ProductionSimpleType' % {"value" : encode_str_2_3(value), "lineno": lineno} ) |
||
| 4257 | result = False |
||
| 4258 | def hasContent_(self): |
||
| 4259 | if ( |
||
| 4260 | self.AlternativeImage or |
||
| 4261 | self.Coords is not None or |
||
| 4262 | self.Glyph or |
||
| 4263 | self.TextEquiv or |
||
| 4264 | self.TextStyle is not None or |
||
| 4265 | self.UserDefined is not None or |
||
| 4266 | self.Labels |
||
| 4267 | ): |
||
| 4268 | return True |
||
| 4269 | else: |
||
| 4270 | return False |
||
| 4271 | def export(self, outfile, level, namespaceprefix_='', namespacedef_='xmlns:pc="http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15"', name_='WordType', pretty_print=True): |
||
| 4272 | imported_ns_def_ = GenerateDSNamespaceDefs_.get('WordType') |
||
| 4273 | if imported_ns_def_ is not None: |
||
| 4274 | namespacedef_ = imported_ns_def_ |
||
| 4275 | if pretty_print: |
||
| 4276 | eol_ = '\n' |
||
| 4277 | else: |
||
| 4278 | eol_ = '' |
||
| 4279 | if self.original_tagname_ is not None and name_ == 'WordType': |
||
| 4280 | name_ = self.original_tagname_ |
||
| 4281 | if UseCapturedNS_ and self.ns_prefix_: |
||
| 4282 | namespaceprefix_ = self.ns_prefix_ + ':' |
||
| 4283 | showIndent(outfile, level, pretty_print) |
||
| 4284 | outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) |
||
| 4285 | already_processed = set() |
||
| 4286 | self.exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='WordType') |
||
| 4287 | if self.hasContent_(): |
||
| 4288 | outfile.write('>%s' % (eol_, )) |
||
| 4289 | self.exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='WordType', pretty_print=pretty_print) |
||
| 4290 | showIndent(outfile, level, pretty_print) |
||
| 4291 | outfile.write('</%s%s>%s' % (namespaceprefix_, name_, eol_)) |
||
| 4292 | else: |
||
| 4293 | outfile.write('/>%s' % (eol_, )) |
||
| 4294 | def exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='WordType'): |
||
| 4295 | if self.id is not None and 'id' not in already_processed: |
||
| 4296 | already_processed.add('id') |
||
| 4297 | outfile.write(' id=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.id), input_name='id')), )) |
||
| 4298 | if self.language is not None and 'language' not in already_processed: |
||
| 4299 | already_processed.add('language') |
||
| 4300 | outfile.write(' language=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.language), input_name='language')), )) |
||
| 4301 | if self.primaryScript is not None and 'primaryScript' not in already_processed: |
||
| 4302 | already_processed.add('primaryScript') |
||
| 4303 | outfile.write(' primaryScript=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.primaryScript), input_name='primaryScript')), )) |
||
| 4304 | if self.secondaryScript is not None and 'secondaryScript' not in already_processed: |
||
| 4305 | already_processed.add('secondaryScript') |
||
| 4306 | outfile.write(' secondaryScript=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.secondaryScript), input_name='secondaryScript')), )) |
||
| 4307 | if self.readingDirection is not None and 'readingDirection' not in already_processed: |
||
| 4308 | already_processed.add('readingDirection') |
||
| 4309 | outfile.write(' readingDirection=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.readingDirection), input_name='readingDirection')), )) |
||
| 4310 | if self.production is not None and 'production' not in already_processed: |
||
| 4311 | already_processed.add('production') |
||
| 4312 | outfile.write(' production=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.production), input_name='production')), )) |
||
| 4313 | if self.custom is not None and 'custom' not in already_processed: |
||
| 4314 | already_processed.add('custom') |
||
| 4315 | outfile.write(' custom=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.custom), input_name='custom')), )) |
||
| 4316 | if self.comments is not None and 'comments' not in already_processed: |
||
| 4317 | already_processed.add('comments') |
||
| 4318 | outfile.write(' comments=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.comments), input_name='comments')), )) |
||
| 4319 | View Code Duplication | def exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='xmlns:pc="http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15"', name_='WordType', fromsubclass_=False, pretty_print=True): |
|
| 4320 | if pretty_print: |
||
| 4321 | eol_ = '\n' |
||
| 4322 | else: |
||
| 4323 | eol_ = '' |
||
| 4324 | for AlternativeImage_ in self.AlternativeImage: |
||
| 4325 | namespaceprefix_ = self.AlternativeImage_nsprefix_ + ':' if (UseCapturedNS_ and self.AlternativeImage_nsprefix_) else '' |
||
| 4326 | AlternativeImage_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='AlternativeImage', pretty_print=pretty_print) |
||
| 4327 | if self.Coords is not None: |
||
| 4328 | namespaceprefix_ = self.Coords_nsprefix_ + ':' if (UseCapturedNS_ and self.Coords_nsprefix_) else '' |
||
| 4329 | self.Coords.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Coords', pretty_print=pretty_print) |
||
| 4330 | for Glyph_ in self.Glyph: |
||
| 4331 | namespaceprefix_ = self.Glyph_nsprefix_ + ':' if (UseCapturedNS_ and self.Glyph_nsprefix_) else '' |
||
| 4332 | Glyph_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Glyph', pretty_print=pretty_print) |
||
| 4333 | for TextEquiv_ in self.TextEquiv: |
||
| 4334 | namespaceprefix_ = self.TextEquiv_nsprefix_ + ':' if (UseCapturedNS_ and self.TextEquiv_nsprefix_) else '' |
||
| 4335 | TextEquiv_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='TextEquiv', pretty_print=pretty_print) |
||
| 4336 | if self.TextStyle is not None: |
||
| 4337 | namespaceprefix_ = self.TextStyle_nsprefix_ + ':' if (UseCapturedNS_ and self.TextStyle_nsprefix_) else '' |
||
| 4338 | self.TextStyle.export(outfile, level, namespaceprefix_, namespacedef_='', name_='TextStyle', pretty_print=pretty_print) |
||
| 4339 | if self.UserDefined is not None: |
||
| 4340 | namespaceprefix_ = self.UserDefined_nsprefix_ + ':' if (UseCapturedNS_ and self.UserDefined_nsprefix_) else '' |
||
| 4341 | self.UserDefined.export(outfile, level, namespaceprefix_, namespacedef_='', name_='UserDefined', pretty_print=pretty_print) |
||
| 4342 | for Labels_ in self.Labels: |
||
| 4343 | namespaceprefix_ = self.Labels_nsprefix_ + ':' if (UseCapturedNS_ and self.Labels_nsprefix_) else '' |
||
| 4344 | Labels_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Labels', pretty_print=pretty_print) |
||
| 4345 | def to_etree(self, parent_element=None, name_='WordType', mapping_=None, nsmap_=None): |
||
| 4346 | if parent_element is None: |
||
| 4347 | element = etree_.Element('{http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15}' + name_, nsmap=nsmap_) |
||
| 4348 | else: |
||
| 4349 | element = etree_.SubElement(parent_element, '{http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15}' + name_, nsmap=nsmap_) |
||
| 4350 | if self.id is not None: |
||
| 4351 | element.set('id', self.gds_format_string(self.id)) |
||
| 4352 | if self.language is not None: |
||
| 4353 | element.set('language', self.gds_format_string(self.language)) |
||
| 4354 | if self.primaryScript is not None: |
||
| 4355 | element.set('primaryScript', self.gds_format_string(self.primaryScript)) |
||
| 4356 | if self.secondaryScript is not None: |
||
| 4357 | element.set('secondaryScript', self.gds_format_string(self.secondaryScript)) |
||
| 4358 | if self.readingDirection is not None: |
||
| 4359 | element.set('readingDirection', self.gds_format_string(self.readingDirection)) |
||
| 4360 | if self.production is not None: |
||
| 4361 | element.set('production', self.gds_format_string(self.production)) |
||
| 4362 | if self.custom is not None: |
||
| 4363 | element.set('custom', self.gds_format_string(self.custom)) |
||
| 4364 | if self.comments is not None: |
||
| 4365 | element.set('comments', self.gds_format_string(self.comments)) |
||
| 4366 | for AlternativeImage_ in self.AlternativeImage: |
||
| 4367 | AlternativeImage_.to_etree(element, name_='AlternativeImage', mapping_=mapping_, nsmap_=nsmap_) |
||
| 4368 | if self.Coords is not None: |
||
| 4369 | Coords_ = self.Coords |
||
| 4370 | Coords_.to_etree(element, name_='Coords', mapping_=mapping_, nsmap_=nsmap_) |
||
| 4371 | for Glyph_ in self.Glyph: |
||
| 4372 | Glyph_.to_etree(element, name_='Glyph', mapping_=mapping_, nsmap_=nsmap_) |
||
| 4373 | for TextEquiv_ in self.TextEquiv: |
||
| 4374 | TextEquiv_.to_etree(element, name_='TextEquiv', mapping_=mapping_, nsmap_=nsmap_) |
||
| 4375 | if self.TextStyle is not None: |
||
| 4376 | TextStyle_ = self.TextStyle |
||
| 4377 | TextStyle_.to_etree(element, name_='TextStyle', mapping_=mapping_, nsmap_=nsmap_) |
||
| 4378 | if self.UserDefined is not None: |
||
| 4379 | UserDefined_ = self.UserDefined |
||
| 4380 | UserDefined_.to_etree(element, name_='UserDefined', mapping_=mapping_, nsmap_=nsmap_) |
||
| 4381 | for Labels_ in self.Labels: |
||
| 4382 | Labels_.to_etree(element, name_='Labels', mapping_=mapping_, nsmap_=nsmap_) |
||
| 4383 | if mapping_ is not None: |
||
| 4384 | mapping_[id(self)] = element |
||
| 4385 | return element |
||
| 4386 | def build(self, node, gds_collector_=None): |
||
| 4387 | self.gds_collector_ = gds_collector_ |
||
| 4388 | if SaveElementTreeNode: |
||
| 4389 | self.gds_elementtree_node_ = node |
||
| 4390 | already_processed = set() |
||
| 4391 | self.ns_prefix_ = node.prefix |
||
| 4392 | self.buildAttributes(node, node.attrib, already_processed) |
||
| 4393 | for child in node: |
||
| 4394 | nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] |
||
| 4395 | self.buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) |
||
| 4396 | return self |
||
| 4397 | def buildAttributes(self, node, attrs, already_processed): |
||
| 4398 | value = find_attr_value_('id', node) |
||
| 4399 | if value is not None and 'id' not in already_processed: |
||
| 4400 | already_processed.add('id') |
||
| 4401 | self.id = value |
||
| 4402 | value = find_attr_value_('language', node) |
||
| 4403 | if value is not None and 'language' not in already_processed: |
||
| 4404 | already_processed.add('language') |
||
| 4405 | self.language = value |
||
| 4406 | self.validate_LanguageSimpleType(self.language) # validate type LanguageSimpleType |
||
| 4407 | value = find_attr_value_('primaryScript', node) |
||
| 4408 | if value is not None and 'primaryScript' not in already_processed: |
||
| 4409 | already_processed.add('primaryScript') |
||
| 4410 | self.primaryScript = value |
||
| 4411 | self.validate_ScriptSimpleType(self.primaryScript) # validate type ScriptSimpleType |
||
| 4412 | value = find_attr_value_('secondaryScript', node) |
||
| 4413 | if value is not None and 'secondaryScript' not in already_processed: |
||
| 4414 | already_processed.add('secondaryScript') |
||
| 4415 | self.secondaryScript = value |
||
| 4416 | self.validate_ScriptSimpleType(self.secondaryScript) # validate type ScriptSimpleType |
||
| 4417 | value = find_attr_value_('readingDirection', node) |
||
| 4418 | if value is not None and 'readingDirection' not in already_processed: |
||
| 4419 | already_processed.add('readingDirection') |
||
| 4420 | self.readingDirection = value |
||
| 4421 | self.validate_ReadingDirectionSimpleType(self.readingDirection) # validate type ReadingDirectionSimpleType |
||
| 4422 | value = find_attr_value_('production', node) |
||
| 4423 | if value is not None and 'production' not in already_processed: |
||
| 4424 | already_processed.add('production') |
||
| 4425 | self.production = value |
||
| 4426 | self.validate_ProductionSimpleType(self.production) # validate type ProductionSimpleType |
||
| 4427 | value = find_attr_value_('custom', node) |
||
| 4428 | if value is not None and 'custom' not in already_processed: |
||
| 4429 | already_processed.add('custom') |
||
| 4430 | self.custom = value |
||
| 4431 | value = find_attr_value_('comments', node) |
||
| 4432 | if value is not None and 'comments' not in already_processed: |
||
| 4433 | already_processed.add('comments') |
||
| 4434 | self.comments = value |
||
| 4435 | View Code Duplication | def buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None): |
|
| 4436 | if nodeName_ == 'AlternativeImage': |
||
| 4437 | obj_ = AlternativeImageType.factory(parent_object_=self) |
||
| 4438 | obj_.build(child_, gds_collector_=gds_collector_) |
||
| 4439 | self.AlternativeImage.append(obj_) |
||
| 4440 | obj_.original_tagname_ = 'AlternativeImage' |
||
| 4441 | elif nodeName_ == 'Coords': |
||
| 4442 | obj_ = CoordsType.factory(parent_object_=self) |
||
| 4443 | obj_.build(child_, gds_collector_=gds_collector_) |
||
| 4444 | self.Coords = obj_ |
||
| 4445 | obj_.original_tagname_ = 'Coords' |
||
| 4446 | elif nodeName_ == 'Glyph': |
||
| 4447 | obj_ = GlyphType.factory(parent_object_=self) |
||
| 4448 | obj_.build(child_, gds_collector_=gds_collector_) |
||
| 4449 | self.Glyph.append(obj_) |
||
| 4450 | obj_.original_tagname_ = 'Glyph' |
||
| 4451 | elif nodeName_ == 'TextEquiv': |
||
| 4452 | obj_ = TextEquivType.factory(parent_object_=self) |
||
| 4453 | obj_.build(child_, gds_collector_=gds_collector_) |
||
| 4454 | self.TextEquiv.append(obj_) |
||
| 4455 | obj_.original_tagname_ = 'TextEquiv' |
||
| 4456 | elif nodeName_ == 'TextStyle': |
||
| 4457 | obj_ = TextStyleType.factory(parent_object_=self) |
||
| 4458 | obj_.build(child_, gds_collector_=gds_collector_) |
||
| 4459 | self.TextStyle = obj_ |
||
| 4460 | obj_.original_tagname_ = 'TextStyle' |
||
| 4461 | elif nodeName_ == 'UserDefined': |
||
| 4462 | obj_ = UserDefinedType.factory(parent_object_=self) |
||
| 4463 | obj_.build(child_, gds_collector_=gds_collector_) |
||
| 4464 | self.UserDefined = obj_ |
||
| 4465 | obj_.original_tagname_ = 'UserDefined' |
||
| 4466 | elif nodeName_ == 'Labels': |
||
| 4467 | obj_ = LabelsType.factory(parent_object_=self) |
||
| 4468 | obj_.build(child_, gds_collector_=gds_collector_) |
||
| 4469 | self.Labels.append(obj_) |
||
| 4470 | obj_.original_tagname_ = 'Labels' |
||
| 4471 | def __hash__(self): |
||
| 4472 | return hash(self.id) |
||
| 4473 | View Code Duplication | def invalidate_AlternativeImage(self, feature_selector=None): |
|
| 4474 | """ |
||
| 4475 | Remove derived images from this segment (due to changed coordinates). |
||
| 4476 | |||
| 4477 | If `feature_selector` is not none, remove only images with |
||
| 4478 | matching ``@comments``, e.g. ``feature_selector=cropped,deskewed``. |
||
| 4479 | """ |
||
| 4480 | existing_images = self.AlternativeImage or [] |
||
| 4481 | removed_images = [] |
||
| 4482 | if feature_selector: |
||
| 4483 | new_images = [] |
||
| 4484 | for image in existing_images: |
||
| 4485 | features = image.get_comments() or '' |
||
| 4486 | if any(feature in features.split(',') |
||
| 4487 | for feature in feature_selector.split(',') if feature): |
||
| 4488 | removed_images.append(image) |
||
| 4489 | else: |
||
| 4490 | new_images.append(image) |
||
| 4491 | self.AlternativeImage = new_images |
||
| 4492 | else: |
||
| 4493 | removed_images = existing_images |
||
| 4494 | self.AlternativeImage = [] |
||
| 4495 | if hasattr(self, 'id'): |
||
| 4496 | name = self.id |
||
| 4497 | elif hasattr(self, 'parent_object_') and hasattr(self.parent_object_, 'pcGtsId'): |
||
| 4498 | name = self.parent_object_.pcGtsId |
||
| 4499 | else: |
||
| 4500 | name = '' |
||
| 4501 | for image in removed_images: |
||
| 4502 | self.gds_collector_.add_message('Removing AlternativeImage %s from "%s"' % ( |
||
| 4503 | image.get_comments() or '', name)) |
||
| 4504 | def set_Coords(self, Coords): |
||
| 4505 | """ |
||
| 4506 | Set coordinate polygon by given :py:class:`CoordsType` object. |
||
| 4507 | Moreover, invalidate self's ``pc:AlternativeImage``s |
||
| 4508 | (because they will have been cropped with a bbox |
||
| 4509 | of the previous polygon). |
||
| 4510 | """ |
||
| 4511 | if hasattr(self, 'invalidate_AlternativeImage'): |
||
| 4512 | # RegionType, TextLineType, WordType, GlyphType: |
||
| 4513 | self.invalidate_AlternativeImage() |
||
| 4514 | elif hasattr(self, 'parent_object_') and hasattr(self.parent_object_, 'invalidate_AlternativeImage'): |
||
| 4515 | # BorderType: |
||
| 4516 | self.parent_object_.invalidate_AlternativeImage(feature_selector='cropped') |
||
| 4517 | self.Coords = Coords |
||
| 4518 | # end class WordType |
||
| 4519 | |||
| 4520 | |||
| 4521 | class GlyphType(GeneratedsSuper): |
||
| 4522 | """The script used for the glyph |
||
| 4523 | Overrides the production attribute of the parent |
||
| 4524 | word / text line / text region. |
||
| 4525 | For generic use""" |
||
| 4526 | __hash__ = GeneratedsSuper.__hash__ |
||
| 4527 | member_data_items_ = [ |
||
| 4528 | MemberSpec_('id', 'string', 0, 0, {'use': 'required'}), |
||
| 4529 | MemberSpec_('ligature', 'boolean', 0, 1, {'use': 'optional'}), |
||
| 4530 | MemberSpec_('symbol', 'boolean', 0, 1, {'use': 'optional'}), |
||
| 4531 | MemberSpec_('script', 'pc:ScriptSimpleType', 0, 1, {'use': 'optional'}), |
||
| 4532 | MemberSpec_('production', 'pc:ProductionSimpleType', 0, 1, {'use': 'optional'}), |
||
| 4533 | MemberSpec_('custom', 'string', 0, 1, {'use': 'optional'}), |
||
| 4534 | MemberSpec_('comments', 'string', 0, 1, {'use': 'optional'}), |
||
| 4535 | MemberSpec_('AlternativeImage', 'AlternativeImageType', 1, 1, {'maxOccurs': 'unbounded', 'minOccurs': '0', 'name': 'AlternativeImage', 'type': 'AlternativeImageType'}, None), |
||
| 4536 | MemberSpec_('Coords', 'CoordsType', 0, 0, {'name': 'Coords', 'type': 'CoordsType'}, None), |
||
| 4537 | MemberSpec_('Graphemes', 'GraphemesType', 0, 1, {'maxOccurs': '1', 'minOccurs': '0', 'name': 'Graphemes', 'type': 'GraphemesType'}, None), |
||
| 4538 | MemberSpec_('TextEquiv', 'TextEquivType', 1, 1, {'maxOccurs': 'unbounded', 'minOccurs': '0', 'name': 'TextEquiv', 'type': 'TextEquivType'}, None), |
||
| 4539 | MemberSpec_('TextStyle', 'TextStyleType', 0, 1, {'minOccurs': '0', 'name': 'TextStyle', 'type': 'TextStyleType'}, None), |
||
| 4540 | MemberSpec_('UserDefined', 'UserDefinedType', 0, 1, {'maxOccurs': '1', 'minOccurs': '0', 'name': 'UserDefined', 'type': 'UserDefinedType'}, None), |
||
| 4541 | MemberSpec_('Labels', 'LabelsType', 1, 1, {'maxOccurs': 'unbounded', 'minOccurs': '0', 'name': 'Labels', 'type': 'LabelsType'}, None), |
||
| 4542 | ] |
||
| 4543 | subclass = None |
||
| 4544 | superclass = None |
||
| 4545 | def __init__(self, id=None, ligature=None, symbol=None, script=None, production=None, custom=None, comments=None, AlternativeImage=None, Coords=None, Graphemes=None, TextEquiv=None, TextStyle=None, UserDefined=None, Labels=None, gds_collector_=None, **kwargs_): |
||
| 4546 | self.gds_collector_ = gds_collector_ |
||
| 4547 | self.gds_elementtree_node_ = None |
||
| 4548 | self.original_tagname_ = None |
||
| 4549 | self.parent_object_ = kwargs_.get('parent_object_') |
||
| 4550 | self.ns_prefix_ = None |
||
| 4551 | self.id = _cast(None, id) |
||
| 4552 | self.id_nsprefix_ = "pc" |
||
| 4553 | self.ligature = _cast(bool, ligature) |
||
| 4554 | self.ligature_nsprefix_ = "pc" |
||
| 4555 | self.symbol = _cast(bool, symbol) |
||
| 4556 | self.symbol_nsprefix_ = "pc" |
||
| 4557 | self.script = _cast(None, script) |
||
| 4558 | self.script_nsprefix_ = "pc" |
||
| 4559 | self.production = _cast(None, production) |
||
| 4560 | self.production_nsprefix_ = "pc" |
||
| 4561 | self.custom = _cast(None, custom) |
||
| 4562 | self.custom_nsprefix_ = "pc" |
||
| 4563 | self.comments = _cast(None, comments) |
||
| 4564 | self.comments_nsprefix_ = "pc" |
||
| 4565 | if AlternativeImage is None: |
||
| 4566 | self.AlternativeImage = [] |
||
| 4567 | else: |
||
| 4568 | self.AlternativeImage = AlternativeImage |
||
| 4569 | self.AlternativeImage_nsprefix_ = "pc" |
||
| 4570 | self.Coords = Coords |
||
| 4571 | self.Coords_nsprefix_ = "pc" |
||
| 4572 | self.Graphemes = Graphemes |
||
| 4573 | self.Graphemes_nsprefix_ = "pc" |
||
| 4574 | if TextEquiv is None: |
||
| 4575 | self.TextEquiv = [] |
||
| 4576 | else: |
||
| 4577 | self.TextEquiv = TextEquiv |
||
| 4578 | self.TextEquiv_nsprefix_ = "pc" |
||
| 4579 | self.TextStyle = TextStyle |
||
| 4580 | self.TextStyle_nsprefix_ = "pc" |
||
| 4581 | self.UserDefined = UserDefined |
||
| 4582 | self.UserDefined_nsprefix_ = "pc" |
||
| 4583 | if Labels is None: |
||
| 4584 | self.Labels = [] |
||
| 4585 | else: |
||
| 4586 | self.Labels = Labels |
||
| 4587 | self.Labels_nsprefix_ = "pc" |
||
| 4588 | def factory(*args_, **kwargs_): |
||
| 4589 | if CurrentSubclassModule_ is not None: |
||
| 4590 | subclass = getSubclassFromModule_( |
||
| 4591 | CurrentSubclassModule_, GlyphType) |
||
| 4592 | if subclass is not None: |
||
| 4593 | return subclass(*args_, **kwargs_) |
||
| 4594 | if GlyphType.subclass: |
||
| 4595 | return GlyphType.subclass(*args_, **kwargs_) |
||
| 4596 | else: |
||
| 4597 | return GlyphType(*args_, **kwargs_) |
||
| 4598 | factory = staticmethod(factory) |
||
| 4599 | def get_ns_prefix_(self): |
||
| 4600 | return self.ns_prefix_ |
||
| 4601 | def set_ns_prefix_(self, ns_prefix): |
||
| 4602 | self.ns_prefix_ = ns_prefix |
||
| 4603 | def get_AlternativeImage(self): |
||
| 4604 | return self.AlternativeImage |
||
| 4605 | def set_AlternativeImage(self, AlternativeImage): |
||
| 4606 | self.AlternativeImage = AlternativeImage |
||
| 4607 | def add_AlternativeImage(self, value): |
||
| 4608 | self.AlternativeImage.append(value) |
||
| 4609 | def insert_AlternativeImage_at(self, index, value): |
||
| 4610 | self.AlternativeImage.insert(index, value) |
||
| 4611 | def replace_AlternativeImage_at(self, index, value): |
||
| 4612 | self.AlternativeImage[index] = value |
||
| 4613 | def get_Coords(self): |
||
| 4614 | return self.Coords |
||
| 4615 | def set_Coords(self, Coords): |
||
| 4616 | self.Coords = Coords |
||
| 4617 | def get_Graphemes(self): |
||
| 4618 | return self.Graphemes |
||
| 4619 | def set_Graphemes(self, Graphemes): |
||
| 4620 | self.Graphemes = Graphemes |
||
| 4621 | def get_TextEquiv(self): |
||
| 4622 | return self.TextEquiv |
||
| 4623 | def set_TextEquiv(self, TextEquiv): |
||
| 4624 | self.TextEquiv = TextEquiv |
||
| 4625 | def add_TextEquiv(self, value): |
||
| 4626 | self.TextEquiv.append(value) |
||
| 4627 | def insert_TextEquiv_at(self, index, value): |
||
| 4628 | self.TextEquiv.insert(index, value) |
||
| 4629 | def replace_TextEquiv_at(self, index, value): |
||
| 4630 | self.TextEquiv[index] = value |
||
| 4631 | def get_TextStyle(self): |
||
| 4632 | return self.TextStyle |
||
| 4633 | def set_TextStyle(self, TextStyle): |
||
| 4634 | self.TextStyle = TextStyle |
||
| 4635 | def get_UserDefined(self): |
||
| 4636 | return self.UserDefined |
||
| 4637 | def set_UserDefined(self, UserDefined): |
||
| 4638 | self.UserDefined = UserDefined |
||
| 4639 | def get_Labels(self): |
||
| 4640 | return self.Labels |
||
| 4641 | def set_Labels(self, Labels): |
||
| 4642 | self.Labels = Labels |
||
| 4643 | def add_Labels(self, value): |
||
| 4644 | self.Labels.append(value) |
||
| 4645 | def insert_Labels_at(self, index, value): |
||
| 4646 | self.Labels.insert(index, value) |
||
| 4647 | def replace_Labels_at(self, index, value): |
||
| 4648 | self.Labels[index] = value |
||
| 4649 | def get_id(self): |
||
| 4650 | return self.id |
||
| 4651 | def set_id(self, id): |
||
| 4652 | self.id = id |
||
| 4653 | def get_ligature(self): |
||
| 4654 | return self.ligature |
||
| 4655 | def set_ligature(self, ligature): |
||
| 4656 | self.ligature = ligature |
||
| 4657 | def get_symbol(self): |
||
| 4658 | return self.symbol |
||
| 4659 | def set_symbol(self, symbol): |
||
| 4660 | self.symbol = symbol |
||
| 4661 | def get_script(self): |
||
| 4662 | return self.script |
||
| 4663 | def set_script(self, script): |
||
| 4664 | self.script = script |
||
| 4665 | def get_production(self): |
||
| 4666 | return self.production |
||
| 4667 | def set_production(self, production): |
||
| 4668 | self.production = production |
||
| 4669 | def get_custom(self): |
||
| 4670 | return self.custom |
||
| 4671 | def set_custom(self, custom): |
||
| 4672 | self.custom = custom |
||
| 4673 | def get_comments(self): |
||
| 4674 | return self.comments |
||
| 4675 | def set_comments(self, comments): |
||
| 4676 | self.comments = comments |
||
| 4677 | def validate_ScriptSimpleType(self, value): |
||
| 4678 | # Validate type pc:ScriptSimpleType, a restriction on string. |
||
| 4679 | if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None: |
||
| 4680 | if not isinstance(value, str): |
||
| 4681 | lineno = self.gds_get_node_lineno_() |
||
| 4682 | self.gds_collector_.add_message('Value "%(value)s"%(lineno)s is not of the correct base simple type (str)' % {"value": value, "lineno": lineno, }) |
||
| 4683 | return False |
||
| 4684 | value = value |
||
| 4685 | enumerations = ['Adlm - Adlam', 'Afak - Afaka', 'Aghb - Caucasian Albanian', 'Ahom - Ahom, Tai Ahom', 'Arab - Arabic', 'Aran - Arabic (Nastaliq variant)', 'Armi - Imperial Aramaic', 'Armn - Armenian', 'Avst - Avestan', 'Bali - Balinese', 'Bamu - Bamum', 'Bass - Bassa Vah', 'Batk - Batak', 'Beng - Bengali', 'Bhks - Bhaiksuki', 'Blis - Blissymbols', 'Bopo - Bopomofo', 'Brah - Brahmi', 'Brai - Braille', 'Bugi - Buginese', 'Buhd - Buhid', 'Cakm - Chakma', 'Cans - Unified Canadian Aboriginal Syllabics', 'Cari - Carian', 'Cham - Cham', 'Cher - Cherokee', 'Cirt - Cirth', 'Copt - Coptic', 'Cprt - Cypriot', 'Cyrl - Cyrillic', 'Cyrs - Cyrillic (Old Church Slavonic variant)', 'Deva - Devanagari (Nagari)', 'Dsrt - Deseret (Mormon)', 'Dupl - Duployan shorthand, Duployan stenography', 'Egyd - Egyptian demotic', 'Egyh - Egyptian hieratic', 'Egyp - Egyptian hieroglyphs', 'Elba - Elbasan', 'Ethi - Ethiopic', 'Geok - Khutsuri (Asomtavruli and Nuskhuri)', 'Geor - Georgian (Mkhedruli)', 'Glag - Glagolitic', 'Goth - Gothic', 'Gran - Grantha', 'Grek - Greek', 'Gujr - Gujarati', 'Guru - Gurmukhi', 'Hanb - Han with Bopomofo', 'Hang - Hangul', 'Hani - Han (Hanzi, Kanji, Hanja)', 'Hano - Hanunoo (Hanunóo)', 'Hans - Han (Simplified variant)', 'Hant - Han (Traditional variant)', 'Hatr - Hatran', 'Hebr - Hebrew', 'Hira - Hiragana', 'Hluw - Anatolian Hieroglyphs', 'Hmng - Pahawh Hmong', 'Hrkt - Japanese syllabaries', 'Hung - Old Hungarian (Hungarian Runic)', 'Inds - Indus (Harappan)', 'Ital - Old Italic (Etruscan, Oscan etc.)', 'Jamo - Jamo', 'Java - Javanese', 'Jpan - Japanese', 'Jurc - Jurchen', 'Kali - Kayah Li', 'Kana - Katakana', 'Khar - Kharoshthi', 'Khmr - Khmer', 'Khoj - Khojki', 'Kitl - Khitan large script', 'Kits - Khitan small script', 'Knda - Kannada', 'Kore - Korean (alias for Hangul + Han)', 'Kpel - Kpelle', 'Kthi - Kaithi', 'Lana - Tai Tham (Lanna)', 'Laoo - Lao', 'Latf - Latin (Fraktur variant)', 'Latg - Latin (Gaelic variant)', 'Latn - Latin', 'Leke - Leke', 'Lepc - Lepcha (Róng)', 'Limb - Limbu', 'Lina - Linear A', 'Linb - Linear B', 'Lisu - Lisu (Fraser)', 'Loma - Loma', 'Lyci - Lycian', 'Lydi - Lydian', 'Mahj - Mahajani', 'Mand - Mandaic, Mandaean', 'Mani - Manichaean', 'Marc - Marchen', 'Maya - Mayan hieroglyphs', 'Mend - Mende Kikakui', 'Merc - Meroitic Cursive', 'Mero - Meroitic Hieroglyphs', 'Mlym - Malayalam', 'Modi - Modi, Moḍī', 'Mong - Mongolian', 'Moon - Moon (Moon code, Moon script, Moon type)', 'Mroo - Mro, Mru', 'Mtei - Meitei Mayek (Meithei, Meetei)', 'Mult - Multani', 'Mymr - Myanmar (Burmese)', 'Narb - Old North Arabian (Ancient North Arabian)', 'Nbat - Nabataean', 'Newa - Newa, Newar, Newari', 'Nkgb - Nakhi Geba', 'Nkoo - N’Ko', 'Nshu - Nüshu', 'Ogam - Ogham', 'Olck - Ol Chiki (Ol Cemet’, Ol, Santali)', 'Orkh - Old Turkic, Orkhon Runic', 'Orya - Oriya', 'Osge - Osage', 'Osma - Osmanya', 'Palm - Palmyrene', 'Pauc - Pau Cin Hau', 'Perm - Old Permic', 'Phag - Phags-pa', 'Phli - Inscriptional Pahlavi', 'Phlp - Psalter Pahlavi', 'Phlv - Book Pahlavi', 'Phnx - Phoenician', 'Piqd - Klingon (KLI pIqaD)', 'Plrd - Miao (Pollard)', 'Prti - Inscriptional Parthian', 'Rjng - Rejang (Redjang, Kaganga)', 'Roro - Rongorongo', 'Runr - Runic', 'Samr - Samaritan', 'Sara - Sarati', 'Sarb - Old South Arabian', 'Saur - Saurashtra', 'Sgnw - SignWriting', 'Shaw - Shavian (Shaw)', 'Shrd - Sharada, Śāradā', 'Sidd - Siddham', 'Sind - Khudawadi, Sindhi', 'Sinh - Sinhala', 'Sora - Sora Sompeng', 'Sund - Sundanese', 'Sylo - Syloti Nagri', 'Syrc - Syriac', 'Syre - Syriac (Estrangelo variant)', 'Syrj - Syriac (Western variant)', 'Syrn - Syriac (Eastern variant)', 'Tagb - Tagbanwa', 'Takr - Takri', 'Tale - Tai Le', 'Talu - New Tai Lue', 'Taml - Tamil', 'Tang - Tangut', 'Tavt - Tai Viet', 'Telu - Telugu', 'Teng - Tengwar', 'Tfng - Tifinagh (Berber)', 'Tglg - Tagalog (Baybayin, Alibata)', 'Thaa - Thaana', 'Thai - Thai', 'Tibt - Tibetan', 'Tirh - Tirhuta', 'Ugar - Ugaritic', 'Vaii - Vai', 'Visp - Visible Speech', 'Wara - Warang Citi (Varang Kshiti)', 'Wole - Woleai', 'Xpeo - Old Persian', 'Xsux - Cuneiform, Sumero-Akkadian', 'Yiii - Yi', 'Zinh - Code for inherited script', 'Zmth - Mathematical notation', 'Zsye - Symbols (Emoji variant)', 'Zsym - Symbols', 'Zxxx - Code for unwritten documents', 'Zyyy - Code for undetermined script', 'Zzzz - Code for uncoded script', 'other'] |
||
| 4686 | if value not in enumerations: |
||
| 4687 | lineno = self.gds_get_node_lineno_() |
||
| 4688 | self.gds_collector_.add_message('Value "%(value)s"%(lineno)s does not match xsd enumeration restriction on ScriptSimpleType' % {"value" : encode_str_2_3(value), "lineno": lineno} ) |
||
| 4689 | result = False |
||
| 4690 | def validate_ProductionSimpleType(self, value): |
||
| 4691 | # Validate type pc:ProductionSimpleType, a restriction on string. |
||
| 4692 | if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None: |
||
| 4693 | if not isinstance(value, str): |
||
| 4694 | lineno = self.gds_get_node_lineno_() |
||
| 4695 | self.gds_collector_.add_message('Value "%(value)s"%(lineno)s is not of the correct base simple type (str)' % {"value": value, "lineno": lineno, }) |
||
| 4696 | return False |
||
| 4697 | value = value |
||
| 4698 | enumerations = ['printed', 'typewritten', 'handwritten-cursive', 'handwritten-printscript', 'medieval-manuscript', 'other'] |
||
| 4699 | if value not in enumerations: |
||
| 4700 | lineno = self.gds_get_node_lineno_() |
||
| 4701 | self.gds_collector_.add_message('Value "%(value)s"%(lineno)s does not match xsd enumeration restriction on ProductionSimpleType' % {"value" : encode_str_2_3(value), "lineno": lineno} ) |
||
| 4702 | result = False |
||
| 4703 | def hasContent_(self): |
||
| 4704 | if ( |
||
| 4705 | self.AlternativeImage or |
||
| 4706 | self.Coords is not None or |
||
| 4707 | self.Graphemes is not None or |
||
| 4708 | self.TextEquiv or |
||
| 4709 | self.TextStyle is not None or |
||
| 4710 | self.UserDefined is not None or |
||
| 4711 | self.Labels |
||
| 4712 | ): |
||
| 4713 | return True |
||
| 4714 | else: |
||
| 4715 | return False |
||
| 4716 | def export(self, outfile, level, namespaceprefix_='', namespacedef_='xmlns:pc="http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15"', name_='GlyphType', pretty_print=True): |
||
| 4717 | imported_ns_def_ = GenerateDSNamespaceDefs_.get('GlyphType') |
||
| 4718 | if imported_ns_def_ is not None: |
||
| 4719 | namespacedef_ = imported_ns_def_ |
||
| 4720 | if pretty_print: |
||
| 4721 | eol_ = '\n' |
||
| 4722 | else: |
||
| 4723 | eol_ = '' |
||
| 4724 | if self.original_tagname_ is not None and name_ == 'GlyphType': |
||
| 4725 | name_ = self.original_tagname_ |
||
| 4726 | if UseCapturedNS_ and self.ns_prefix_: |
||
| 4727 | namespaceprefix_ = self.ns_prefix_ + ':' |
||
| 4728 | showIndent(outfile, level, pretty_print) |
||
| 4729 | outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) |
||
| 4730 | already_processed = set() |
||
| 4731 | self.exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='GlyphType') |
||
| 4732 | if self.hasContent_(): |
||
| 4733 | outfile.write('>%s' % (eol_, )) |
||
| 4734 | self.exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='GlyphType', pretty_print=pretty_print) |
||
| 4735 | showIndent(outfile, level, pretty_print) |
||
| 4736 | outfile.write('</%s%s>%s' % (namespaceprefix_, name_, eol_)) |
||
| 4737 | else: |
||
| 4738 | outfile.write('/>%s' % (eol_, )) |
||
| 4739 | def exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='GlyphType'): |
||
| 4740 | if self.id is not None and 'id' not in already_processed: |
||
| 4741 | already_processed.add('id') |
||
| 4742 | outfile.write(' id=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.id), input_name='id')), )) |
||
| 4743 | if self.ligature is not None and 'ligature' not in already_processed: |
||
| 4744 | already_processed.add('ligature') |
||
| 4745 | outfile.write(' ligature="%s"' % self.gds_format_boolean(self.ligature, input_name='ligature')) |
||
| 4746 | if self.symbol is not None and 'symbol' not in already_processed: |
||
| 4747 | already_processed.add('symbol') |
||
| 4748 | outfile.write(' symbol="%s"' % self.gds_format_boolean(self.symbol, input_name='symbol')) |
||
| 4749 | if self.script is not None and 'script' not in already_processed: |
||
| 4750 | already_processed.add('script') |
||
| 4751 | outfile.write(' script=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.script), input_name='script')), )) |
||
| 4752 | if self.production is not None and 'production' not in already_processed: |
||
| 4753 | already_processed.add('production') |
||
| 4754 | outfile.write(' production=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.production), input_name='production')), )) |
||
| 4755 | if self.custom is not None and 'custom' not in already_processed: |
||
| 4756 | already_processed.add('custom') |
||
| 4757 | outfile.write(' custom=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.custom), input_name='custom')), )) |
||
| 4758 | if self.comments is not None and 'comments' not in already_processed: |
||
| 4759 | already_processed.add('comments') |
||
| 4760 | outfile.write(' comments=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.comments), input_name='comments')), )) |
||
| 4761 | View Code Duplication | def exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='xmlns:pc="http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15"', name_='GlyphType', fromsubclass_=False, pretty_print=True): |
|
| 4762 | if pretty_print: |
||
| 4763 | eol_ = '\n' |
||
| 4764 | else: |
||
| 4765 | eol_ = '' |
||
| 4766 | for AlternativeImage_ in self.AlternativeImage: |
||
| 4767 | namespaceprefix_ = self.AlternativeImage_nsprefix_ + ':' if (UseCapturedNS_ and self.AlternativeImage_nsprefix_) else '' |
||
| 4768 | AlternativeImage_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='AlternativeImage', pretty_print=pretty_print) |
||
| 4769 | if self.Coords is not None: |
||
| 4770 | namespaceprefix_ = self.Coords_nsprefix_ + ':' if (UseCapturedNS_ and self.Coords_nsprefix_) else '' |
||
| 4771 | self.Coords.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Coords', pretty_print=pretty_print) |
||
| 4772 | if self.Graphemes is not None: |
||
| 4773 | namespaceprefix_ = self.Graphemes_nsprefix_ + ':' if (UseCapturedNS_ and self.Graphemes_nsprefix_) else '' |
||
| 4774 | self.Graphemes.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Graphemes', pretty_print=pretty_print) |
||
| 4775 | for TextEquiv_ in self.TextEquiv: |
||
| 4776 | namespaceprefix_ = self.TextEquiv_nsprefix_ + ':' if (UseCapturedNS_ and self.TextEquiv_nsprefix_) else '' |
||
| 4777 | TextEquiv_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='TextEquiv', pretty_print=pretty_print) |
||
| 4778 | if self.TextStyle is not None: |
||
| 4779 | namespaceprefix_ = self.TextStyle_nsprefix_ + ':' if (UseCapturedNS_ and self.TextStyle_nsprefix_) else '' |
||
| 4780 | self.TextStyle.export(outfile, level, namespaceprefix_, namespacedef_='', name_='TextStyle', pretty_print=pretty_print) |
||
| 4781 | if self.UserDefined is not None: |
||
| 4782 | namespaceprefix_ = self.UserDefined_nsprefix_ + ':' if (UseCapturedNS_ and self.UserDefined_nsprefix_) else '' |
||
| 4783 | self.UserDefined.export(outfile, level, namespaceprefix_, namespacedef_='', name_='UserDefined', pretty_print=pretty_print) |
||
| 4784 | for Labels_ in self.Labels: |
||
| 4785 | namespaceprefix_ = self.Labels_nsprefix_ + ':' if (UseCapturedNS_ and self.Labels_nsprefix_) else '' |
||
| 4786 | Labels_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Labels', pretty_print=pretty_print) |
||
| 4787 | def to_etree(self, parent_element=None, name_='GlyphType', mapping_=None, nsmap_=None): |
||
| 4788 | if parent_element is None: |
||
| 4789 | element = etree_.Element('{http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15}' + name_, nsmap=nsmap_) |
||
| 4790 | else: |
||
| 4791 | element = etree_.SubElement(parent_element, '{http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15}' + name_, nsmap=nsmap_) |
||
| 4792 | if self.id is not None: |
||
| 4793 | element.set('id', self.gds_format_string(self.id)) |
||
| 4794 | if self.ligature is not None: |
||
| 4795 | element.set('ligature', self.gds_format_boolean(self.ligature)) |
||
| 4796 | if self.symbol is not None: |
||
| 4797 | element.set('symbol', self.gds_format_boolean(self.symbol)) |
||
| 4798 | if self.script is not None: |
||
| 4799 | element.set('script', self.gds_format_string(self.script)) |
||
| 4800 | if self.production is not None: |
||
| 4801 | element.set('production', self.gds_format_string(self.production)) |
||
| 4802 | if self.custom is not None: |
||
| 4803 | element.set('custom', self.gds_format_string(self.custom)) |
||
| 4804 | if self.comments is not None: |
||
| 4805 | element.set('comments', self.gds_format_string(self.comments)) |
||
| 4806 | for AlternativeImage_ in self.AlternativeImage: |
||
| 4807 | AlternativeImage_.to_etree(element, name_='AlternativeImage', mapping_=mapping_, nsmap_=nsmap_) |
||
| 4808 | if self.Coords is not None: |
||
| 4809 | Coords_ = self.Coords |
||
| 4810 | Coords_.to_etree(element, name_='Coords', mapping_=mapping_, nsmap_=nsmap_) |
||
| 4811 | if self.Graphemes is not None: |
||
| 4812 | Graphemes_ = self.Graphemes |
||
| 4813 | Graphemes_.to_etree(element, name_='Graphemes', mapping_=mapping_, nsmap_=nsmap_) |
||
| 4814 | for TextEquiv_ in self.TextEquiv: |
||
| 4815 | TextEquiv_.to_etree(element, name_='TextEquiv', mapping_=mapping_, nsmap_=nsmap_) |
||
| 4816 | if self.TextStyle is not None: |
||
| 4817 | TextStyle_ = self.TextStyle |
||
| 4818 | TextStyle_.to_etree(element, name_='TextStyle', mapping_=mapping_, nsmap_=nsmap_) |
||
| 4819 | if self.UserDefined is not None: |
||
| 4820 | UserDefined_ = self.UserDefined |
||
| 4821 | UserDefined_.to_etree(element, name_='UserDefined', mapping_=mapping_, nsmap_=nsmap_) |
||
| 4822 | for Labels_ in self.Labels: |
||
| 4823 | Labels_.to_etree(element, name_='Labels', mapping_=mapping_, nsmap_=nsmap_) |
||
| 4824 | if mapping_ is not None: |
||
| 4825 | mapping_[id(self)] = element |
||
| 4826 | return element |
||
| 4827 | def build(self, node, gds_collector_=None): |
||
| 4828 | self.gds_collector_ = gds_collector_ |
||
| 4829 | if SaveElementTreeNode: |
||
| 4830 | self.gds_elementtree_node_ = node |
||
| 4831 | already_processed = set() |
||
| 4832 | self.ns_prefix_ = node.prefix |
||
| 4833 | self.buildAttributes(node, node.attrib, already_processed) |
||
| 4834 | for child in node: |
||
| 4835 | nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] |
||
| 4836 | self.buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) |
||
| 4837 | return self |
||
| 4838 | def buildAttributes(self, node, attrs, already_processed): |
||
| 4839 | value = find_attr_value_('id', node) |
||
| 4840 | if value is not None and 'id' not in already_processed: |
||
| 4841 | already_processed.add('id') |
||
| 4842 | self.id = value |
||
| 4843 | value = find_attr_value_('ligature', node) |
||
| 4844 | if value is not None and 'ligature' not in already_processed: |
||
| 4845 | already_processed.add('ligature') |
||
| 4846 | if value in ('true', '1'): |
||
| 4847 | self.ligature = True |
||
| 4848 | elif value in ('false', '0'): |
||
| 4849 | self.ligature = False |
||
| 4850 | else: |
||
| 4851 | raise_parse_error(node, 'Bad boolean attribute') |
||
| 4852 | value = find_attr_value_('symbol', node) |
||
| 4853 | if value is not None and 'symbol' not in already_processed: |
||
| 4854 | already_processed.add('symbol') |
||
| 4855 | if value in ('true', '1'): |
||
| 4856 | self.symbol = True |
||
| 4857 | elif value in ('false', '0'): |
||
| 4858 | self.symbol = False |
||
| 4859 | else: |
||
| 4860 | raise_parse_error(node, 'Bad boolean attribute') |
||
| 4861 | value = find_attr_value_('script', node) |
||
| 4862 | if value is not None and 'script' not in already_processed: |
||
| 4863 | already_processed.add('script') |
||
| 4864 | self.script = value |
||
| 4865 | self.validate_ScriptSimpleType(self.script) # validate type ScriptSimpleType |
||
| 4866 | value = find_attr_value_('production', node) |
||
| 4867 | if value is not None and 'production' not in already_processed: |
||
| 4868 | already_processed.add('production') |
||
| 4869 | self.production = value |
||
| 4870 | self.validate_ProductionSimpleType(self.production) # validate type ProductionSimpleType |
||
| 4871 | value = find_attr_value_('custom', node) |
||
| 4872 | if value is not None and 'custom' not in already_processed: |
||
| 4873 | already_processed.add('custom') |
||
| 4874 | self.custom = value |
||
| 4875 | value = find_attr_value_('comments', node) |
||
| 4876 | if value is not None and 'comments' not in already_processed: |
||
| 4877 | already_processed.add('comments') |
||
| 4878 | self.comments = value |
||
| 4879 | View Code Duplication | def buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None): |
|
| 4880 | if nodeName_ == 'AlternativeImage': |
||
| 4881 | obj_ = AlternativeImageType.factory(parent_object_=self) |
||
| 4882 | obj_.build(child_, gds_collector_=gds_collector_) |
||
| 4883 | self.AlternativeImage.append(obj_) |
||
| 4884 | obj_.original_tagname_ = 'AlternativeImage' |
||
| 4885 | elif nodeName_ == 'Coords': |
||
| 4886 | obj_ = CoordsType.factory(parent_object_=self) |
||
| 4887 | obj_.build(child_, gds_collector_=gds_collector_) |
||
| 4888 | self.Coords = obj_ |
||
| 4889 | obj_.original_tagname_ = 'Coords' |
||
| 4890 | elif nodeName_ == 'Graphemes': |
||
| 4891 | obj_ = GraphemesType.factory(parent_object_=self) |
||
| 4892 | obj_.build(child_, gds_collector_=gds_collector_) |
||
| 4893 | self.Graphemes = obj_ |
||
| 4894 | obj_.original_tagname_ = 'Graphemes' |
||
| 4895 | elif nodeName_ == 'TextEquiv': |
||
| 4896 | obj_ = TextEquivType.factory(parent_object_=self) |
||
| 4897 | obj_.build(child_, gds_collector_=gds_collector_) |
||
| 4898 | self.TextEquiv.append(obj_) |
||
| 4899 | obj_.original_tagname_ = 'TextEquiv' |
||
| 4900 | elif nodeName_ == 'TextStyle': |
||
| 4901 | obj_ = TextStyleType.factory(parent_object_=self) |
||
| 4902 | obj_.build(child_, gds_collector_=gds_collector_) |
||
| 4903 | self.TextStyle = obj_ |
||
| 4904 | obj_.original_tagname_ = 'TextStyle' |
||
| 4905 | elif nodeName_ == 'UserDefined': |
||
| 4906 | obj_ = UserDefinedType.factory(parent_object_=self) |
||
| 4907 | obj_.build(child_, gds_collector_=gds_collector_) |
||
| 4908 | self.UserDefined = obj_ |
||
| 4909 | obj_.original_tagname_ = 'UserDefined' |
||
| 4910 | elif nodeName_ == 'Labels': |
||
| 4911 | obj_ = LabelsType.factory(parent_object_=self) |
||
| 4912 | obj_.build(child_, gds_collector_=gds_collector_) |
||
| 4913 | self.Labels.append(obj_) |
||
| 4914 | obj_.original_tagname_ = 'Labels' |
||
| 4915 | def __hash__(self): |
||
| 4916 | return hash(self.id) |
||
| 4917 | View Code Duplication | def invalidate_AlternativeImage(self, feature_selector=None): |
|
| 4918 | """ |
||
| 4919 | Remove derived images from this segment (due to changed coordinates). |
||
| 4920 | |||
| 4921 | If `feature_selector` is not none, remove only images with |
||
| 4922 | matching ``@comments``, e.g. ``feature_selector=cropped,deskewed``. |
||
| 4923 | """ |
||
| 4924 | existing_images = self.AlternativeImage or [] |
||
| 4925 | removed_images = [] |
||
| 4926 | if feature_selector: |
||
| 4927 | new_images = [] |
||
| 4928 | for image in existing_images: |
||
| 4929 | features = image.get_comments() or '' |
||
| 4930 | if any(feature in features.split(',') |
||
| 4931 | for feature in feature_selector.split(',') if feature): |
||
| 4932 | removed_images.append(image) |
||
| 4933 | else: |
||
| 4934 | new_images.append(image) |
||
| 4935 | self.AlternativeImage = new_images |
||
| 4936 | else: |
||
| 4937 | removed_images = existing_images |
||
| 4938 | self.AlternativeImage = [] |
||
| 4939 | if hasattr(self, 'id'): |
||
| 4940 | name = self.id |
||
| 4941 | elif hasattr(self, 'parent_object_') and hasattr(self.parent_object_, 'pcGtsId'): |
||
| 4942 | name = self.parent_object_.pcGtsId |
||
| 4943 | else: |
||
| 4944 | name = '' |
||
| 4945 | for image in removed_images: |
||
| 4946 | self.gds_collector_.add_message('Removing AlternativeImage %s from "%s"' % ( |
||
| 4947 | image.get_comments() or '', name)) |
||
| 4948 | def set_Coords(self, Coords): |
||
| 4949 | """ |
||
| 4950 | Set coordinate polygon by given :py:class:`CoordsType` object. |
||
| 4951 | Moreover, invalidate self's ``pc:AlternativeImage``s |
||
| 4952 | (because they will have been cropped with a bbox |
||
| 4953 | of the previous polygon). |
||
| 4954 | """ |
||
| 4955 | if hasattr(self, 'invalidate_AlternativeImage'): |
||
| 4956 | # RegionType, TextLineType, WordType, GlyphType: |
||
| 4957 | self.invalidate_AlternativeImage() |
||
| 4958 | elif hasattr(self, 'parent_object_') and hasattr(self.parent_object_, 'invalidate_AlternativeImage'): |
||
| 4959 | # BorderType: |
||
| 4960 | self.parent_object_.invalidate_AlternativeImage(feature_selector='cropped') |
||
| 4961 | self.Coords = Coords |
||
| 4962 | # end class GlyphType |
||
| 4963 | |||
| 4964 | |||
| 4965 | class TextEquivType(GeneratedsSuper): |
||
| 4966 | """Used for sort order in case multiple TextEquivs are defined. |
||
| 4967 | The text content with the lowest index should be interpreted |
||
| 4968 | as the main text content. |
||
| 4969 | OCR confidence value (between 0 and 1) |
||
| 4970 | Type of text content (is it free text or a number, for instance). |
||
| 4971 | This is only a descriptive attribute, the text type |
||
| 4972 | is not checked during XML validation. |
||
| 4973 | Refinement for dataType attribute. Can be a regular expression, for |
||
| 4974 | instance.""" |
||
| 4975 | __hash__ = GeneratedsSuper.__hash__ |
||
| 4976 | member_data_items_ = [ |
||
| 4977 | MemberSpec_('index', 'integer', 0, 1, {'use': 'optional'}), |
||
| 4978 | MemberSpec_('conf', 'pc:ConfSimpleType', 0, 1, {'use': 'optional'}), |
||
| 4979 | MemberSpec_('dataType', 'pc:TextDataTypeSimpleType', 0, 1, {'use': 'optional'}), |
||
| 4980 | MemberSpec_('dataTypeDetails', 'string', 0, 1, {'use': 'optional'}), |
||
| 4981 | MemberSpec_('comments', 'string', 0, 1, {'use': 'optional'}), |
||
| 4982 | MemberSpec_('PlainText', 'string', 0, 1, {'minOccurs': '0', 'name': 'PlainText', 'type': 'string'}, None), |
||
| 4983 | MemberSpec_('Unicode', 'string', 0, 0, {'name': 'Unicode', 'type': 'string'}, None), |
||
| 4984 | ] |
||
| 4985 | subclass = None |
||
| 4986 | superclass = None |
||
| 4987 | def __init__(self, index=None, conf=None, dataType=None, dataTypeDetails=None, comments=None, PlainText=None, Unicode=None, gds_collector_=None, **kwargs_): |
||
| 4988 | self.gds_collector_ = gds_collector_ |
||
| 4989 | self.gds_elementtree_node_ = None |
||
| 4990 | self.original_tagname_ = None |
||
| 4991 | self.parent_object_ = kwargs_.get('parent_object_') |
||
| 4992 | self.ns_prefix_ = None |
||
| 4993 | self.index = _cast(int, index) |
||
| 4994 | self.index_nsprefix_ = "pc" |
||
| 4995 | self.conf = _cast(float, conf) |
||
| 4996 | self.conf_nsprefix_ = "pc" |
||
| 4997 | self.dataType = _cast(None, dataType) |
||
| 4998 | self.dataType_nsprefix_ = "pc" |
||
| 4999 | self.dataTypeDetails = _cast(None, dataTypeDetails) |
||
| 5000 | self.dataTypeDetails_nsprefix_ = "pc" |
||
| 5001 | self.comments = _cast(None, comments) |
||
| 5002 | self.comments_nsprefix_ = "pc" |
||
| 5003 | self.PlainText = PlainText |
||
| 5004 | self.PlainText_nsprefix_ = "pc" |
||
| 5005 | self.Unicode = Unicode |
||
| 5006 | self.Unicode_nsprefix_ = "pc" |
||
| 5007 | def factory(*args_, **kwargs_): |
||
| 5008 | if CurrentSubclassModule_ is not None: |
||
| 5009 | subclass = getSubclassFromModule_( |
||
| 5010 | CurrentSubclassModule_, TextEquivType) |
||
| 5011 | if subclass is not None: |
||
| 5012 | return subclass(*args_, **kwargs_) |
||
| 5013 | if TextEquivType.subclass: |
||
| 5014 | return TextEquivType.subclass(*args_, **kwargs_) |
||
| 5015 | else: |
||
| 5016 | return TextEquivType(*args_, **kwargs_) |
||
| 5017 | factory = staticmethod(factory) |
||
| 5018 | def get_ns_prefix_(self): |
||
| 5019 | return self.ns_prefix_ |
||
| 5020 | def set_ns_prefix_(self, ns_prefix): |
||
| 5021 | self.ns_prefix_ = ns_prefix |
||
| 5022 | def get_PlainText(self): |
||
| 5023 | return self.PlainText |
||
| 5024 | def set_PlainText(self, PlainText): |
||
| 5025 | self.PlainText = PlainText |
||
| 5026 | def get_Unicode(self): |
||
| 5027 | return self.Unicode |
||
| 5028 | def set_Unicode(self, Unicode): |
||
| 5029 | self.Unicode = Unicode |
||
| 5030 | def get_index(self): |
||
| 5031 | return self.index |
||
| 5032 | def set_index(self, index): |
||
| 5033 | self.index = index |
||
| 5034 | def get_conf(self): |
||
| 5035 | return self.conf |
||
| 5036 | def set_conf(self, conf): |
||
| 5037 | self.conf = conf |
||
| 5038 | def get_dataType(self): |
||
| 5039 | return self.dataType |
||
| 5040 | def set_dataType(self, dataType): |
||
| 5041 | self.dataType = dataType |
||
| 5042 | def get_dataTypeDetails(self): |
||
| 5043 | return self.dataTypeDetails |
||
| 5044 | def set_dataTypeDetails(self, dataTypeDetails): |
||
| 5045 | self.dataTypeDetails = dataTypeDetails |
||
| 5046 | def get_comments(self): |
||
| 5047 | return self.comments |
||
| 5048 | def set_comments(self, comments): |
||
| 5049 | self.comments = comments |
||
| 5050 | View Code Duplication | def validate_ConfSimpleType(self, value): |
|
| 5051 | # Validate type pc:ConfSimpleType, a restriction on float. |
||
| 5052 | if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None: |
||
| 5053 | if not isinstance(value, float): |
||
| 5054 | lineno = self.gds_get_node_lineno_() |
||
| 5055 | self.gds_collector_.add_message('Value "%(value)s"%(lineno)s is not of the correct base simple type (float)' % {"value": value, "lineno": lineno, }) |
||
| 5056 | return False |
||
| 5057 | if value < 0: |
||
| 5058 | lineno = self.gds_get_node_lineno_() |
||
| 5059 | self.gds_collector_.add_message('Value "%(value)s"%(lineno)s does not match xsd minInclusive restriction on ConfSimpleType' % {"value": value, "lineno": lineno} ) |
||
| 5060 | result = False |
||
| 5061 | if value > 1: |
||
| 5062 | lineno = self.gds_get_node_lineno_() |
||
| 5063 | self.gds_collector_.add_message('Value "%(value)s"%(lineno)s does not match xsd maxInclusive restriction on ConfSimpleType' % {"value": value, "lineno": lineno} ) |
||
| 5064 | result = False |
||
| 5065 | def validate_TextDataTypeSimpleType(self, value): |
||
| 5066 | # Validate type pc:TextDataTypeSimpleType, a restriction on string. |
||
| 5067 | if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None: |
||
| 5068 | if not isinstance(value, str): |
||
| 5069 | lineno = self.gds_get_node_lineno_() |
||
| 5070 | self.gds_collector_.add_message('Value "%(value)s"%(lineno)s is not of the correct base simple type (str)' % {"value": value, "lineno": lineno, }) |
||
| 5071 | return False |
||
| 5072 | value = value |
||
| 5073 | enumerations = ['xsd:decimal', 'xsd:float', 'xsd:integer', 'xsd:boolean', 'xsd:date', 'xsd:time', 'xsd:dateTime', 'xsd:string', 'other'] |
||
| 5074 | if value not in enumerations: |
||
| 5075 | lineno = self.gds_get_node_lineno_() |
||
| 5076 | self.gds_collector_.add_message('Value "%(value)s"%(lineno)s does not match xsd enumeration restriction on TextDataTypeSimpleType' % {"value" : encode_str_2_3(value), "lineno": lineno} ) |
||
| 5077 | result = False |
||
| 5078 | def hasContent_(self): |
||
| 5079 | if ( |
||
| 5080 | self.PlainText is not None or |
||
| 5081 | self.Unicode is not None |
||
| 5082 | ): |
||
| 5083 | return True |
||
| 5084 | else: |
||
| 5085 | return False |
||
| 5086 | def export(self, outfile, level, namespaceprefix_='', namespacedef_='xmlns:pc="http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15" xmlns:None="http://www.w3.org/2001/XMLSchema" ', name_='TextEquivType', pretty_print=True): |
||
| 5087 | imported_ns_def_ = GenerateDSNamespaceDefs_.get('TextEquivType') |
||
| 5088 | if imported_ns_def_ is not None: |
||
| 5089 | namespacedef_ = imported_ns_def_ |
||
| 5090 | if pretty_print: |
||
| 5091 | eol_ = '\n' |
||
| 5092 | else: |
||
| 5093 | eol_ = '' |
||
| 5094 | if self.original_tagname_ is not None and name_ == 'TextEquivType': |
||
| 5095 | name_ = self.original_tagname_ |
||
| 5096 | if UseCapturedNS_ and self.ns_prefix_: |
||
| 5097 | namespaceprefix_ = self.ns_prefix_ + ':' |
||
| 5098 | showIndent(outfile, level, pretty_print) |
||
| 5099 | outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) |
||
| 5100 | already_processed = set() |
||
| 5101 | self.exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='TextEquivType') |
||
| 5102 | if self.hasContent_(): |
||
| 5103 | outfile.write('>%s' % (eol_, )) |
||
| 5104 | self.exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='TextEquivType', pretty_print=pretty_print) |
||
| 5105 | showIndent(outfile, level, pretty_print) |
||
| 5106 | outfile.write('</%s%s>%s' % (namespaceprefix_, name_, eol_)) |
||
| 5107 | else: |
||
| 5108 | outfile.write('/>%s' % (eol_, )) |
||
| 5109 | def exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='TextEquivType'): |
||
| 5110 | if self.index is not None and 'index' not in already_processed: |
||
| 5111 | already_processed.add('index') |
||
| 5112 | outfile.write(' index="%s"' % self.gds_format_integer(self.index, input_name='index')) |
||
| 5113 | if self.conf is not None and 'conf' not in already_processed: |
||
| 5114 | already_processed.add('conf') |
||
| 5115 | outfile.write(' conf="%s"' % self.gds_format_float(self.conf, input_name='conf')) |
||
| 5116 | if self.dataType is not None and 'dataType' not in already_processed: |
||
| 5117 | already_processed.add('dataType') |
||
| 5118 | outfile.write(' dataType=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.dataType), input_name='dataType')), )) |
||
| 5119 | if self.dataTypeDetails is not None and 'dataTypeDetails' not in already_processed: |
||
| 5120 | already_processed.add('dataTypeDetails') |
||
| 5121 | outfile.write(' dataTypeDetails=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.dataTypeDetails), input_name='dataTypeDetails')), )) |
||
| 5122 | if self.comments is not None and 'comments' not in already_processed: |
||
| 5123 | already_processed.add('comments') |
||
| 5124 | outfile.write(' comments=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.comments), input_name='comments')), )) |
||
| 5125 | def exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='xmlns:pc="http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15" xmlns:None="http://www.w3.org/2001/XMLSchema" ', name_='TextEquivType', fromsubclass_=False, pretty_print=True): |
||
| 5126 | if pretty_print: |
||
| 5127 | eol_ = '\n' |
||
| 5128 | else: |
||
| 5129 | eol_ = '' |
||
| 5130 | if self.PlainText is not None: |
||
| 5131 | namespaceprefix_ = self.PlainText_nsprefix_ + ':' if (UseCapturedNS_ and self.PlainText_nsprefix_) else '' |
||
| 5132 | showIndent(outfile, level, pretty_print) |
||
| 5133 | outfile.write('<%sPlainText>%s</%sPlainText>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.PlainText), input_name='PlainText')), namespaceprefix_ , eol_)) |
||
| 5134 | if self.Unicode is not None: |
||
| 5135 | namespaceprefix_ = self.Unicode_nsprefix_ + ':' if (UseCapturedNS_ and self.Unicode_nsprefix_) else '' |
||
| 5136 | showIndent(outfile, level, pretty_print) |
||
| 5137 | outfile.write('<%sUnicode>%s</%sUnicode>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.Unicode), input_name='Unicode')), namespaceprefix_ , eol_)) |
||
| 5138 | def to_etree(self, parent_element=None, name_='TextEquivType', mapping_=None, nsmap_=None): |
||
| 5139 | if parent_element is None: |
||
| 5140 | element = etree_.Element('{http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15}' + name_, nsmap=nsmap_) |
||
| 5141 | else: |
||
| 5142 | element = etree_.SubElement(parent_element, '{http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15}' + name_, nsmap=nsmap_) |
||
| 5143 | if self.index is not None: |
||
| 5144 | element.set('index', self.gds_format_integer(self.index)) |
||
| 5145 | if self.conf is not None: |
||
| 5146 | element.set('conf', self.gds_format_float(self.conf)) |
||
| 5147 | if self.dataType is not None: |
||
| 5148 | element.set('dataType', self.gds_format_string(self.dataType)) |
||
| 5149 | if self.dataTypeDetails is not None: |
||
| 5150 | element.set('dataTypeDetails', self.gds_format_string(self.dataTypeDetails)) |
||
| 5151 | if self.comments is not None: |
||
| 5152 | element.set('comments', self.gds_format_string(self.comments)) |
||
| 5153 | if self.PlainText is not None: |
||
| 5154 | PlainText_ = self.PlainText |
||
| 5155 | etree_.SubElement(element, '{http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15}PlainText').text = self.gds_format_string(PlainText_) |
||
| 5156 | if self.Unicode is not None: |
||
| 5157 | Unicode_ = self.Unicode |
||
| 5158 | etree_.SubElement(element, '{http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15}Unicode').text = self.gds_format_string(Unicode_) |
||
| 5159 | if mapping_ is not None: |
||
| 5160 | mapping_[id(self)] = element |
||
| 5161 | return element |
||
| 5162 | def build(self, node, gds_collector_=None): |
||
| 5163 | self.gds_collector_ = gds_collector_ |
||
| 5164 | if SaveElementTreeNode: |
||
| 5165 | self.gds_elementtree_node_ = node |
||
| 5166 | already_processed = set() |
||
| 5167 | self.ns_prefix_ = node.prefix |
||
| 5168 | self.buildAttributes(node, node.attrib, already_processed) |
||
| 5169 | for child in node: |
||
| 5170 | nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] |
||
| 5171 | self.buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) |
||
| 5172 | return self |
||
| 5173 | def buildAttributes(self, node, attrs, already_processed): |
||
| 5174 | value = find_attr_value_('index', node) |
||
| 5175 | if value is not None and 'index' not in already_processed: |
||
| 5176 | already_processed.add('index') |
||
| 5177 | self.index = self.gds_parse_integer(value, node, 'index') |
||
| 5178 | value = find_attr_value_('conf', node) |
||
| 5179 | if value is not None and 'conf' not in already_processed: |
||
| 5180 | already_processed.add('conf') |
||
| 5181 | value = self.gds_parse_float(value, node, 'conf') |
||
| 5182 | self.conf = value |
||
| 5183 | self.validate_ConfSimpleType(self.conf) # validate type ConfSimpleType |
||
| 5184 | value = find_attr_value_('dataType', node) |
||
| 5185 | if value is not None and 'dataType' not in already_processed: |
||
| 5186 | already_processed.add('dataType') |
||
| 5187 | self.dataType = value |
||
| 5188 | self.validate_TextDataTypeSimpleType(self.dataType) # validate type TextDataTypeSimpleType |
||
| 5189 | value = find_attr_value_('dataTypeDetails', node) |
||
| 5190 | if value is not None and 'dataTypeDetails' not in already_processed: |
||
| 5191 | already_processed.add('dataTypeDetails') |
||
| 5192 | self.dataTypeDetails = value |
||
| 5193 | value = find_attr_value_('comments', node) |
||
| 5194 | if value is not None and 'comments' not in already_processed: |
||
| 5195 | already_processed.add('comments') |
||
| 5196 | self.comments = value |
||
| 5197 | def buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None): |
||
| 5198 | if nodeName_ == 'PlainText': |
||
| 5199 | value_ = child_.text |
||
| 5200 | value_ = self.gds_parse_string(value_, node, 'PlainText') |
||
| 5201 | value_ = self.gds_validate_string(value_, node, 'PlainText') |
||
| 5202 | self.PlainText = value_ |
||
| 5203 | |||
| 5204 | elif nodeName_ == 'Unicode': |
||
| 5205 | value_ = child_.text |
||
| 5206 | value_ = self.gds_parse_string(value_, node, 'Unicode') |
||
| 5207 | value_ = self.gds_validate_string(value_, node, 'Unicode') |
||
| 5208 | self.Unicode = value_ |
||
| 5209 | |||
| 5210 | def __hash__(self): |
||
| 5211 | return hash(self.id) |
||
| 5212 | # end class TextEquivType |
||
| 5213 | |||
| 5214 | |||
| 5215 | View Code Duplication | class GridType(GeneratedsSuper): |
|
| 5216 | """Matrix of grid points defining the table grid on the page.""" |
||
| 5217 | __hash__ = GeneratedsSuper.__hash__ |
||
| 5218 | member_data_items_ = [ |
||
| 5219 | MemberSpec_('GridPoints', 'GridPointsType', 1, 0, {'maxOccurs': 'unbounded', 'minOccurs': '2', 'name': 'GridPoints', 'type': 'GridPointsType'}, None), |
||
| 5220 | ] |
||
| 5221 | subclass = None |
||
| 5222 | superclass = None |
||
| 5223 | def __init__(self, GridPoints=None, gds_collector_=None, **kwargs_): |
||
| 5224 | self.gds_collector_ = gds_collector_ |
||
| 5225 | self.gds_elementtree_node_ = None |
||
| 5226 | self.original_tagname_ = None |
||
| 5227 | self.parent_object_ = kwargs_.get('parent_object_') |
||
| 5228 | self.ns_prefix_ = None |
||
| 5229 | if GridPoints is None: |
||
| 5230 | self.GridPoints = [] |
||
| 5231 | else: |
||
| 5232 | self.GridPoints = GridPoints |
||
| 5233 | self.GridPoints_nsprefix_ = "pc" |
||
| 5234 | def factory(*args_, **kwargs_): |
||
| 5235 | if CurrentSubclassModule_ is not None: |
||
| 5236 | subclass = getSubclassFromModule_( |
||
| 5237 | CurrentSubclassModule_, GridType) |
||
| 5238 | if subclass is not None: |
||
| 5239 | return subclass(*args_, **kwargs_) |
||
| 5240 | if GridType.subclass: |
||
| 5241 | return GridType.subclass(*args_, **kwargs_) |
||
| 5242 | else: |
||
| 5243 | return GridType(*args_, **kwargs_) |
||
| 5244 | factory = staticmethod(factory) |
||
| 5245 | def get_ns_prefix_(self): |
||
| 5246 | return self.ns_prefix_ |
||
| 5247 | def set_ns_prefix_(self, ns_prefix): |
||
| 5248 | self.ns_prefix_ = ns_prefix |
||
| 5249 | def get_GridPoints(self): |
||
| 5250 | return self.GridPoints |
||
| 5251 | def set_GridPoints(self, GridPoints): |
||
| 5252 | self.GridPoints = GridPoints |
||
| 5253 | def add_GridPoints(self, value): |
||
| 5254 | self.GridPoints.append(value) |
||
| 5255 | def insert_GridPoints_at(self, index, value): |
||
| 5256 | self.GridPoints.insert(index, value) |
||
| 5257 | def replace_GridPoints_at(self, index, value): |
||
| 5258 | self.GridPoints[index] = value |
||
| 5259 | def hasContent_(self): |
||
| 5260 | if ( |
||
| 5261 | self.GridPoints |
||
| 5262 | ): |
||
| 5263 | return True |
||
| 5264 | else: |
||
| 5265 | return False |
||
| 5266 | def export(self, outfile, level, namespaceprefix_='', namespacedef_='xmlns:pc="http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15"', name_='GridType', pretty_print=True): |
||
| 5267 | imported_ns_def_ = GenerateDSNamespaceDefs_.get('GridType') |
||
| 5268 | if imported_ns_def_ is not None: |
||
| 5269 | namespacedef_ = imported_ns_def_ |
||
| 5270 | if pretty_print: |
||
| 5271 | eol_ = '\n' |
||
| 5272 | else: |
||
| 5273 | eol_ = '' |
||
| 5274 | if self.original_tagname_ is not None and name_ == 'GridType': |
||
| 5275 | name_ = self.original_tagname_ |
||
| 5276 | if UseCapturedNS_ and self.ns_prefix_: |
||
| 5277 | namespaceprefix_ = self.ns_prefix_ + ':' |
||
| 5278 | showIndent(outfile, level, pretty_print) |
||
| 5279 | outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) |
||
| 5280 | already_processed = set() |
||
| 5281 | self.exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='GridType') |
||
| 5282 | if self.hasContent_(): |
||
| 5283 | outfile.write('>%s' % (eol_, )) |
||
| 5284 | self.exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='GridType', pretty_print=pretty_print) |
||
| 5285 | showIndent(outfile, level, pretty_print) |
||
| 5286 | outfile.write('</%s%s>%s' % (namespaceprefix_, name_, eol_)) |
||
| 5287 | else: |
||
| 5288 | outfile.write('/>%s' % (eol_, )) |
||
| 5289 | def exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='GridType'): |
||
| 5290 | pass |
||
| 5291 | 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): |
||
| 5292 | if pretty_print: |
||
| 5293 | eol_ = '\n' |
||
| 5294 | else: |
||
| 5295 | eol_ = '' |
||
| 5296 | for GridPoints_ in self.GridPoints: |
||
| 5297 | namespaceprefix_ = self.GridPoints_nsprefix_ + ':' if (UseCapturedNS_ and self.GridPoints_nsprefix_) else '' |
||
| 5298 | GridPoints_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='GridPoints', pretty_print=pretty_print) |
||
| 5299 | def to_etree(self, parent_element=None, name_='GridType', mapping_=None, nsmap_=None): |
||
| 5300 | if parent_element is None: |
||
| 5301 | element = etree_.Element('{http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15}' + name_, nsmap=nsmap_) |
||
| 5302 | else: |
||
| 5303 | element = etree_.SubElement(parent_element, '{http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15}' + name_, nsmap=nsmap_) |
||
| 5304 | for GridPoints_ in self.GridPoints: |
||
| 5305 | GridPoints_.to_etree(element, name_='GridPoints', mapping_=mapping_, nsmap_=nsmap_) |
||
| 5306 | if mapping_ is not None: |
||
| 5307 | mapping_[id(self)] = element |
||
| 5308 | return element |
||
| 5309 | def build(self, node, gds_collector_=None): |
||
| 5310 | self.gds_collector_ = gds_collector_ |
||
| 5311 | if SaveElementTreeNode: |
||
| 5312 | self.gds_elementtree_node_ = node |
||
| 5313 | already_processed = set() |
||
| 5314 | self.ns_prefix_ = node.prefix |
||
| 5315 | self.buildAttributes(node, node.attrib, already_processed) |
||
| 5316 | for child in node: |
||
| 5317 | nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] |
||
| 5318 | self.buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) |
||
| 5319 | return self |
||
| 5320 | def buildAttributes(self, node, attrs, already_processed): |
||
| 5321 | pass |
||
| 5322 | def buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None): |
||
| 5323 | if nodeName_ == 'GridPoints': |
||
| 5324 | obj_ = GridPointsType.factory(parent_object_=self) |
||
| 5325 | obj_.build(child_, gds_collector_=gds_collector_) |
||
| 5326 | self.GridPoints.append(obj_) |
||
| 5327 | obj_.original_tagname_ = 'GridPoints' |
||
| 5328 | def __hash__(self): |
||
| 5329 | return hash(self.id) |
||
| 5330 | # end class GridType |
||
| 5331 | |||
| 5332 | |||
| 5333 | class GridPointsType(GeneratedsSuper): |
||
| 5334 | """Points with x,y coordinates. |
||
| 5335 | The grid row index""" |
||
| 5336 | __hash__ = GeneratedsSuper.__hash__ |
||
| 5337 | member_data_items_ = [ |
||
| 5338 | MemberSpec_('index', 'int', 0, 0, {'use': 'required'}), |
||
| 5339 | MemberSpec_('points', 'pc:PointsType', 0, 0, {'use': 'required'}), |
||
| 5340 | ] |
||
| 5341 | subclass = None |
||
| 5342 | superclass = None |
||
| 5343 | def __init__(self, index=None, points=None, gds_collector_=None, **kwargs_): |
||
| 5344 | self.gds_collector_ = gds_collector_ |
||
| 5345 | self.gds_elementtree_node_ = None |
||
| 5346 | self.original_tagname_ = None |
||
| 5347 | self.parent_object_ = kwargs_.get('parent_object_') |
||
| 5348 | self.ns_prefix_ = None |
||
| 5349 | self.index = _cast(int, index) |
||
| 5350 | self.index_nsprefix_ = "pc" |
||
| 5351 | self.points = _cast(None, points) |
||
| 5352 | self.points_nsprefix_ = "pc" |
||
| 5353 | def factory(*args_, **kwargs_): |
||
| 5354 | if CurrentSubclassModule_ is not None: |
||
| 5355 | subclass = getSubclassFromModule_( |
||
| 5356 | CurrentSubclassModule_, GridPointsType) |
||
| 5357 | if subclass is not None: |
||
| 5358 | return subclass(*args_, **kwargs_) |
||
| 5359 | if GridPointsType.subclass: |
||
| 5360 | return GridPointsType.subclass(*args_, **kwargs_) |
||
| 5361 | else: |
||
| 5362 | return GridPointsType(*args_, **kwargs_) |
||
| 5363 | factory = staticmethod(factory) |
||
| 5364 | def get_ns_prefix_(self): |
||
| 5365 | return self.ns_prefix_ |
||
| 5366 | def set_ns_prefix_(self, ns_prefix): |
||
| 5367 | self.ns_prefix_ = ns_prefix |
||
| 5368 | def get_index(self): |
||
| 5369 | return self.index |
||
| 5370 | def set_index(self, index): |
||
| 5371 | self.index = index |
||
| 5372 | def get_points(self): |
||
| 5373 | return self.points |
||
| 5374 | def set_points(self, points): |
||
| 5375 | self.points = points |
||
| 5376 | View Code Duplication | def validate_PointsType(self, value): |
|
| 5377 | # Validate type pc:PointsType, a restriction on string. |
||
| 5378 | if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None: |
||
| 5379 | if not isinstance(value, str): |
||
| 5380 | lineno = self.gds_get_node_lineno_() |
||
| 5381 | self.gds_collector_.add_message('Value "%(value)s"%(lineno)s is not of the correct base simple type (str)' % {"value": value, "lineno": lineno, }) |
||
| 5382 | return False |
||
| 5383 | if not self.gds_validate_simple_patterns( |
||
| 5384 | self.validate_PointsType_patterns_, value): |
||
| 5385 | self.gds_collector_.add_message('Value "%s" does not match xsd pattern restrictions: %s' % (encode_str_2_3(value), self.validate_PointsType_patterns_, )) |
||
| 5386 | validate_PointsType_patterns_ = [['^(([0-9]+,[0-9]+ )+([0-9]+,[0-9]+))$']] |
||
| 5387 | def hasContent_(self): |
||
| 5388 | if ( |
||
| 5389 | |||
| 5390 | ): |
||
| 5391 | return True |
||
| 5392 | else: |
||
| 5393 | return False |
||
| 5394 | def export(self, outfile, level, namespaceprefix_='', namespacedef_='xmlns:pc="http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15"', name_='GridPointsType', pretty_print=True): |
||
| 5395 | imported_ns_def_ = GenerateDSNamespaceDefs_.get('GridPointsType') |
||
| 5396 | if imported_ns_def_ is not None: |
||
| 5397 | namespacedef_ = imported_ns_def_ |
||
| 5398 | if pretty_print: |
||
| 5399 | eol_ = '\n' |
||
| 5400 | else: |
||
| 5401 | eol_ = '' |
||
| 5402 | if self.original_tagname_ is not None and name_ == 'GridPointsType': |
||
| 5403 | name_ = self.original_tagname_ |
||
| 5404 | if UseCapturedNS_ and self.ns_prefix_: |
||
| 5405 | namespaceprefix_ = self.ns_prefix_ + ':' |
||
| 5406 | showIndent(outfile, level, pretty_print) |
||
| 5407 | outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) |
||
| 5408 | already_processed = set() |
||
| 5409 | self.exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='GridPointsType') |
||
| 5410 | if self.hasContent_(): |
||
| 5411 | outfile.write('>%s' % (eol_, )) |
||
| 5412 | self.exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='GridPointsType', pretty_print=pretty_print) |
||
| 5413 | outfile.write('</%s%s>%s' % (namespaceprefix_, name_, eol_)) |
||
| 5414 | else: |
||
| 5415 | outfile.write('/>%s' % (eol_, )) |
||
| 5416 | def exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='GridPointsType'): |
||
| 5417 | if self.index is not None and 'index' not in already_processed: |
||
| 5418 | already_processed.add('index') |
||
| 5419 | outfile.write(' index="%s"' % self.gds_format_integer(self.index, input_name='index')) |
||
| 5420 | if self.points is not None and 'points' not in already_processed: |
||
| 5421 | already_processed.add('points') |
||
| 5422 | outfile.write(' points=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.points), input_name='points')), )) |
||
| 5423 | def exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='xmlns:pc="http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15"', name_='GridPointsType', fromsubclass_=False, pretty_print=True): |
||
| 5424 | pass |
||
| 5425 | View Code Duplication | def to_etree(self, parent_element=None, name_='GridPointsType', mapping_=None, nsmap_=None): |
|
| 5426 | if parent_element is None: |
||
| 5427 | element = etree_.Element('{http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15}' + name_, nsmap=nsmap_) |
||
| 5428 | else: |
||
| 5429 | element = etree_.SubElement(parent_element, '{http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15}' + name_, nsmap=nsmap_) |
||
| 5430 | if self.index is not None: |
||
| 5431 | element.set('index', self.gds_format_integer(self.index)) |
||
| 5432 | if self.points is not None: |
||
| 5433 | element.set('points', self.gds_format_string(self.points)) |
||
| 5434 | if mapping_ is not None: |
||
| 5435 | mapping_[id(self)] = element |
||
| 5436 | return element |
||
| 5437 | def build(self, node, gds_collector_=None): |
||
| 5438 | self.gds_collector_ = gds_collector_ |
||
| 5439 | if SaveElementTreeNode: |
||
| 5440 | self.gds_elementtree_node_ = node |
||
| 5441 | already_processed = set() |
||
| 5442 | self.ns_prefix_ = node.prefix |
||
| 5443 | self.buildAttributes(node, node.attrib, already_processed) |
||
| 5444 | for child in node: |
||
| 5445 | nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] |
||
| 5446 | self.buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) |
||
| 5447 | return self |
||
| 5448 | def buildAttributes(self, node, attrs, already_processed): |
||
| 5449 | value = find_attr_value_('index', node) |
||
| 5450 | if value is not None and 'index' not in already_processed: |
||
| 5451 | already_processed.add('index') |
||
| 5452 | self.index = self.gds_parse_integer(value, node, 'index') |
||
| 5453 | value = find_attr_value_('points', node) |
||
| 5454 | if value is not None and 'points' not in already_processed: |
||
| 5455 | already_processed.add('points') |
||
| 5456 | self.points = value |
||
| 5457 | self.validate_PointsType(self.points) # validate type PointsType |
||
| 5458 | def buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None): |
||
| 5459 | pass |
||
| 5460 | def __hash__(self): |
||
| 5461 | return hash(self.id) |
||
| 5462 | # end class GridPointsType |
||
| 5463 | |||
| 5464 | |||
| 5465 | View Code Duplication | class PrintSpaceType(GeneratedsSuper): |
|
| 5466 | """Determines the effective area on the paper of a printed page. |
||
| 5467 | Its size is equal for all pages of a book |
||
| 5468 | (exceptions: titlepage, multipage pictures). |
||
| 5469 | It contains all living elements (except marginals) |
||
| 5470 | like body type, footnotes, headings, running titles. |
||
| 5471 | It does not contain pagenumber (if not part of running title), |
||
| 5472 | marginals, signature mark, preview words.""" |
||
| 5473 | __hash__ = GeneratedsSuper.__hash__ |
||
| 5474 | member_data_items_ = [ |
||
| 5475 | MemberSpec_('Coords', 'CoordsType', 0, 0, {'name': 'Coords', 'type': 'CoordsType'}, None), |
||
| 5476 | ] |
||
| 5477 | subclass = None |
||
| 5478 | superclass = None |
||
| 5479 | def __init__(self, Coords=None, gds_collector_=None, **kwargs_): |
||
| 5480 | self.gds_collector_ = gds_collector_ |
||
| 5481 | self.gds_elementtree_node_ = None |
||
| 5482 | self.original_tagname_ = None |
||
| 5483 | self.parent_object_ = kwargs_.get('parent_object_') |
||
| 5484 | self.ns_prefix_ = None |
||
| 5485 | self.Coords = Coords |
||
| 5486 | self.Coords_nsprefix_ = "pc" |
||
| 5487 | def factory(*args_, **kwargs_): |
||
| 5488 | if CurrentSubclassModule_ is not None: |
||
| 5489 | subclass = getSubclassFromModule_( |
||
| 5490 | CurrentSubclassModule_, PrintSpaceType) |
||
| 5491 | if subclass is not None: |
||
| 5492 | return subclass(*args_, **kwargs_) |
||
| 5493 | if PrintSpaceType.subclass: |
||
| 5494 | return PrintSpaceType.subclass(*args_, **kwargs_) |
||
| 5495 | else: |
||
| 5496 | return PrintSpaceType(*args_, **kwargs_) |
||
| 5497 | factory = staticmethod(factory) |
||
| 5498 | def get_ns_prefix_(self): |
||
| 5499 | return self.ns_prefix_ |
||
| 5500 | def set_ns_prefix_(self, ns_prefix): |
||
| 5501 | self.ns_prefix_ = ns_prefix |
||
| 5502 | def get_Coords(self): |
||
| 5503 | return self.Coords |
||
| 5504 | def set_Coords(self, Coords): |
||
| 5505 | self.Coords = Coords |
||
| 5506 | def hasContent_(self): |
||
| 5507 | if ( |
||
| 5508 | self.Coords is not None |
||
| 5509 | ): |
||
| 5510 | return True |
||
| 5511 | else: |
||
| 5512 | return False |
||
| 5513 | def export(self, outfile, level, namespaceprefix_='', namespacedef_='xmlns:pc="http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15"', name_='PrintSpaceType', pretty_print=True): |
||
| 5514 | imported_ns_def_ = GenerateDSNamespaceDefs_.get('PrintSpaceType') |
||
| 5515 | if imported_ns_def_ is not None: |
||
| 5516 | namespacedef_ = imported_ns_def_ |
||
| 5517 | if pretty_print: |
||
| 5518 | eol_ = '\n' |
||
| 5519 | else: |
||
| 5520 | eol_ = '' |
||
| 5521 | if self.original_tagname_ is not None and name_ == 'PrintSpaceType': |
||
| 5522 | name_ = self.original_tagname_ |
||
| 5523 | if UseCapturedNS_ and self.ns_prefix_: |
||
| 5524 | namespaceprefix_ = self.ns_prefix_ + ':' |
||
| 5525 | showIndent(outfile, level, pretty_print) |
||
| 5526 | outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) |
||
| 5527 | already_processed = set() |
||
| 5528 | self.exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='PrintSpaceType') |
||
| 5529 | if self.hasContent_(): |
||
| 5530 | outfile.write('>%s' % (eol_, )) |
||
| 5531 | self.exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='PrintSpaceType', pretty_print=pretty_print) |
||
| 5532 | showIndent(outfile, level, pretty_print) |
||
| 5533 | outfile.write('</%s%s>%s' % (namespaceprefix_, name_, eol_)) |
||
| 5534 | else: |
||
| 5535 | outfile.write('/>%s' % (eol_, )) |
||
| 5536 | def exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='PrintSpaceType'): |
||
| 5537 | pass |
||
| 5538 | def exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='xmlns:pc="http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15"', name_='PrintSpaceType', fromsubclass_=False, pretty_print=True): |
||
| 5539 | if pretty_print: |
||
| 5540 | eol_ = '\n' |
||
| 5541 | else: |
||
| 5542 | eol_ = '' |
||
| 5543 | if self.Coords is not None: |
||
| 5544 | namespaceprefix_ = self.Coords_nsprefix_ + ':' if (UseCapturedNS_ and self.Coords_nsprefix_) else '' |
||
| 5545 | self.Coords.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Coords', pretty_print=pretty_print) |
||
| 5546 | def to_etree(self, parent_element=None, name_='PrintSpaceType', mapping_=None, nsmap_=None): |
||
| 5547 | if parent_element is None: |
||
| 5548 | element = etree_.Element('{http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15}' + name_, nsmap=nsmap_) |
||
| 5549 | else: |
||
| 5550 | element = etree_.SubElement(parent_element, '{http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15}' + name_, nsmap=nsmap_) |
||
| 5551 | if self.Coords is not None: |
||
| 5552 | Coords_ = self.Coords |
||
| 5553 | Coords_.to_etree(element, name_='Coords', mapping_=mapping_, nsmap_=nsmap_) |
||
| 5554 | if mapping_ is not None: |
||
| 5555 | mapping_[id(self)] = element |
||
| 5556 | return element |
||
| 5557 | def build(self, node, gds_collector_=None): |
||
| 5558 | self.gds_collector_ = gds_collector_ |
||
| 5559 | if SaveElementTreeNode: |
||
| 5560 | self.gds_elementtree_node_ = node |
||
| 5561 | already_processed = set() |
||
| 5562 | self.ns_prefix_ = node.prefix |
||
| 5563 | self.buildAttributes(node, node.attrib, already_processed) |
||
| 5564 | for child in node: |
||
| 5565 | nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] |
||
| 5566 | self.buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) |
||
| 5567 | return self |
||
| 5568 | def buildAttributes(self, node, attrs, already_processed): |
||
| 5569 | pass |
||
| 5570 | def buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None): |
||
| 5571 | if nodeName_ == 'Coords': |
||
| 5572 | obj_ = CoordsType.factory(parent_object_=self) |
||
| 5573 | obj_.build(child_, gds_collector_=gds_collector_) |
||
| 5574 | self.Coords = obj_ |
||
| 5575 | obj_.original_tagname_ = 'Coords' |
||
| 5576 | def __hash__(self): |
||
| 5577 | return hash(self.id) |
||
| 5578 | # end class PrintSpaceType |
||
| 5579 | |||
| 5580 | |||
| 5581 | class ReadingOrderType(GeneratedsSuper): |
||
| 5582 | """Definition of the reading order within the page. |
||
| 5583 | To express a reading order between elements |
||
| 5584 | they have to be included in an OrderedGroup. |
||
| 5585 | Groups may contain further groups. |
||
| 5586 | Confidence value (between 0 and 1)""" |
||
| 5587 | __hash__ = GeneratedsSuper.__hash__ |
||
| 5588 | member_data_items_ = [ |
||
| 5589 | MemberSpec_('conf', 'pc:ConfSimpleType', 0, 1, {'use': 'optional'}), |
||
| 5590 | MemberSpec_('OrderedGroup', 'OrderedGroupType', 0, 0, {'name': 'OrderedGroup', 'type': 'OrderedGroupType'}, 2), |
||
| 5591 | MemberSpec_('UnorderedGroup', 'UnorderedGroupType', 0, 0, {'name': 'UnorderedGroup', 'type': 'UnorderedGroupType'}, 2), |
||
| 5592 | ] |
||
| 5593 | subclass = None |
||
| 5594 | superclass = None |
||
| 5595 | def __init__(self, conf=None, OrderedGroup=None, UnorderedGroup=None, gds_collector_=None, **kwargs_): |
||
| 5596 | self.gds_collector_ = gds_collector_ |
||
| 5597 | self.gds_elementtree_node_ = None |
||
| 5598 | self.original_tagname_ = None |
||
| 5599 | self.parent_object_ = kwargs_.get('parent_object_') |
||
| 5600 | self.ns_prefix_ = None |
||
| 5601 | self.conf = _cast(float, conf) |
||
| 5602 | self.conf_nsprefix_ = "pc" |
||
| 5603 | self.OrderedGroup = OrderedGroup |
||
| 5604 | self.OrderedGroup_nsprefix_ = "pc" |
||
| 5605 | self.UnorderedGroup = UnorderedGroup |
||
| 5606 | self.UnorderedGroup_nsprefix_ = "pc" |
||
| 5607 | def factory(*args_, **kwargs_): |
||
| 5608 | if CurrentSubclassModule_ is not None: |
||
| 5609 | subclass = getSubclassFromModule_( |
||
| 5610 | CurrentSubclassModule_, ReadingOrderType) |
||
| 5611 | if subclass is not None: |
||
| 5612 | return subclass(*args_, **kwargs_) |
||
| 5613 | if ReadingOrderType.subclass: |
||
| 5614 | return ReadingOrderType.subclass(*args_, **kwargs_) |
||
| 5615 | else: |
||
| 5616 | return ReadingOrderType(*args_, **kwargs_) |
||
| 5617 | factory = staticmethod(factory) |
||
| 5618 | def get_ns_prefix_(self): |
||
| 5619 | return self.ns_prefix_ |
||
| 5620 | def set_ns_prefix_(self, ns_prefix): |
||
| 5621 | self.ns_prefix_ = ns_prefix |
||
| 5622 | def get_OrderedGroup(self): |
||
| 5623 | return self.OrderedGroup |
||
| 5624 | def set_OrderedGroup(self, OrderedGroup): |
||
| 5625 | self.OrderedGroup = OrderedGroup |
||
| 5626 | def get_UnorderedGroup(self): |
||
| 5627 | return self.UnorderedGroup |
||
| 5628 | def set_UnorderedGroup(self, UnorderedGroup): |
||
| 5629 | self.UnorderedGroup = UnorderedGroup |
||
| 5630 | def get_conf(self): |
||
| 5631 | return self.conf |
||
| 5632 | def set_conf(self, conf): |
||
| 5633 | self.conf = conf |
||
| 5634 | View Code Duplication | def validate_ConfSimpleType(self, value): |
|
| 5635 | # Validate type pc:ConfSimpleType, a restriction on float. |
||
| 5636 | if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None: |
||
| 5637 | if not isinstance(value, float): |
||
| 5638 | lineno = self.gds_get_node_lineno_() |
||
| 5639 | self.gds_collector_.add_message('Value "%(value)s"%(lineno)s is not of the correct base simple type (float)' % {"value": value, "lineno": lineno, }) |
||
| 5640 | return False |
||
| 5641 | if value < 0: |
||
| 5642 | lineno = self.gds_get_node_lineno_() |
||
| 5643 | self.gds_collector_.add_message('Value "%(value)s"%(lineno)s does not match xsd minInclusive restriction on ConfSimpleType' % {"value": value, "lineno": lineno} ) |
||
| 5644 | result = False |
||
| 5645 | if value > 1: |
||
| 5646 | lineno = self.gds_get_node_lineno_() |
||
| 5647 | self.gds_collector_.add_message('Value "%(value)s"%(lineno)s does not match xsd maxInclusive restriction on ConfSimpleType' % {"value": value, "lineno": lineno} ) |
||
| 5648 | result = False |
||
| 5649 | def hasContent_(self): |
||
| 5650 | if ( |
||
| 5651 | self.OrderedGroup is not None or |
||
| 5652 | self.UnorderedGroup is not None |
||
| 5653 | ): |
||
| 5654 | return True |
||
| 5655 | else: |
||
| 5656 | return False |
||
| 5657 | def export(self, outfile, level, namespaceprefix_='', namespacedef_='xmlns:pc="http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15"', name_='ReadingOrderType', pretty_print=True): |
||
| 5658 | imported_ns_def_ = GenerateDSNamespaceDefs_.get('ReadingOrderType') |
||
| 5659 | if imported_ns_def_ is not None: |
||
| 5660 | namespacedef_ = imported_ns_def_ |
||
| 5661 | if pretty_print: |
||
| 5662 | eol_ = '\n' |
||
| 5663 | else: |
||
| 5664 | eol_ = '' |
||
| 5665 | if self.original_tagname_ is not None and name_ == 'ReadingOrderType': |
||
| 5666 | name_ = self.original_tagname_ |
||
| 5667 | if UseCapturedNS_ and self.ns_prefix_: |
||
| 5668 | namespaceprefix_ = self.ns_prefix_ + ':' |
||
| 5669 | showIndent(outfile, level, pretty_print) |
||
| 5670 | outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) |
||
| 5671 | already_processed = set() |
||
| 5672 | self.exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='ReadingOrderType') |
||
| 5673 | if self.hasContent_(): |
||
| 5674 | outfile.write('>%s' % (eol_, )) |
||
| 5675 | self.exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='ReadingOrderType', pretty_print=pretty_print) |
||
| 5676 | showIndent(outfile, level, pretty_print) |
||
| 5677 | outfile.write('</%s%s>%s' % (namespaceprefix_, name_, eol_)) |
||
| 5678 | else: |
||
| 5679 | outfile.write('/>%s' % (eol_, )) |
||
| 5680 | def exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='ReadingOrderType'): |
||
| 5681 | if self.conf is not None and 'conf' not in already_processed: |
||
| 5682 | already_processed.add('conf') |
||
| 5683 | outfile.write(' conf="%s"' % self.gds_format_float(self.conf, input_name='conf')) |
||
| 5684 | def exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='xmlns:pc="http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15"', name_='ReadingOrderType', fromsubclass_=False, pretty_print=True): |
||
| 5685 | if pretty_print: |
||
| 5686 | eol_ = '\n' |
||
| 5687 | else: |
||
| 5688 | eol_ = '' |
||
| 5689 | if self.OrderedGroup is not None: |
||
| 5690 | namespaceprefix_ = self.OrderedGroup_nsprefix_ + ':' if (UseCapturedNS_ and self.OrderedGroup_nsprefix_) else '' |
||
| 5691 | self.OrderedGroup.export(outfile, level, namespaceprefix_, namespacedef_='', name_='OrderedGroup', pretty_print=pretty_print) |
||
| 5692 | if self.UnorderedGroup is not None: |
||
| 5693 | namespaceprefix_ = self.UnorderedGroup_nsprefix_ + ':' if (UseCapturedNS_ and self.UnorderedGroup_nsprefix_) else '' |
||
| 5694 | self.UnorderedGroup.export(outfile, level, namespaceprefix_, namespacedef_='', name_='UnorderedGroup', pretty_print=pretty_print) |
||
| 5695 | def to_etree(self, parent_element=None, name_='ReadingOrderType', mapping_=None, nsmap_=None): |
||
| 5696 | if parent_element is None: |
||
| 5697 | element = etree_.Element('{http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15}' + name_, nsmap=nsmap_) |
||
| 5698 | else: |
||
| 5699 | element = etree_.SubElement(parent_element, '{http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15}' + name_, nsmap=nsmap_) |
||
| 5700 | if self.conf is not None: |
||
| 5701 | element.set('conf', self.gds_format_float(self.conf)) |
||
| 5702 | if self.OrderedGroup is not None: |
||
| 5703 | OrderedGroup_ = self.OrderedGroup |
||
| 5704 | OrderedGroup_.to_etree(element, name_='OrderedGroup', mapping_=mapping_, nsmap_=nsmap_) |
||
| 5705 | if self.UnorderedGroup is not None: |
||
| 5706 | UnorderedGroup_ = self.UnorderedGroup |
||
| 5707 | UnorderedGroup_.to_etree(element, name_='UnorderedGroup', mapping_=mapping_, nsmap_=nsmap_) |
||
| 5708 | if mapping_ is not None: |
||
| 5709 | mapping_[id(self)] = element |
||
| 5710 | return element |
||
| 5711 | def build(self, node, gds_collector_=None): |
||
| 5712 | self.gds_collector_ = gds_collector_ |
||
| 5713 | if SaveElementTreeNode: |
||
| 5714 | self.gds_elementtree_node_ = node |
||
| 5715 | already_processed = set() |
||
| 5716 | self.ns_prefix_ = node.prefix |
||
| 5717 | self.buildAttributes(node, node.attrib, already_processed) |
||
| 5718 | for child in node: |
||
| 5719 | nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] |
||
| 5720 | self.buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) |
||
| 5721 | return self |
||
| 5722 | def buildAttributes(self, node, attrs, already_processed): |
||
| 5723 | value = find_attr_value_('conf', node) |
||
| 5724 | if value is not None and 'conf' not in already_processed: |
||
| 5725 | already_processed.add('conf') |
||
| 5726 | value = self.gds_parse_float(value, node, 'conf') |
||
| 5727 | self.conf = value |
||
| 5728 | self.validate_ConfSimpleType(self.conf) # validate type ConfSimpleType |
||
| 5729 | def buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None): |
||
| 5730 | if nodeName_ == 'OrderedGroup': |
||
| 5731 | obj_ = OrderedGroupType.factory(parent_object_=self) |
||
| 5732 | obj_.build(child_, gds_collector_=gds_collector_) |
||
| 5733 | self.OrderedGroup = obj_ |
||
| 5734 | obj_.original_tagname_ = 'OrderedGroup' |
||
| 5735 | elif nodeName_ == 'UnorderedGroup': |
||
| 5736 | obj_ = UnorderedGroupType.factory(parent_object_=self) |
||
| 5737 | obj_.build(child_, gds_collector_=gds_collector_) |
||
| 5738 | self.UnorderedGroup = obj_ |
||
| 5739 | obj_.original_tagname_ = 'UnorderedGroup' |
||
| 5740 | def __hash__(self): |
||
| 5741 | return hash(self.id) |
||
| 5742 | # end class ReadingOrderType |
||
| 5743 | |||
| 5744 | |||
| 5745 | class RegionRefIndexedType(GeneratedsSuper): |
||
| 5746 | """Numbered regionPosition (order number) of this item within the current |
||
| 5747 | hierarchy level.""" |
||
| 5748 | __hash__ = GeneratedsSuper.__hash__ |
||
| 5749 | member_data_items_ = [ |
||
| 5750 | MemberSpec_('index', 'int', 0, 0, {'use': 'required'}), |
||
| 5751 | MemberSpec_('regionRef', 'string', 0, 0, {'use': 'required'}), |
||
| 5752 | ] |
||
| 5753 | subclass = None |
||
| 5754 | superclass = None |
||
| 5755 | def __init__(self, index=None, regionRef=None, gds_collector_=None, **kwargs_): |
||
| 5756 | self.gds_collector_ = gds_collector_ |
||
| 5757 | self.gds_elementtree_node_ = None |
||
| 5758 | self.original_tagname_ = None |
||
| 5759 | self.parent_object_ = kwargs_.get('parent_object_') |
||
| 5760 | self.ns_prefix_ = None |
||
| 5761 | self.index = _cast(int, index) |
||
| 5762 | self.index_nsprefix_ = "pc" |
||
| 5763 | self.regionRef = _cast(None, regionRef) |
||
| 5764 | self.regionRef_nsprefix_ = "pc" |
||
| 5765 | def factory(*args_, **kwargs_): |
||
| 5766 | if CurrentSubclassModule_ is not None: |
||
| 5767 | subclass = getSubclassFromModule_( |
||
| 5768 | CurrentSubclassModule_, RegionRefIndexedType) |
||
| 5769 | if subclass is not None: |
||
| 5770 | return subclass(*args_, **kwargs_) |
||
| 5771 | if RegionRefIndexedType.subclass: |
||
| 5772 | return RegionRefIndexedType.subclass(*args_, **kwargs_) |
||
| 5773 | else: |
||
| 5774 | return RegionRefIndexedType(*args_, **kwargs_) |
||
| 5775 | factory = staticmethod(factory) |
||
| 5776 | def get_ns_prefix_(self): |
||
| 5777 | return self.ns_prefix_ |
||
| 5778 | def set_ns_prefix_(self, ns_prefix): |
||
| 5779 | self.ns_prefix_ = ns_prefix |
||
| 5780 | def get_index(self): |
||
| 5781 | return self.index |
||
| 5782 | def set_index(self, index): |
||
| 5783 | self.index = index |
||
| 5784 | def get_regionRef(self): |
||
| 5785 | return self.regionRef |
||
| 5786 | def set_regionRef(self, regionRef): |
||
| 5787 | self.regionRef = regionRef |
||
| 5788 | def hasContent_(self): |
||
| 5789 | if ( |
||
| 5790 | |||
| 5791 | ): |
||
| 5792 | return True |
||
| 5793 | else: |
||
| 5794 | return False |
||
| 5795 | def export(self, outfile, level, namespaceprefix_='', namespacedef_='xmlns:pc="http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15"', name_='RegionRefIndexedType', pretty_print=True): |
||
| 5796 | imported_ns_def_ = GenerateDSNamespaceDefs_.get('RegionRefIndexedType') |
||
| 5797 | if imported_ns_def_ is not None: |
||
| 5798 | namespacedef_ = imported_ns_def_ |
||
| 5799 | if pretty_print: |
||
| 5800 | eol_ = '\n' |
||
| 5801 | else: |
||
| 5802 | eol_ = '' |
||
| 5803 | if self.original_tagname_ is not None and name_ == 'RegionRefIndexedType': |
||
| 5804 | name_ = self.original_tagname_ |
||
| 5805 | if UseCapturedNS_ and self.ns_prefix_: |
||
| 5806 | namespaceprefix_ = self.ns_prefix_ + ':' |
||
| 5807 | showIndent(outfile, level, pretty_print) |
||
| 5808 | outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) |
||
| 5809 | already_processed = set() |
||
| 5810 | self.exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='RegionRefIndexedType') |
||
| 5811 | if self.hasContent_(): |
||
| 5812 | outfile.write('>%s' % (eol_, )) |
||
| 5813 | self.exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='RegionRefIndexedType', pretty_print=pretty_print) |
||
| 5814 | outfile.write('</%s%s>%s' % (namespaceprefix_, name_, eol_)) |
||
| 5815 | else: |
||
| 5816 | outfile.write('/>%s' % (eol_, )) |
||
| 5817 | def exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='RegionRefIndexedType'): |
||
| 5818 | if self.index is not None and 'index' not in already_processed: |
||
| 5819 | already_processed.add('index') |
||
| 5820 | outfile.write(' index="%s"' % self.gds_format_integer(self.index, input_name='index')) |
||
| 5821 | if self.regionRef is not None and 'regionRef' not in already_processed: |
||
| 5822 | already_processed.add('regionRef') |
||
| 5823 | outfile.write(' regionRef=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.regionRef), input_name='regionRef')), )) |
||
| 5824 | def exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='xmlns:pc="http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15"', name_='RegionRefIndexedType', fromsubclass_=False, pretty_print=True): |
||
| 5825 | pass |
||
| 5826 | View Code Duplication | def to_etree(self, parent_element=None, name_='RegionRefIndexedType', mapping_=None, nsmap_=None): |
|
| 5827 | if parent_element is None: |
||
| 5828 | element = etree_.Element('{http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15}' + name_, nsmap=nsmap_) |
||
| 5829 | else: |
||
| 5830 | element = etree_.SubElement(parent_element, '{http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15}' + name_, nsmap=nsmap_) |
||
| 5831 | if self.index is not None: |
||
| 5832 | element.set('index', self.gds_format_integer(self.index)) |
||
| 5833 | if self.regionRef is not None: |
||
| 5834 | element.set('regionRef', self.gds_format_string(self.regionRef)) |
||
| 5835 | if mapping_ is not None: |
||
| 5836 | mapping_[id(self)] = element |
||
| 5837 | return element |
||
| 5838 | def build(self, node, gds_collector_=None): |
||
| 5839 | self.gds_collector_ = gds_collector_ |
||
| 5840 | if SaveElementTreeNode: |
||
| 5841 | self.gds_elementtree_node_ = node |
||
| 5842 | already_processed = set() |
||
| 5843 | self.ns_prefix_ = node.prefix |
||
| 5844 | self.buildAttributes(node, node.attrib, already_processed) |
||
| 5845 | for child in node: |
||
| 5846 | nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] |
||
| 5847 | self.buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) |
||
| 5848 | return self |
||
| 5849 | def buildAttributes(self, node, attrs, already_processed): |
||
| 5850 | value = find_attr_value_('index', node) |
||
| 5851 | if value is not None and 'index' not in already_processed: |
||
| 5852 | already_processed.add('index') |
||
| 5853 | self.index = self.gds_parse_integer(value, node, 'index') |
||
| 5854 | value = find_attr_value_('regionRef', node) |
||
| 5855 | if value is not None and 'regionRef' not in already_processed: |
||
| 5856 | already_processed.add('regionRef') |
||
| 5857 | self.regionRef = value |
||
| 5858 | def buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None): |
||
| 5859 | pass |
||
| 5860 | def __hash__(self): |
||
| 5861 | return hash(self.id) |
||
| 5862 | # end class RegionRefIndexedType |
||
| 5863 | |||
| 5864 | |||
| 5865 | class OrderedGroupIndexedType(GeneratedsSuper): |
||
| 5866 | """Indexed group containing ordered elements |
||
| 5867 | Optional link to a parent region of nested regions. |
||
| 5868 | The parent region doubles as reading order group. |
||
| 5869 | Only the nested regions should be allowed as group members. |
||
| 5870 | Position (order number) of this item within the |
||
| 5871 | current hierarchy level. |
||
| 5872 | Is this group a continuation of another group (from |
||
| 5873 | previous column or page, for example)? |
||
| 5874 | For generic use""" |
||
| 5875 | __hash__ = GeneratedsSuper.__hash__ |
||
| 5876 | member_data_items_ = [ |
||
| 5877 | MemberSpec_('id', 'string', 0, 0, {'use': 'required'}), |
||
| 5878 | MemberSpec_('regionRef', 'string', 0, 1, {'use': 'optional'}), |
||
| 5879 | MemberSpec_('index', 'int', 0, 0, {'use': 'required'}), |
||
| 5880 | MemberSpec_('caption', 'string', 0, 1, {'use': 'optional'}), |
||
| 5881 | MemberSpec_('type_', 'pc:GroupTypeSimpleType', 0, 1, {'use': 'optional'}), |
||
| 5882 | MemberSpec_('continuation', 'boolean', 0, 1, {'use': 'optional'}), |
||
| 5883 | MemberSpec_('custom', 'string', 0, 1, {'use': 'optional'}), |
||
| 5884 | MemberSpec_('comments', 'string', 0, 1, {'use': 'optional'}), |
||
| 5885 | MemberSpec_('UserDefined', 'UserDefinedType', 0, 1, {'maxOccurs': '1', 'minOccurs': '0', 'name': 'UserDefined', 'type': 'UserDefinedType'}, None), |
||
| 5886 | MemberSpec_('Labels', 'LabelsType', 1, 1, {'maxOccurs': 'unbounded', 'minOccurs': '0', 'name': 'Labels', 'type': 'LabelsType'}, None), |
||
| 5887 | MemberSpec_('RegionRefIndexed', 'RegionRefIndexedType', 1, 0, {'name': 'RegionRefIndexed', 'type': 'RegionRefIndexedType'}, 3), |
||
| 5888 | MemberSpec_('OrderedGroupIndexed', 'OrderedGroupIndexedType', 1, 0, {'name': 'OrderedGroupIndexed', 'type': 'OrderedGroupIndexedType'}, 3), |
||
| 5889 | MemberSpec_('UnorderedGroupIndexed', 'UnorderedGroupIndexedType', 1, 0, {'name': 'UnorderedGroupIndexed', 'type': 'UnorderedGroupIndexedType'}, 3), |
||
| 5890 | ] |
||
| 5891 | subclass = None |
||
| 5892 | superclass = None |
||
| 5893 | View Code Duplication | def __init__(self, id=None, regionRef=None, index=None, caption=None, type_=None, continuation=None, custom=None, comments=None, UserDefined=None, Labels=None, RegionRefIndexed=None, OrderedGroupIndexed=None, UnorderedGroupIndexed=None, gds_collector_=None, **kwargs_): |
|
| 5894 | self.gds_collector_ = gds_collector_ |
||
| 5895 | self.gds_elementtree_node_ = None |
||
| 5896 | self.original_tagname_ = None |
||
| 5897 | self.parent_object_ = kwargs_.get('parent_object_') |
||
| 5898 | self.ns_prefix_ = None |
||
| 5899 | self.id = _cast(None, id) |
||
| 5900 | self.id_nsprefix_ = "pc" |
||
| 5901 | self.regionRef = _cast(None, regionRef) |
||
| 5902 | self.regionRef_nsprefix_ = "pc" |
||
| 5903 | self.index = _cast(int, index) |
||
| 5904 | self.index_nsprefix_ = "pc" |
||
| 5905 | self.caption = _cast(None, caption) |
||
| 5906 | self.caption_nsprefix_ = "pc" |
||
| 5907 | self.type_ = _cast(None, type_) |
||
| 5908 | self.type__nsprefix_ = "pc" |
||
| 5909 | self.continuation = _cast(bool, continuation) |
||
| 5910 | self.continuation_nsprefix_ = "pc" |
||
| 5911 | self.custom = _cast(None, custom) |
||
| 5912 | self.custom_nsprefix_ = "pc" |
||
| 5913 | self.comments = _cast(None, comments) |
||
| 5914 | self.comments_nsprefix_ = "pc" |
||
| 5915 | self.UserDefined = UserDefined |
||
| 5916 | self.UserDefined_nsprefix_ = "pc" |
||
| 5917 | if Labels is None: |
||
| 5918 | self.Labels = [] |
||
| 5919 | else: |
||
| 5920 | self.Labels = Labels |
||
| 5921 | self.Labels_nsprefix_ = "pc" |
||
| 5922 | if RegionRefIndexed is None: |
||
| 5923 | self.RegionRefIndexed = [] |
||
| 5924 | else: |
||
| 5925 | self.RegionRefIndexed = RegionRefIndexed |
||
| 5926 | self.RegionRefIndexed_nsprefix_ = "pc" |
||
| 5927 | if OrderedGroupIndexed is None: |
||
| 5928 | self.OrderedGroupIndexed = [] |
||
| 5929 | else: |
||
| 5930 | self.OrderedGroupIndexed = OrderedGroupIndexed |
||
| 5931 | self.OrderedGroupIndexed_nsprefix_ = "pc" |
||
| 5932 | if UnorderedGroupIndexed is None: |
||
| 5933 | self.UnorderedGroupIndexed = [] |
||
| 5934 | else: |
||
| 5935 | self.UnorderedGroupIndexed = UnorderedGroupIndexed |
||
| 5936 | self.UnorderedGroupIndexed_nsprefix_ = "pc" |
||
| 5937 | def factory(*args_, **kwargs_): |
||
| 5938 | if CurrentSubclassModule_ is not None: |
||
| 5939 | subclass = getSubclassFromModule_( |
||
| 5940 | CurrentSubclassModule_, OrderedGroupIndexedType) |
||
| 5941 | if subclass is not None: |
||
| 5942 | return subclass(*args_, **kwargs_) |
||
| 5943 | if OrderedGroupIndexedType.subclass: |
||
| 5944 | return OrderedGroupIndexedType.subclass(*args_, **kwargs_) |
||
| 5945 | else: |
||
| 5946 | return OrderedGroupIndexedType(*args_, **kwargs_) |
||
| 5947 | factory = staticmethod(factory) |
||
| 5948 | def get_ns_prefix_(self): |
||
| 5949 | return self.ns_prefix_ |
||
| 5950 | def set_ns_prefix_(self, ns_prefix): |
||
| 5951 | self.ns_prefix_ = ns_prefix |
||
| 5952 | def get_UserDefined(self): |
||
| 5953 | return self.UserDefined |
||
| 5954 | def set_UserDefined(self, UserDefined): |
||
| 5955 | self.UserDefined = UserDefined |
||
| 5956 | def get_Labels(self): |
||
| 5957 | return self.Labels |
||
| 5958 | def set_Labels(self, Labels): |
||
| 5959 | self.Labels = Labels |
||
| 5960 | def add_Labels(self, value): |
||
| 5961 | self.Labels.append(value) |
||
| 5962 | def insert_Labels_at(self, index, value): |
||
| 5963 | self.Labels.insert(index, value) |
||
| 5964 | def replace_Labels_at(self, index, value): |
||
| 5965 | self.Labels[index] = value |
||
| 5966 | def get_RegionRefIndexed(self): |
||
| 5967 | return self.RegionRefIndexed |
||
| 5968 | def set_RegionRefIndexed(self, RegionRefIndexed): |
||
| 5969 | self.RegionRefIndexed = RegionRefIndexed |
||
| 5970 | def add_RegionRefIndexed(self, value): |
||
| 5971 | self.RegionRefIndexed.append(value) |
||
| 5972 | def insert_RegionRefIndexed_at(self, index, value): |
||
| 5973 | self.RegionRefIndexed.insert(index, value) |
||
| 5974 | def replace_RegionRefIndexed_at(self, index, value): |
||
| 5975 | self.RegionRefIndexed[index] = value |
||
| 5976 | def get_OrderedGroupIndexed(self): |
||
| 5977 | return self.OrderedGroupIndexed |
||
| 5978 | def set_OrderedGroupIndexed(self, OrderedGroupIndexed): |
||
| 5979 | self.OrderedGroupIndexed = OrderedGroupIndexed |
||
| 5980 | def add_OrderedGroupIndexed(self, value): |
||
| 5981 | self.OrderedGroupIndexed.append(value) |
||
| 5982 | def insert_OrderedGroupIndexed_at(self, index, value): |
||
| 5983 | self.OrderedGroupIndexed.insert(index, value) |
||
| 5984 | def replace_OrderedGroupIndexed_at(self, index, value): |
||
| 5985 | self.OrderedGroupIndexed[index] = value |
||
| 5986 | def get_UnorderedGroupIndexed(self): |
||
| 5987 | return self.UnorderedGroupIndexed |
||
| 5988 | def set_UnorderedGroupIndexed(self, UnorderedGroupIndexed): |
||
| 5989 | self.UnorderedGroupIndexed = UnorderedGroupIndexed |
||
| 5990 | def add_UnorderedGroupIndexed(self, value): |
||
| 5991 | self.UnorderedGroupIndexed.append(value) |
||
| 5992 | def insert_UnorderedGroupIndexed_at(self, index, value): |
||
| 5993 | self.UnorderedGroupIndexed.insert(index, value) |
||
| 5994 | def replace_UnorderedGroupIndexed_at(self, index, value): |
||
| 5995 | self.UnorderedGroupIndexed[index] = value |
||
| 5996 | def get_id(self): |
||
| 5997 | return self.id |
||
| 5998 | def set_id(self, id): |
||
| 5999 | self.id = id |
||
| 6000 | def get_regionRef(self): |
||
| 6001 | return self.regionRef |
||
| 6002 | def set_regionRef(self, regionRef): |
||
| 6003 | self.regionRef = regionRef |
||
| 6004 | def get_index(self): |
||
| 6005 | return self.index |
||
| 6006 | def set_index(self, index): |
||
| 6007 | self.index = index |
||
| 6008 | def get_caption(self): |
||
| 6009 | return self.caption |
||
| 6010 | def set_caption(self, caption): |
||
| 6011 | self.caption = caption |
||
| 6012 | def get_type(self): |
||
| 6013 | return self.type_ |
||
| 6014 | def set_type(self, type_): |
||
| 6015 | self.type_ = type_ |
||
| 6016 | def get_continuation(self): |
||
| 6017 | return self.continuation |
||
| 6018 | def set_continuation(self, continuation): |
||
| 6019 | self.continuation = continuation |
||
| 6020 | def get_custom(self): |
||
| 6021 | return self.custom |
||
| 6022 | def set_custom(self, custom): |
||
| 6023 | self.custom = custom |
||
| 6024 | def get_comments(self): |
||
| 6025 | return self.comments |
||
| 6026 | def set_comments(self, comments): |
||
| 6027 | self.comments = comments |
||
| 6028 | def validate_GroupTypeSimpleType(self, value): |
||
| 6029 | # Validate type pc:GroupTypeSimpleType, a restriction on string. |
||
| 6030 | if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None: |
||
| 6031 | if not isinstance(value, str): |
||
| 6032 | lineno = self.gds_get_node_lineno_() |
||
| 6033 | self.gds_collector_.add_message('Value "%(value)s"%(lineno)s is not of the correct base simple type (str)' % {"value": value, "lineno": lineno, }) |
||
| 6034 | return False |
||
| 6035 | value = value |
||
| 6036 | enumerations = ['paragraph', 'list', 'list-item', 'figure', 'article', 'div', 'other'] |
||
| 6037 | if value not in enumerations: |
||
| 6038 | lineno = self.gds_get_node_lineno_() |
||
| 6039 | self.gds_collector_.add_message('Value "%(value)s"%(lineno)s does not match xsd enumeration restriction on GroupTypeSimpleType' % {"value" : encode_str_2_3(value), "lineno": lineno} ) |
||
| 6040 | result = False |
||
| 6041 | def hasContent_(self): |
||
| 6042 | if ( |
||
| 6043 | self.UserDefined is not None or |
||
| 6044 | self.Labels or |
||
| 6045 | self.RegionRefIndexed or |
||
| 6046 | self.OrderedGroupIndexed or |
||
| 6047 | self.UnorderedGroupIndexed |
||
| 6048 | ): |
||
| 6049 | return True |
||
| 6050 | else: |
||
| 6051 | return False |
||
| 6052 | def export(self, outfile, level, namespaceprefix_='', namespacedef_='xmlns:pc="http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15"', name_='OrderedGroupIndexedType', pretty_print=True): |
||
| 6053 | imported_ns_def_ = GenerateDSNamespaceDefs_.get('OrderedGroupIndexedType') |
||
| 6054 | if imported_ns_def_ is not None: |
||
| 6055 | namespacedef_ = imported_ns_def_ |
||
| 6056 | if pretty_print: |
||
| 6057 | eol_ = '\n' |
||
| 6058 | else: |
||
| 6059 | eol_ = '' |
||
| 6060 | if self.original_tagname_ is not None and name_ == 'OrderedGroupIndexedType': |
||
| 6061 | name_ = self.original_tagname_ |
||
| 6062 | if UseCapturedNS_ and self.ns_prefix_: |
||
| 6063 | namespaceprefix_ = self.ns_prefix_ + ':' |
||
| 6064 | showIndent(outfile, level, pretty_print) |
||
| 6065 | outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) |
||
| 6066 | already_processed = set() |
||
| 6067 | self.exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='OrderedGroupIndexedType') |
||
| 6068 | if self.hasContent_(): |
||
| 6069 | outfile.write('>%s' % (eol_, )) |
||
| 6070 | self.exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='OrderedGroupIndexedType', pretty_print=pretty_print) |
||
| 6071 | showIndent(outfile, level, pretty_print) |
||
| 6072 | outfile.write('</%s%s>%s' % (namespaceprefix_, name_, eol_)) |
||
| 6073 | else: |
||
| 6074 | outfile.write('/>%s' % (eol_, )) |
||
| 6075 | View Code Duplication | def exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='OrderedGroupIndexedType'): |
|
| 6076 | if self.id is not None and 'id' not in already_processed: |
||
| 6077 | already_processed.add('id') |
||
| 6078 | outfile.write(' id=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.id), input_name='id')), )) |
||
| 6079 | if self.regionRef is not None and 'regionRef' not in already_processed: |
||
| 6080 | already_processed.add('regionRef') |
||
| 6081 | outfile.write(' regionRef=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.regionRef), input_name='regionRef')), )) |
||
| 6082 | if self.index is not None and 'index' not in already_processed: |
||
| 6083 | already_processed.add('index') |
||
| 6084 | outfile.write(' index="%s"' % self.gds_format_integer(self.index, input_name='index')) |
||
| 6085 | if self.caption is not None and 'caption' not in already_processed: |
||
| 6086 | already_processed.add('caption') |
||
| 6087 | outfile.write(' caption=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.caption), input_name='caption')), )) |
||
| 6088 | if self.type_ is not None and 'type_' not in already_processed: |
||
| 6089 | already_processed.add('type_') |
||
| 6090 | outfile.write(' type=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.type_), input_name='type')), )) |
||
| 6091 | if self.continuation is not None and 'continuation' not in already_processed: |
||
| 6092 | already_processed.add('continuation') |
||
| 6093 | outfile.write(' continuation="%s"' % self.gds_format_boolean(self.continuation, input_name='continuation')) |
||
| 6094 | if self.custom is not None and 'custom' not in already_processed: |
||
| 6095 | already_processed.add('custom') |
||
| 6096 | outfile.write(' custom=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.custom), input_name='custom')), )) |
||
| 6097 | if self.comments is not None and 'comments' not in already_processed: |
||
| 6098 | already_processed.add('comments') |
||
| 6099 | outfile.write(' comments=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.comments), input_name='comments')), )) |
||
| 6100 | View Code Duplication | def exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='xmlns:pc="http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15"', name_='OrderedGroupIndexedType', fromsubclass_=False, pretty_print=True): |
|
| 6101 | if pretty_print: |
||
| 6102 | eol_ = '\n' |
||
| 6103 | else: |
||
| 6104 | eol_ = '' |
||
| 6105 | if self.UserDefined is not None: |
||
| 6106 | namespaceprefix_ = self.UserDefined_nsprefix_ + ':' if (UseCapturedNS_ and self.UserDefined_nsprefix_) else '' |
||
| 6107 | self.UserDefined.export(outfile, level, namespaceprefix_, namespacedef_='', name_='UserDefined', pretty_print=pretty_print) |
||
| 6108 | for Labels_ in self.Labels: |
||
| 6109 | namespaceprefix_ = self.Labels_nsprefix_ + ':' if (UseCapturedNS_ and self.Labels_nsprefix_) else '' |
||
| 6110 | Labels_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Labels', pretty_print=pretty_print) |
||
| 6111 | for RegionRefIndexed_ in self.RegionRefIndexed: |
||
| 6112 | namespaceprefix_ = self.RegionRefIndexed_nsprefix_ + ':' if (UseCapturedNS_ and self.RegionRefIndexed_nsprefix_) else '' |
||
| 6113 | RegionRefIndexed_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='RegionRefIndexed', pretty_print=pretty_print) |
||
| 6114 | for OrderedGroupIndexed_ in self.OrderedGroupIndexed: |
||
| 6115 | namespaceprefix_ = self.OrderedGroupIndexed_nsprefix_ + ':' if (UseCapturedNS_ and self.OrderedGroupIndexed_nsprefix_) else '' |
||
| 6116 | OrderedGroupIndexed_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='OrderedGroupIndexed', pretty_print=pretty_print) |
||
| 6117 | for UnorderedGroupIndexed_ in self.UnorderedGroupIndexed: |
||
| 6118 | namespaceprefix_ = self.UnorderedGroupIndexed_nsprefix_ + ':' if (UseCapturedNS_ and self.UnorderedGroupIndexed_nsprefix_) else '' |
||
| 6119 | UnorderedGroupIndexed_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='UnorderedGroupIndexed', pretty_print=pretty_print) |
||
| 6120 | View Code Duplication | def to_etree(self, parent_element=None, name_='OrderedGroupIndexedType', mapping_=None, nsmap_=None): |
|
| 6121 | if parent_element is None: |
||
| 6122 | element = etree_.Element('{http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15}' + name_, nsmap=nsmap_) |
||
| 6123 | else: |
||
| 6124 | element = etree_.SubElement(parent_element, '{http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15}' + name_, nsmap=nsmap_) |
||
| 6125 | if self.id is not None: |
||
| 6126 | element.set('id', self.gds_format_string(self.id)) |
||
| 6127 | if self.regionRef is not None: |
||
| 6128 | element.set('regionRef', self.gds_format_string(self.regionRef)) |
||
| 6129 | if self.index is not None: |
||
| 6130 | element.set('index', self.gds_format_integer(self.index)) |
||
| 6131 | if self.caption is not None: |
||
| 6132 | element.set('caption', self.gds_format_string(self.caption)) |
||
| 6133 | if self.type_ is not None: |
||
| 6134 | element.set('type', self.gds_format_string(self.type_)) |
||
| 6135 | if self.continuation is not None: |
||
| 6136 | element.set('continuation', self.gds_format_boolean(self.continuation)) |
||
| 6137 | if self.custom is not None: |
||
| 6138 | element.set('custom', self.gds_format_string(self.custom)) |
||
| 6139 | if self.comments is not None: |
||
| 6140 | element.set('comments', self.gds_format_string(self.comments)) |
||
| 6141 | if self.UserDefined is not None: |
||
| 6142 | UserDefined_ = self.UserDefined |
||
| 6143 | UserDefined_.to_etree(element, name_='UserDefined', mapping_=mapping_, nsmap_=nsmap_) |
||
| 6144 | for Labels_ in self.Labels: |
||
| 6145 | Labels_.to_etree(element, name_='Labels', mapping_=mapping_, nsmap_=nsmap_) |
||
| 6146 | for RegionRefIndexed_ in self.RegionRefIndexed: |
||
| 6147 | RegionRefIndexed_.to_etree(element, name_='RegionRefIndexed', mapping_=mapping_, nsmap_=nsmap_) |
||
| 6148 | for OrderedGroupIndexed_ in self.OrderedGroupIndexed: |
||
| 6149 | OrderedGroupIndexed_.to_etree(element, name_='OrderedGroupIndexed', mapping_=mapping_, nsmap_=nsmap_) |
||
| 6150 | for UnorderedGroupIndexed_ in self.UnorderedGroupIndexed: |
||
| 6151 | UnorderedGroupIndexed_.to_etree(element, name_='UnorderedGroupIndexed', mapping_=mapping_, nsmap_=nsmap_) |
||
| 6152 | if mapping_ is not None: |
||
| 6153 | mapping_[id(self)] = element |
||
| 6154 | return element |
||
| 6155 | def build(self, node, gds_collector_=None): |
||
| 6156 | self.gds_collector_ = gds_collector_ |
||
| 6157 | if SaveElementTreeNode: |
||
| 6158 | self.gds_elementtree_node_ = node |
||
| 6159 | already_processed = set() |
||
| 6160 | self.ns_prefix_ = node.prefix |
||
| 6161 | self.buildAttributes(node, node.attrib, already_processed) |
||
| 6162 | for child in node: |
||
| 6163 | nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] |
||
| 6164 | self.buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) |
||
| 6165 | return self |
||
| 6166 | View Code Duplication | def buildAttributes(self, node, attrs, already_processed): |
|
| 6167 | value = find_attr_value_('id', node) |
||
| 6168 | if value is not None and 'id' not in already_processed: |
||
| 6169 | already_processed.add('id') |
||
| 6170 | self.id = value |
||
| 6171 | value = find_attr_value_('regionRef', node) |
||
| 6172 | if value is not None and 'regionRef' not in already_processed: |
||
| 6173 | already_processed.add('regionRef') |
||
| 6174 | self.regionRef = value |
||
| 6175 | value = find_attr_value_('index', node) |
||
| 6176 | if value is not None and 'index' not in already_processed: |
||
| 6177 | already_processed.add('index') |
||
| 6178 | self.index = self.gds_parse_integer(value, node, 'index') |
||
| 6179 | value = find_attr_value_('caption', node) |
||
| 6180 | if value is not None and 'caption' not in already_processed: |
||
| 6181 | already_processed.add('caption') |
||
| 6182 | self.caption = value |
||
| 6183 | value = find_attr_value_('type', node) |
||
| 6184 | if value is not None and 'type' not in already_processed: |
||
| 6185 | already_processed.add('type') |
||
| 6186 | self.type_ = value |
||
| 6187 | self.validate_GroupTypeSimpleType(self.type_) # validate type GroupTypeSimpleType |
||
| 6188 | value = find_attr_value_('continuation', node) |
||
| 6189 | if value is not None and 'continuation' not in already_processed: |
||
| 6190 | already_processed.add('continuation') |
||
| 6191 | if value in ('true', '1'): |
||
| 6192 | self.continuation = True |
||
| 6193 | elif value in ('false', '0'): |
||
| 6194 | self.continuation = False |
||
| 6195 | else: |
||
| 6196 | raise_parse_error(node, 'Bad boolean attribute') |
||
| 6197 | value = find_attr_value_('custom', node) |
||
| 6198 | if value is not None and 'custom' not in already_processed: |
||
| 6199 | already_processed.add('custom') |
||
| 6200 | self.custom = value |
||
| 6201 | value = find_attr_value_('comments', node) |
||
| 6202 | if value is not None and 'comments' not in already_processed: |
||
| 6203 | already_processed.add('comments') |
||
| 6204 | self.comments = value |
||
| 6205 | View Code Duplication | def buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None): |
|
| 6206 | if nodeName_ == 'UserDefined': |
||
| 6207 | obj_ = UserDefinedType.factory(parent_object_=self) |
||
| 6208 | obj_.build(child_, gds_collector_=gds_collector_) |
||
| 6209 | self.UserDefined = obj_ |
||
| 6210 | obj_.original_tagname_ = 'UserDefined' |
||
| 6211 | elif nodeName_ == 'Labels': |
||
| 6212 | obj_ = LabelsType.factory(parent_object_=self) |
||
| 6213 | obj_.build(child_, gds_collector_=gds_collector_) |
||
| 6214 | self.Labels.append(obj_) |
||
| 6215 | obj_.original_tagname_ = 'Labels' |
||
| 6216 | elif nodeName_ == 'RegionRefIndexed': |
||
| 6217 | obj_ = RegionRefIndexedType.factory(parent_object_=self) |
||
| 6218 | obj_.build(child_, gds_collector_=gds_collector_) |
||
| 6219 | self.RegionRefIndexed.append(obj_) |
||
| 6220 | obj_.original_tagname_ = 'RegionRefIndexed' |
||
| 6221 | elif nodeName_ == 'OrderedGroupIndexed': |
||
| 6222 | obj_ = OrderedGroupIndexedType.factory(parent_object_=self) |
||
| 6223 | obj_.build(child_, gds_collector_=gds_collector_) |
||
| 6224 | self.OrderedGroupIndexed.append(obj_) |
||
| 6225 | obj_.original_tagname_ = 'OrderedGroupIndexed' |
||
| 6226 | elif nodeName_ == 'UnorderedGroupIndexed': |
||
| 6227 | obj_ = UnorderedGroupIndexedType.factory(parent_object_=self) |
||
| 6228 | obj_.build(child_, gds_collector_=gds_collector_) |
||
| 6229 | self.UnorderedGroupIndexed.append(obj_) |
||
| 6230 | obj_.original_tagname_ = 'UnorderedGroupIndexed' |
||
| 6231 | def __hash__(self): |
||
| 6232 | return hash(self.id) |
||
| 6233 | # pylint: disable=invalid-name,missing-module-docstring,line-too-long |
||
| 6234 | View Code Duplication | def get_AllIndexed(self, classes=None, index_sort=True): |
|
| 6235 | """ |
||
| 6236 | Get all indexed children sorted by their ``@index``. |
||
| 6237 | |||
| 6238 | Arguments: |
||
| 6239 | classes (list): Type of children (sans ``Indexed``) to return. \ |
||
| 6240 | Default: ``['RegionRef', 'OrderedGroup', 'UnorderedGroup']`` |
||
| 6241 | index_sort (boolean): Whether to sort by ``@index`` |
||
| 6242 | |||
| 6243 | Returns: |
||
| 6244 | a list of :py:class:`RegionRefIndexedType`, \ |
||
| 6245 | :py:class:`OrderedGroupIndexedType`, and \ |
||
| 6246 | :py:class:`UnorderedGroupIndexedType` |
||
| 6247 | """ |
||
| 6248 | if not classes: |
||
| 6249 | classes = ['RegionRef', 'OrderedGroup', 'UnorderedGroup'] |
||
| 6250 | ret = [] |
||
| 6251 | for class_ in classes: |
||
| 6252 | ret += getattr(self, 'get_{}Indexed'.format(class_))() |
||
| 6253 | if index_sort: |
||
| 6254 | return sorted(ret, key=lambda x: x.index) |
||
| 6255 | return ret |
||
| 6256 | def clear_AllIndexed(self): |
||
| 6257 | ret = self.get_AllIndexed() |
||
| 6258 | self.set_RegionRefIndexed([]) |
||
| 6259 | self.set_OrderedGroupIndexed([]) |
||
| 6260 | self.set_UnorderedGroupIndexed([]) |
||
| 6261 | return ret |
||
| 6262 | |||
| 6263 | # pylint: disable=line-too-long,invalid-name,missing-module-docstring |
||
| 6264 | View Code Duplication | def extend_AllIndexed(self, elements, validate_continuity=False): |
|
| 6265 | """ |
||
| 6266 | Add all elements in list `elements`, respecting ``@index`` order. |
||
| 6267 | With `validate_continuity`, check that all new elements come after all old elements |
||
| 6268 | (or raise an exception). |
||
| 6269 | Otherwise, ensure this condition silently (by increasing ``@index`` accordingly). |
||
| 6270 | """ |
||
| 6271 | if not isinstance(elements, list): |
||
| 6272 | elements = [elements] |
||
| 6273 | siblings = self.get_AllIndexed() |
||
| 6274 | highest_sibling_index = siblings[-1].index if siblings else -1 |
||
| 6275 | if validate_continuity: |
||
| 6276 | elements = sorted(elements, key=lambda x: x.index) |
||
| 6277 | lowest_element_index = elements[0].index |
||
| 6278 | if lowest_element_index <= highest_sibling_index: |
||
| 6279 | raise Exception("@index already used: {}".format(lowest_element_index)) |
||
| 6280 | else: |
||
| 6281 | for element in elements: |
||
| 6282 | highest_sibling_index += 1 |
||
| 6283 | element.index = highest_sibling_index |
||
| 6284 | for element in elements: |
||
| 6285 | if isinstance(element, RegionRefIndexedType): # pylint: disable=undefined-variable |
||
| 6286 | self.add_RegionRefIndexed(element) |
||
| 6287 | elif isinstance(element, OrderedGroupIndexedType): # pylint: disable=undefined-variable |
||
| 6288 | self.add_OrderedGroupIndexed(element) |
||
| 6289 | elif isinstance(element, UnorderedGroupIndexedType): # pylint: disable=undefined-variable |
||
| 6290 | self.add_UnorderedGroupIndexed(element) |
||
| 6291 | return self.get_AllIndexed() |
||
| 6292 | # pylint: disable=line-too-long,invalid-name,missing-module-docstring |
||
| 6293 | View Code Duplication | def sort_AllIndexed(self, validate_uniqueness=True): |
|
| 6294 | """ |
||
| 6295 | Sort all indexed children in-place. |
||
| 6296 | """ |
||
| 6297 | elements = self.get_AllIndexed(index_sort=True) |
||
| 6298 | self.clear_AllIndexed() |
||
| 6299 | for element in elements: |
||
| 6300 | if isinstance(element, RegionRefIndexedType): # pylint: disable=undefined-variable |
||
| 6301 | self.add_RegionRefIndexed(element) |
||
| 6302 | elif isinstance(element, OrderedGroupIndexedType): # pylint: disable=undefined-variable |
||
| 6303 | self.add_OrderedGroupIndexed(element) |
||
| 6304 | elif isinstance(element, UnorderedGroupIndexedType): # pylint: disable=undefined-variable |
||
| 6305 | self.add_UnorderedGroupIndexed(element) |
||
| 6306 | return self.get_AllIndexed() |
||
| 6307 | |||
| 6308 | # pylint: disable=line-too-long,invalid-name,missing-module-docstring,missing-function-docstring |
||
| 6309 | View Code Duplication | def exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='xmlns:pc="http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15"', name_='OrderedGroupType', fromsubclass_=False, pretty_print=True): # pylint: disable=unused-argument,too-many-arguments |
|
| 6310 | namespaceprefix_ = 'pc:' |
||
| 6311 | if self.UserDefined is not None: |
||
| 6312 | self.UserDefined.export(outfile, level, namespaceprefix_, namespacedef_='', name_='UserDefined', pretty_print=pretty_print) |
||
| 6313 | for Labels_ in self.Labels: |
||
| 6314 | Labels_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Labels', pretty_print=pretty_print) |
||
| 6315 | cleaned = [] |
||
| 6316 | def replaceWithRRI(group): |
||
| 6317 | rri = RegionRefIndexedType.factory(parent_object_=self) # pylint: disable=undefined-variable |
||
| 6318 | rri.index = group.index |
||
| 6319 | rri.regionRef = group.regionRef |
||
| 6320 | cleaned.append(rri) |
||
| 6321 | # remove empty groups and replace with RegionRefIndexedType |
||
| 6322 | for entry in self.get_AllIndexed(): |
||
| 6323 | # pylint: disable=undefined-variable |
||
| 6324 | if isinstance(entry, (OrderedGroupIndexedType)) and not entry.get_AllIndexed(): |
||
| 6325 | replaceWithRRI(entry) |
||
| 6326 | elif isinstance(entry, UnorderedGroupIndexedType) and not entry.get_UnorderedGroupChildren(): |
||
| 6327 | replaceWithRRI(entry) |
||
| 6328 | else: |
||
| 6329 | cleaned.append(entry) |
||
| 6330 | for entry in cleaned: |
||
| 6331 | entry.export(outfile, level, namespaceprefix_, namespacedef_='', name_=entry.__class__.__name__[:-4], pretty_print=pretty_print) |
||
| 6332 | # end class OrderedGroupIndexedType |
||
| 6333 | |||
| 6334 | |||
| 6335 | class UnorderedGroupIndexedType(GeneratedsSuper): |
||
| 6336 | """Indexed group containing unordered elements |
||
| 6337 | Optional link to a parent region of nested regions. |
||
| 6338 | The parent region doubles as reading order group. |
||
| 6339 | Only the nested regions should be allowed as group members. |
||
| 6340 | Position (order number) of this item within the |
||
| 6341 | current hierarchy level. |
||
| 6342 | Is this group a continuation of another group |
||
| 6343 | (from previous column or page, for example)? |
||
| 6344 | For generic use""" |
||
| 6345 | __hash__ = GeneratedsSuper.__hash__ |
||
| 6346 | member_data_items_ = [ |
||
| 6347 | MemberSpec_('id', 'string', 0, 0, {'use': 'required'}), |
||
| 6348 | MemberSpec_('regionRef', 'string', 0, 1, {'use': 'optional'}), |
||
| 6349 | MemberSpec_('index', 'int', 0, 0, {'use': 'required'}), |
||
| 6350 | MemberSpec_('caption', 'string', 0, 1, {'use': 'optional'}), |
||
| 6351 | MemberSpec_('type_', 'pc:GroupTypeSimpleType', 0, 1, {'use': 'optional'}), |
||
| 6352 | MemberSpec_('continuation', 'boolean', 0, 1, {'use': 'optional'}), |
||
| 6353 | MemberSpec_('custom', 'string', 0, 1, {'use': 'optional'}), |
||
| 6354 | MemberSpec_('comments', 'string', 0, 1, {'use': 'optional'}), |
||
| 6355 | MemberSpec_('UserDefined', 'UserDefinedType', 0, 1, {'maxOccurs': '1', 'minOccurs': '0', 'name': 'UserDefined', 'type': 'UserDefinedType'}, None), |
||
| 6356 | MemberSpec_('Labels', 'LabelsType', 1, 1, {'maxOccurs': 'unbounded', 'minOccurs': '0', 'name': 'Labels', 'type': 'LabelsType'}, None), |
||
| 6357 | MemberSpec_('RegionRef', 'RegionRefType', 1, 0, {'name': 'RegionRef', 'type': 'RegionRefType'}, 4), |
||
| 6358 | MemberSpec_('OrderedGroup', 'OrderedGroupType', 1, 0, {'name': 'OrderedGroup', 'type': 'OrderedGroupType'}, 4), |
||
| 6359 | MemberSpec_('UnorderedGroup', 'UnorderedGroupType', 1, 0, {'name': 'UnorderedGroup', 'type': 'UnorderedGroupType'}, 4), |
||
| 6360 | ] |
||
| 6361 | subclass = None |
||
| 6362 | superclass = None |
||
| 6363 | def __init__(self, id=None, regionRef=None, index=None, caption=None, type_=None, continuation=None, custom=None, comments=None, UserDefined=None, Labels=None, RegionRef=None, OrderedGroup=None, UnorderedGroup=None, gds_collector_=None, **kwargs_): |
||
| 6364 | self.gds_collector_ = gds_collector_ |
||
| 6365 | self.gds_elementtree_node_ = None |
||
| 6366 | self.original_tagname_ = None |
||
| 6367 | self.parent_object_ = kwargs_.get('parent_object_') |
||
| 6368 | self.ns_prefix_ = None |
||
| 6369 | self.id = _cast(None, id) |
||
| 6370 | self.id_nsprefix_ = "pc" |
||
| 6371 | self.regionRef = _cast(None, regionRef) |
||
| 6372 | self.regionRef_nsprefix_ = "pc" |
||
| 6373 | self.index = _cast(int, index) |
||
| 6374 | self.index_nsprefix_ = "pc" |
||
| 6375 | self.caption = _cast(None, caption) |
||
| 6376 | self.caption_nsprefix_ = "pc" |
||
| 6377 | self.type_ = _cast(None, type_) |
||
| 6378 | self.type__nsprefix_ = "pc" |
||
| 6379 | self.continuation = _cast(bool, continuation) |
||
| 6380 | self.continuation_nsprefix_ = "pc" |
||
| 6381 | self.custom = _cast(None, custom) |
||
| 6382 | self.custom_nsprefix_ = "pc" |
||
| 6383 | self.comments = _cast(None, comments) |
||
| 6384 | self.comments_nsprefix_ = "pc" |
||
| 6385 | self.UserDefined = UserDefined |
||
| 6386 | self.UserDefined_nsprefix_ = "pc" |
||
| 6387 | if Labels is None: |
||
| 6388 | self.Labels = [] |
||
| 6389 | else: |
||
| 6390 | self.Labels = Labels |
||
| 6391 | self.Labels_nsprefix_ = "pc" |
||
| 6392 | if RegionRef is None: |
||
| 6393 | self.RegionRef = [] |
||
| 6394 | else: |
||
| 6395 | self.RegionRef = RegionRef |
||
| 6396 | self.RegionRef_nsprefix_ = "pc" |
||
| 6397 | if OrderedGroup is None: |
||
| 6398 | self.OrderedGroup = [] |
||
| 6399 | else: |
||
| 6400 | self.OrderedGroup = OrderedGroup |
||
| 6401 | self.OrderedGroup_nsprefix_ = "pc" |
||
| 6402 | if UnorderedGroup is None: |
||
| 6403 | self.UnorderedGroup = [] |
||
| 6404 | else: |
||
| 6405 | self.UnorderedGroup = UnorderedGroup |
||
| 6406 | self.UnorderedGroup_nsprefix_ = "pc" |
||
| 6407 | def factory(*args_, **kwargs_): |
||
| 6408 | if CurrentSubclassModule_ is not None: |
||
| 6409 | subclass = getSubclassFromModule_( |
||
| 6410 | CurrentSubclassModule_, UnorderedGroupIndexedType) |
||
| 6411 | if subclass is not None: |
||
| 6412 | return subclass(*args_, **kwargs_) |
||
| 6413 | if UnorderedGroupIndexedType.subclass: |
||
| 6414 | return UnorderedGroupIndexedType.subclass(*args_, **kwargs_) |
||
| 6415 | else: |
||
| 6416 | return UnorderedGroupIndexedType(*args_, **kwargs_) |
||
| 6417 | factory = staticmethod(factory) |
||
| 6418 | def get_ns_prefix_(self): |
||
| 6419 | return self.ns_prefix_ |
||
| 6420 | def set_ns_prefix_(self, ns_prefix): |
||
| 6421 | self.ns_prefix_ = ns_prefix |
||
| 6422 | def get_UserDefined(self): |
||
| 6423 | return self.UserDefined |
||
| 6424 | def set_UserDefined(self, UserDefined): |
||
| 6425 | self.UserDefined = UserDefined |
||
| 6426 | def get_Labels(self): |
||
| 6427 | return self.Labels |
||
| 6428 | def set_Labels(self, Labels): |
||
| 6429 | self.Labels = Labels |
||
| 6430 | def add_Labels(self, value): |
||
| 6431 | self.Labels.append(value) |
||
| 6432 | def insert_Labels_at(self, index, value): |
||
| 6433 | self.Labels.insert(index, value) |
||
| 6434 | def replace_Labels_at(self, index, value): |
||
| 6435 | self.Labels[index] = value |
||
| 6436 | def get_RegionRef(self): |
||
| 6437 | return self.RegionRef |
||
| 6438 | def set_RegionRef(self, RegionRef): |
||
| 6439 | self.RegionRef = RegionRef |
||
| 6440 | def add_RegionRef(self, value): |
||
| 6441 | self.RegionRef.append(value) |
||
| 6442 | def insert_RegionRef_at(self, index, value): |
||
| 6443 | self.RegionRef.insert(index, value) |
||
| 6444 | def replace_RegionRef_at(self, index, value): |
||
| 6445 | self.RegionRef[index] = value |
||
| 6446 | def get_OrderedGroup(self): |
||
| 6447 | return self.OrderedGroup |
||
| 6448 | def set_OrderedGroup(self, OrderedGroup): |
||
| 6449 | self.OrderedGroup = OrderedGroup |
||
| 6450 | def add_OrderedGroup(self, value): |
||
| 6451 | self.OrderedGroup.append(value) |
||
| 6452 | def insert_OrderedGroup_at(self, index, value): |
||
| 6453 | self.OrderedGroup.insert(index, value) |
||
| 6454 | def replace_OrderedGroup_at(self, index, value): |
||
| 6455 | self.OrderedGroup[index] = value |
||
| 6456 | def get_UnorderedGroup(self): |
||
| 6457 | return self.UnorderedGroup |
||
| 6458 | def set_UnorderedGroup(self, UnorderedGroup): |
||
| 6459 | self.UnorderedGroup = UnorderedGroup |
||
| 6460 | def add_UnorderedGroup(self, value): |
||
| 6461 | self.UnorderedGroup.append(value) |
||
| 6462 | def insert_UnorderedGroup_at(self, index, value): |
||
| 6463 | self.UnorderedGroup.insert(index, value) |
||
| 6464 | def replace_UnorderedGroup_at(self, index, value): |
||
| 6465 | self.UnorderedGroup[index] = value |
||
| 6466 | def get_id(self): |
||
| 6467 | return self.id |
||
| 6468 | def set_id(self, id): |
||
| 6469 | self.id = id |
||
| 6470 | def get_regionRef(self): |
||
| 6471 | return self.regionRef |
||
| 6472 | def set_regionRef(self, regionRef): |
||
| 6473 | self.regionRef = regionRef |
||
| 6474 | def get_index(self): |
||
| 6475 | return self.index |
||
| 6476 | def set_index(self, index): |
||
| 6477 | self.index = index |
||
| 6478 | def get_caption(self): |
||
| 6479 | return self.caption |
||
| 6480 | def set_caption(self, caption): |
||
| 6481 | self.caption = caption |
||
| 6482 | def get_type(self): |
||
| 6483 | return self.type_ |
||
| 6484 | def set_type(self, type_): |
||
| 6485 | self.type_ = type_ |
||
| 6486 | def get_continuation(self): |
||
| 6487 | return self.continuation |
||
| 6488 | def set_continuation(self, continuation): |
||
| 6489 | self.continuation = continuation |
||
| 6490 | def get_custom(self): |
||
| 6491 | return self.custom |
||
| 6492 | def set_custom(self, custom): |
||
| 6493 | self.custom = custom |
||
| 6494 | def get_comments(self): |
||
| 6495 | return self.comments |
||
| 6496 | def set_comments(self, comments): |
||
| 6497 | self.comments = comments |
||
| 6498 | def validate_GroupTypeSimpleType(self, value): |
||
| 6499 | # Validate type pc:GroupTypeSimpleType, a restriction on string. |
||
| 6500 | if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None: |
||
| 6501 | if not isinstance(value, str): |
||
| 6502 | lineno = self.gds_get_node_lineno_() |
||
| 6503 | self.gds_collector_.add_message('Value "%(value)s"%(lineno)s is not of the correct base simple type (str)' % {"value": value, "lineno": lineno, }) |
||
| 6504 | return False |
||
| 6505 | value = value |
||
| 6506 | enumerations = ['paragraph', 'list', 'list-item', 'figure', 'article', 'div', 'other'] |
||
| 6507 | if value not in enumerations: |
||
| 6508 | lineno = self.gds_get_node_lineno_() |
||
| 6509 | self.gds_collector_.add_message('Value "%(value)s"%(lineno)s does not match xsd enumeration restriction on GroupTypeSimpleType' % {"value" : encode_str_2_3(value), "lineno": lineno} ) |
||
| 6510 | result = False |
||
| 6511 | def hasContent_(self): |
||
| 6512 | if ( |
||
| 6513 | self.UserDefined is not None or |
||
| 6514 | self.Labels or |
||
| 6515 | self.RegionRef or |
||
| 6516 | self.OrderedGroup or |
||
| 6517 | self.UnorderedGroup |
||
| 6518 | ): |
||
| 6519 | return True |
||
| 6520 | else: |
||
| 6521 | return False |
||
| 6522 | def export(self, outfile, level, namespaceprefix_='', namespacedef_='xmlns:pc="http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15"', name_='UnorderedGroupIndexedType', pretty_print=True): |
||
| 6523 | imported_ns_def_ = GenerateDSNamespaceDefs_.get('UnorderedGroupIndexedType') |
||
| 6524 | if imported_ns_def_ is not None: |
||
| 6525 | namespacedef_ = imported_ns_def_ |
||
| 6526 | if pretty_print: |
||
| 6527 | eol_ = '\n' |
||
| 6528 | else: |
||
| 6529 | eol_ = '' |
||
| 6530 | if self.original_tagname_ is not None and name_ == 'UnorderedGroupIndexedType': |
||
| 6531 | name_ = self.original_tagname_ |
||
| 6532 | if UseCapturedNS_ and self.ns_prefix_: |
||
| 6533 | namespaceprefix_ = self.ns_prefix_ + ':' |
||
| 6534 | showIndent(outfile, level, pretty_print) |
||
| 6535 | outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) |
||
| 6536 | already_processed = set() |
||
| 6537 | self.exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='UnorderedGroupIndexedType') |
||
| 6538 | if self.hasContent_(): |
||
| 6539 | outfile.write('>%s' % (eol_, )) |
||
| 6540 | self.exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='UnorderedGroupIndexedType', pretty_print=pretty_print) |
||
| 6541 | showIndent(outfile, level, pretty_print) |
||
| 6542 | outfile.write('</%s%s>%s' % (namespaceprefix_, name_, eol_)) |
||
| 6543 | else: |
||
| 6544 | outfile.write('/>%s' % (eol_, )) |
||
| 6545 | View Code Duplication | def exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='UnorderedGroupIndexedType'): |
|
| 6546 | if self.id is not None and 'id' not in already_processed: |
||
| 6547 | already_processed.add('id') |
||
| 6548 | outfile.write(' id=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.id), input_name='id')), )) |
||
| 6549 | if self.regionRef is not None and 'regionRef' not in already_processed: |
||
| 6550 | already_processed.add('regionRef') |
||
| 6551 | outfile.write(' regionRef=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.regionRef), input_name='regionRef')), )) |
||
| 6552 | if self.index is not None and 'index' not in already_processed: |
||
| 6553 | already_processed.add('index') |
||
| 6554 | outfile.write(' index="%s"' % self.gds_format_integer(self.index, input_name='index')) |
||
| 6555 | if self.caption is not None and 'caption' not in already_processed: |
||
| 6556 | already_processed.add('caption') |
||
| 6557 | outfile.write(' caption=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.caption), input_name='caption')), )) |
||
| 6558 | if self.type_ is not None and 'type_' not in already_processed: |
||
| 6559 | already_processed.add('type_') |
||
| 6560 | outfile.write(' type=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.type_), input_name='type')), )) |
||
| 6561 | if self.continuation is not None and 'continuation' not in already_processed: |
||
| 6562 | already_processed.add('continuation') |
||
| 6563 | outfile.write(' continuation="%s"' % self.gds_format_boolean(self.continuation, input_name='continuation')) |
||
| 6564 | if self.custom is not None and 'custom' not in already_processed: |
||
| 6565 | already_processed.add('custom') |
||
| 6566 | outfile.write(' custom=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.custom), input_name='custom')), )) |
||
| 6567 | if self.comments is not None and 'comments' not in already_processed: |
||
| 6568 | already_processed.add('comments') |
||
| 6569 | outfile.write(' comments=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.comments), input_name='comments')), )) |
||
| 6570 | View Code Duplication | def exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='xmlns:pc="http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15"', name_='UnorderedGroupIndexedType', fromsubclass_=False, pretty_print=True): |
|
| 6571 | if pretty_print: |
||
| 6572 | eol_ = '\n' |
||
| 6573 | else: |
||
| 6574 | eol_ = '' |
||
| 6575 | if self.UserDefined is not None: |
||
| 6576 | namespaceprefix_ = self.UserDefined_nsprefix_ + ':' if (UseCapturedNS_ and self.UserDefined_nsprefix_) else '' |
||
| 6577 | self.UserDefined.export(outfile, level, namespaceprefix_, namespacedef_='', name_='UserDefined', pretty_print=pretty_print) |
||
| 6578 | for Labels_ in self.Labels: |
||
| 6579 | namespaceprefix_ = self.Labels_nsprefix_ + ':' if (UseCapturedNS_ and self.Labels_nsprefix_) else '' |
||
| 6580 | Labels_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Labels', pretty_print=pretty_print) |
||
| 6581 | for RegionRef_ in self.RegionRef: |
||
| 6582 | namespaceprefix_ = self.RegionRef_nsprefix_ + ':' if (UseCapturedNS_ and self.RegionRef_nsprefix_) else '' |
||
| 6583 | RegionRef_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='RegionRef', pretty_print=pretty_print) |
||
| 6584 | for OrderedGroup_ in self.OrderedGroup: |
||
| 6585 | namespaceprefix_ = self.OrderedGroup_nsprefix_ + ':' if (UseCapturedNS_ and self.OrderedGroup_nsprefix_) else '' |
||
| 6586 | OrderedGroup_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='OrderedGroup', pretty_print=pretty_print) |
||
| 6587 | for UnorderedGroup_ in self.UnorderedGroup: |
||
| 6588 | namespaceprefix_ = self.UnorderedGroup_nsprefix_ + ':' if (UseCapturedNS_ and self.UnorderedGroup_nsprefix_) else '' |
||
| 6589 | UnorderedGroup_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='UnorderedGroup', pretty_print=pretty_print) |
||
| 6590 | View Code Duplication | def to_etree(self, parent_element=None, name_='UnorderedGroupIndexedType', mapping_=None, nsmap_=None): |
|
| 6591 | if parent_element is None: |
||
| 6592 | element = etree_.Element('{http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15}' + name_, nsmap=nsmap_) |
||
| 6593 | else: |
||
| 6594 | element = etree_.SubElement(parent_element, '{http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15}' + name_, nsmap=nsmap_) |
||
| 6595 | if self.id is not None: |
||
| 6596 | element.set('id', self.gds_format_string(self.id)) |
||
| 6597 | if self.regionRef is not None: |
||
| 6598 | element.set('regionRef', self.gds_format_string(self.regionRef)) |
||
| 6599 | if self.index is not None: |
||
| 6600 | element.set('index', self.gds_format_integer(self.index)) |
||
| 6601 | if self.caption is not None: |
||
| 6602 | element.set('caption', self.gds_format_string(self.caption)) |
||
| 6603 | if self.type_ is not None: |
||
| 6604 | element.set('type', self.gds_format_string(self.type_)) |
||
| 6605 | if self.continuation is not None: |
||
| 6606 | element.set('continuation', self.gds_format_boolean(self.continuation)) |
||
| 6607 | if self.custom is not None: |
||
| 6608 | element.set('custom', self.gds_format_string(self.custom)) |
||
| 6609 | if self.comments is not None: |
||
| 6610 | element.set('comments', self.gds_format_string(self.comments)) |
||
| 6611 | if self.UserDefined is not None: |
||
| 6612 | UserDefined_ = self.UserDefined |
||
| 6613 | UserDefined_.to_etree(element, name_='UserDefined', mapping_=mapping_, nsmap_=nsmap_) |
||
| 6614 | for Labels_ in self.Labels: |
||
| 6615 | Labels_.to_etree(element, name_='Labels', mapping_=mapping_, nsmap_=nsmap_) |
||
| 6616 | for RegionRef_ in self.RegionRef: |
||
| 6617 | RegionRef_.to_etree(element, name_='RegionRef', mapping_=mapping_, nsmap_=nsmap_) |
||
| 6618 | for OrderedGroup_ in self.OrderedGroup: |
||
| 6619 | OrderedGroup_.to_etree(element, name_='OrderedGroup', mapping_=mapping_, nsmap_=nsmap_) |
||
| 6620 | for UnorderedGroup_ in self.UnorderedGroup: |
||
| 6621 | UnorderedGroup_.to_etree(element, name_='UnorderedGroup', mapping_=mapping_, nsmap_=nsmap_) |
||
| 6622 | if mapping_ is not None: |
||
| 6623 | mapping_[id(self)] = element |
||
| 6624 | return element |
||
| 6625 | def build(self, node, gds_collector_=None): |
||
| 6626 | self.gds_collector_ = gds_collector_ |
||
| 6627 | if SaveElementTreeNode: |
||
| 6628 | self.gds_elementtree_node_ = node |
||
| 6629 | already_processed = set() |
||
| 6630 | self.ns_prefix_ = node.prefix |
||
| 6631 | self.buildAttributes(node, node.attrib, already_processed) |
||
| 6632 | for child in node: |
||
| 6633 | nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] |
||
| 6634 | self.buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) |
||
| 6635 | return self |
||
| 6636 | View Code Duplication | def buildAttributes(self, node, attrs, already_processed): |
|
| 6637 | value = find_attr_value_('id', node) |
||
| 6638 | if value is not None and 'id' not in already_processed: |
||
| 6639 | already_processed.add('id') |
||
| 6640 | self.id = value |
||
| 6641 | value = find_attr_value_('regionRef', node) |
||
| 6642 | if value is not None and 'regionRef' not in already_processed: |
||
| 6643 | already_processed.add('regionRef') |
||
| 6644 | self.regionRef = value |
||
| 6645 | value = find_attr_value_('index', node) |
||
| 6646 | if value is not None and 'index' not in already_processed: |
||
| 6647 | already_processed.add('index') |
||
| 6648 | self.index = self.gds_parse_integer(value, node, 'index') |
||
| 6649 | value = find_attr_value_('caption', node) |
||
| 6650 | if value is not None and 'caption' not in already_processed: |
||
| 6651 | already_processed.add('caption') |
||
| 6652 | self.caption = value |
||
| 6653 | value = find_attr_value_('type', node) |
||
| 6654 | if value is not None and 'type' not in already_processed: |
||
| 6655 | already_processed.add('type') |
||
| 6656 | self.type_ = value |
||
| 6657 | self.validate_GroupTypeSimpleType(self.type_) # validate type GroupTypeSimpleType |
||
| 6658 | value = find_attr_value_('continuation', node) |
||
| 6659 | if value is not None and 'continuation' not in already_processed: |
||
| 6660 | already_processed.add('continuation') |
||
| 6661 | if value in ('true', '1'): |
||
| 6662 | self.continuation = True |
||
| 6663 | elif value in ('false', '0'): |
||
| 6664 | self.continuation = False |
||
| 6665 | else: |
||
| 6666 | raise_parse_error(node, 'Bad boolean attribute') |
||
| 6667 | value = find_attr_value_('custom', node) |
||
| 6668 | if value is not None and 'custom' not in already_processed: |
||
| 6669 | already_processed.add('custom') |
||
| 6670 | self.custom = value |
||
| 6671 | value = find_attr_value_('comments', node) |
||
| 6672 | if value is not None and 'comments' not in already_processed: |
||
| 6673 | already_processed.add('comments') |
||
| 6674 | self.comments = value |
||
| 6675 | View Code Duplication | def buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None): |
|
| 6676 | if nodeName_ == 'UserDefined': |
||
| 6677 | obj_ = UserDefinedType.factory(parent_object_=self) |
||
| 6678 | obj_.build(child_, gds_collector_=gds_collector_) |
||
| 6679 | self.UserDefined = obj_ |
||
| 6680 | obj_.original_tagname_ = 'UserDefined' |
||
| 6681 | elif nodeName_ == 'Labels': |
||
| 6682 | obj_ = LabelsType.factory(parent_object_=self) |
||
| 6683 | obj_.build(child_, gds_collector_=gds_collector_) |
||
| 6684 | self.Labels.append(obj_) |
||
| 6685 | obj_.original_tagname_ = 'Labels' |
||
| 6686 | elif nodeName_ == 'RegionRef': |
||
| 6687 | obj_ = RegionRefType.factory(parent_object_=self) |
||
| 6688 | obj_.build(child_, gds_collector_=gds_collector_) |
||
| 6689 | self.RegionRef.append(obj_) |
||
| 6690 | obj_.original_tagname_ = 'RegionRef' |
||
| 6691 | elif nodeName_ == 'OrderedGroup': |
||
| 6692 | obj_ = OrderedGroupType.factory(parent_object_=self) |
||
| 6693 | obj_.build(child_, gds_collector_=gds_collector_) |
||
| 6694 | self.OrderedGroup.append(obj_) |
||
| 6695 | obj_.original_tagname_ = 'OrderedGroup' |
||
| 6696 | elif nodeName_ == 'UnorderedGroup': |
||
| 6697 | obj_ = UnorderedGroupType.factory(parent_object_=self) |
||
| 6698 | obj_.build(child_, gds_collector_=gds_collector_) |
||
| 6699 | self.UnorderedGroup.append(obj_) |
||
| 6700 | obj_.original_tagname_ = 'UnorderedGroup' |
||
| 6701 | def __hash__(self): |
||
| 6702 | return hash(self.id) |
||
| 6703 | def get_UnorderedGroupChildren(self): |
||
| 6704 | """ |
||
| 6705 | List all non-metadata children of an :py:class:`UnorderedGroupType` |
||
| 6706 | """ |
||
| 6707 | # TODO: should not change order |
||
| 6708 | return self.get_RegionRef() + self.get_OrderedGroup() + self.get_UnorderedGroup() |
||
| 6709 | |||
| 6710 | # end class UnorderedGroupIndexedType |
||
| 6711 | |||
| 6712 | |||
| 6713 | class RegionRefType(GeneratedsSuper): |
||
| 6714 | __hash__ = GeneratedsSuper.__hash__ |
||
| 6715 | member_data_items_ = [ |
||
| 6716 | MemberSpec_('regionRef', 'string', 0, 0, {'use': 'required'}), |
||
| 6717 | ] |
||
| 6718 | subclass = None |
||
| 6719 | superclass = None |
||
| 6720 | def __init__(self, regionRef=None, gds_collector_=None, **kwargs_): |
||
| 6721 | self.gds_collector_ = gds_collector_ |
||
| 6722 | self.gds_elementtree_node_ = None |
||
| 6723 | self.original_tagname_ = None |
||
| 6724 | self.parent_object_ = kwargs_.get('parent_object_') |
||
| 6725 | self.ns_prefix_ = None |
||
| 6726 | self.regionRef = _cast(None, regionRef) |
||
| 6727 | self.regionRef_nsprefix_ = "pc" |
||
| 6728 | def factory(*args_, **kwargs_): |
||
| 6729 | if CurrentSubclassModule_ is not None: |
||
| 6730 | subclass = getSubclassFromModule_( |
||
| 6731 | CurrentSubclassModule_, RegionRefType) |
||
| 6732 | if subclass is not None: |
||
| 6733 | return subclass(*args_, **kwargs_) |
||
| 6734 | if RegionRefType.subclass: |
||
| 6735 | return RegionRefType.subclass(*args_, **kwargs_) |
||
| 6736 | else: |
||
| 6737 | return RegionRefType(*args_, **kwargs_) |
||
| 6738 | factory = staticmethod(factory) |
||
| 6739 | def get_ns_prefix_(self): |
||
| 6740 | return self.ns_prefix_ |
||
| 6741 | def set_ns_prefix_(self, ns_prefix): |
||
| 6742 | self.ns_prefix_ = ns_prefix |
||
| 6743 | def get_regionRef(self): |
||
| 6744 | return self.regionRef |
||
| 6745 | def set_regionRef(self, regionRef): |
||
| 6746 | self.regionRef = regionRef |
||
| 6747 | def hasContent_(self): |
||
| 6748 | if ( |
||
| 6749 | |||
| 6750 | ): |
||
| 6751 | return True |
||
| 6752 | else: |
||
| 6753 | return False |
||
| 6754 | def export(self, outfile, level, namespaceprefix_='', namespacedef_='xmlns:pc="http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15"', name_='RegionRefType', pretty_print=True): |
||
| 6755 | imported_ns_def_ = GenerateDSNamespaceDefs_.get('RegionRefType') |
||
| 6756 | if imported_ns_def_ is not None: |
||
| 6757 | namespacedef_ = imported_ns_def_ |
||
| 6758 | if pretty_print: |
||
| 6759 | eol_ = '\n' |
||
| 6760 | else: |
||
| 6761 | eol_ = '' |
||
| 6762 | if self.original_tagname_ is not None and name_ == 'RegionRefType': |
||
| 6763 | name_ = self.original_tagname_ |
||
| 6764 | if UseCapturedNS_ and self.ns_prefix_: |
||
| 6765 | namespaceprefix_ = self.ns_prefix_ + ':' |
||
| 6766 | showIndent(outfile, level, pretty_print) |
||
| 6767 | outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) |
||
| 6768 | already_processed = set() |
||
| 6769 | self.exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='RegionRefType') |
||
| 6770 | if self.hasContent_(): |
||
| 6771 | outfile.write('>%s' % (eol_, )) |
||
| 6772 | self.exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='RegionRefType', pretty_print=pretty_print) |
||
| 6773 | outfile.write('</%s%s>%s' % (namespaceprefix_, name_, eol_)) |
||
| 6774 | else: |
||
| 6775 | outfile.write('/>%s' % (eol_, )) |
||
| 6776 | def exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='RegionRefType'): |
||
| 6777 | if self.regionRef is not None and 'regionRef' not in already_processed: |
||
| 6778 | already_processed.add('regionRef') |
||
| 6779 | outfile.write(' regionRef=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.regionRef), input_name='regionRef')), )) |
||
| 6780 | def exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='xmlns:pc="http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15"', name_='RegionRefType', fromsubclass_=False, pretty_print=True): |
||
| 6781 | pass |
||
| 6782 | def to_etree(self, parent_element=None, name_='RegionRefType', mapping_=None, nsmap_=None): |
||
| 6783 | if parent_element is None: |
||
| 6784 | element = etree_.Element('{http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15}' + name_, nsmap=nsmap_) |
||
| 6785 | else: |
||
| 6786 | element = etree_.SubElement(parent_element, '{http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15}' + name_, nsmap=nsmap_) |
||
| 6787 | if self.regionRef is not None: |
||
| 6788 | element.set('regionRef', self.gds_format_string(self.regionRef)) |
||
| 6789 | if mapping_ is not None: |
||
| 6790 | mapping_[id(self)] = element |
||
| 6791 | return element |
||
| 6792 | def build(self, node, gds_collector_=None): |
||
| 6793 | self.gds_collector_ = gds_collector_ |
||
| 6794 | if SaveElementTreeNode: |
||
| 6795 | self.gds_elementtree_node_ = node |
||
| 6796 | already_processed = set() |
||
| 6797 | self.ns_prefix_ = node.prefix |
||
| 6798 | self.buildAttributes(node, node.attrib, already_processed) |
||
| 6799 | for child in node: |
||
| 6800 | nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] |
||
| 6801 | self.buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) |
||
| 6802 | return self |
||
| 6803 | def buildAttributes(self, node, attrs, already_processed): |
||
| 6804 | value = find_attr_value_('regionRef', node) |
||
| 6805 | if value is not None and 'regionRef' not in already_processed: |
||
| 6806 | already_processed.add('regionRef') |
||
| 6807 | self.regionRef = value |
||
| 6808 | def buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None): |
||
| 6809 | pass |
||
| 6810 | def __hash__(self): |
||
| 6811 | return hash(self.id) |
||
| 6812 | # end class RegionRefType |
||
| 6813 | |||
| 6814 | |||
| 6815 | class OrderedGroupType(GeneratedsSuper): |
||
| 6816 | """Numbered group (contains ordered elements) |
||
| 6817 | Optional link to a parent region of nested regions. |
||
| 6818 | The parent region doubles as reading order group. |
||
| 6819 | Only the nested regions should be allowed as group members. |
||
| 6820 | Is this group a continuation of another group |
||
| 6821 | (from previous column or page, for example)? |
||
| 6822 | For generic use""" |
||
| 6823 | __hash__ = GeneratedsSuper.__hash__ |
||
| 6824 | member_data_items_ = [ |
||
| 6825 | MemberSpec_('id', 'string', 0, 0, {'use': 'required'}), |
||
| 6826 | MemberSpec_('regionRef', 'string', 0, 1, {'use': 'optional'}), |
||
| 6827 | MemberSpec_('caption', 'string', 0, 1, {'use': 'optional'}), |
||
| 6828 | MemberSpec_('type_', 'pc:GroupTypeSimpleType', 0, 1, {'use': 'optional'}), |
||
| 6829 | MemberSpec_('continuation', 'boolean', 0, 1, {'use': 'optional'}), |
||
| 6830 | MemberSpec_('custom', 'string', 0, 1, {'use': 'optional'}), |
||
| 6831 | MemberSpec_('comments', 'string', 0, 1, {'use': 'optional'}), |
||
| 6832 | MemberSpec_('UserDefined', 'UserDefinedType', 0, 1, {'maxOccurs': '1', 'minOccurs': '0', 'name': 'UserDefined', 'type': 'UserDefinedType'}, None), |
||
| 6833 | MemberSpec_('Labels', 'LabelsType', 1, 1, {'maxOccurs': 'unbounded', 'minOccurs': '0', 'name': 'Labels', 'type': 'LabelsType'}, None), |
||
| 6834 | MemberSpec_('RegionRefIndexed', 'RegionRefIndexedType', 1, 0, {'name': 'RegionRefIndexed', 'type': 'RegionRefIndexedType'}, 5), |
||
| 6835 | MemberSpec_('OrderedGroupIndexed', 'OrderedGroupIndexedType', 1, 0, {'name': 'OrderedGroupIndexed', 'type': 'OrderedGroupIndexedType'}, 5), |
||
| 6836 | MemberSpec_('UnorderedGroupIndexed', 'UnorderedGroupIndexedType', 1, 0, {'name': 'UnorderedGroupIndexed', 'type': 'UnorderedGroupIndexedType'}, 5), |
||
| 6837 | ] |
||
| 6838 | subclass = None |
||
| 6839 | superclass = None |
||
| 6840 | View Code Duplication | def __init__(self, id=None, regionRef=None, caption=None, type_=None, continuation=None, custom=None, comments=None, UserDefined=None, Labels=None, RegionRefIndexed=None, OrderedGroupIndexed=None, UnorderedGroupIndexed=None, gds_collector_=None, **kwargs_): |
|
| 6841 | self.gds_collector_ = gds_collector_ |
||
| 6842 | self.gds_elementtree_node_ = None |
||
| 6843 | self.original_tagname_ = None |
||
| 6844 | self.parent_object_ = kwargs_.get('parent_object_') |
||
| 6845 | self.ns_prefix_ = None |
||
| 6846 | self.id = _cast(None, id) |
||
| 6847 | self.id_nsprefix_ = "pc" |
||
| 6848 | self.regionRef = _cast(None, regionRef) |
||
| 6849 | self.regionRef_nsprefix_ = "pc" |
||
| 6850 | self.caption = _cast(None, caption) |
||
| 6851 | self.caption_nsprefix_ = "pc" |
||
| 6852 | self.type_ = _cast(None, type_) |
||
| 6853 | self.type__nsprefix_ = "pc" |
||
| 6854 | self.continuation = _cast(bool, continuation) |
||
| 6855 | self.continuation_nsprefix_ = "pc" |
||
| 6856 | self.custom = _cast(None, custom) |
||
| 6857 | self.custom_nsprefix_ = "pc" |
||
| 6858 | self.comments = _cast(None, comments) |
||
| 6859 | self.comments_nsprefix_ = "pc" |
||
| 6860 | self.UserDefined = UserDefined |
||
| 6861 | self.UserDefined_nsprefix_ = "pc" |
||
| 6862 | if Labels is None: |
||
| 6863 | self.Labels = [] |
||
| 6864 | else: |
||
| 6865 | self.Labels = Labels |
||
| 6866 | self.Labels_nsprefix_ = "pc" |
||
| 6867 | if RegionRefIndexed is None: |
||
| 6868 | self.RegionRefIndexed = [] |
||
| 6869 | else: |
||
| 6870 | self.RegionRefIndexed = RegionRefIndexed |
||
| 6871 | self.RegionRefIndexed_nsprefix_ = "pc" |
||
| 6872 | if OrderedGroupIndexed is None: |
||
| 6873 | self.OrderedGroupIndexed = [] |
||
| 6874 | else: |
||
| 6875 | self.OrderedGroupIndexed = OrderedGroupIndexed |
||
| 6876 | self.OrderedGroupIndexed_nsprefix_ = "pc" |
||
| 6877 | if UnorderedGroupIndexed is None: |
||
| 6878 | self.UnorderedGroupIndexed = [] |
||
| 6879 | else: |
||
| 6880 | self.UnorderedGroupIndexed = UnorderedGroupIndexed |
||
| 6881 | self.UnorderedGroupIndexed_nsprefix_ = "pc" |
||
| 6882 | def factory(*args_, **kwargs_): |
||
| 6883 | if CurrentSubclassModule_ is not None: |
||
| 6884 | subclass = getSubclassFromModule_( |
||
| 6885 | CurrentSubclassModule_, OrderedGroupType) |
||
| 6886 | if subclass is not None: |
||
| 6887 | return subclass(*args_, **kwargs_) |
||
| 6888 | if OrderedGroupType.subclass: |
||
| 6889 | return OrderedGroupType.subclass(*args_, **kwargs_) |
||
| 6890 | else: |
||
| 6891 | return OrderedGroupType(*args_, **kwargs_) |
||
| 6892 | factory = staticmethod(factory) |
||
| 6893 | def get_ns_prefix_(self): |
||
| 6894 | return self.ns_prefix_ |
||
| 6895 | def set_ns_prefix_(self, ns_prefix): |
||
| 6896 | self.ns_prefix_ = ns_prefix |
||
| 6897 | def get_UserDefined(self): |
||
| 6898 | return self.UserDefined |
||
| 6899 | def set_UserDefined(self, UserDefined): |
||
| 6900 | self.UserDefined = UserDefined |
||
| 6901 | def get_Labels(self): |
||
| 6902 | return self.Labels |
||
| 6903 | def set_Labels(self, Labels): |
||
| 6904 | self.Labels = Labels |
||
| 6905 | def add_Labels(self, value): |
||
| 6906 | self.Labels.append(value) |
||
| 6907 | def insert_Labels_at(self, index, value): |
||
| 6908 | self.Labels.insert(index, value) |
||
| 6909 | def replace_Labels_at(self, index, value): |
||
| 6910 | self.Labels[index] = value |
||
| 6911 | def get_RegionRefIndexed(self): |
||
| 6912 | return self.RegionRefIndexed |
||
| 6913 | def set_RegionRefIndexed(self, RegionRefIndexed): |
||
| 6914 | self.RegionRefIndexed = RegionRefIndexed |
||
| 6915 | def add_RegionRefIndexed(self, value): |
||
| 6916 | self.RegionRefIndexed.append(value) |
||
| 6917 | def insert_RegionRefIndexed_at(self, index, value): |
||
| 6918 | self.RegionRefIndexed.insert(index, value) |
||
| 6919 | def replace_RegionRefIndexed_at(self, index, value): |
||
| 6920 | self.RegionRefIndexed[index] = value |
||
| 6921 | def get_OrderedGroupIndexed(self): |
||
| 6922 | return self.OrderedGroupIndexed |
||
| 6923 | def set_OrderedGroupIndexed(self, OrderedGroupIndexed): |
||
| 6924 | self.OrderedGroupIndexed = OrderedGroupIndexed |
||
| 6925 | def add_OrderedGroupIndexed(self, value): |
||
| 6926 | self.OrderedGroupIndexed.append(value) |
||
| 6927 | def insert_OrderedGroupIndexed_at(self, index, value): |
||
| 6928 | self.OrderedGroupIndexed.insert(index, value) |
||
| 6929 | def replace_OrderedGroupIndexed_at(self, index, value): |
||
| 6930 | self.OrderedGroupIndexed[index] = value |
||
| 6931 | def get_UnorderedGroupIndexed(self): |
||
| 6932 | return self.UnorderedGroupIndexed |
||
| 6933 | def set_UnorderedGroupIndexed(self, UnorderedGroupIndexed): |
||
| 6934 | self.UnorderedGroupIndexed = UnorderedGroupIndexed |
||
| 6935 | def add_UnorderedGroupIndexed(self, value): |
||
| 6936 | self.UnorderedGroupIndexed.append(value) |
||
| 6937 | def insert_UnorderedGroupIndexed_at(self, index, value): |
||
| 6938 | self.UnorderedGroupIndexed.insert(index, value) |
||
| 6939 | def replace_UnorderedGroupIndexed_at(self, index, value): |
||
| 6940 | self.UnorderedGroupIndexed[index] = value |
||
| 6941 | def get_id(self): |
||
| 6942 | return self.id |
||
| 6943 | def set_id(self, id): |
||
| 6944 | self.id = id |
||
| 6945 | def get_regionRef(self): |
||
| 6946 | return self.regionRef |
||
| 6947 | def set_regionRef(self, regionRef): |
||
| 6948 | self.regionRef = regionRef |
||
| 6949 | def get_caption(self): |
||
| 6950 | return self.caption |
||
| 6951 | def set_caption(self, caption): |
||
| 6952 | self.caption = caption |
||
| 6953 | def get_type(self): |
||
| 6954 | return self.type_ |
||
| 6955 | def set_type(self, type_): |
||
| 6956 | self.type_ = type_ |
||
| 6957 | def get_continuation(self): |
||
| 6958 | return self.continuation |
||
| 6959 | def set_continuation(self, continuation): |
||
| 6960 | self.continuation = continuation |
||
| 6961 | def get_custom(self): |
||
| 6962 | return self.custom |
||
| 6963 | def set_custom(self, custom): |
||
| 6964 | self.custom = custom |
||
| 6965 | def get_comments(self): |
||
| 6966 | return self.comments |
||
| 6967 | def set_comments(self, comments): |
||
| 6968 | self.comments = comments |
||
| 6969 | def validate_GroupTypeSimpleType(self, value): |
||
| 6970 | # Validate type pc:GroupTypeSimpleType, a restriction on string. |
||
| 6971 | if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None: |
||
| 6972 | if not isinstance(value, str): |
||
| 6973 | lineno = self.gds_get_node_lineno_() |
||
| 6974 | self.gds_collector_.add_message('Value "%(value)s"%(lineno)s is not of the correct base simple type (str)' % {"value": value, "lineno": lineno, }) |
||
| 6975 | return False |
||
| 6976 | value = value |
||
| 6977 | enumerations = ['paragraph', 'list', 'list-item', 'figure', 'article', 'div', 'other'] |
||
| 6978 | if value not in enumerations: |
||
| 6979 | lineno = self.gds_get_node_lineno_() |
||
| 6980 | self.gds_collector_.add_message('Value "%(value)s"%(lineno)s does not match xsd enumeration restriction on GroupTypeSimpleType' % {"value" : encode_str_2_3(value), "lineno": lineno} ) |
||
| 6981 | result = False |
||
| 6982 | def hasContent_(self): |
||
| 6983 | if ( |
||
| 6984 | self.UserDefined is not None or |
||
| 6985 | self.Labels or |
||
| 6986 | self.RegionRefIndexed or |
||
| 6987 | self.OrderedGroupIndexed or |
||
| 6988 | self.UnorderedGroupIndexed |
||
| 6989 | ): |
||
| 6990 | return True |
||
| 6991 | else: |
||
| 6992 | return False |
||
| 6993 | def export(self, outfile, level, namespaceprefix_='', namespacedef_='xmlns:pc="http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15"', name_='OrderedGroupType', pretty_print=True): |
||
| 6994 | imported_ns_def_ = GenerateDSNamespaceDefs_.get('OrderedGroupType') |
||
| 6995 | if imported_ns_def_ is not None: |
||
| 6996 | namespacedef_ = imported_ns_def_ |
||
| 6997 | if pretty_print: |
||
| 6998 | eol_ = '\n' |
||
| 6999 | else: |
||
| 7000 | eol_ = '' |
||
| 7001 | if self.original_tagname_ is not None and name_ == 'OrderedGroupType': |
||
| 7002 | name_ = self.original_tagname_ |
||
| 7003 | if UseCapturedNS_ and self.ns_prefix_: |
||
| 7004 | namespaceprefix_ = self.ns_prefix_ + ':' |
||
| 7005 | showIndent(outfile, level, pretty_print) |
||
| 7006 | outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) |
||
| 7007 | already_processed = set() |
||
| 7008 | self.exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='OrderedGroupType') |
||
| 7009 | if self.hasContent_(): |
||
| 7010 | outfile.write('>%s' % (eol_, )) |
||
| 7011 | self.exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='OrderedGroupType', pretty_print=pretty_print) |
||
| 7012 | showIndent(outfile, level, pretty_print) |
||
| 7013 | outfile.write('</%s%s>%s' % (namespaceprefix_, name_, eol_)) |
||
| 7014 | else: |
||
| 7015 | outfile.write('/>%s' % (eol_, )) |
||
| 7016 | View Code Duplication | def exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='OrderedGroupType'): |
|
| 7017 | if self.id is not None and 'id' not in already_processed: |
||
| 7018 | already_processed.add('id') |
||
| 7019 | outfile.write(' id=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.id), input_name='id')), )) |
||
| 7020 | if self.regionRef is not None and 'regionRef' not in already_processed: |
||
| 7021 | already_processed.add('regionRef') |
||
| 7022 | outfile.write(' regionRef=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.regionRef), input_name='regionRef')), )) |
||
| 7023 | if self.caption is not None and 'caption' not in already_processed: |
||
| 7024 | already_processed.add('caption') |
||
| 7025 | outfile.write(' caption=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.caption), input_name='caption')), )) |
||
| 7026 | if self.type_ is not None and 'type_' not in already_processed: |
||
| 7027 | already_processed.add('type_') |
||
| 7028 | outfile.write(' type=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.type_), input_name='type')), )) |
||
| 7029 | if self.continuation is not None and 'continuation' not in already_processed: |
||
| 7030 | already_processed.add('continuation') |
||
| 7031 | outfile.write(' continuation="%s"' % self.gds_format_boolean(self.continuation, input_name='continuation')) |
||
| 7032 | if self.custom is not None and 'custom' not in already_processed: |
||
| 7033 | already_processed.add('custom') |
||
| 7034 | outfile.write(' custom=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.custom), input_name='custom')), )) |
||
| 7035 | if self.comments is not None and 'comments' not in already_processed: |
||
| 7036 | already_processed.add('comments') |
||
| 7037 | outfile.write(' comments=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.comments), input_name='comments')), )) |
||
| 7038 | View Code Duplication | def exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='xmlns:pc="http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15"', name_='OrderedGroupType', fromsubclass_=False, pretty_print=True): |
|
| 7039 | if pretty_print: |
||
| 7040 | eol_ = '\n' |
||
| 7041 | else: |
||
| 7042 | eol_ = '' |
||
| 7043 | if self.UserDefined is not None: |
||
| 7044 | namespaceprefix_ = self.UserDefined_nsprefix_ + ':' if (UseCapturedNS_ and self.UserDefined_nsprefix_) else '' |
||
| 7045 | self.UserDefined.export(outfile, level, namespaceprefix_, namespacedef_='', name_='UserDefined', pretty_print=pretty_print) |
||
| 7046 | for Labels_ in self.Labels: |
||
| 7047 | namespaceprefix_ = self.Labels_nsprefix_ + ':' if (UseCapturedNS_ and self.Labels_nsprefix_) else '' |
||
| 7048 | Labels_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Labels', pretty_print=pretty_print) |
||
| 7049 | for RegionRefIndexed_ in self.RegionRefIndexed: |
||
| 7050 | namespaceprefix_ = self.RegionRefIndexed_nsprefix_ + ':' if (UseCapturedNS_ and self.RegionRefIndexed_nsprefix_) else '' |
||
| 7051 | RegionRefIndexed_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='RegionRefIndexed', pretty_print=pretty_print) |
||
| 7052 | for OrderedGroupIndexed_ in self.OrderedGroupIndexed: |
||
| 7053 | namespaceprefix_ = self.OrderedGroupIndexed_nsprefix_ + ':' if (UseCapturedNS_ and self.OrderedGroupIndexed_nsprefix_) else '' |
||
| 7054 | OrderedGroupIndexed_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='OrderedGroupIndexed', pretty_print=pretty_print) |
||
| 7055 | for UnorderedGroupIndexed_ in self.UnorderedGroupIndexed: |
||
| 7056 | namespaceprefix_ = self.UnorderedGroupIndexed_nsprefix_ + ':' if (UseCapturedNS_ and self.UnorderedGroupIndexed_nsprefix_) else '' |
||
| 7057 | UnorderedGroupIndexed_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='UnorderedGroupIndexed', pretty_print=pretty_print) |
||
| 7058 | def to_etree(self, parent_element=None, name_='OrderedGroupType', mapping_=None, nsmap_=None): |
||
| 7059 | if parent_element is None: |
||
| 7060 | element = etree_.Element('{http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15}' + name_, nsmap=nsmap_) |
||
| 7061 | else: |
||
| 7062 | element = etree_.SubElement(parent_element, '{http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15}' + name_, nsmap=nsmap_) |
||
| 7063 | if self.id is not None: |
||
| 7064 | element.set('id', self.gds_format_string(self.id)) |
||
| 7065 | if self.regionRef is not None: |
||
| 7066 | element.set('regionRef', self.gds_format_string(self.regionRef)) |
||
| 7067 | if self.caption is not None: |
||
| 7068 | element.set('caption', self.gds_format_string(self.caption)) |
||
| 7069 | if self.type_ is not None: |
||
| 7070 | element.set('type', self.gds_format_string(self.type_)) |
||
| 7071 | if self.continuation is not None: |
||
| 7072 | element.set('continuation', self.gds_format_boolean(self.continuation)) |
||
| 7073 | if self.custom is not None: |
||
| 7074 | element.set('custom', self.gds_format_string(self.custom)) |
||
| 7075 | if self.comments is not None: |
||
| 7076 | element.set('comments', self.gds_format_string(self.comments)) |
||
| 7077 | if self.UserDefined is not None: |
||
| 7078 | UserDefined_ = self.UserDefined |
||
| 7079 | UserDefined_.to_etree(element, name_='UserDefined', mapping_=mapping_, nsmap_=nsmap_) |
||
| 7080 | for Labels_ in self.Labels: |
||
| 7081 | Labels_.to_etree(element, name_='Labels', mapping_=mapping_, nsmap_=nsmap_) |
||
| 7082 | for RegionRefIndexed_ in self.RegionRefIndexed: |
||
| 7083 | RegionRefIndexed_.to_etree(element, name_='RegionRefIndexed', mapping_=mapping_, nsmap_=nsmap_) |
||
| 7084 | for OrderedGroupIndexed_ in self.OrderedGroupIndexed: |
||
| 7085 | OrderedGroupIndexed_.to_etree(element, name_='OrderedGroupIndexed', mapping_=mapping_, nsmap_=nsmap_) |
||
| 7086 | for UnorderedGroupIndexed_ in self.UnorderedGroupIndexed: |
||
| 7087 | UnorderedGroupIndexed_.to_etree(element, name_='UnorderedGroupIndexed', mapping_=mapping_, nsmap_=nsmap_) |
||
| 7088 | if mapping_ is not None: |
||
| 7089 | mapping_[id(self)] = element |
||
| 7090 | return element |
||
| 7091 | def build(self, node, gds_collector_=None): |
||
| 7092 | self.gds_collector_ = gds_collector_ |
||
| 7093 | if SaveElementTreeNode: |
||
| 7094 | self.gds_elementtree_node_ = node |
||
| 7095 | already_processed = set() |
||
| 7096 | self.ns_prefix_ = node.prefix |
||
| 7097 | self.buildAttributes(node, node.attrib, already_processed) |
||
| 7098 | for child in node: |
||
| 7099 | nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] |
||
| 7100 | self.buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) |
||
| 7101 | return self |
||
| 7102 | View Code Duplication | def buildAttributes(self, node, attrs, already_processed): |
|
| 7103 | value = find_attr_value_('id', node) |
||
| 7104 | if value is not None and 'id' not in already_processed: |
||
| 7105 | already_processed.add('id') |
||
| 7106 | self.id = value |
||
| 7107 | value = find_attr_value_('regionRef', node) |
||
| 7108 | if value is not None and 'regionRef' not in already_processed: |
||
| 7109 | already_processed.add('regionRef') |
||
| 7110 | self.regionRef = value |
||
| 7111 | value = find_attr_value_('caption', node) |
||
| 7112 | if value is not None and 'caption' not in already_processed: |
||
| 7113 | already_processed.add('caption') |
||
| 7114 | self.caption = value |
||
| 7115 | value = find_attr_value_('type', node) |
||
| 7116 | if value is not None and 'type' not in already_processed: |
||
| 7117 | already_processed.add('type') |
||
| 7118 | self.type_ = value |
||
| 7119 | self.validate_GroupTypeSimpleType(self.type_) # validate type GroupTypeSimpleType |
||
| 7120 | value = find_attr_value_('continuation', node) |
||
| 7121 | if value is not None and 'continuation' not in already_processed: |
||
| 7122 | already_processed.add('continuation') |
||
| 7123 | if value in ('true', '1'): |
||
| 7124 | self.continuation = True |
||
| 7125 | elif value in ('false', '0'): |
||
| 7126 | self.continuation = False |
||
| 7127 | else: |
||
| 7128 | raise_parse_error(node, 'Bad boolean attribute') |
||
| 7129 | value = find_attr_value_('custom', node) |
||
| 7130 | if value is not None and 'custom' not in already_processed: |
||
| 7131 | already_processed.add('custom') |
||
| 7132 | self.custom = value |
||
| 7133 | value = find_attr_value_('comments', node) |
||
| 7134 | if value is not None and 'comments' not in already_processed: |
||
| 7135 | already_processed.add('comments') |
||
| 7136 | self.comments = value |
||
| 7137 | View Code Duplication | def buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None): |
|
| 7138 | if nodeName_ == 'UserDefined': |
||
| 7139 | obj_ = UserDefinedType.factory(parent_object_=self) |
||
| 7140 | obj_.build(child_, gds_collector_=gds_collector_) |
||
| 7141 | self.UserDefined = obj_ |
||
| 7142 | obj_.original_tagname_ = 'UserDefined' |
||
| 7143 | elif nodeName_ == 'Labels': |
||
| 7144 | obj_ = LabelsType.factory(parent_object_=self) |
||
| 7145 | obj_.build(child_, gds_collector_=gds_collector_) |
||
| 7146 | self.Labels.append(obj_) |
||
| 7147 | obj_.original_tagname_ = 'Labels' |
||
| 7148 | elif nodeName_ == 'RegionRefIndexed': |
||
| 7149 | obj_ = RegionRefIndexedType.factory(parent_object_=self) |
||
| 7150 | obj_.build(child_, gds_collector_=gds_collector_) |
||
| 7151 | self.RegionRefIndexed.append(obj_) |
||
| 7152 | obj_.original_tagname_ = 'RegionRefIndexed' |
||
| 7153 | elif nodeName_ == 'OrderedGroupIndexed': |
||
| 7154 | obj_ = OrderedGroupIndexedType.factory(parent_object_=self) |
||
| 7155 | obj_.build(child_, gds_collector_=gds_collector_) |
||
| 7156 | self.OrderedGroupIndexed.append(obj_) |
||
| 7157 | obj_.original_tagname_ = 'OrderedGroupIndexed' |
||
| 7158 | elif nodeName_ == 'UnorderedGroupIndexed': |
||
| 7159 | obj_ = UnorderedGroupIndexedType.factory(parent_object_=self) |
||
| 7160 | obj_.build(child_, gds_collector_=gds_collector_) |
||
| 7161 | self.UnorderedGroupIndexed.append(obj_) |
||
| 7162 | obj_.original_tagname_ = 'UnorderedGroupIndexed' |
||
| 7163 | def __hash__(self): |
||
| 7164 | return hash(self.id) |
||
| 7165 | # pylint: disable=invalid-name,missing-module-docstring,line-too-long |
||
| 7166 | View Code Duplication | def get_AllIndexed(self, classes=None, index_sort=True): |
|
| 7167 | """ |
||
| 7168 | Get all indexed children sorted by their ``@index``. |
||
| 7169 | |||
| 7170 | Arguments: |
||
| 7171 | classes (list): Type of children (sans ``Indexed``) to return. \ |
||
| 7172 | Default: ``['RegionRef', 'OrderedGroup', 'UnorderedGroup']`` |
||
| 7173 | index_sort (boolean): Whether to sort by ``@index`` |
||
| 7174 | |||
| 7175 | Returns: |
||
| 7176 | a list of :py:class:`RegionRefIndexedType`, \ |
||
| 7177 | :py:class:`OrderedGroupIndexedType`, and \ |
||
| 7178 | :py:class:`UnorderedGroupIndexedType` |
||
| 7179 | """ |
||
| 7180 | if not classes: |
||
| 7181 | classes = ['RegionRef', 'OrderedGroup', 'UnorderedGroup'] |
||
| 7182 | ret = [] |
||
| 7183 | for class_ in classes: |
||
| 7184 | ret += getattr(self, 'get_{}Indexed'.format(class_))() |
||
| 7185 | if index_sort: |
||
| 7186 | return sorted(ret, key=lambda x: x.index) |
||
| 7187 | return ret |
||
| 7188 | def clear_AllIndexed(self): |
||
| 7189 | ret = self.get_AllIndexed() |
||
| 7190 | self.set_RegionRefIndexed([]) |
||
| 7191 | self.set_OrderedGroupIndexed([]) |
||
| 7192 | self.set_UnorderedGroupIndexed([]) |
||
| 7193 | return ret |
||
| 7194 | |||
| 7195 | # pylint: disable=line-too-long,invalid-name,missing-module-docstring |
||
| 7196 | View Code Duplication | def extend_AllIndexed(self, elements, validate_continuity=False): |
|
| 7197 | """ |
||
| 7198 | Add all elements in list `elements`, respecting ``@index`` order. |
||
| 7199 | With `validate_continuity`, check that all new elements come after all old elements |
||
| 7200 | (or raise an exception). |
||
| 7201 | Otherwise, ensure this condition silently (by increasing ``@index`` accordingly). |
||
| 7202 | """ |
||
| 7203 | if not isinstance(elements, list): |
||
| 7204 | elements = [elements] |
||
| 7205 | siblings = self.get_AllIndexed() |
||
| 7206 | highest_sibling_index = siblings[-1].index if siblings else -1 |
||
| 7207 | if validate_continuity: |
||
| 7208 | elements = sorted(elements, key=lambda x: x.index) |
||
| 7209 | lowest_element_index = elements[0].index |
||
| 7210 | if lowest_element_index <= highest_sibling_index: |
||
| 7211 | raise Exception("@index already used: {}".format(lowest_element_index)) |
||
| 7212 | else: |
||
| 7213 | for element in elements: |
||
| 7214 | highest_sibling_index += 1 |
||
| 7215 | element.index = highest_sibling_index |
||
| 7216 | for element in elements: |
||
| 7217 | if isinstance(element, RegionRefIndexedType): # pylint: disable=undefined-variable |
||
| 7218 | self.add_RegionRefIndexed(element) |
||
| 7219 | elif isinstance(element, OrderedGroupIndexedType): # pylint: disable=undefined-variable |
||
| 7220 | self.add_OrderedGroupIndexed(element) |
||
| 7221 | elif isinstance(element, UnorderedGroupIndexedType): # pylint: disable=undefined-variable |
||
| 7222 | self.add_UnorderedGroupIndexed(element) |
||
| 7223 | return self.get_AllIndexed() |
||
| 7224 | # pylint: disable=line-too-long,invalid-name,missing-module-docstring |
||
| 7225 | View Code Duplication | def sort_AllIndexed(self, validate_uniqueness=True): |
|
| 7226 | """ |
||
| 7227 | Sort all indexed children in-place. |
||
| 7228 | """ |
||
| 7229 | elements = self.get_AllIndexed(index_sort=True) |
||
| 7230 | self.clear_AllIndexed() |
||
| 7231 | for element in elements: |
||
| 7232 | if isinstance(element, RegionRefIndexedType): # pylint: disable=undefined-variable |
||
| 7233 | self.add_RegionRefIndexed(element) |
||
| 7234 | elif isinstance(element, OrderedGroupIndexedType): # pylint: disable=undefined-variable |
||
| 7235 | self.add_OrderedGroupIndexed(element) |
||
| 7236 | elif isinstance(element, UnorderedGroupIndexedType): # pylint: disable=undefined-variable |
||
| 7237 | self.add_UnorderedGroupIndexed(element) |
||
| 7238 | return self.get_AllIndexed() |
||
| 7239 | |||
| 7240 | # pylint: disable=line-too-long,invalid-name,missing-module-docstring,missing-function-docstring |
||
| 7241 | View Code Duplication | def exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='xmlns:pc="http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15"', name_='OrderedGroupType', fromsubclass_=False, pretty_print=True): # pylint: disable=unused-argument,too-many-arguments |
|
| 7242 | namespaceprefix_ = 'pc:' |
||
| 7243 | if self.UserDefined is not None: |
||
| 7244 | self.UserDefined.export(outfile, level, namespaceprefix_, namespacedef_='', name_='UserDefined', pretty_print=pretty_print) |
||
| 7245 | for Labels_ in self.Labels: |
||
| 7246 | Labels_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Labels', pretty_print=pretty_print) |
||
| 7247 | cleaned = [] |
||
| 7248 | def replaceWithRRI(group): |
||
| 7249 | rri = RegionRefIndexedType.factory(parent_object_=self) # pylint: disable=undefined-variable |
||
| 7250 | rri.index = group.index |
||
| 7251 | rri.regionRef = group.regionRef |
||
| 7252 | cleaned.append(rri) |
||
| 7253 | # remove empty groups and replace with RegionRefIndexedType |
||
| 7254 | for entry in self.get_AllIndexed(): |
||
| 7255 | # pylint: disable=undefined-variable |
||
| 7256 | if isinstance(entry, (OrderedGroupIndexedType)) and not entry.get_AllIndexed(): |
||
| 7257 | replaceWithRRI(entry) |
||
| 7258 | elif isinstance(entry, UnorderedGroupIndexedType) and not entry.get_UnorderedGroupChildren(): |
||
| 7259 | replaceWithRRI(entry) |
||
| 7260 | else: |
||
| 7261 | cleaned.append(entry) |
||
| 7262 | for entry in cleaned: |
||
| 7263 | entry.export(outfile, level, namespaceprefix_, namespacedef_='', name_=entry.__class__.__name__[:-4], pretty_print=pretty_print) |
||
| 7264 | # end class OrderedGroupType |
||
| 7265 | |||
| 7266 | |||
| 7267 | class UnorderedGroupType(GeneratedsSuper): |
||
| 7268 | """Numbered group (contains unordered elements) |
||
| 7269 | Optional link to a parent region of nested regions. |
||
| 7270 | The parent region doubles as reading order group. |
||
| 7271 | Only the nested regions should be allowed as group members. |
||
| 7272 | Is this group a continuation of another group |
||
| 7273 | (from previous column or page, for example)? |
||
| 7274 | For generic use""" |
||
| 7275 | __hash__ = GeneratedsSuper.__hash__ |
||
| 7276 | member_data_items_ = [ |
||
| 7277 | MemberSpec_('id', 'string', 0, 0, {'use': 'required'}), |
||
| 7278 | MemberSpec_('regionRef', 'string', 0, 1, {'use': 'optional'}), |
||
| 7279 | MemberSpec_('caption', 'string', 0, 1, {'use': 'optional'}), |
||
| 7280 | MemberSpec_('type_', 'pc:GroupTypeSimpleType', 0, 1, {'use': 'optional'}), |
||
| 7281 | MemberSpec_('continuation', 'boolean', 0, 1, {'use': 'optional'}), |
||
| 7282 | MemberSpec_('custom', 'string', 0, 1, {'use': 'optional'}), |
||
| 7283 | MemberSpec_('comments', 'string', 0, 1, {'use': 'optional'}), |
||
| 7284 | MemberSpec_('UserDefined', 'UserDefinedType', 0, 1, {'maxOccurs': '1', 'minOccurs': '0', 'name': 'UserDefined', 'type': 'UserDefinedType'}, None), |
||
| 7285 | MemberSpec_('Labels', 'LabelsType', 1, 1, {'maxOccurs': 'unbounded', 'minOccurs': '0', 'name': 'Labels', 'type': 'LabelsType'}, None), |
||
| 7286 | MemberSpec_('RegionRef', 'RegionRefType', 1, 0, {'name': 'RegionRef', 'type': 'RegionRefType'}, 6), |
||
| 7287 | MemberSpec_('OrderedGroup', 'OrderedGroupType', 1, 0, {'name': 'OrderedGroup', 'type': 'OrderedGroupType'}, 6), |
||
| 7288 | MemberSpec_('UnorderedGroup', 'UnorderedGroupType', 1, 0, {'name': 'UnorderedGroup', 'type': 'UnorderedGroupType'}, 6), |
||
| 7289 | ] |
||
| 7290 | subclass = None |
||
| 7291 | superclass = None |
||
| 7292 | View Code Duplication | def __init__(self, id=None, regionRef=None, caption=None, type_=None, continuation=None, custom=None, comments=None, UserDefined=None, Labels=None, RegionRef=None, OrderedGroup=None, UnorderedGroup=None, gds_collector_=None, **kwargs_): |
|
| 7293 | self.gds_collector_ = gds_collector_ |
||
| 7294 | self.gds_elementtree_node_ = None |
||
| 7295 | self.original_tagname_ = None |
||
| 7296 | self.parent_object_ = kwargs_.get('parent_object_') |
||
| 7297 | self.ns_prefix_ = None |
||
| 7298 | self.id = _cast(None, id) |
||
| 7299 | self.id_nsprefix_ = "pc" |
||
| 7300 | self.regionRef = _cast(None, regionRef) |
||
| 7301 | self.regionRef_nsprefix_ = "pc" |
||
| 7302 | self.caption = _cast(None, caption) |
||
| 7303 | self.caption_nsprefix_ = "pc" |
||
| 7304 | self.type_ = _cast(None, type_) |
||
| 7305 | self.type__nsprefix_ = "pc" |
||
| 7306 | self.continuation = _cast(bool, continuation) |
||
| 7307 | self.continuation_nsprefix_ = "pc" |
||
| 7308 | self.custom = _cast(None, custom) |
||
| 7309 | self.custom_nsprefix_ = "pc" |
||
| 7310 | self.comments = _cast(None, comments) |
||
| 7311 | self.comments_nsprefix_ = "pc" |
||
| 7312 | self.UserDefined = UserDefined |
||
| 7313 | self.UserDefined_nsprefix_ = "pc" |
||
| 7314 | if Labels is None: |
||
| 7315 | self.Labels = [] |
||
| 7316 | else: |
||
| 7317 | self.Labels = Labels |
||
| 7318 | self.Labels_nsprefix_ = "pc" |
||
| 7319 | if RegionRef is None: |
||
| 7320 | self.RegionRef = [] |
||
| 7321 | else: |
||
| 7322 | self.RegionRef = RegionRef |
||
| 7323 | self.RegionRef_nsprefix_ = "pc" |
||
| 7324 | if OrderedGroup is None: |
||
| 7325 | self.OrderedGroup = [] |
||
| 7326 | else: |
||
| 7327 | self.OrderedGroup = OrderedGroup |
||
| 7328 | self.OrderedGroup_nsprefix_ = "pc" |
||
| 7329 | if UnorderedGroup is None: |
||
| 7330 | self.UnorderedGroup = [] |
||
| 7331 | else: |
||
| 7332 | self.UnorderedGroup = UnorderedGroup |
||
| 7333 | self.UnorderedGroup_nsprefix_ = "pc" |
||
| 7334 | def factory(*args_, **kwargs_): |
||
| 7335 | if CurrentSubclassModule_ is not None: |
||
| 7336 | subclass = getSubclassFromModule_( |
||
| 7337 | CurrentSubclassModule_, UnorderedGroupType) |
||
| 7338 | if subclass is not None: |
||
| 7339 | return subclass(*args_, **kwargs_) |
||
| 7340 | if UnorderedGroupType.subclass: |
||
| 7341 | return UnorderedGroupType.subclass(*args_, **kwargs_) |
||
| 7342 | else: |
||
| 7343 | return UnorderedGroupType(*args_, **kwargs_) |
||
| 7344 | factory = staticmethod(factory) |
||
| 7345 | def get_ns_prefix_(self): |
||
| 7346 | return self.ns_prefix_ |
||
| 7347 | def set_ns_prefix_(self, ns_prefix): |
||
| 7348 | self.ns_prefix_ = ns_prefix |
||
| 7349 | def get_UserDefined(self): |
||
| 7350 | return self.UserDefined |
||
| 7351 | def set_UserDefined(self, UserDefined): |
||
| 7352 | self.UserDefined = UserDefined |
||
| 7353 | def get_Labels(self): |
||
| 7354 | return self.Labels |
||
| 7355 | def set_Labels(self, Labels): |
||
| 7356 | self.Labels = Labels |
||
| 7357 | def add_Labels(self, value): |
||
| 7358 | self.Labels.append(value) |
||
| 7359 | def insert_Labels_at(self, index, value): |
||
| 7360 | self.Labels.insert(index, value) |
||
| 7361 | def replace_Labels_at(self, index, value): |
||
| 7362 | self.Labels[index] = value |
||
| 7363 | def get_RegionRef(self): |
||
| 7364 | return self.RegionRef |
||
| 7365 | def set_RegionRef(self, RegionRef): |
||
| 7366 | self.RegionRef = RegionRef |
||
| 7367 | def add_RegionRef(self, value): |
||
| 7368 | self.RegionRef.append(value) |
||
| 7369 | def insert_RegionRef_at(self, index, value): |
||
| 7370 | self.RegionRef.insert(index, value) |
||
| 7371 | def replace_RegionRef_at(self, index, value): |
||
| 7372 | self.RegionRef[index] = value |
||
| 7373 | def get_OrderedGroup(self): |
||
| 7374 | return self.OrderedGroup |
||
| 7375 | def set_OrderedGroup(self, OrderedGroup): |
||
| 7376 | self.OrderedGroup = OrderedGroup |
||
| 7377 | def add_OrderedGroup(self, value): |
||
| 7378 | self.OrderedGroup.append(value) |
||
| 7379 | def insert_OrderedGroup_at(self, index, value): |
||
| 7380 | self.OrderedGroup.insert(index, value) |
||
| 7381 | def replace_OrderedGroup_at(self, index, value): |
||
| 7382 | self.OrderedGroup[index] = value |
||
| 7383 | def get_UnorderedGroup(self): |
||
| 7384 | return self.UnorderedGroup |
||
| 7385 | def set_UnorderedGroup(self, UnorderedGroup): |
||
| 7386 | self.UnorderedGroup = UnorderedGroup |
||
| 7387 | def add_UnorderedGroup(self, value): |
||
| 7388 | self.UnorderedGroup.append(value) |
||
| 7389 | def insert_UnorderedGroup_at(self, index, value): |
||
| 7390 | self.UnorderedGroup.insert(index, value) |
||
| 7391 | def replace_UnorderedGroup_at(self, index, value): |
||
| 7392 | self.UnorderedGroup[index] = value |
||
| 7393 | def get_id(self): |
||
| 7394 | return self.id |
||
| 7395 | def set_id(self, id): |
||
| 7396 | self.id = id |
||
| 7397 | def get_regionRef(self): |
||
| 7398 | return self.regionRef |
||
| 7399 | def set_regionRef(self, regionRef): |
||
| 7400 | self.regionRef = regionRef |
||
| 7401 | def get_caption(self): |
||
| 7402 | return self.caption |
||
| 7403 | def set_caption(self, caption): |
||
| 7404 | self.caption = caption |
||
| 7405 | def get_type(self): |
||
| 7406 | return self.type_ |
||
| 7407 | def set_type(self, type_): |
||
| 7408 | self.type_ = type_ |
||
| 7409 | def get_continuation(self): |
||
| 7410 | return self.continuation |
||
| 7411 | def set_continuation(self, continuation): |
||
| 7412 | self.continuation = continuation |
||
| 7413 | def get_custom(self): |
||
| 7414 | return self.custom |
||
| 7415 | def set_custom(self, custom): |
||
| 7416 | self.custom = custom |
||
| 7417 | def get_comments(self): |
||
| 7418 | return self.comments |
||
| 7419 | def set_comments(self, comments): |
||
| 7420 | self.comments = comments |
||
| 7421 | def validate_GroupTypeSimpleType(self, value): |
||
| 7422 | # Validate type pc:GroupTypeSimpleType, a restriction on string. |
||
| 7423 | if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None: |
||
| 7424 | if not isinstance(value, str): |
||
| 7425 | lineno = self.gds_get_node_lineno_() |
||
| 7426 | self.gds_collector_.add_message('Value "%(value)s"%(lineno)s is not of the correct base simple type (str)' % {"value": value, "lineno": lineno, }) |
||
| 7427 | return False |
||
| 7428 | value = value |
||
| 7429 | enumerations = ['paragraph', 'list', 'list-item', 'figure', 'article', 'div', 'other'] |
||
| 7430 | if value not in enumerations: |
||
| 7431 | lineno = self.gds_get_node_lineno_() |
||
| 7432 | self.gds_collector_.add_message('Value "%(value)s"%(lineno)s does not match xsd enumeration restriction on GroupTypeSimpleType' % {"value" : encode_str_2_3(value), "lineno": lineno} ) |
||
| 7433 | result = False |
||
| 7434 | def hasContent_(self): |
||
| 7435 | if ( |
||
| 7436 | self.UserDefined is not None or |
||
| 7437 | self.Labels or |
||
| 7438 | self.RegionRef or |
||
| 7439 | self.OrderedGroup or |
||
| 7440 | self.UnorderedGroup |
||
| 7441 | ): |
||
| 7442 | return True |
||
| 7443 | else: |
||
| 7444 | return False |
||
| 7445 | def export(self, outfile, level, namespaceprefix_='', namespacedef_='xmlns:pc="http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15"', name_='UnorderedGroupType', pretty_print=True): |
||
| 7446 | imported_ns_def_ = GenerateDSNamespaceDefs_.get('UnorderedGroupType') |
||
| 7447 | if imported_ns_def_ is not None: |
||
| 7448 | namespacedef_ = imported_ns_def_ |
||
| 7449 | if pretty_print: |
||
| 7450 | eol_ = '\n' |
||
| 7451 | else: |
||
| 7452 | eol_ = '' |
||
| 7453 | if self.original_tagname_ is not None and name_ == 'UnorderedGroupType': |
||
| 7454 | name_ = self.original_tagname_ |
||
| 7455 | if UseCapturedNS_ and self.ns_prefix_: |
||
| 7456 | namespaceprefix_ = self.ns_prefix_ + ':' |
||
| 7457 | showIndent(outfile, level, pretty_print) |
||
| 7458 | outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) |
||
| 7459 | already_processed = set() |
||
| 7460 | self.exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='UnorderedGroupType') |
||
| 7461 | if self.hasContent_(): |
||
| 7462 | outfile.write('>%s' % (eol_, )) |
||
| 7463 | self.exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='UnorderedGroupType', pretty_print=pretty_print) |
||
| 7464 | showIndent(outfile, level, pretty_print) |
||
| 7465 | outfile.write('</%s%s>%s' % (namespaceprefix_, name_, eol_)) |
||
| 7466 | else: |
||
| 7467 | outfile.write('/>%s' % (eol_, )) |
||
| 7468 | View Code Duplication | def exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='UnorderedGroupType'): |
|
| 7469 | if self.id is not None and 'id' not in already_processed: |
||
| 7470 | already_processed.add('id') |
||
| 7471 | outfile.write(' id=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.id), input_name='id')), )) |
||
| 7472 | if self.regionRef is not None and 'regionRef' not in already_processed: |
||
| 7473 | already_processed.add('regionRef') |
||
| 7474 | outfile.write(' regionRef=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.regionRef), input_name='regionRef')), )) |
||
| 7475 | if self.caption is not None and 'caption' not in already_processed: |
||
| 7476 | already_processed.add('caption') |
||
| 7477 | outfile.write(' caption=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.caption), input_name='caption')), )) |
||
| 7478 | if self.type_ is not None and 'type_' not in already_processed: |
||
| 7479 | already_processed.add('type_') |
||
| 7480 | outfile.write(' type=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.type_), input_name='type')), )) |
||
| 7481 | if self.continuation is not None and 'continuation' not in already_processed: |
||
| 7482 | already_processed.add('continuation') |
||
| 7483 | outfile.write(' continuation="%s"' % self.gds_format_boolean(self.continuation, input_name='continuation')) |
||
| 7484 | if self.custom is not None and 'custom' not in already_processed: |
||
| 7485 | already_processed.add('custom') |
||
| 7486 | outfile.write(' custom=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.custom), input_name='custom')), )) |
||
| 7487 | if self.comments is not None and 'comments' not in already_processed: |
||
| 7488 | already_processed.add('comments') |
||
| 7489 | outfile.write(' comments=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.comments), input_name='comments')), )) |
||
| 7490 | View Code Duplication | def exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='xmlns:pc="http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15"', name_='UnorderedGroupType', fromsubclass_=False, pretty_print=True): |
|
| 7491 | if pretty_print: |
||
| 7492 | eol_ = '\n' |
||
| 7493 | else: |
||
| 7494 | eol_ = '' |
||
| 7495 | if self.UserDefined is not None: |
||
| 7496 | namespaceprefix_ = self.UserDefined_nsprefix_ + ':' if (UseCapturedNS_ and self.UserDefined_nsprefix_) else '' |
||
| 7497 | self.UserDefined.export(outfile, level, namespaceprefix_, namespacedef_='', name_='UserDefined', pretty_print=pretty_print) |
||
| 7498 | for Labels_ in self.Labels: |
||
| 7499 | namespaceprefix_ = self.Labels_nsprefix_ + ':' if (UseCapturedNS_ and self.Labels_nsprefix_) else '' |
||
| 7500 | Labels_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Labels', pretty_print=pretty_print) |
||
| 7501 | for RegionRef_ in self.RegionRef: |
||
| 7502 | namespaceprefix_ = self.RegionRef_nsprefix_ + ':' if (UseCapturedNS_ and self.RegionRef_nsprefix_) else '' |
||
| 7503 | RegionRef_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='RegionRef', pretty_print=pretty_print) |
||
| 7504 | for OrderedGroup_ in self.OrderedGroup: |
||
| 7505 | namespaceprefix_ = self.OrderedGroup_nsprefix_ + ':' if (UseCapturedNS_ and self.OrderedGroup_nsprefix_) else '' |
||
| 7506 | OrderedGroup_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='OrderedGroup', pretty_print=pretty_print) |
||
| 7507 | for UnorderedGroup_ in self.UnorderedGroup: |
||
| 7508 | namespaceprefix_ = self.UnorderedGroup_nsprefix_ + ':' if (UseCapturedNS_ and self.UnorderedGroup_nsprefix_) else '' |
||
| 7509 | UnorderedGroup_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='UnorderedGroup', pretty_print=pretty_print) |
||
| 7510 | def to_etree(self, parent_element=None, name_='UnorderedGroupType', mapping_=None, nsmap_=None): |
||
| 7511 | if parent_element is None: |
||
| 7512 | element = etree_.Element('{http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15}' + name_, nsmap=nsmap_) |
||
| 7513 | else: |
||
| 7514 | element = etree_.SubElement(parent_element, '{http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15}' + name_, nsmap=nsmap_) |
||
| 7515 | if self.id is not None: |
||
| 7516 | element.set('id', self.gds_format_string(self.id)) |
||
| 7517 | if self.regionRef is not None: |
||
| 7518 | element.set('regionRef', self.gds_format_string(self.regionRef)) |
||
| 7519 | if self.caption is not None: |
||
| 7520 | element.set('caption', self.gds_format_string(self.caption)) |
||
| 7521 | if self.type_ is not None: |
||
| 7522 | element.set('type', self.gds_format_string(self.type_)) |
||
| 7523 | if self.continuation is not None: |
||
| 7524 | element.set('continuation', self.gds_format_boolean(self.continuation)) |
||
| 7525 | if self.custom is not None: |
||
| 7526 | element.set('custom', self.gds_format_string(self.custom)) |
||
| 7527 | if self.comments is not None: |
||
| 7528 | element.set('comments', self.gds_format_string(self.comments)) |
||
| 7529 | if self.UserDefined is not None: |
||
| 7530 | UserDefined_ = self.UserDefined |
||
| 7531 | UserDefined_.to_etree(element, name_='UserDefined', mapping_=mapping_, nsmap_=nsmap_) |
||
| 7532 | for Labels_ in self.Labels: |
||
| 7533 | Labels_.to_etree(element, name_='Labels', mapping_=mapping_, nsmap_=nsmap_) |
||
| 7534 | for RegionRef_ in self.RegionRef: |
||
| 7535 | RegionRef_.to_etree(element, name_='RegionRef', mapping_=mapping_, nsmap_=nsmap_) |
||
| 7536 | for OrderedGroup_ in self.OrderedGroup: |
||
| 7537 | OrderedGroup_.to_etree(element, name_='OrderedGroup', mapping_=mapping_, nsmap_=nsmap_) |
||
| 7538 | for UnorderedGroup_ in self.UnorderedGroup: |
||
| 7539 | UnorderedGroup_.to_etree(element, name_='UnorderedGroup', mapping_=mapping_, nsmap_=nsmap_) |
||
| 7540 | if mapping_ is not None: |
||
| 7541 | mapping_[id(self)] = element |
||
| 7542 | return element |
||
| 7543 | def build(self, node, gds_collector_=None): |
||
| 7544 | self.gds_collector_ = gds_collector_ |
||
| 7545 | if SaveElementTreeNode: |
||
| 7546 | self.gds_elementtree_node_ = node |
||
| 7547 | already_processed = set() |
||
| 7548 | self.ns_prefix_ = node.prefix |
||
| 7549 | self.buildAttributes(node, node.attrib, already_processed) |
||
| 7550 | for child in node: |
||
| 7551 | nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] |
||
| 7552 | self.buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) |
||
| 7553 | return self |
||
| 7554 | View Code Duplication | def buildAttributes(self, node, attrs, already_processed): |
|
| 7555 | value = find_attr_value_('id', node) |
||
| 7556 | if value is not None and 'id' not in already_processed: |
||
| 7557 | already_processed.add('id') |
||
| 7558 | self.id = value |
||
| 7559 | value = find_attr_value_('regionRef', node) |
||
| 7560 | if value is not None and 'regionRef' not in already_processed: |
||
| 7561 | already_processed.add('regionRef') |
||
| 7562 | self.regionRef = value |
||
| 7563 | value = find_attr_value_('caption', node) |
||
| 7564 | if value is not None and 'caption' not in already_processed: |
||
| 7565 | already_processed.add('caption') |
||
| 7566 | self.caption = value |
||
| 7567 | value = find_attr_value_('type', node) |
||
| 7568 | if value is not None and 'type' not in already_processed: |
||
| 7569 | already_processed.add('type') |
||
| 7570 | self.type_ = value |
||
| 7571 | self.validate_GroupTypeSimpleType(self.type_) # validate type GroupTypeSimpleType |
||
| 7572 | value = find_attr_value_('continuation', node) |
||
| 7573 | if value is not None and 'continuation' not in already_processed: |
||
| 7574 | already_processed.add('continuation') |
||
| 7575 | if value in ('true', '1'): |
||
| 7576 | self.continuation = True |
||
| 7577 | elif value in ('false', '0'): |
||
| 7578 | self.continuation = False |
||
| 7579 | else: |
||
| 7580 | raise_parse_error(node, 'Bad boolean attribute') |
||
| 7581 | value = find_attr_value_('custom', node) |
||
| 7582 | if value is not None and 'custom' not in already_processed: |
||
| 7583 | already_processed.add('custom') |
||
| 7584 | self.custom = value |
||
| 7585 | value = find_attr_value_('comments', node) |
||
| 7586 | if value is not None and 'comments' not in already_processed: |
||
| 7587 | already_processed.add('comments') |
||
| 7588 | self.comments = value |
||
| 7589 | View Code Duplication | def buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None): |
|
| 7590 | if nodeName_ == 'UserDefined': |
||
| 7591 | obj_ = UserDefinedType.factory(parent_object_=self) |
||
| 7592 | obj_.build(child_, gds_collector_=gds_collector_) |
||
| 7593 | self.UserDefined = obj_ |
||
| 7594 | obj_.original_tagname_ = 'UserDefined' |
||
| 7595 | elif nodeName_ == 'Labels': |
||
| 7596 | obj_ = LabelsType.factory(parent_object_=self) |
||
| 7597 | obj_.build(child_, gds_collector_=gds_collector_) |
||
| 7598 | self.Labels.append(obj_) |
||
| 7599 | obj_.original_tagname_ = 'Labels' |
||
| 7600 | elif nodeName_ == 'RegionRef': |
||
| 7601 | obj_ = RegionRefType.factory(parent_object_=self) |
||
| 7602 | obj_.build(child_, gds_collector_=gds_collector_) |
||
| 7603 | self.RegionRef.append(obj_) |
||
| 7604 | obj_.original_tagname_ = 'RegionRef' |
||
| 7605 | elif nodeName_ == 'OrderedGroup': |
||
| 7606 | obj_ = OrderedGroupType.factory(parent_object_=self) |
||
| 7607 | obj_.build(child_, gds_collector_=gds_collector_) |
||
| 7608 | self.OrderedGroup.append(obj_) |
||
| 7609 | obj_.original_tagname_ = 'OrderedGroup' |
||
| 7610 | elif nodeName_ == 'UnorderedGroup': |
||
| 7611 | obj_ = UnorderedGroupType.factory(parent_object_=self) |
||
| 7612 | obj_.build(child_, gds_collector_=gds_collector_) |
||
| 7613 | self.UnorderedGroup.append(obj_) |
||
| 7614 | obj_.original_tagname_ = 'UnorderedGroup' |
||
| 7615 | def __hash__(self): |
||
| 7616 | return hash(self.id) |
||
| 7617 | def get_UnorderedGroupChildren(self): |
||
| 7618 | """ |
||
| 7619 | List all non-metadata children of an :py:class:`UnorderedGroupType` |
||
| 7620 | """ |
||
| 7621 | # TODO: should not change order |
||
| 7622 | return self.get_RegionRef() + self.get_OrderedGroup() + self.get_UnorderedGroup() |
||
| 7623 | |||
| 7624 | # end class UnorderedGroupType |
||
| 7625 | |||
| 7626 | |||
| 7627 | class BorderType(GeneratedsSuper): |
||
| 7628 | """Border of the actual page (if the scanned image |
||
| 7629 | contains parts not belonging to the page).""" |
||
| 7630 | __hash__ = GeneratedsSuper.__hash__ |
||
| 7631 | member_data_items_ = [ |
||
| 7632 | MemberSpec_('Coords', 'CoordsType', 0, 0, {'name': 'Coords', 'type': 'CoordsType'}, None), |
||
| 7633 | ] |
||
| 7634 | subclass = None |
||
| 7635 | superclass = None |
||
| 7636 | def __init__(self, Coords=None, gds_collector_=None, **kwargs_): |
||
| 7637 | self.gds_collector_ = gds_collector_ |
||
| 7638 | self.gds_elementtree_node_ = None |
||
| 7639 | self.original_tagname_ = None |
||
| 7640 | self.parent_object_ = kwargs_.get('parent_object_') |
||
| 7641 | self.ns_prefix_ = None |
||
| 7642 | self.Coords = Coords |
||
| 7643 | self.Coords_nsprefix_ = "pc" |
||
| 7644 | def factory(*args_, **kwargs_): |
||
| 7645 | if CurrentSubclassModule_ is not None: |
||
| 7646 | subclass = getSubclassFromModule_( |
||
| 7647 | CurrentSubclassModule_, BorderType) |
||
| 7648 | if subclass is not None: |
||
| 7649 | return subclass(*args_, **kwargs_) |
||
| 7650 | if BorderType.subclass: |
||
| 7651 | return BorderType.subclass(*args_, **kwargs_) |
||
| 7652 | else: |
||
| 7653 | return BorderType(*args_, **kwargs_) |
||
| 7654 | factory = staticmethod(factory) |
||
| 7655 | def get_ns_prefix_(self): |
||
| 7656 | return self.ns_prefix_ |
||
| 7657 | def set_ns_prefix_(self, ns_prefix): |
||
| 7658 | self.ns_prefix_ = ns_prefix |
||
| 7659 | def get_Coords(self): |
||
| 7660 | return self.Coords |
||
| 7661 | def set_Coords(self, Coords): |
||
| 7662 | self.Coords = Coords |
||
| 7663 | def hasContent_(self): |
||
| 7664 | if ( |
||
| 7665 | self.Coords is not None |
||
| 7666 | ): |
||
| 7667 | return True |
||
| 7668 | else: |
||
| 7669 | return False |
||
| 7670 | def export(self, outfile, level, namespaceprefix_='', namespacedef_='xmlns:pc="http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15"', name_='BorderType', pretty_print=True): |
||
| 7671 | imported_ns_def_ = GenerateDSNamespaceDefs_.get('BorderType') |
||
| 7672 | if imported_ns_def_ is not None: |
||
| 7673 | namespacedef_ = imported_ns_def_ |
||
| 7674 | if pretty_print: |
||
| 7675 | eol_ = '\n' |
||
| 7676 | else: |
||
| 7677 | eol_ = '' |
||
| 7678 | if self.original_tagname_ is not None and name_ == 'BorderType': |
||
| 7679 | name_ = self.original_tagname_ |
||
| 7680 | if UseCapturedNS_ and self.ns_prefix_: |
||
| 7681 | namespaceprefix_ = self.ns_prefix_ + ':' |
||
| 7682 | showIndent(outfile, level, pretty_print) |
||
| 7683 | outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) |
||
| 7684 | already_processed = set() |
||
| 7685 | self.exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='BorderType') |
||
| 7686 | if self.hasContent_(): |
||
| 7687 | outfile.write('>%s' % (eol_, )) |
||
| 7688 | self.exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='BorderType', pretty_print=pretty_print) |
||
| 7689 | showIndent(outfile, level, pretty_print) |
||
| 7690 | outfile.write('</%s%s>%s' % (namespaceprefix_, name_, eol_)) |
||
| 7691 | else: |
||
| 7692 | outfile.write('/>%s' % (eol_, )) |
||
| 7693 | def exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='BorderType'): |
||
| 7694 | pass |
||
| 7695 | def exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='xmlns:pc="http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15"', name_='BorderType', fromsubclass_=False, pretty_print=True): |
||
| 7696 | if pretty_print: |
||
| 7697 | eol_ = '\n' |
||
| 7698 | else: |
||
| 7699 | eol_ = '' |
||
| 7700 | if self.Coords is not None: |
||
| 7701 | namespaceprefix_ = self.Coords_nsprefix_ + ':' if (UseCapturedNS_ and self.Coords_nsprefix_) else '' |
||
| 7702 | self.Coords.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Coords', pretty_print=pretty_print) |
||
| 7703 | def to_etree(self, parent_element=None, name_='BorderType', mapping_=None, nsmap_=None): |
||
| 7704 | if parent_element is None: |
||
| 7705 | element = etree_.Element('{http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15}' + name_, nsmap=nsmap_) |
||
| 7706 | else: |
||
| 7707 | element = etree_.SubElement(parent_element, '{http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15}' + name_, nsmap=nsmap_) |
||
| 7708 | if self.Coords is not None: |
||
| 7709 | Coords_ = self.Coords |
||
| 7710 | Coords_.to_etree(element, name_='Coords', mapping_=mapping_, nsmap_=nsmap_) |
||
| 7711 | if mapping_ is not None: |
||
| 7712 | mapping_[id(self)] = element |
||
| 7713 | return element |
||
| 7714 | def build(self, node, gds_collector_=None): |
||
| 7715 | self.gds_collector_ = gds_collector_ |
||
| 7716 | if SaveElementTreeNode: |
||
| 7717 | self.gds_elementtree_node_ = node |
||
| 7718 | already_processed = set() |
||
| 7719 | self.ns_prefix_ = node.prefix |
||
| 7720 | self.buildAttributes(node, node.attrib, already_processed) |
||
| 7721 | for child in node: |
||
| 7722 | nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] |
||
| 7723 | self.buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) |
||
| 7724 | return self |
||
| 7725 | def buildAttributes(self, node, attrs, already_processed): |
||
| 7726 | pass |
||
| 7727 | def buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None): |
||
| 7728 | if nodeName_ == 'Coords': |
||
| 7729 | obj_ = CoordsType.factory(parent_object_=self) |
||
| 7730 | obj_.build(child_, gds_collector_=gds_collector_) |
||
| 7731 | self.Coords = obj_ |
||
| 7732 | obj_.original_tagname_ = 'Coords' |
||
| 7733 | def __hash__(self): |
||
| 7734 | return hash(self.id) |
||
| 7735 | def set_Coords(self, Coords): |
||
| 7736 | """ |
||
| 7737 | Set coordinate polygon by given :py:class:`CoordsType` object. |
||
| 7738 | Moreover, invalidate self's ``pc:AlternativeImage``s |
||
| 7739 | (because they will have been cropped with a bbox |
||
| 7740 | of the previous polygon). |
||
| 7741 | """ |
||
| 7742 | if hasattr(self, 'invalidate_AlternativeImage'): |
||
| 7743 | # RegionType, TextLineType, WordType, GlyphType: |
||
| 7744 | self.invalidate_AlternativeImage() |
||
| 7745 | elif hasattr(self, 'parent_object_') and hasattr(self.parent_object_, 'invalidate_AlternativeImage'): |
||
| 7746 | # BorderType: |
||
| 7747 | self.parent_object_.invalidate_AlternativeImage(feature_selector='cropped') |
||
| 7748 | self.Coords = Coords |
||
| 7749 | # end class BorderType |
||
| 7750 | |||
| 7751 | |||
| 7752 | View Code Duplication | class LayersType(GeneratedsSuper): |
|
| 7753 | """Can be used to express the z-index of overlapping |
||
| 7754 | regions. An element with a greater z-index is always in |
||
| 7755 | front of another element with lower z-index.""" |
||
| 7756 | __hash__ = GeneratedsSuper.__hash__ |
||
| 7757 | member_data_items_ = [ |
||
| 7758 | MemberSpec_('Layer', 'LayerType', 1, 0, {'maxOccurs': 'unbounded', 'minOccurs': '1', 'name': 'Layer', 'type': 'LayerType'}, None), |
||
| 7759 | ] |
||
| 7760 | subclass = None |
||
| 7761 | superclass = None |
||
| 7762 | def __init__(self, Layer=None, gds_collector_=None, **kwargs_): |
||
| 7763 | self.gds_collector_ = gds_collector_ |
||
| 7764 | self.gds_elementtree_node_ = None |
||
| 7765 | self.original_tagname_ = None |
||
| 7766 | self.parent_object_ = kwargs_.get('parent_object_') |
||
| 7767 | self.ns_prefix_ = None |
||
| 7768 | if Layer is None: |
||
| 7769 | self.Layer = [] |
||
| 7770 | else: |
||
| 7771 | self.Layer = Layer |
||
| 7772 | self.Layer_nsprefix_ = "pc" |
||
| 7773 | def factory(*args_, **kwargs_): |
||
| 7774 | if CurrentSubclassModule_ is not None: |
||
| 7775 | subclass = getSubclassFromModule_( |
||
| 7776 | CurrentSubclassModule_, LayersType) |
||
| 7777 | if subclass is not None: |
||
| 7778 | return subclass(*args_, **kwargs_) |
||
| 7779 | if LayersType.subclass: |
||
| 7780 | return LayersType.subclass(*args_, **kwargs_) |
||
| 7781 | else: |
||
| 7782 | return LayersType(*args_, **kwargs_) |
||
| 7783 | factory = staticmethod(factory) |
||
| 7784 | def get_ns_prefix_(self): |
||
| 7785 | return self.ns_prefix_ |
||
| 7786 | def set_ns_prefix_(self, ns_prefix): |
||
| 7787 | self.ns_prefix_ = ns_prefix |
||
| 7788 | def get_Layer(self): |
||
| 7789 | return self.Layer |
||
| 7790 | def set_Layer(self, Layer): |
||
| 7791 | self.Layer = Layer |
||
| 7792 | def add_Layer(self, value): |
||
| 7793 | self.Layer.append(value) |
||
| 7794 | def insert_Layer_at(self, index, value): |
||
| 7795 | self.Layer.insert(index, value) |
||
| 7796 | def replace_Layer_at(self, index, value): |
||
| 7797 | self.Layer[index] = value |
||
| 7798 | def hasContent_(self): |
||
| 7799 | if ( |
||
| 7800 | self.Layer |
||
| 7801 | ): |
||
| 7802 | return True |
||
| 7803 | else: |
||
| 7804 | return False |
||
| 7805 | def export(self, outfile, level, namespaceprefix_='', namespacedef_='xmlns:pc="http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15"', name_='LayersType', pretty_print=True): |
||
| 7806 | imported_ns_def_ = GenerateDSNamespaceDefs_.get('LayersType') |
||
| 7807 | if imported_ns_def_ is not None: |
||
| 7808 | namespacedef_ = imported_ns_def_ |
||
| 7809 | if pretty_print: |
||
| 7810 | eol_ = '\n' |
||
| 7811 | else: |
||
| 7812 | eol_ = '' |
||
| 7813 | if self.original_tagname_ is not None and name_ == 'LayersType': |
||
| 7814 | name_ = self.original_tagname_ |
||
| 7815 | if UseCapturedNS_ and self.ns_prefix_: |
||
| 7816 | namespaceprefix_ = self.ns_prefix_ + ':' |
||
| 7817 | showIndent(outfile, level, pretty_print) |
||
| 7818 | outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) |
||
| 7819 | already_processed = set() |
||
| 7820 | self.exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='LayersType') |
||
| 7821 | if self.hasContent_(): |
||
| 7822 | outfile.write('>%s' % (eol_, )) |
||
| 7823 | self.exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='LayersType', pretty_print=pretty_print) |
||
| 7824 | showIndent(outfile, level, pretty_print) |
||
| 7825 | outfile.write('</%s%s>%s' % (namespaceprefix_, name_, eol_)) |
||
| 7826 | else: |
||
| 7827 | outfile.write('/>%s' % (eol_, )) |
||
| 7828 | def exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='LayersType'): |
||
| 7829 | pass |
||
| 7830 | 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): |
||
| 7831 | if pretty_print: |
||
| 7832 | eol_ = '\n' |
||
| 7833 | else: |
||
| 7834 | eol_ = '' |
||
| 7835 | for Layer_ in self.Layer: |
||
| 7836 | namespaceprefix_ = self.Layer_nsprefix_ + ':' if (UseCapturedNS_ and self.Layer_nsprefix_) else '' |
||
| 7837 | Layer_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Layer', pretty_print=pretty_print) |
||
| 7838 | def to_etree(self, parent_element=None, name_='LayersType', mapping_=None, nsmap_=None): |
||
| 7839 | if parent_element is None: |
||
| 7840 | element = etree_.Element('{http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15}' + name_, nsmap=nsmap_) |
||
| 7841 | else: |
||
| 7842 | element = etree_.SubElement(parent_element, '{http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15}' + name_, nsmap=nsmap_) |
||
| 7843 | for Layer_ in self.Layer: |
||
| 7844 | Layer_.to_etree(element, name_='Layer', mapping_=mapping_, nsmap_=nsmap_) |
||
| 7845 | if mapping_ is not None: |
||
| 7846 | mapping_[id(self)] = element |
||
| 7847 | return element |
||
| 7848 | def build(self, node, gds_collector_=None): |
||
| 7849 | self.gds_collector_ = gds_collector_ |
||
| 7850 | if SaveElementTreeNode: |
||
| 7851 | self.gds_elementtree_node_ = node |
||
| 7852 | already_processed = set() |
||
| 7853 | self.ns_prefix_ = node.prefix |
||
| 7854 | self.buildAttributes(node, node.attrib, already_processed) |
||
| 7855 | for child in node: |
||
| 7856 | nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] |
||
| 7857 | self.buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) |
||
| 7858 | return self |
||
| 7859 | def buildAttributes(self, node, attrs, already_processed): |
||
| 7860 | pass |
||
| 7861 | def buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None): |
||
| 7862 | if nodeName_ == 'Layer': |
||
| 7863 | obj_ = LayerType.factory(parent_object_=self) |
||
| 7864 | obj_.build(child_, gds_collector_=gds_collector_) |
||
| 7865 | self.Layer.append(obj_) |
||
| 7866 | obj_.original_tagname_ = 'Layer' |
||
| 7867 | def __hash__(self): |
||
| 7868 | return hash(self.id) |
||
| 7869 | # end class LayersType |
||
| 7870 | |||
| 7871 | |||
| 7872 | class LayerType(GeneratedsSuper): |
||
| 7873 | __hash__ = GeneratedsSuper.__hash__ |
||
| 7874 | member_data_items_ = [ |
||
| 7875 | MemberSpec_('id', 'string', 0, 0, {'use': 'required'}), |
||
| 7876 | MemberSpec_('zIndex', 'int', 0, 0, {'use': 'required'}), |
||
| 7877 | MemberSpec_('caption', 'string', 0, 1, {'use': 'optional'}), |
||
| 7878 | MemberSpec_('RegionRef', 'RegionRefType', 1, 0, {'maxOccurs': 'unbounded', 'minOccurs': '1', 'name': 'RegionRef', 'type': 'RegionRefType'}, None), |
||
| 7879 | ] |
||
| 7880 | subclass = None |
||
| 7881 | superclass = None |
||
| 7882 | def __init__(self, id=None, zIndex=None, caption=None, RegionRef=None, gds_collector_=None, **kwargs_): |
||
| 7883 | self.gds_collector_ = gds_collector_ |
||
| 7884 | self.gds_elementtree_node_ = None |
||
| 7885 | self.original_tagname_ = None |
||
| 7886 | self.parent_object_ = kwargs_.get('parent_object_') |
||
| 7887 | self.ns_prefix_ = None |
||
| 7888 | self.id = _cast(None, id) |
||
| 7889 | self.id_nsprefix_ = "pc" |
||
| 7890 | self.zIndex = _cast(int, zIndex) |
||
| 7891 | self.zIndex_nsprefix_ = "pc" |
||
| 7892 | self.caption = _cast(None, caption) |
||
| 7893 | self.caption_nsprefix_ = "pc" |
||
| 7894 | if RegionRef is None: |
||
| 7895 | self.RegionRef = [] |
||
| 7896 | else: |
||
| 7897 | self.RegionRef = RegionRef |
||
| 7898 | self.RegionRef_nsprefix_ = "pc" |
||
| 7899 | def factory(*args_, **kwargs_): |
||
| 7900 | if CurrentSubclassModule_ is not None: |
||
| 7901 | subclass = getSubclassFromModule_( |
||
| 7902 | CurrentSubclassModule_, LayerType) |
||
| 7903 | if subclass is not None: |
||
| 7904 | return subclass(*args_, **kwargs_) |
||
| 7905 | if LayerType.subclass: |
||
| 7906 | return LayerType.subclass(*args_, **kwargs_) |
||
| 7907 | else: |
||
| 7908 | return LayerType(*args_, **kwargs_) |
||
| 7909 | factory = staticmethod(factory) |
||
| 7910 | def get_ns_prefix_(self): |
||
| 7911 | return self.ns_prefix_ |
||
| 7912 | def set_ns_prefix_(self, ns_prefix): |
||
| 7913 | self.ns_prefix_ = ns_prefix |
||
| 7914 | def get_RegionRef(self): |
||
| 7915 | return self.RegionRef |
||
| 7916 | def set_RegionRef(self, RegionRef): |
||
| 7917 | self.RegionRef = RegionRef |
||
| 7918 | def add_RegionRef(self, value): |
||
| 7919 | self.RegionRef.append(value) |
||
| 7920 | def insert_RegionRef_at(self, index, value): |
||
| 7921 | self.RegionRef.insert(index, value) |
||
| 7922 | def replace_RegionRef_at(self, index, value): |
||
| 7923 | self.RegionRef[index] = value |
||
| 7924 | def get_id(self): |
||
| 7925 | return self.id |
||
| 7926 | def set_id(self, id): |
||
| 7927 | self.id = id |
||
| 7928 | def get_zIndex(self): |
||
| 7929 | return self.zIndex |
||
| 7930 | def set_zIndex(self, zIndex): |
||
| 7931 | self.zIndex = zIndex |
||
| 7932 | def get_caption(self): |
||
| 7933 | return self.caption |
||
| 7934 | def set_caption(self, caption): |
||
| 7935 | self.caption = caption |
||
| 7936 | def hasContent_(self): |
||
| 7937 | if ( |
||
| 7938 | self.RegionRef |
||
| 7939 | ): |
||
| 7940 | return True |
||
| 7941 | else: |
||
| 7942 | return False |
||
| 7943 | def export(self, outfile, level, namespaceprefix_='', namespacedef_='xmlns:pc="http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15"', name_='LayerType', pretty_print=True): |
||
| 7944 | imported_ns_def_ = GenerateDSNamespaceDefs_.get('LayerType') |
||
| 7945 | if imported_ns_def_ is not None: |
||
| 7946 | namespacedef_ = imported_ns_def_ |
||
| 7947 | if pretty_print: |
||
| 7948 | eol_ = '\n' |
||
| 7949 | else: |
||
| 7950 | eol_ = '' |
||
| 7951 | if self.original_tagname_ is not None and name_ == 'LayerType': |
||
| 7952 | name_ = self.original_tagname_ |
||
| 7953 | if UseCapturedNS_ and self.ns_prefix_: |
||
| 7954 | namespaceprefix_ = self.ns_prefix_ + ':' |
||
| 7955 | showIndent(outfile, level, pretty_print) |
||
| 7956 | outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) |
||
| 7957 | already_processed = set() |
||
| 7958 | self.exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='LayerType') |
||
| 7959 | if self.hasContent_(): |
||
| 7960 | outfile.write('>%s' % (eol_, )) |
||
| 7961 | self.exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='LayerType', pretty_print=pretty_print) |
||
| 7962 | showIndent(outfile, level, pretty_print) |
||
| 7963 | outfile.write('</%s%s>%s' % (namespaceprefix_, name_, eol_)) |
||
| 7964 | else: |
||
| 7965 | outfile.write('/>%s' % (eol_, )) |
||
| 7966 | def exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='LayerType'): |
||
| 7967 | if self.id is not None and 'id' not in already_processed: |
||
| 7968 | already_processed.add('id') |
||
| 7969 | outfile.write(' id=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.id), input_name='id')), )) |
||
| 7970 | if self.zIndex is not None and 'zIndex' not in already_processed: |
||
| 7971 | already_processed.add('zIndex') |
||
| 7972 | outfile.write(' zIndex="%s"' % self.gds_format_integer(self.zIndex, input_name='zIndex')) |
||
| 7973 | if self.caption is not None and 'caption' not in already_processed: |
||
| 7974 | already_processed.add('caption') |
||
| 7975 | outfile.write(' caption=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.caption), input_name='caption')), )) |
||
| 7976 | def exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='xmlns:pc="http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15"', name_='LayerType', fromsubclass_=False, pretty_print=True): |
||
| 7977 | if pretty_print: |
||
| 7978 | eol_ = '\n' |
||
| 7979 | else: |
||
| 7980 | eol_ = '' |
||
| 7981 | for RegionRef_ in self.RegionRef: |
||
| 7982 | namespaceprefix_ = self.RegionRef_nsprefix_ + ':' if (UseCapturedNS_ and self.RegionRef_nsprefix_) else '' |
||
| 7983 | RegionRef_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='RegionRef', pretty_print=pretty_print) |
||
| 7984 | def to_etree(self, parent_element=None, name_='LayerType', mapping_=None, nsmap_=None): |
||
| 7985 | if parent_element is None: |
||
| 7986 | element = etree_.Element('{http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15}' + name_, nsmap=nsmap_) |
||
| 7987 | else: |
||
| 7988 | element = etree_.SubElement(parent_element, '{http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15}' + name_, nsmap=nsmap_) |
||
| 7989 | if self.id is not None: |
||
| 7990 | element.set('id', self.gds_format_string(self.id)) |
||
| 7991 | if self.zIndex is not None: |
||
| 7992 | element.set('zIndex', self.gds_format_integer(self.zIndex)) |
||
| 7993 | if self.caption is not None: |
||
| 7994 | element.set('caption', self.gds_format_string(self.caption)) |
||
| 7995 | for RegionRef_ in self.RegionRef: |
||
| 7996 | RegionRef_.to_etree(element, name_='RegionRef', mapping_=mapping_, nsmap_=nsmap_) |
||
| 7997 | if mapping_ is not None: |
||
| 7998 | mapping_[id(self)] = element |
||
| 7999 | return element |
||
| 8000 | def build(self, node, gds_collector_=None): |
||
| 8001 | self.gds_collector_ = gds_collector_ |
||
| 8002 | if SaveElementTreeNode: |
||
| 8003 | self.gds_elementtree_node_ = node |
||
| 8004 | already_processed = set() |
||
| 8005 | self.ns_prefix_ = node.prefix |
||
| 8006 | self.buildAttributes(node, node.attrib, already_processed) |
||
| 8007 | for child in node: |
||
| 8008 | nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] |
||
| 8009 | self.buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) |
||
| 8010 | return self |
||
| 8011 | def buildAttributes(self, node, attrs, already_processed): |
||
| 8012 | value = find_attr_value_('id', node) |
||
| 8013 | if value is not None and 'id' not in already_processed: |
||
| 8014 | already_processed.add('id') |
||
| 8015 | self.id = value |
||
| 8016 | value = find_attr_value_('zIndex', node) |
||
| 8017 | if value is not None and 'zIndex' not in already_processed: |
||
| 8018 | already_processed.add('zIndex') |
||
| 8019 | self.zIndex = self.gds_parse_integer(value, node, 'zIndex') |
||
| 8020 | value = find_attr_value_('caption', node) |
||
| 8021 | if value is not None and 'caption' not in already_processed: |
||
| 8022 | already_processed.add('caption') |
||
| 8023 | self.caption = value |
||
| 8024 | def buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None): |
||
| 8025 | if nodeName_ == 'RegionRef': |
||
| 8026 | obj_ = RegionRefType.factory(parent_object_=self) |
||
| 8027 | obj_.build(child_, gds_collector_=gds_collector_) |
||
| 8028 | self.RegionRef.append(obj_) |
||
| 8029 | obj_.original_tagname_ = 'RegionRef' |
||
| 8030 | def __hash__(self): |
||
| 8031 | return hash(self.id) |
||
| 8032 | # end class LayerType |
||
| 8033 | |||
| 8034 | |||
| 8035 | class BaselineType(GeneratedsSuper): |
||
| 8036 | """Confidence value (between 0 and 1)""" |
||
| 8037 | __hash__ = GeneratedsSuper.__hash__ |
||
| 8038 | member_data_items_ = [ |
||
| 8039 | MemberSpec_('points', 'pc:PointsType', 0, 0, {'use': 'required'}), |
||
| 8040 | MemberSpec_('conf', 'pc:ConfSimpleType', 0, 1, {'use': 'optional'}), |
||
| 8041 | ] |
||
| 8042 | subclass = None |
||
| 8043 | superclass = None |
||
| 8044 | View Code Duplication | def __init__(self, points=None, conf=None, gds_collector_=None, **kwargs_): |
|
| 8045 | self.gds_collector_ = gds_collector_ |
||
| 8046 | self.gds_elementtree_node_ = None |
||
| 8047 | self.original_tagname_ = None |
||
| 8048 | self.parent_object_ = kwargs_.get('parent_object_') |
||
| 8049 | self.ns_prefix_ = None |
||
| 8050 | self.points = _cast(None, points) |
||
| 8051 | self.points_nsprefix_ = "pc" |
||
| 8052 | self.conf = _cast(float, conf) |
||
| 8053 | self.conf_nsprefix_ = "pc" |
||
| 8054 | def factory(*args_, **kwargs_): |
||
| 8055 | if CurrentSubclassModule_ is not None: |
||
| 8056 | subclass = getSubclassFromModule_( |
||
| 8057 | CurrentSubclassModule_, BaselineType) |
||
| 8058 | if subclass is not None: |
||
| 8059 | return subclass(*args_, **kwargs_) |
||
| 8060 | if BaselineType.subclass: |
||
| 8061 | return BaselineType.subclass(*args_, **kwargs_) |
||
| 8062 | else: |
||
| 8063 | return BaselineType(*args_, **kwargs_) |
||
| 8064 | factory = staticmethod(factory) |
||
| 8065 | def get_ns_prefix_(self): |
||
| 8066 | return self.ns_prefix_ |
||
| 8067 | def set_ns_prefix_(self, ns_prefix): |
||
| 8068 | self.ns_prefix_ = ns_prefix |
||
| 8069 | def get_points(self): |
||
| 8070 | return self.points |
||
| 8071 | def set_points(self, points): |
||
| 8072 | self.points = points |
||
| 8073 | def get_conf(self): |
||
| 8074 | return self.conf |
||
| 8075 | def set_conf(self, conf): |
||
| 8076 | self.conf = conf |
||
| 8077 | View Code Duplication | def validate_PointsType(self, value): |
|
| 8078 | # Validate type pc:PointsType, a restriction on string. |
||
| 8079 | if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None: |
||
| 8080 | if not isinstance(value, str): |
||
| 8081 | lineno = self.gds_get_node_lineno_() |
||
| 8082 | self.gds_collector_.add_message('Value "%(value)s"%(lineno)s is not of the correct base simple type (str)' % {"value": value, "lineno": lineno, }) |
||
| 8083 | return False |
||
| 8084 | if not self.gds_validate_simple_patterns( |
||
| 8085 | self.validate_PointsType_patterns_, value): |
||
| 8086 | self.gds_collector_.add_message('Value "%s" does not match xsd pattern restrictions: %s' % (encode_str_2_3(value), self.validate_PointsType_patterns_, )) |
||
| 8087 | validate_PointsType_patterns_ = [['^(([0-9]+,[0-9]+ )+([0-9]+,[0-9]+))$']] |
||
| 8088 | View Code Duplication | def validate_ConfSimpleType(self, value): |
|
| 8089 | # Validate type pc:ConfSimpleType, a restriction on float. |
||
| 8090 | if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None: |
||
| 8091 | if not isinstance(value, float): |
||
| 8092 | lineno = self.gds_get_node_lineno_() |
||
| 8093 | self.gds_collector_.add_message('Value "%(value)s"%(lineno)s is not of the correct base simple type (float)' % {"value": value, "lineno": lineno, }) |
||
| 8094 | return False |
||
| 8095 | if value < 0: |
||
| 8096 | lineno = self.gds_get_node_lineno_() |
||
| 8097 | self.gds_collector_.add_message('Value "%(value)s"%(lineno)s does not match xsd minInclusive restriction on ConfSimpleType' % {"value": value, "lineno": lineno} ) |
||
| 8098 | result = False |
||
| 8099 | if value > 1: |
||
| 8100 | lineno = self.gds_get_node_lineno_() |
||
| 8101 | self.gds_collector_.add_message('Value "%(value)s"%(lineno)s does not match xsd maxInclusive restriction on ConfSimpleType' % {"value": value, "lineno": lineno} ) |
||
| 8102 | result = False |
||
| 8103 | def hasContent_(self): |
||
| 8104 | if ( |
||
| 8105 | |||
| 8106 | ): |
||
| 8107 | return True |
||
| 8108 | else: |
||
| 8109 | return False |
||
| 8110 | def export(self, outfile, level, namespaceprefix_='', namespacedef_='xmlns:pc="http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15"', name_='BaselineType', pretty_print=True): |
||
| 8111 | imported_ns_def_ = GenerateDSNamespaceDefs_.get('BaselineType') |
||
| 8112 | if imported_ns_def_ is not None: |
||
| 8113 | namespacedef_ = imported_ns_def_ |
||
| 8114 | if pretty_print: |
||
| 8115 | eol_ = '\n' |
||
| 8116 | else: |
||
| 8117 | eol_ = '' |
||
| 8118 | if self.original_tagname_ is not None and name_ == 'BaselineType': |
||
| 8119 | name_ = self.original_tagname_ |
||
| 8120 | if UseCapturedNS_ and self.ns_prefix_: |
||
| 8121 | namespaceprefix_ = self.ns_prefix_ + ':' |
||
| 8122 | showIndent(outfile, level, pretty_print) |
||
| 8123 | outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) |
||
| 8124 | already_processed = set() |
||
| 8125 | self.exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='BaselineType') |
||
| 8126 | if self.hasContent_(): |
||
| 8127 | outfile.write('>%s' % (eol_, )) |
||
| 8128 | self.exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='BaselineType', pretty_print=pretty_print) |
||
| 8129 | outfile.write('</%s%s>%s' % (namespaceprefix_, name_, eol_)) |
||
| 8130 | else: |
||
| 8131 | outfile.write('/>%s' % (eol_, )) |
||
| 8132 | def exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='BaselineType'): |
||
| 8133 | if self.points is not None and 'points' not in already_processed: |
||
| 8134 | already_processed.add('points') |
||
| 8135 | outfile.write(' points=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.points), input_name='points')), )) |
||
| 8136 | if self.conf is not None and 'conf' not in already_processed: |
||
| 8137 | already_processed.add('conf') |
||
| 8138 | outfile.write(' conf="%s"' % self.gds_format_float(self.conf, input_name='conf')) |
||
| 8139 | def exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='xmlns:pc="http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15"', name_='BaselineType', fromsubclass_=False, pretty_print=True): |
||
| 8140 | pass |
||
| 8141 | View Code Duplication | def to_etree(self, parent_element=None, name_='BaselineType', mapping_=None, nsmap_=None): |
|
| 8142 | if parent_element is None: |
||
| 8143 | element = etree_.Element('{http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15}' + name_, nsmap=nsmap_) |
||
| 8144 | else: |
||
| 8145 | element = etree_.SubElement(parent_element, '{http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15}' + name_, nsmap=nsmap_) |
||
| 8146 | if self.points is not None: |
||
| 8147 | element.set('points', self.gds_format_string(self.points)) |
||
| 8148 | if self.conf is not None: |
||
| 8149 | element.set('conf', self.gds_format_float(self.conf)) |
||
| 8150 | if mapping_ is not None: |
||
| 8151 | mapping_[id(self)] = element |
||
| 8152 | return element |
||
| 8153 | def build(self, node, gds_collector_=None): |
||
| 8154 | self.gds_collector_ = gds_collector_ |
||
| 8155 | if SaveElementTreeNode: |
||
| 8156 | self.gds_elementtree_node_ = node |
||
| 8157 | already_processed = set() |
||
| 8158 | self.ns_prefix_ = node.prefix |
||
| 8159 | self.buildAttributes(node, node.attrib, already_processed) |
||
| 8160 | for child in node: |
||
| 8161 | nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] |
||
| 8162 | self.buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) |
||
| 8163 | return self |
||
| 8164 | View Code Duplication | def buildAttributes(self, node, attrs, already_processed): |
|
| 8165 | value = find_attr_value_('points', node) |
||
| 8166 | if value is not None and 'points' not in already_processed: |
||
| 8167 | already_processed.add('points') |
||
| 8168 | self.points = value |
||
| 8169 | self.validate_PointsType(self.points) # validate type PointsType |
||
| 8170 | value = find_attr_value_('conf', node) |
||
| 8171 | if value is not None and 'conf' not in already_processed: |
||
| 8172 | already_processed.add('conf') |
||
| 8173 | value = self.gds_parse_float(value, node, 'conf') |
||
| 8174 | self.conf = value |
||
| 8175 | self.validate_ConfSimpleType(self.conf) # validate type ConfSimpleType |
||
| 8176 | def buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None): |
||
| 8177 | pass |
||
| 8178 | def __hash__(self): |
||
| 8179 | return hash(self.id) |
||
| 8180 | # end class BaselineType |
||
| 8181 | |||
| 8182 | |||
| 8183 | View Code Duplication | class RelationsType(GeneratedsSuper): |
|
| 8184 | """Container for one-to-one relations between layout |
||
| 8185 | objects (for example: DropCap - paragraph, caption - |
||
| 8186 | image).""" |
||
| 8187 | __hash__ = GeneratedsSuper.__hash__ |
||
| 8188 | member_data_items_ = [ |
||
| 8189 | MemberSpec_('Relation', 'RelationType', 1, 0, {'maxOccurs': 'unbounded', 'minOccurs': '1', 'name': 'Relation', 'type': 'RelationType'}, None), |
||
| 8190 | ] |
||
| 8191 | subclass = None |
||
| 8192 | superclass = None |
||
| 8193 | def __init__(self, Relation=None, gds_collector_=None, **kwargs_): |
||
| 8194 | self.gds_collector_ = gds_collector_ |
||
| 8195 | self.gds_elementtree_node_ = None |
||
| 8196 | self.original_tagname_ = None |
||
| 8197 | self.parent_object_ = kwargs_.get('parent_object_') |
||
| 8198 | self.ns_prefix_ = None |
||
| 8199 | if Relation is None: |
||
| 8200 | self.Relation = [] |
||
| 8201 | else: |
||
| 8202 | self.Relation = Relation |
||
| 8203 | self.Relation_nsprefix_ = "pc" |
||
| 8204 | def factory(*args_, **kwargs_): |
||
| 8205 | if CurrentSubclassModule_ is not None: |
||
| 8206 | subclass = getSubclassFromModule_( |
||
| 8207 | CurrentSubclassModule_, RelationsType) |
||
| 8208 | if subclass is not None: |
||
| 8209 | return subclass(*args_, **kwargs_) |
||
| 8210 | if RelationsType.subclass: |
||
| 8211 | return RelationsType.subclass(*args_, **kwargs_) |
||
| 8212 | else: |
||
| 8213 | return RelationsType(*args_, **kwargs_) |
||
| 8214 | factory = staticmethod(factory) |
||
| 8215 | def get_ns_prefix_(self): |
||
| 8216 | return self.ns_prefix_ |
||
| 8217 | def set_ns_prefix_(self, ns_prefix): |
||
| 8218 | self.ns_prefix_ = ns_prefix |
||
| 8219 | def get_Relation(self): |
||
| 8220 | return self.Relation |
||
| 8221 | def set_Relation(self, Relation): |
||
| 8222 | self.Relation = Relation |
||
| 8223 | def add_Relation(self, value): |
||
| 8224 | self.Relation.append(value) |
||
| 8225 | def insert_Relation_at(self, index, value): |
||
| 8226 | self.Relation.insert(index, value) |
||
| 8227 | def replace_Relation_at(self, index, value): |
||
| 8228 | self.Relation[index] = value |
||
| 8229 | def hasContent_(self): |
||
| 8230 | if ( |
||
| 8231 | self.Relation |
||
| 8232 | ): |
||
| 8233 | return True |
||
| 8234 | else: |
||
| 8235 | return False |
||
| 8236 | def export(self, outfile, level, namespaceprefix_='', namespacedef_='xmlns:pc="http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15"', name_='RelationsType', pretty_print=True): |
||
| 8237 | imported_ns_def_ = GenerateDSNamespaceDefs_.get('RelationsType') |
||
| 8238 | if imported_ns_def_ is not None: |
||
| 8239 | namespacedef_ = imported_ns_def_ |
||
| 8240 | if pretty_print: |
||
| 8241 | eol_ = '\n' |
||
| 8242 | else: |
||
| 8243 | eol_ = '' |
||
| 8244 | if self.original_tagname_ is not None and name_ == 'RelationsType': |
||
| 8245 | name_ = self.original_tagname_ |
||
| 8246 | if UseCapturedNS_ and self.ns_prefix_: |
||
| 8247 | namespaceprefix_ = self.ns_prefix_ + ':' |
||
| 8248 | showIndent(outfile, level, pretty_print) |
||
| 8249 | outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) |
||
| 8250 | already_processed = set() |
||
| 8251 | self.exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='RelationsType') |
||
| 8252 | if self.hasContent_(): |
||
| 8253 | outfile.write('>%s' % (eol_, )) |
||
| 8254 | self.exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='RelationsType', pretty_print=pretty_print) |
||
| 8255 | showIndent(outfile, level, pretty_print) |
||
| 8256 | outfile.write('</%s%s>%s' % (namespaceprefix_, name_, eol_)) |
||
| 8257 | else: |
||
| 8258 | outfile.write('/>%s' % (eol_, )) |
||
| 8259 | def exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='RelationsType'): |
||
| 8260 | pass |
||
| 8261 | 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): |
||
| 8262 | if pretty_print: |
||
| 8263 | eol_ = '\n' |
||
| 8264 | else: |
||
| 8265 | eol_ = '' |
||
| 8266 | for Relation_ in self.Relation: |
||
| 8267 | namespaceprefix_ = self.Relation_nsprefix_ + ':' if (UseCapturedNS_ and self.Relation_nsprefix_) else '' |
||
| 8268 | Relation_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Relation', pretty_print=pretty_print) |
||
| 8269 | def to_etree(self, parent_element=None, name_='RelationsType', mapping_=None, nsmap_=None): |
||
| 8270 | if parent_element is None: |
||
| 8271 | element = etree_.Element('{http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15}' + name_, nsmap=nsmap_) |
||
| 8272 | else: |
||
| 8273 | element = etree_.SubElement(parent_element, '{http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15}' + name_, nsmap=nsmap_) |
||
| 8274 | for Relation_ in self.Relation: |
||
| 8275 | Relation_.to_etree(element, name_='Relation', mapping_=mapping_, nsmap_=nsmap_) |
||
| 8276 | if mapping_ is not None: |
||
| 8277 | mapping_[id(self)] = element |
||
| 8278 | return element |
||
| 8279 | def build(self, node, gds_collector_=None): |
||
| 8280 | self.gds_collector_ = gds_collector_ |
||
| 8281 | if SaveElementTreeNode: |
||
| 8282 | self.gds_elementtree_node_ = node |
||
| 8283 | already_processed = set() |
||
| 8284 | self.ns_prefix_ = node.prefix |
||
| 8285 | self.buildAttributes(node, node.attrib, already_processed) |
||
| 8286 | for child in node: |
||
| 8287 | nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] |
||
| 8288 | self.buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) |
||
| 8289 | return self |
||
| 8290 | def buildAttributes(self, node, attrs, already_processed): |
||
| 8291 | pass |
||
| 8292 | def buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None): |
||
| 8293 | if nodeName_ == 'Relation': |
||
| 8294 | obj_ = RelationType.factory(parent_object_=self) |
||
| 8295 | obj_.build(child_, gds_collector_=gds_collector_) |
||
| 8296 | self.Relation.append(obj_) |
||
| 8297 | obj_.original_tagname_ = 'Relation' |
||
| 8298 | def __hash__(self): |
||
| 8299 | return hash(self.id) |
||
| 8300 | # end class RelationsType |
||
| 8301 | |||
| 8302 | |||
| 8303 | class RelationType(GeneratedsSuper): |
||
| 8304 | """One-to-one relation between to layout object. Use 'link' |
||
| 8305 | for loose relations and 'join' for strong relations |
||
| 8306 | (where something is fragmented for instance). |
||
| 8307 | Examples for 'link': caption - image floating - |
||
| 8308 | paragraph paragraph - paragraph (when a paragraph is |
||
| 8309 | split across columns and the last word of the first |
||
| 8310 | paragraph DOES NOT continue in the second paragraph) |
||
| 8311 | drop-cap - paragraph (when the drop-cap is a whole word) |
||
| 8312 | Examples for 'join': word - word (separated word at the |
||
| 8313 | end of a line) drop-cap - paragraph (when the drop-cap |
||
| 8314 | is not a whole word) paragraph - paragraph (when a |
||
| 8315 | pragraph is split across columns and the last word of |
||
| 8316 | the first paragraph DOES continue in the second |
||
| 8317 | paragraph) |
||
| 8318 | For generic use""" |
||
| 8319 | __hash__ = GeneratedsSuper.__hash__ |
||
| 8320 | member_data_items_ = [ |
||
| 8321 | MemberSpec_('id', 'string', 0, 0, {'use': 'required'}), |
||
| 8322 | MemberSpec_('type_', 'string', 0, 1, {'use': 'optional'}), |
||
| 8323 | MemberSpec_('custom', 'string', 0, 1, {'use': 'optional'}), |
||
| 8324 | MemberSpec_('comments', 'string', 0, 1, {'use': 'optional'}), |
||
| 8325 | MemberSpec_('Labels', 'LabelsType', 1, 1, {'maxOccurs': 'unbounded', 'minOccurs': '0', 'name': 'Labels', 'type': 'LabelsType'}, None), |
||
| 8326 | MemberSpec_('SourceRegionRef', 'RegionRefType', 0, 0, {'maxOccurs': '1', 'minOccurs': '1', 'name': 'SourceRegionRef', 'type': 'RegionRefType'}, None), |
||
| 8327 | MemberSpec_('TargetRegionRef', 'RegionRefType', 0, 0, {'maxOccurs': '1', 'minOccurs': '1', 'name': 'TargetRegionRef', 'type': 'RegionRefType'}, None), |
||
| 8328 | ] |
||
| 8329 | subclass = None |
||
| 8330 | superclass = None |
||
| 8331 | def __init__(self, id=None, type_=None, custom=None, comments=None, Labels=None, SourceRegionRef=None, TargetRegionRef=None, gds_collector_=None, **kwargs_): |
||
| 8332 | self.gds_collector_ = gds_collector_ |
||
| 8333 | self.gds_elementtree_node_ = None |
||
| 8334 | self.original_tagname_ = None |
||
| 8335 | self.parent_object_ = kwargs_.get('parent_object_') |
||
| 8336 | self.ns_prefix_ = None |
||
| 8337 | self.id = _cast(None, id) |
||
| 8338 | self.id_nsprefix_ = "pc" |
||
| 8339 | self.type_ = _cast(None, type_) |
||
| 8340 | self.type__nsprefix_ = "pc" |
||
| 8341 | self.custom = _cast(None, custom) |
||
| 8342 | self.custom_nsprefix_ = "pc" |
||
| 8343 | self.comments = _cast(None, comments) |
||
| 8344 | self.comments_nsprefix_ = "pc" |
||
| 8345 | if Labels is None: |
||
| 8346 | self.Labels = [] |
||
| 8347 | else: |
||
| 8348 | self.Labels = Labels |
||
| 8349 | self.Labels_nsprefix_ = "pc" |
||
| 8350 | self.SourceRegionRef = SourceRegionRef |
||
| 8351 | self.SourceRegionRef_nsprefix_ = "pc" |
||
| 8352 | self.TargetRegionRef = TargetRegionRef |
||
| 8353 | self.TargetRegionRef_nsprefix_ = "pc" |
||
| 8354 | def factory(*args_, **kwargs_): |
||
| 8355 | if CurrentSubclassModule_ is not None: |
||
| 8356 | subclass = getSubclassFromModule_( |
||
| 8357 | CurrentSubclassModule_, RelationType) |
||
| 8358 | if subclass is not None: |
||
| 8359 | return subclass(*args_, **kwargs_) |
||
| 8360 | if RelationType.subclass: |
||
| 8361 | return RelationType.subclass(*args_, **kwargs_) |
||
| 8362 | else: |
||
| 8363 | return RelationType(*args_, **kwargs_) |
||
| 8364 | factory = staticmethod(factory) |
||
| 8365 | def get_ns_prefix_(self): |
||
| 8366 | return self.ns_prefix_ |
||
| 8367 | def set_ns_prefix_(self, ns_prefix): |
||
| 8368 | self.ns_prefix_ = ns_prefix |
||
| 8369 | def get_Labels(self): |
||
| 8370 | return self.Labels |
||
| 8371 | def set_Labels(self, Labels): |
||
| 8372 | self.Labels = Labels |
||
| 8373 | def add_Labels(self, value): |
||
| 8374 | self.Labels.append(value) |
||
| 8375 | def insert_Labels_at(self, index, value): |
||
| 8376 | self.Labels.insert(index, value) |
||
| 8377 | def replace_Labels_at(self, index, value): |
||
| 8378 | self.Labels[index] = value |
||
| 8379 | def get_SourceRegionRef(self): |
||
| 8380 | return self.SourceRegionRef |
||
| 8381 | def set_SourceRegionRef(self, SourceRegionRef): |
||
| 8382 | self.SourceRegionRef = SourceRegionRef |
||
| 8383 | def get_TargetRegionRef(self): |
||
| 8384 | return self.TargetRegionRef |
||
| 8385 | def set_TargetRegionRef(self, TargetRegionRef): |
||
| 8386 | self.TargetRegionRef = TargetRegionRef |
||
| 8387 | def get_id(self): |
||
| 8388 | return self.id |
||
| 8389 | def set_id(self, id): |
||
| 8390 | self.id = id |
||
| 8391 | def get_type(self): |
||
| 8392 | return self.type_ |
||
| 8393 | def set_type(self, type_): |
||
| 8394 | self.type_ = type_ |
||
| 8395 | def get_custom(self): |
||
| 8396 | return self.custom |
||
| 8397 | def set_custom(self, custom): |
||
| 8398 | self.custom = custom |
||
| 8399 | def get_comments(self): |
||
| 8400 | return self.comments |
||
| 8401 | def set_comments(self, comments): |
||
| 8402 | self.comments = comments |
||
| 8403 | def hasContent_(self): |
||
| 8404 | if ( |
||
| 8405 | self.Labels or |
||
| 8406 | self.SourceRegionRef is not None or |
||
| 8407 | self.TargetRegionRef is not None |
||
| 8408 | ): |
||
| 8409 | return True |
||
| 8410 | else: |
||
| 8411 | return False |
||
| 8412 | def export(self, outfile, level, namespaceprefix_='', namespacedef_='xmlns:pc="http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15"', name_='RelationType', pretty_print=True): |
||
| 8413 | imported_ns_def_ = GenerateDSNamespaceDefs_.get('RelationType') |
||
| 8414 | if imported_ns_def_ is not None: |
||
| 8415 | namespacedef_ = imported_ns_def_ |
||
| 8416 | if pretty_print: |
||
| 8417 | eol_ = '\n' |
||
| 8418 | else: |
||
| 8419 | eol_ = '' |
||
| 8420 | if self.original_tagname_ is not None and name_ == 'RelationType': |
||
| 8421 | name_ = self.original_tagname_ |
||
| 8422 | if UseCapturedNS_ and self.ns_prefix_: |
||
| 8423 | namespaceprefix_ = self.ns_prefix_ + ':' |
||
| 8424 | showIndent(outfile, level, pretty_print) |
||
| 8425 | outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) |
||
| 8426 | already_processed = set() |
||
| 8427 | self.exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='RelationType') |
||
| 8428 | if self.hasContent_(): |
||
| 8429 | outfile.write('>%s' % (eol_, )) |
||
| 8430 | self.exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='RelationType', pretty_print=pretty_print) |
||
| 8431 | showIndent(outfile, level, pretty_print) |
||
| 8432 | outfile.write('</%s%s>%s' % (namespaceprefix_, name_, eol_)) |
||
| 8433 | else: |
||
| 8434 | outfile.write('/>%s' % (eol_, )) |
||
| 8435 | View Code Duplication | def exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='RelationType'): |
|
| 8436 | if self.id is not None and 'id' not in already_processed: |
||
| 8437 | already_processed.add('id') |
||
| 8438 | outfile.write(' id=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.id), input_name='id')), )) |
||
| 8439 | if self.type_ is not None and 'type_' not in already_processed: |
||
| 8440 | already_processed.add('type_') |
||
| 8441 | outfile.write(' type=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.type_), input_name='type')), )) |
||
| 8442 | if self.custom is not None and 'custom' not in already_processed: |
||
| 8443 | already_processed.add('custom') |
||
| 8444 | outfile.write(' custom=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.custom), input_name='custom')), )) |
||
| 8445 | if self.comments is not None and 'comments' not in already_processed: |
||
| 8446 | already_processed.add('comments') |
||
| 8447 | outfile.write(' comments=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.comments), input_name='comments')), )) |
||
| 8448 | def exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='xmlns:pc="http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15"', name_='RelationType', fromsubclass_=False, pretty_print=True): |
||
| 8449 | if pretty_print: |
||
| 8450 | eol_ = '\n' |
||
| 8451 | else: |
||
| 8452 | eol_ = '' |
||
| 8453 | for Labels_ in self.Labels: |
||
| 8454 | namespaceprefix_ = self.Labels_nsprefix_ + ':' if (UseCapturedNS_ and self.Labels_nsprefix_) else '' |
||
| 8455 | Labels_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Labels', pretty_print=pretty_print) |
||
| 8456 | if self.SourceRegionRef is not None: |
||
| 8457 | namespaceprefix_ = self.SourceRegionRef_nsprefix_ + ':' if (UseCapturedNS_ and self.SourceRegionRef_nsprefix_) else '' |
||
| 8458 | self.SourceRegionRef.export(outfile, level, namespaceprefix_, namespacedef_='', name_='SourceRegionRef', pretty_print=pretty_print) |
||
| 8459 | if self.TargetRegionRef is not None: |
||
| 8460 | namespaceprefix_ = self.TargetRegionRef_nsprefix_ + ':' if (UseCapturedNS_ and self.TargetRegionRef_nsprefix_) else '' |
||
| 8461 | self.TargetRegionRef.export(outfile, level, namespaceprefix_, namespacedef_='', name_='TargetRegionRef', pretty_print=pretty_print) |
||
| 8462 | def to_etree(self, parent_element=None, name_='RelationType', mapping_=None, nsmap_=None): |
||
| 8463 | if parent_element is None: |
||
| 8464 | element = etree_.Element('{http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15}' + name_, nsmap=nsmap_) |
||
| 8465 | else: |
||
| 8466 | element = etree_.SubElement(parent_element, '{http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15}' + name_, nsmap=nsmap_) |
||
| 8467 | if self.id is not None: |
||
| 8468 | element.set('id', self.gds_format_string(self.id)) |
||
| 8469 | if self.type_ is not None: |
||
| 8470 | element.set('type', self.gds_format_string(self.type_)) |
||
| 8471 | if self.custom is not None: |
||
| 8472 | element.set('custom', self.gds_format_string(self.custom)) |
||
| 8473 | if self.comments is not None: |
||
| 8474 | element.set('comments', self.gds_format_string(self.comments)) |
||
| 8475 | for Labels_ in self.Labels: |
||
| 8476 | Labels_.to_etree(element, name_='Labels', mapping_=mapping_, nsmap_=nsmap_) |
||
| 8477 | if self.SourceRegionRef is not None: |
||
| 8478 | SourceRegionRef_ = self.SourceRegionRef |
||
| 8479 | SourceRegionRef_.to_etree(element, name_='SourceRegionRef', mapping_=mapping_, nsmap_=nsmap_) |
||
| 8480 | if self.TargetRegionRef is not None: |
||
| 8481 | TargetRegionRef_ = self.TargetRegionRef |
||
| 8482 | TargetRegionRef_.to_etree(element, name_='TargetRegionRef', mapping_=mapping_, nsmap_=nsmap_) |
||
| 8483 | if mapping_ is not None: |
||
| 8484 | mapping_[id(self)] = element |
||
| 8485 | return element |
||
| 8486 | def build(self, node, gds_collector_=None): |
||
| 8487 | self.gds_collector_ = gds_collector_ |
||
| 8488 | if SaveElementTreeNode: |
||
| 8489 | self.gds_elementtree_node_ = node |
||
| 8490 | already_processed = set() |
||
| 8491 | self.ns_prefix_ = node.prefix |
||
| 8492 | self.buildAttributes(node, node.attrib, already_processed) |
||
| 8493 | for child in node: |
||
| 8494 | nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] |
||
| 8495 | self.buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) |
||
| 8496 | return self |
||
| 8497 | View Code Duplication | def buildAttributes(self, node, attrs, already_processed): |
|
| 8498 | value = find_attr_value_('id', node) |
||
| 8499 | if value is not None and 'id' not in already_processed: |
||
| 8500 | already_processed.add('id') |
||
| 8501 | self.id = value |
||
| 8502 | value = find_attr_value_('type', node) |
||
| 8503 | if value is not None and 'type' not in already_processed: |
||
| 8504 | already_processed.add('type') |
||
| 8505 | self.type_ = value |
||
| 8506 | value = find_attr_value_('custom', node) |
||
| 8507 | if value is not None and 'custom' not in already_processed: |
||
| 8508 | already_processed.add('custom') |
||
| 8509 | self.custom = value |
||
| 8510 | value = find_attr_value_('comments', node) |
||
| 8511 | if value is not None and 'comments' not in already_processed: |
||
| 8512 | already_processed.add('comments') |
||
| 8513 | self.comments = value |
||
| 8514 | def buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None): |
||
| 8515 | if nodeName_ == 'Labels': |
||
| 8516 | obj_ = LabelsType.factory(parent_object_=self) |
||
| 8517 | obj_.build(child_, gds_collector_=gds_collector_) |
||
| 8518 | self.Labels.append(obj_) |
||
| 8519 | obj_.original_tagname_ = 'Labels' |
||
| 8520 | elif nodeName_ == 'SourceRegionRef': |
||
| 8521 | obj_ = RegionRefType.factory(parent_object_=self) |
||
| 8522 | obj_.build(child_, gds_collector_=gds_collector_) |
||
| 8523 | self.SourceRegionRef = obj_ |
||
| 8524 | obj_.original_tagname_ = 'SourceRegionRef' |
||
| 8525 | elif nodeName_ == 'TargetRegionRef': |
||
| 8526 | obj_ = RegionRefType.factory(parent_object_=self) |
||
| 8527 | obj_.build(child_, gds_collector_=gds_collector_) |
||
| 8528 | self.TargetRegionRef = obj_ |
||
| 8529 | obj_.original_tagname_ = 'TargetRegionRef' |
||
| 8530 | def __hash__(self): |
||
| 8531 | return hash(self.id) |
||
| 8532 | # end class RelationType |
||
| 8533 | |||
| 8534 | |||
| 8535 | class TextStyleType(GeneratedsSuper): |
||
| 8536 | """Monospace (fixed-pitch, non-proportional) or |
||
| 8537 | proportional font. |
||
| 8538 | For instance: Arial, Times New Roman. |
||
| 8539 | Add more information if necessary |
||
| 8540 | (e.g. blackletter, antiqua). |
||
| 8541 | Serif or sans-serif typeface. |
||
| 8542 | The size of the characters in points. |
||
| 8543 | The x-height or corpus size refers to the distance |
||
| 8544 | between the baseline and the mean line of |
||
| 8545 | lower-case letters in a typeface. |
||
| 8546 | The unit is assumed to be pixels. |
||
| 8547 | The degree of space (in points) between |
||
| 8548 | the characters in a string of text. |
||
| 8549 | Text colour in RGB encoded format |
||
| 8550 | (red value) + (256 x green value) + (65536 x blue value). |
||
| 8551 | Background colour |
||
| 8552 | Background colour in RGB encoded format |
||
| 8553 | (red value) + (256 x green value) + (65536 x blue value). |
||
| 8554 | Specifies whether the colour of the text appears |
||
| 8555 | reversed against a background colour. |
||
| 8556 | Line style details if "underlined" is TRUE""" |
||
| 8557 | __hash__ = GeneratedsSuper.__hash__ |
||
| 8558 | member_data_items_ = [ |
||
| 8559 | MemberSpec_('fontFamily', 'string', 0, 1, {'use': 'optional'}), |
||
| 8560 | MemberSpec_('serif', 'boolean', 0, 1, {'use': 'optional'}), |
||
| 8561 | MemberSpec_('monospace', 'boolean', 0, 1, {'use': 'optional'}), |
||
| 8562 | MemberSpec_('fontSize', 'float', 0, 1, {'use': 'optional'}), |
||
| 8563 | MemberSpec_('xHeight', 'integer', 0, 1, {'use': 'optional'}), |
||
| 8564 | MemberSpec_('kerning', 'int', 0, 1, {'use': 'optional'}), |
||
| 8565 | MemberSpec_('textColour', 'pc:ColourSimpleType', 0, 1, {'use': 'optional'}), |
||
| 8566 | MemberSpec_('textColourRgb', 'integer', 0, 1, {'use': 'optional'}), |
||
| 8567 | MemberSpec_('bgColour', 'pc:ColourSimpleType', 0, 1, {'use': 'optional'}), |
||
| 8568 | MemberSpec_('bgColourRgb', 'integer', 0, 1, {'use': 'optional'}), |
||
| 8569 | MemberSpec_('reverseVideo', 'boolean', 0, 1, {'use': 'optional'}), |
||
| 8570 | MemberSpec_('bold', 'boolean', 0, 1, {'use': 'optional'}), |
||
| 8571 | MemberSpec_('italic', 'boolean', 0, 1, {'use': 'optional'}), |
||
| 8572 | MemberSpec_('underlined', 'boolean', 0, 1, {'use': 'optional'}), |
||
| 8573 | MemberSpec_('underlineStyle', 'pc:UnderlineStyleSimpleType', 0, 1, {'use': 'optional'}), |
||
| 8574 | MemberSpec_('subscript', 'boolean', 0, 1, {'use': 'optional'}), |
||
| 8575 | MemberSpec_('superscript', 'boolean', 0, 1, {'use': 'optional'}), |
||
| 8576 | MemberSpec_('strikethrough', 'boolean', 0, 1, {'use': 'optional'}), |
||
| 8577 | MemberSpec_('smallCaps', 'boolean', 0, 1, {'use': 'optional'}), |
||
| 8578 | MemberSpec_('letterSpaced', 'boolean', 0, 1, {'use': 'optional'}), |
||
| 8579 | ] |
||
| 8580 | subclass = None |
||
| 8581 | superclass = None |
||
| 8582 | def __init__(self, fontFamily=None, serif=None, monospace=None, fontSize=None, xHeight=None, kerning=None, textColour=None, textColourRgb=None, bgColour=None, bgColourRgb=None, reverseVideo=None, bold=None, italic=None, underlined=None, underlineStyle=None, subscript=None, superscript=None, strikethrough=None, smallCaps=None, letterSpaced=None, gds_collector_=None, **kwargs_): |
||
| 8583 | self.gds_collector_ = gds_collector_ |
||
| 8584 | self.gds_elementtree_node_ = None |
||
| 8585 | self.original_tagname_ = None |
||
| 8586 | self.parent_object_ = kwargs_.get('parent_object_') |
||
| 8587 | self.ns_prefix_ = None |
||
| 8588 | self.fontFamily = _cast(None, fontFamily) |
||
| 8589 | self.fontFamily_nsprefix_ = "pc" |
||
| 8590 | self.serif = _cast(bool, serif) |
||
| 8591 | self.serif_nsprefix_ = "pc" |
||
| 8592 | self.monospace = _cast(bool, monospace) |
||
| 8593 | self.monospace_nsprefix_ = "pc" |
||
| 8594 | self.fontSize = _cast(float, fontSize) |
||
| 8595 | self.fontSize_nsprefix_ = "pc" |
||
| 8596 | self.xHeight = _cast(int, xHeight) |
||
| 8597 | self.xHeight_nsprefix_ = "pc" |
||
| 8598 | self.kerning = _cast(int, kerning) |
||
| 8599 | self.kerning_nsprefix_ = "pc" |
||
| 8600 | self.textColour = _cast(None, textColour) |
||
| 8601 | self.textColour_nsprefix_ = "pc" |
||
| 8602 | self.textColourRgb = _cast(int, textColourRgb) |
||
| 8603 | self.textColourRgb_nsprefix_ = "pc" |
||
| 8604 | self.bgColour = _cast(None, bgColour) |
||
| 8605 | self.bgColour_nsprefix_ = "pc" |
||
| 8606 | self.bgColourRgb = _cast(int, bgColourRgb) |
||
| 8607 | self.bgColourRgb_nsprefix_ = "pc" |
||
| 8608 | self.reverseVideo = _cast(bool, reverseVideo) |
||
| 8609 | self.reverseVideo_nsprefix_ = "pc" |
||
| 8610 | self.bold = _cast(bool, bold) |
||
| 8611 | self.bold_nsprefix_ = "pc" |
||
| 8612 | self.italic = _cast(bool, italic) |
||
| 8613 | self.italic_nsprefix_ = "pc" |
||
| 8614 | self.underlined = _cast(bool, underlined) |
||
| 8615 | self.underlined_nsprefix_ = "pc" |
||
| 8616 | self.underlineStyle = _cast(None, underlineStyle) |
||
| 8617 | self.underlineStyle_nsprefix_ = "pc" |
||
| 8618 | self.subscript = _cast(bool, subscript) |
||
| 8619 | self.subscript_nsprefix_ = "pc" |
||
| 8620 | self.superscript = _cast(bool, superscript) |
||
| 8621 | self.superscript_nsprefix_ = "pc" |
||
| 8622 | self.strikethrough = _cast(bool, strikethrough) |
||
| 8623 | self.strikethrough_nsprefix_ = "pc" |
||
| 8624 | self.smallCaps = _cast(bool, smallCaps) |
||
| 8625 | self.smallCaps_nsprefix_ = "pc" |
||
| 8626 | self.letterSpaced = _cast(bool, letterSpaced) |
||
| 8627 | self.letterSpaced_nsprefix_ = "pc" |
||
| 8628 | def factory(*args_, **kwargs_): |
||
| 8629 | if CurrentSubclassModule_ is not None: |
||
| 8630 | subclass = getSubclassFromModule_( |
||
| 8631 | CurrentSubclassModule_, TextStyleType) |
||
| 8632 | if subclass is not None: |
||
| 8633 | return subclass(*args_, **kwargs_) |
||
| 8634 | if TextStyleType.subclass: |
||
| 8635 | return TextStyleType.subclass(*args_, **kwargs_) |
||
| 8636 | else: |
||
| 8637 | return TextStyleType(*args_, **kwargs_) |
||
| 8638 | factory = staticmethod(factory) |
||
| 8639 | def get_ns_prefix_(self): |
||
| 8640 | return self.ns_prefix_ |
||
| 8641 | def set_ns_prefix_(self, ns_prefix): |
||
| 8642 | self.ns_prefix_ = ns_prefix |
||
| 8643 | def get_fontFamily(self): |
||
| 8644 | return self.fontFamily |
||
| 8645 | def set_fontFamily(self, fontFamily): |
||
| 8646 | self.fontFamily = fontFamily |
||
| 8647 | def get_serif(self): |
||
| 8648 | return self.serif |
||
| 8649 | def set_serif(self, serif): |
||
| 8650 | self.serif = serif |
||
| 8651 | def get_monospace(self): |
||
| 8652 | return self.monospace |
||
| 8653 | def set_monospace(self, monospace): |
||
| 8654 | self.monospace = monospace |
||
| 8655 | def get_fontSize(self): |
||
| 8656 | return self.fontSize |
||
| 8657 | def set_fontSize(self, fontSize): |
||
| 8658 | self.fontSize = fontSize |
||
| 8659 | def get_xHeight(self): |
||
| 8660 | return self.xHeight |
||
| 8661 | def set_xHeight(self, xHeight): |
||
| 8662 | self.xHeight = xHeight |
||
| 8663 | def get_kerning(self): |
||
| 8664 | return self.kerning |
||
| 8665 | def set_kerning(self, kerning): |
||
| 8666 | self.kerning = kerning |
||
| 8667 | def get_textColour(self): |
||
| 8668 | return self.textColour |
||
| 8669 | def set_textColour(self, textColour): |
||
| 8670 | self.textColour = textColour |
||
| 8671 | def get_textColourRgb(self): |
||
| 8672 | return self.textColourRgb |
||
| 8673 | def set_textColourRgb(self, textColourRgb): |
||
| 8674 | self.textColourRgb = textColourRgb |
||
| 8675 | def get_bgColour(self): |
||
| 8676 | return self.bgColour |
||
| 8677 | def set_bgColour(self, bgColour): |
||
| 8678 | self.bgColour = bgColour |
||
| 8679 | def get_bgColourRgb(self): |
||
| 8680 | return self.bgColourRgb |
||
| 8681 | def set_bgColourRgb(self, bgColourRgb): |
||
| 8682 | self.bgColourRgb = bgColourRgb |
||
| 8683 | def get_reverseVideo(self): |
||
| 8684 | return self.reverseVideo |
||
| 8685 | def set_reverseVideo(self, reverseVideo): |
||
| 8686 | self.reverseVideo = reverseVideo |
||
| 8687 | def get_bold(self): |
||
| 8688 | return self.bold |
||
| 8689 | def set_bold(self, bold): |
||
| 8690 | self.bold = bold |
||
| 8691 | def get_italic(self): |
||
| 8692 | return self.italic |
||
| 8693 | def set_italic(self, italic): |
||
| 8694 | self.italic = italic |
||
| 8695 | def get_underlined(self): |
||
| 8696 | return self.underlined |
||
| 8697 | def set_underlined(self, underlined): |
||
| 8698 | self.underlined = underlined |
||
| 8699 | def get_underlineStyle(self): |
||
| 8700 | return self.underlineStyle |
||
| 8701 | def set_underlineStyle(self, underlineStyle): |
||
| 8702 | self.underlineStyle = underlineStyle |
||
| 8703 | def get_subscript(self): |
||
| 8704 | return self.subscript |
||
| 8705 | def set_subscript(self, subscript): |
||
| 8706 | self.subscript = subscript |
||
| 8707 | def get_superscript(self): |
||
| 8708 | return self.superscript |
||
| 8709 | def set_superscript(self, superscript): |
||
| 8710 | self.superscript = superscript |
||
| 8711 | def get_strikethrough(self): |
||
| 8712 | return self.strikethrough |
||
| 8713 | def set_strikethrough(self, strikethrough): |
||
| 8714 | self.strikethrough = strikethrough |
||
| 8715 | def get_smallCaps(self): |
||
| 8716 | return self.smallCaps |
||
| 8717 | def set_smallCaps(self, smallCaps): |
||
| 8718 | self.smallCaps = smallCaps |
||
| 8719 | def get_letterSpaced(self): |
||
| 8720 | return self.letterSpaced |
||
| 8721 | def set_letterSpaced(self, letterSpaced): |
||
| 8722 | self.letterSpaced = letterSpaced |
||
| 8723 | def validate_ColourSimpleType(self, value): |
||
| 8724 | # Validate type pc:ColourSimpleType, a restriction on string. |
||
| 8725 | if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None: |
||
| 8726 | if not isinstance(value, str): |
||
| 8727 | lineno = self.gds_get_node_lineno_() |
||
| 8728 | self.gds_collector_.add_message('Value "%(value)s"%(lineno)s is not of the correct base simple type (str)' % {"value": value, "lineno": lineno, }) |
||
| 8729 | return False |
||
| 8730 | value = value |
||
| 8731 | enumerations = ['black', 'blue', 'brown', 'cyan', 'green', 'grey', 'indigo', 'magenta', 'orange', 'pink', 'red', 'turquoise', 'violet', 'white', 'yellow', 'other'] |
||
| 8732 | if value not in enumerations: |
||
| 8733 | lineno = self.gds_get_node_lineno_() |
||
| 8734 | self.gds_collector_.add_message('Value "%(value)s"%(lineno)s does not match xsd enumeration restriction on ColourSimpleType' % {"value" : encode_str_2_3(value), "lineno": lineno} ) |
||
| 8735 | result = False |
||
| 8736 | def validate_UnderlineStyleSimpleType(self, value): |
||
| 8737 | # Validate type pc:UnderlineStyleSimpleType, a restriction on string. |
||
| 8738 | if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None: |
||
| 8739 | if not isinstance(value, str): |
||
| 8740 | lineno = self.gds_get_node_lineno_() |
||
| 8741 | self.gds_collector_.add_message('Value "%(value)s"%(lineno)s is not of the correct base simple type (str)' % {"value": value, "lineno": lineno, }) |
||
| 8742 | return False |
||
| 8743 | value = value |
||
| 8744 | enumerations = ['singleLine', 'doubleLine', 'other'] |
||
| 8745 | if value not in enumerations: |
||
| 8746 | lineno = self.gds_get_node_lineno_() |
||
| 8747 | self.gds_collector_.add_message('Value "%(value)s"%(lineno)s does not match xsd enumeration restriction on UnderlineStyleSimpleType' % {"value" : encode_str_2_3(value), "lineno": lineno} ) |
||
| 8748 | result = False |
||
| 8749 | def hasContent_(self): |
||
| 8750 | if ( |
||
| 8751 | |||
| 8752 | ): |
||
| 8753 | return True |
||
| 8754 | else: |
||
| 8755 | return False |
||
| 8756 | def export(self, outfile, level, namespaceprefix_='', namespacedef_='xmlns:pc="http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15"', name_='TextStyleType', pretty_print=True): |
||
| 8757 | imported_ns_def_ = GenerateDSNamespaceDefs_.get('TextStyleType') |
||
| 8758 | if imported_ns_def_ is not None: |
||
| 8759 | namespacedef_ = imported_ns_def_ |
||
| 8760 | if pretty_print: |
||
| 8761 | eol_ = '\n' |
||
| 8762 | else: |
||
| 8763 | eol_ = '' |
||
| 8764 | if self.original_tagname_ is not None and name_ == 'TextStyleType': |
||
| 8765 | name_ = self.original_tagname_ |
||
| 8766 | if UseCapturedNS_ and self.ns_prefix_: |
||
| 8767 | namespaceprefix_ = self.ns_prefix_ + ':' |
||
| 8768 | showIndent(outfile, level, pretty_print) |
||
| 8769 | outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) |
||
| 8770 | already_processed = set() |
||
| 8771 | self.exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='TextStyleType') |
||
| 8772 | if self.hasContent_(): |
||
| 8773 | outfile.write('>%s' % (eol_, )) |
||
| 8774 | self.exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='TextStyleType', pretty_print=pretty_print) |
||
| 8775 | outfile.write('</%s%s>%s' % (namespaceprefix_, name_, eol_)) |
||
| 8776 | else: |
||
| 8777 | outfile.write('/>%s' % (eol_, )) |
||
| 8778 | def exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='TextStyleType'): |
||
| 8779 | if self.fontFamily is not None and 'fontFamily' not in already_processed: |
||
| 8780 | already_processed.add('fontFamily') |
||
| 8781 | outfile.write(' fontFamily=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.fontFamily), input_name='fontFamily')), )) |
||
| 8782 | if self.serif is not None and 'serif' not in already_processed: |
||
| 8783 | already_processed.add('serif') |
||
| 8784 | outfile.write(' serif="%s"' % self.gds_format_boolean(self.serif, input_name='serif')) |
||
| 8785 | if self.monospace is not None and 'monospace' not in already_processed: |
||
| 8786 | already_processed.add('monospace') |
||
| 8787 | outfile.write(' monospace="%s"' % self.gds_format_boolean(self.monospace, input_name='monospace')) |
||
| 8788 | if self.fontSize is not None and 'fontSize' not in already_processed: |
||
| 8789 | already_processed.add('fontSize') |
||
| 8790 | outfile.write(' fontSize="%s"' % self.gds_format_float(self.fontSize, input_name='fontSize')) |
||
| 8791 | if self.xHeight is not None and 'xHeight' not in already_processed: |
||
| 8792 | already_processed.add('xHeight') |
||
| 8793 | outfile.write(' xHeight="%s"' % self.gds_format_integer(self.xHeight, input_name='xHeight')) |
||
| 8794 | if self.kerning is not None and 'kerning' not in already_processed: |
||
| 8795 | already_processed.add('kerning') |
||
| 8796 | outfile.write(' kerning="%s"' % self.gds_format_integer(self.kerning, input_name='kerning')) |
||
| 8797 | if self.textColour is not None and 'textColour' not in already_processed: |
||
| 8798 | already_processed.add('textColour') |
||
| 8799 | outfile.write(' textColour=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.textColour), input_name='textColour')), )) |
||
| 8800 | if self.textColourRgb is not None and 'textColourRgb' not in already_processed: |
||
| 8801 | already_processed.add('textColourRgb') |
||
| 8802 | outfile.write(' textColourRgb="%s"' % self.gds_format_integer(self.textColourRgb, input_name='textColourRgb')) |
||
| 8803 | if self.bgColour is not None and 'bgColour' not in already_processed: |
||
| 8804 | already_processed.add('bgColour') |
||
| 8805 | outfile.write(' bgColour=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.bgColour), input_name='bgColour')), )) |
||
| 8806 | if self.bgColourRgb is not None and 'bgColourRgb' not in already_processed: |
||
| 8807 | already_processed.add('bgColourRgb') |
||
| 8808 | outfile.write(' bgColourRgb="%s"' % self.gds_format_integer(self.bgColourRgb, input_name='bgColourRgb')) |
||
| 8809 | if self.reverseVideo is not None and 'reverseVideo' not in already_processed: |
||
| 8810 | already_processed.add('reverseVideo') |
||
| 8811 | outfile.write(' reverseVideo="%s"' % self.gds_format_boolean(self.reverseVideo, input_name='reverseVideo')) |
||
| 8812 | if self.bold is not None and 'bold' not in already_processed: |
||
| 8813 | already_processed.add('bold') |
||
| 8814 | outfile.write(' bold="%s"' % self.gds_format_boolean(self.bold, input_name='bold')) |
||
| 8815 | if self.italic is not None and 'italic' not in already_processed: |
||
| 8816 | already_processed.add('italic') |
||
| 8817 | outfile.write(' italic="%s"' % self.gds_format_boolean(self.italic, input_name='italic')) |
||
| 8818 | if self.underlined is not None and 'underlined' not in already_processed: |
||
| 8819 | already_processed.add('underlined') |
||
| 8820 | outfile.write(' underlined="%s"' % self.gds_format_boolean(self.underlined, input_name='underlined')) |
||
| 8821 | if self.underlineStyle is not None and 'underlineStyle' not in already_processed: |
||
| 8822 | already_processed.add('underlineStyle') |
||
| 8823 | outfile.write(' underlineStyle=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.underlineStyle), input_name='underlineStyle')), )) |
||
| 8824 | if self.subscript is not None and 'subscript' not in already_processed: |
||
| 8825 | already_processed.add('subscript') |
||
| 8826 | outfile.write(' subscript="%s"' % self.gds_format_boolean(self.subscript, input_name='subscript')) |
||
| 8827 | if self.superscript is not None and 'superscript' not in already_processed: |
||
| 8828 | already_processed.add('superscript') |
||
| 8829 | outfile.write(' superscript="%s"' % self.gds_format_boolean(self.superscript, input_name='superscript')) |
||
| 8830 | if self.strikethrough is not None and 'strikethrough' not in already_processed: |
||
| 8831 | already_processed.add('strikethrough') |
||
| 8832 | outfile.write(' strikethrough="%s"' % self.gds_format_boolean(self.strikethrough, input_name='strikethrough')) |
||
| 8833 | if self.smallCaps is not None and 'smallCaps' not in already_processed: |
||
| 8834 | already_processed.add('smallCaps') |
||
| 8835 | outfile.write(' smallCaps="%s"' % self.gds_format_boolean(self.smallCaps, input_name='smallCaps')) |
||
| 8836 | if self.letterSpaced is not None and 'letterSpaced' not in already_processed: |
||
| 8837 | already_processed.add('letterSpaced') |
||
| 8838 | outfile.write(' letterSpaced="%s"' % self.gds_format_boolean(self.letterSpaced, input_name='letterSpaced')) |
||
| 8839 | def exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='xmlns:pc="http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15"', name_='TextStyleType', fromsubclass_=False, pretty_print=True): |
||
| 8840 | pass |
||
| 8841 | def to_etree(self, parent_element=None, name_='TextStyleType', mapping_=None, nsmap_=None): |
||
| 8842 | if parent_element is None: |
||
| 8843 | element = etree_.Element('{http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15}' + name_, nsmap=nsmap_) |
||
| 8844 | else: |
||
| 8845 | element = etree_.SubElement(parent_element, '{http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15}' + name_, nsmap=nsmap_) |
||
| 8846 | if self.fontFamily is not None: |
||
| 8847 | element.set('fontFamily', self.gds_format_string(self.fontFamily)) |
||
| 8848 | if self.serif is not None: |
||
| 8849 | element.set('serif', self.gds_format_boolean(self.serif)) |
||
| 8850 | if self.monospace is not None: |
||
| 8851 | element.set('monospace', self.gds_format_boolean(self.monospace)) |
||
| 8852 | if self.fontSize is not None: |
||
| 8853 | element.set('fontSize', self.gds_format_float(self.fontSize)) |
||
| 8854 | if self.xHeight is not None: |
||
| 8855 | element.set('xHeight', self.gds_format_integer(self.xHeight)) |
||
| 8856 | if self.kerning is not None: |
||
| 8857 | element.set('kerning', self.gds_format_integer(self.kerning)) |
||
| 8858 | if self.textColour is not None: |
||
| 8859 | element.set('textColour', self.gds_format_string(self.textColour)) |
||
| 8860 | if self.textColourRgb is not None: |
||
| 8861 | element.set('textColourRgb', self.gds_format_integer(self.textColourRgb)) |
||
| 8862 | if self.bgColour is not None: |
||
| 8863 | element.set('bgColour', self.gds_format_string(self.bgColour)) |
||
| 8864 | if self.bgColourRgb is not None: |
||
| 8865 | element.set('bgColourRgb', self.gds_format_integer(self.bgColourRgb)) |
||
| 8866 | if self.reverseVideo is not None: |
||
| 8867 | element.set('reverseVideo', self.gds_format_boolean(self.reverseVideo)) |
||
| 8868 | if self.bold is not None: |
||
| 8869 | element.set('bold', self.gds_format_boolean(self.bold)) |
||
| 8870 | if self.italic is not None: |
||
| 8871 | element.set('italic', self.gds_format_boolean(self.italic)) |
||
| 8872 | if self.underlined is not None: |
||
| 8873 | element.set('underlined', self.gds_format_boolean(self.underlined)) |
||
| 8874 | if self.underlineStyle is not None: |
||
| 8875 | element.set('underlineStyle', self.gds_format_string(self.underlineStyle)) |
||
| 8876 | if self.subscript is not None: |
||
| 8877 | element.set('subscript', self.gds_format_boolean(self.subscript)) |
||
| 8878 | if self.superscript is not None: |
||
| 8879 | element.set('superscript', self.gds_format_boolean(self.superscript)) |
||
| 8880 | if self.strikethrough is not None: |
||
| 8881 | element.set('strikethrough', self.gds_format_boolean(self.strikethrough)) |
||
| 8882 | if self.smallCaps is not None: |
||
| 8883 | element.set('smallCaps', self.gds_format_boolean(self.smallCaps)) |
||
| 8884 | if self.letterSpaced is not None: |
||
| 8885 | element.set('letterSpaced', self.gds_format_boolean(self.letterSpaced)) |
||
| 8886 | if mapping_ is not None: |
||
| 8887 | mapping_[id(self)] = element |
||
| 8888 | return element |
||
| 8889 | def build(self, node, gds_collector_=None): |
||
| 8890 | self.gds_collector_ = gds_collector_ |
||
| 8891 | if SaveElementTreeNode: |
||
| 8892 | self.gds_elementtree_node_ = node |
||
| 8893 | already_processed = set() |
||
| 8894 | self.ns_prefix_ = node.prefix |
||
| 8895 | self.buildAttributes(node, node.attrib, already_processed) |
||
| 8896 | for child in node: |
||
| 8897 | nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] |
||
| 8898 | self.buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) |
||
| 8899 | return self |
||
| 8900 | def buildAttributes(self, node, attrs, already_processed): |
||
| 8901 | value = find_attr_value_('fontFamily', node) |
||
| 8902 | if value is not None and 'fontFamily' not in already_processed: |
||
| 8903 | already_processed.add('fontFamily') |
||
| 8904 | self.fontFamily = value |
||
| 8905 | value = find_attr_value_('serif', node) |
||
| 8906 | if value is not None and 'serif' not in already_processed: |
||
| 8907 | already_processed.add('serif') |
||
| 8908 | if value in ('true', '1'): |
||
| 8909 | self.serif = True |
||
| 8910 | elif value in ('false', '0'): |
||
| 8911 | self.serif = False |
||
| 8912 | else: |
||
| 8913 | raise_parse_error(node, 'Bad boolean attribute') |
||
| 8914 | value = find_attr_value_('monospace', node) |
||
| 8915 | if value is not None and 'monospace' not in already_processed: |
||
| 8916 | already_processed.add('monospace') |
||
| 8917 | if value in ('true', '1'): |
||
| 8918 | self.monospace = True |
||
| 8919 | elif value in ('false', '0'): |
||
| 8920 | self.monospace = False |
||
| 8921 | else: |
||
| 8922 | raise_parse_error(node, 'Bad boolean attribute') |
||
| 8923 | value = find_attr_value_('fontSize', node) |
||
| 8924 | if value is not None and 'fontSize' not in already_processed: |
||
| 8925 | already_processed.add('fontSize') |
||
| 8926 | value = self.gds_parse_float(value, node, 'fontSize') |
||
| 8927 | self.fontSize = value |
||
| 8928 | value = find_attr_value_('xHeight', node) |
||
| 8929 | if value is not None and 'xHeight' not in already_processed: |
||
| 8930 | already_processed.add('xHeight') |
||
| 8931 | self.xHeight = self.gds_parse_integer(value, node, 'xHeight') |
||
| 8932 | value = find_attr_value_('kerning', node) |
||
| 8933 | if value is not None and 'kerning' not in already_processed: |
||
| 8934 | already_processed.add('kerning') |
||
| 8935 | self.kerning = self.gds_parse_integer(value, node, 'kerning') |
||
| 8936 | value = find_attr_value_('textColour', node) |
||
| 8937 | if value is not None and 'textColour' not in already_processed: |
||
| 8938 | already_processed.add('textColour') |
||
| 8939 | self.textColour = value |
||
| 8940 | self.validate_ColourSimpleType(self.textColour) # validate type ColourSimpleType |
||
| 8941 | value = find_attr_value_('textColourRgb', node) |
||
| 8942 | if value is not None and 'textColourRgb' not in already_processed: |
||
| 8943 | already_processed.add('textColourRgb') |
||
| 8944 | self.textColourRgb = self.gds_parse_integer(value, node, 'textColourRgb') |
||
| 8945 | value = find_attr_value_('bgColour', node) |
||
| 8946 | if value is not None and 'bgColour' not in already_processed: |
||
| 8947 | already_processed.add('bgColour') |
||
| 8948 | self.bgColour = value |
||
| 8949 | self.validate_ColourSimpleType(self.bgColour) # validate type ColourSimpleType |
||
| 8950 | value = find_attr_value_('bgColourRgb', node) |
||
| 8951 | if value is not None and 'bgColourRgb' not in already_processed: |
||
| 8952 | already_processed.add('bgColourRgb') |
||
| 8953 | self.bgColourRgb = self.gds_parse_integer(value, node, 'bgColourRgb') |
||
| 8954 | value = find_attr_value_('reverseVideo', node) |
||
| 8955 | if value is not None and 'reverseVideo' not in already_processed: |
||
| 8956 | already_processed.add('reverseVideo') |
||
| 8957 | if value in ('true', '1'): |
||
| 8958 | self.reverseVideo = True |
||
| 8959 | elif value in ('false', '0'): |
||
| 8960 | self.reverseVideo = False |
||
| 8961 | else: |
||
| 8962 | raise_parse_error(node, 'Bad boolean attribute') |
||
| 8963 | value = find_attr_value_('bold', node) |
||
| 8964 | if value is not None and 'bold' not in already_processed: |
||
| 8965 | already_processed.add('bold') |
||
| 8966 | if value in ('true', '1'): |
||
| 8967 | self.bold = True |
||
| 8968 | elif value in ('false', '0'): |
||
| 8969 | self.bold = False |
||
| 8970 | else: |
||
| 8971 | raise_parse_error(node, 'Bad boolean attribute') |
||
| 8972 | value = find_attr_value_('italic', node) |
||
| 8973 | if value is not None and 'italic' not in already_processed: |
||
| 8974 | already_processed.add('italic') |
||
| 8975 | if value in ('true', '1'): |
||
| 8976 | self.italic = True |
||
| 8977 | elif value in ('false', '0'): |
||
| 8978 | self.italic = False |
||
| 8979 | else: |
||
| 8980 | raise_parse_error(node, 'Bad boolean attribute') |
||
| 8981 | value = find_attr_value_('underlined', node) |
||
| 8982 | if value is not None and 'underlined' not in already_processed: |
||
| 8983 | already_processed.add('underlined') |
||
| 8984 | if value in ('true', '1'): |
||
| 8985 | self.underlined = True |
||
| 8986 | elif value in ('false', '0'): |
||
| 8987 | self.underlined = False |
||
| 8988 | else: |
||
| 8989 | raise_parse_error(node, 'Bad boolean attribute') |
||
| 8990 | value = find_attr_value_('underlineStyle', node) |
||
| 8991 | if value is not None and 'underlineStyle' not in already_processed: |
||
| 8992 | already_processed.add('underlineStyle') |
||
| 8993 | self.underlineStyle = value |
||
| 8994 | self.validate_UnderlineStyleSimpleType(self.underlineStyle) # validate type UnderlineStyleSimpleType |
||
| 8995 | value = find_attr_value_('subscript', node) |
||
| 8996 | if value is not None and 'subscript' not in already_processed: |
||
| 8997 | already_processed.add('subscript') |
||
| 8998 | if value in ('true', '1'): |
||
| 8999 | self.subscript = True |
||
| 9000 | elif value in ('false', '0'): |
||
| 9001 | self.subscript = False |
||
| 9002 | else: |
||
| 9003 | raise_parse_error(node, 'Bad boolean attribute') |
||
| 9004 | value = find_attr_value_('superscript', node) |
||
| 9005 | if value is not None and 'superscript' not in already_processed: |
||
| 9006 | already_processed.add('superscript') |
||
| 9007 | if value in ('true', '1'): |
||
| 9008 | self.superscript = True |
||
| 9009 | elif value in ('false', '0'): |
||
| 9010 | self.superscript = False |
||
| 9011 | else: |
||
| 9012 | raise_parse_error(node, 'Bad boolean attribute') |
||
| 9013 | value = find_attr_value_('strikethrough', node) |
||
| 9014 | if value is not None and 'strikethrough' not in already_processed: |
||
| 9015 | already_processed.add('strikethrough') |
||
| 9016 | if value in ('true', '1'): |
||
| 9017 | self.strikethrough = True |
||
| 9018 | elif value in ('false', '0'): |
||
| 9019 | self.strikethrough = False |
||
| 9020 | else: |
||
| 9021 | raise_parse_error(node, 'Bad boolean attribute') |
||
| 9022 | value = find_attr_value_('smallCaps', node) |
||
| 9023 | if value is not None and 'smallCaps' not in already_processed: |
||
| 9024 | already_processed.add('smallCaps') |
||
| 9025 | if value in ('true', '1'): |
||
| 9026 | self.smallCaps = True |
||
| 9027 | elif value in ('false', '0'): |
||
| 9028 | self.smallCaps = False |
||
| 9029 | else: |
||
| 9030 | raise_parse_error(node, 'Bad boolean attribute') |
||
| 9031 | value = find_attr_value_('letterSpaced', node) |
||
| 9032 | if value is not None and 'letterSpaced' not in already_processed: |
||
| 9033 | already_processed.add('letterSpaced') |
||
| 9034 | if value in ('true', '1'): |
||
| 9035 | self.letterSpaced = True |
||
| 9036 | elif value in ('false', '0'): |
||
| 9037 | self.letterSpaced = False |
||
| 9038 | else: |
||
| 9039 | raise_parse_error(node, 'Bad boolean attribute') |
||
| 9040 | def buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None): |
||
| 9041 | pass |
||
| 9042 | def __hash__(self): |
||
| 9043 | return hash(self.id) |
||
| 9044 | # end class TextStyleType |
||
| 9045 | |||
| 9046 | |||
| 9047 | class RegionType(GeneratedsSuper): |
||
| 9048 | """For generic use |
||
| 9049 | Is this region a continuation of another region |
||
| 9050 | (in previous column or page, for example)?""" |
||
| 9051 | __hash__ = GeneratedsSuper.__hash__ |
||
| 9052 | member_data_items_ = [ |
||
| 9053 | MemberSpec_('id', 'string', 0, 0, {'use': 'required'}), |
||
| 9054 | MemberSpec_('custom', 'string', 0, 1, {'use': 'optional'}), |
||
| 9055 | MemberSpec_('comments', 'string', 0, 1, {'use': 'optional'}), |
||
| 9056 | MemberSpec_('continuation', 'boolean', 0, 1, {'use': 'optional'}), |
||
| 9057 | MemberSpec_('AlternativeImage', 'AlternativeImageType', 1, 1, {'maxOccurs': 'unbounded', 'minOccurs': '0', 'name': 'AlternativeImage', 'type': 'AlternativeImageType'}, None), |
||
| 9058 | MemberSpec_('Coords', 'CoordsType', 0, 0, {'name': 'Coords', 'type': 'CoordsType'}, None), |
||
| 9059 | MemberSpec_('UserDefined', 'UserDefinedType', 0, 1, {'maxOccurs': '1', 'minOccurs': '0', 'name': 'UserDefined', 'type': 'UserDefinedType'}, None), |
||
| 9060 | MemberSpec_('Labels', 'LabelsType', 1, 1, {'maxOccurs': 'unbounded', 'minOccurs': '0', 'name': 'Labels', 'type': 'LabelsType'}, None), |
||
| 9061 | MemberSpec_('Roles', 'RolesType', 0, 1, {'maxOccurs': '1', 'minOccurs': '0', 'name': 'Roles', 'type': 'RolesType'}, None), |
||
| 9062 | MemberSpec_('TextRegion', 'TextRegionType', 1, 1, {'name': 'TextRegion', 'type': 'TextRegionType'}, 7), |
||
| 9063 | MemberSpec_('ImageRegion', 'ImageRegionType', 1, 1, {'name': 'ImageRegion', 'type': 'ImageRegionType'}, 7), |
||
| 9064 | MemberSpec_('LineDrawingRegion', 'LineDrawingRegionType', 1, 1, {'name': 'LineDrawingRegion', 'type': 'LineDrawingRegionType'}, 7), |
||
| 9065 | MemberSpec_('GraphicRegion', 'GraphicRegionType', 1, 1, {'name': 'GraphicRegion', 'type': 'GraphicRegionType'}, 7), |
||
| 9066 | MemberSpec_('TableRegion', 'TableRegionType', 1, 1, {'name': 'TableRegion', 'type': 'TableRegionType'}, 7), |
||
| 9067 | MemberSpec_('ChartRegion', 'ChartRegionType', 1, 1, {'name': 'ChartRegion', 'type': 'ChartRegionType'}, 7), |
||
| 9068 | MemberSpec_('SeparatorRegion', 'SeparatorRegionType', 1, 1, {'name': 'SeparatorRegion', 'type': 'SeparatorRegionType'}, 7), |
||
| 9069 | MemberSpec_('MathsRegion', 'MathsRegionType', 1, 1, {'name': 'MathsRegion', 'type': 'MathsRegionType'}, 7), |
||
| 9070 | MemberSpec_('ChemRegion', 'ChemRegionType', 1, 1, {'name': 'ChemRegion', 'type': 'ChemRegionType'}, 7), |
||
| 9071 | MemberSpec_('MusicRegion', 'MusicRegionType', 1, 1, {'name': 'MusicRegion', 'type': 'MusicRegionType'}, 7), |
||
| 9072 | MemberSpec_('AdvertRegion', 'AdvertRegionType', 1, 1, {'name': 'AdvertRegion', 'type': 'AdvertRegionType'}, 7), |
||
| 9073 | MemberSpec_('NoiseRegion', 'NoiseRegionType', 1, 1, {'name': 'NoiseRegion', 'type': 'NoiseRegionType'}, 7), |
||
| 9074 | MemberSpec_('UnknownRegion', 'UnknownRegionType', 1, 1, {'name': 'UnknownRegion', 'type': 'UnknownRegionType'}, 7), |
||
| 9075 | MemberSpec_('CustomRegion', 'CustomRegionType', 1, 1, {'name': 'CustomRegion', 'type': 'CustomRegionType'}, 7), |
||
| 9076 | ] |
||
| 9077 | subclass = None |
||
| 9078 | superclass = None |
||
| 9079 | def __init__(self, id=None, custom=None, comments=None, continuation=None, AlternativeImage=None, Coords=None, UserDefined=None, Labels=None, Roles=None, TextRegion=None, ImageRegion=None, LineDrawingRegion=None, GraphicRegion=None, TableRegion=None, ChartRegion=None, SeparatorRegion=None, MathsRegion=None, ChemRegion=None, MusicRegion=None, AdvertRegion=None, NoiseRegion=None, UnknownRegion=None, CustomRegion=None, extensiontype_=None, gds_collector_=None, **kwargs_): |
||
| 9080 | self.gds_collector_ = gds_collector_ |
||
| 9081 | self.gds_elementtree_node_ = None |
||
| 9082 | self.original_tagname_ = None |
||
| 9083 | self.parent_object_ = kwargs_.get('parent_object_') |
||
| 9084 | self.ns_prefix_ = None |
||
| 9085 | self.id = _cast(None, id) |
||
| 9086 | self.id_nsprefix_ = "pc" |
||
| 9087 | self.custom = _cast(None, custom) |
||
| 9088 | self.custom_nsprefix_ = "pc" |
||
| 9089 | self.comments = _cast(None, comments) |
||
| 9090 | self.comments_nsprefix_ = "pc" |
||
| 9091 | self.continuation = _cast(bool, continuation) |
||
| 9092 | self.continuation_nsprefix_ = "pc" |
||
| 9093 | if AlternativeImage is None: |
||
| 9094 | self.AlternativeImage = [] |
||
| 9095 | else: |
||
| 9096 | self.AlternativeImage = AlternativeImage |
||
| 9097 | self.AlternativeImage_nsprefix_ = "pc" |
||
| 9098 | self.Coords = Coords |
||
| 9099 | self.Coords_nsprefix_ = "pc" |
||
| 9100 | self.UserDefined = UserDefined |
||
| 9101 | self.UserDefined_nsprefix_ = "pc" |
||
| 9102 | if Labels is None: |
||
| 9103 | self.Labels = [] |
||
| 9104 | else: |
||
| 9105 | self.Labels = Labels |
||
| 9106 | self.Labels_nsprefix_ = "pc" |
||
| 9107 | self.Roles = Roles |
||
| 9108 | self.Roles_nsprefix_ = "pc" |
||
| 9109 | if TextRegion is None: |
||
| 9110 | self.TextRegion = [] |
||
| 9111 | else: |
||
| 9112 | self.TextRegion = TextRegion |
||
| 9113 | self.TextRegion_nsprefix_ = "pc" |
||
| 9114 | if ImageRegion is None: |
||
| 9115 | self.ImageRegion = [] |
||
| 9116 | else: |
||
| 9117 | self.ImageRegion = ImageRegion |
||
| 9118 | self.ImageRegion_nsprefix_ = "pc" |
||
| 9119 | if LineDrawingRegion is None: |
||
| 9120 | self.LineDrawingRegion = [] |
||
| 9121 | else: |
||
| 9122 | self.LineDrawingRegion = LineDrawingRegion |
||
| 9123 | self.LineDrawingRegion_nsprefix_ = "pc" |
||
| 9124 | if GraphicRegion is None: |
||
| 9125 | self.GraphicRegion = [] |
||
| 9126 | else: |
||
| 9127 | self.GraphicRegion = GraphicRegion |
||
| 9128 | self.GraphicRegion_nsprefix_ = "pc" |
||
| 9129 | if TableRegion is None: |
||
| 9130 | self.TableRegion = [] |
||
| 9131 | else: |
||
| 9132 | self.TableRegion = TableRegion |
||
| 9133 | self.TableRegion_nsprefix_ = "pc" |
||
| 9134 | if ChartRegion is None: |
||
| 9135 | self.ChartRegion = [] |
||
| 9136 | else: |
||
| 9137 | self.ChartRegion = ChartRegion |
||
| 9138 | self.ChartRegion_nsprefix_ = "pc" |
||
| 9139 | if SeparatorRegion is None: |
||
| 9140 | self.SeparatorRegion = [] |
||
| 9141 | else: |
||
| 9142 | self.SeparatorRegion = SeparatorRegion |
||
| 9143 | self.SeparatorRegion_nsprefix_ = "pc" |
||
| 9144 | if MathsRegion is None: |
||
| 9145 | self.MathsRegion = [] |
||
| 9146 | else: |
||
| 9147 | self.MathsRegion = MathsRegion |
||
| 9148 | self.MathsRegion_nsprefix_ = "pc" |
||
| 9149 | if ChemRegion is None: |
||
| 9150 | self.ChemRegion = [] |
||
| 9151 | else: |
||
| 9152 | self.ChemRegion = ChemRegion |
||
| 9153 | self.ChemRegion_nsprefix_ = "pc" |
||
| 9154 | if MusicRegion is None: |
||
| 9155 | self.MusicRegion = [] |
||
| 9156 | else: |
||
| 9157 | self.MusicRegion = MusicRegion |
||
| 9158 | self.MusicRegion_nsprefix_ = "pc" |
||
| 9159 | if AdvertRegion is None: |
||
| 9160 | self.AdvertRegion = [] |
||
| 9161 | else: |
||
| 9162 | self.AdvertRegion = AdvertRegion |
||
| 9163 | self.AdvertRegion_nsprefix_ = "pc" |
||
| 9164 | if NoiseRegion is None: |
||
| 9165 | self.NoiseRegion = [] |
||
| 9166 | else: |
||
| 9167 | self.NoiseRegion = NoiseRegion |
||
| 9168 | self.NoiseRegion_nsprefix_ = "pc" |
||
| 9169 | if UnknownRegion is None: |
||
| 9170 | self.UnknownRegion = [] |
||
| 9171 | else: |
||
| 9172 | self.UnknownRegion = UnknownRegion |
||
| 9173 | self.UnknownRegion_nsprefix_ = "pc" |
||
| 9174 | if CustomRegion is None: |
||
| 9175 | self.CustomRegion = [] |
||
| 9176 | else: |
||
| 9177 | self.CustomRegion = CustomRegion |
||
| 9178 | self.CustomRegion_nsprefix_ = "pc" |
||
| 9179 | self.extensiontype_ = extensiontype_ |
||
| 9180 | def factory(*args_, **kwargs_): |
||
| 9181 | if CurrentSubclassModule_ is not None: |
||
| 9182 | subclass = getSubclassFromModule_( |
||
| 9183 | CurrentSubclassModule_, RegionType) |
||
| 9184 | if subclass is not None: |
||
| 9185 | return subclass(*args_, **kwargs_) |
||
| 9186 | if RegionType.subclass: |
||
| 9187 | return RegionType.subclass(*args_, **kwargs_) |
||
| 9188 | else: |
||
| 9189 | return RegionType(*args_, **kwargs_) |
||
| 9190 | factory = staticmethod(factory) |
||
| 9191 | def get_ns_prefix_(self): |
||
| 9192 | return self.ns_prefix_ |
||
| 9193 | def set_ns_prefix_(self, ns_prefix): |
||
| 9194 | self.ns_prefix_ = ns_prefix |
||
| 9195 | def get_AlternativeImage(self): |
||
| 9196 | return self.AlternativeImage |
||
| 9197 | def set_AlternativeImage(self, AlternativeImage): |
||
| 9198 | self.AlternativeImage = AlternativeImage |
||
| 9199 | def add_AlternativeImage(self, value): |
||
| 9200 | self.AlternativeImage.append(value) |
||
| 9201 | def insert_AlternativeImage_at(self, index, value): |
||
| 9202 | self.AlternativeImage.insert(index, value) |
||
| 9203 | def replace_AlternativeImage_at(self, index, value): |
||
| 9204 | self.AlternativeImage[index] = value |
||
| 9205 | def get_Coords(self): |
||
| 9206 | return self.Coords |
||
| 9207 | def set_Coords(self, Coords): |
||
| 9208 | self.Coords = Coords |
||
| 9209 | def get_UserDefined(self): |
||
| 9210 | return self.UserDefined |
||
| 9211 | def set_UserDefined(self, UserDefined): |
||
| 9212 | self.UserDefined = UserDefined |
||
| 9213 | def get_Labels(self): |
||
| 9214 | return self.Labels |
||
| 9215 | def set_Labels(self, Labels): |
||
| 9216 | self.Labels = Labels |
||
| 9217 | def add_Labels(self, value): |
||
| 9218 | self.Labels.append(value) |
||
| 9219 | def insert_Labels_at(self, index, value): |
||
| 9220 | self.Labels.insert(index, value) |
||
| 9221 | def replace_Labels_at(self, index, value): |
||
| 9222 | self.Labels[index] = value |
||
| 9223 | def get_Roles(self): |
||
| 9224 | return self.Roles |
||
| 9225 | def set_Roles(self, Roles): |
||
| 9226 | self.Roles = Roles |
||
| 9227 | def get_TextRegion(self): |
||
| 9228 | return self.TextRegion |
||
| 9229 | def set_TextRegion(self, TextRegion): |
||
| 9230 | self.TextRegion = TextRegion |
||
| 9231 | def add_TextRegion(self, value): |
||
| 9232 | self.TextRegion.append(value) |
||
| 9233 | def insert_TextRegion_at(self, index, value): |
||
| 9234 | self.TextRegion.insert(index, value) |
||
| 9235 | def replace_TextRegion_at(self, index, value): |
||
| 9236 | self.TextRegion[index] = value |
||
| 9237 | def get_ImageRegion(self): |
||
| 9238 | return self.ImageRegion |
||
| 9239 | def set_ImageRegion(self, ImageRegion): |
||
| 9240 | self.ImageRegion = ImageRegion |
||
| 9241 | def add_ImageRegion(self, value): |
||
| 9242 | self.ImageRegion.append(value) |
||
| 9243 | def insert_ImageRegion_at(self, index, value): |
||
| 9244 | self.ImageRegion.insert(index, value) |
||
| 9245 | def replace_ImageRegion_at(self, index, value): |
||
| 9246 | self.ImageRegion[index] = value |
||
| 9247 | def get_LineDrawingRegion(self): |
||
| 9248 | return self.LineDrawingRegion |
||
| 9249 | def set_LineDrawingRegion(self, LineDrawingRegion): |
||
| 9250 | self.LineDrawingRegion = LineDrawingRegion |
||
| 9251 | def add_LineDrawingRegion(self, value): |
||
| 9252 | self.LineDrawingRegion.append(value) |
||
| 9253 | def insert_LineDrawingRegion_at(self, index, value): |
||
| 9254 | self.LineDrawingRegion.insert(index, value) |
||
| 9255 | def replace_LineDrawingRegion_at(self, index, value): |
||
| 9256 | self.LineDrawingRegion[index] = value |
||
| 9257 | def get_GraphicRegion(self): |
||
| 9258 | return self.GraphicRegion |
||
| 9259 | def set_GraphicRegion(self, GraphicRegion): |
||
| 9260 | self.GraphicRegion = GraphicRegion |
||
| 9261 | def add_GraphicRegion(self, value): |
||
| 9262 | self.GraphicRegion.append(value) |
||
| 9263 | def insert_GraphicRegion_at(self, index, value): |
||
| 9264 | self.GraphicRegion.insert(index, value) |
||
| 9265 | def replace_GraphicRegion_at(self, index, value): |
||
| 9266 | self.GraphicRegion[index] = value |
||
| 9267 | def get_TableRegion(self): |
||
| 9268 | return self.TableRegion |
||
| 9269 | def set_TableRegion(self, TableRegion): |
||
| 9270 | self.TableRegion = TableRegion |
||
| 9271 | def add_TableRegion(self, value): |
||
| 9272 | self.TableRegion.append(value) |
||
| 9273 | def insert_TableRegion_at(self, index, value): |
||
| 9274 | self.TableRegion.insert(index, value) |
||
| 9275 | def replace_TableRegion_at(self, index, value): |
||
| 9276 | self.TableRegion[index] = value |
||
| 9277 | def get_ChartRegion(self): |
||
| 9278 | return self.ChartRegion |
||
| 9279 | def set_ChartRegion(self, ChartRegion): |
||
| 9280 | self.ChartRegion = ChartRegion |
||
| 9281 | def add_ChartRegion(self, value): |
||
| 9282 | self.ChartRegion.append(value) |
||
| 9283 | def insert_ChartRegion_at(self, index, value): |
||
| 9284 | self.ChartRegion.insert(index, value) |
||
| 9285 | def replace_ChartRegion_at(self, index, value): |
||
| 9286 | self.ChartRegion[index] = value |
||
| 9287 | def get_SeparatorRegion(self): |
||
| 9288 | return self.SeparatorRegion |
||
| 9289 | def set_SeparatorRegion(self, SeparatorRegion): |
||
| 9290 | self.SeparatorRegion = SeparatorRegion |
||
| 9291 | def add_SeparatorRegion(self, value): |
||
| 9292 | self.SeparatorRegion.append(value) |
||
| 9293 | def insert_SeparatorRegion_at(self, index, value): |
||
| 9294 | self.SeparatorRegion.insert(index, value) |
||
| 9295 | def replace_SeparatorRegion_at(self, index, value): |
||
| 9296 | self.SeparatorRegion[index] = value |
||
| 9297 | def get_MathsRegion(self): |
||
| 9298 | return self.MathsRegion |
||
| 9299 | def set_MathsRegion(self, MathsRegion): |
||
| 9300 | self.MathsRegion = MathsRegion |
||
| 9301 | def add_MathsRegion(self, value): |
||
| 9302 | self.MathsRegion.append(value) |
||
| 9303 | def insert_MathsRegion_at(self, index, value): |
||
| 9304 | self.MathsRegion.insert(index, value) |
||
| 9305 | def replace_MathsRegion_at(self, index, value): |
||
| 9306 | self.MathsRegion[index] = value |
||
| 9307 | def get_ChemRegion(self): |
||
| 9308 | return self.ChemRegion |
||
| 9309 | def set_ChemRegion(self, ChemRegion): |
||
| 9310 | self.ChemRegion = ChemRegion |
||
| 9311 | def add_ChemRegion(self, value): |
||
| 9312 | self.ChemRegion.append(value) |
||
| 9313 | def insert_ChemRegion_at(self, index, value): |
||
| 9314 | self.ChemRegion.insert(index, value) |
||
| 9315 | def replace_ChemRegion_at(self, index, value): |
||
| 9316 | self.ChemRegion[index] = value |
||
| 9317 | def get_MusicRegion(self): |
||
| 9318 | return self.MusicRegion |
||
| 9319 | def set_MusicRegion(self, MusicRegion): |
||
| 9320 | self.MusicRegion = MusicRegion |
||
| 9321 | def add_MusicRegion(self, value): |
||
| 9322 | self.MusicRegion.append(value) |
||
| 9323 | def insert_MusicRegion_at(self, index, value): |
||
| 9324 | self.MusicRegion.insert(index, value) |
||
| 9325 | def replace_MusicRegion_at(self, index, value): |
||
| 9326 | self.MusicRegion[index] = value |
||
| 9327 | def get_AdvertRegion(self): |
||
| 9328 | return self.AdvertRegion |
||
| 9329 | def set_AdvertRegion(self, AdvertRegion): |
||
| 9330 | self.AdvertRegion = AdvertRegion |
||
| 9331 | def add_AdvertRegion(self, value): |
||
| 9332 | self.AdvertRegion.append(value) |
||
| 9333 | def insert_AdvertRegion_at(self, index, value): |
||
| 9334 | self.AdvertRegion.insert(index, value) |
||
| 9335 | def replace_AdvertRegion_at(self, index, value): |
||
| 9336 | self.AdvertRegion[index] = value |
||
| 9337 | def get_NoiseRegion(self): |
||
| 9338 | return self.NoiseRegion |
||
| 9339 | def set_NoiseRegion(self, NoiseRegion): |
||
| 9340 | self.NoiseRegion = NoiseRegion |
||
| 9341 | def add_NoiseRegion(self, value): |
||
| 9342 | self.NoiseRegion.append(value) |
||
| 9343 | def insert_NoiseRegion_at(self, index, value): |
||
| 9344 | self.NoiseRegion.insert(index, value) |
||
| 9345 | def replace_NoiseRegion_at(self, index, value): |
||
| 9346 | self.NoiseRegion[index] = value |
||
| 9347 | def get_UnknownRegion(self): |
||
| 9348 | return self.UnknownRegion |
||
| 9349 | def set_UnknownRegion(self, UnknownRegion): |
||
| 9350 | self.UnknownRegion = UnknownRegion |
||
| 9351 | def add_UnknownRegion(self, value): |
||
| 9352 | self.UnknownRegion.append(value) |
||
| 9353 | def insert_UnknownRegion_at(self, index, value): |
||
| 9354 | self.UnknownRegion.insert(index, value) |
||
| 9355 | def replace_UnknownRegion_at(self, index, value): |
||
| 9356 | self.UnknownRegion[index] = value |
||
| 9357 | def get_CustomRegion(self): |
||
| 9358 | return self.CustomRegion |
||
| 9359 | def set_CustomRegion(self, CustomRegion): |
||
| 9360 | self.CustomRegion = CustomRegion |
||
| 9361 | def add_CustomRegion(self, value): |
||
| 9362 | self.CustomRegion.append(value) |
||
| 9363 | def insert_CustomRegion_at(self, index, value): |
||
| 9364 | self.CustomRegion.insert(index, value) |
||
| 9365 | def replace_CustomRegion_at(self, index, value): |
||
| 9366 | self.CustomRegion[index] = value |
||
| 9367 | def get_id(self): |
||
| 9368 | return self.id |
||
| 9369 | def set_id(self, id): |
||
| 9370 | self.id = id |
||
| 9371 | def get_custom(self): |
||
| 9372 | return self.custom |
||
| 9373 | def set_custom(self, custom): |
||
| 9374 | self.custom = custom |
||
| 9375 | def get_comments(self): |
||
| 9376 | return self.comments |
||
| 9377 | def set_comments(self, comments): |
||
| 9378 | self.comments = comments |
||
| 9379 | def get_continuation(self): |
||
| 9380 | return self.continuation |
||
| 9381 | def set_continuation(self, continuation): |
||
| 9382 | self.continuation = continuation |
||
| 9383 | def get_extensiontype_(self): return self.extensiontype_ |
||
| 9384 | def set_extensiontype_(self, extensiontype_): self.extensiontype_ = extensiontype_ |
||
| 9385 | def hasContent_(self): |
||
| 9386 | if ( |
||
| 9387 | self.AlternativeImage or |
||
| 9388 | self.Coords is not None or |
||
| 9389 | self.UserDefined is not None or |
||
| 9390 | self.Labels or |
||
| 9391 | self.Roles is not None or |
||
| 9392 | self.TextRegion or |
||
| 9393 | self.ImageRegion or |
||
| 9394 | self.LineDrawingRegion or |
||
| 9395 | self.GraphicRegion or |
||
| 9396 | self.TableRegion or |
||
| 9397 | self.ChartRegion or |
||
| 9398 | self.SeparatorRegion or |
||
| 9399 | self.MathsRegion or |
||
| 9400 | self.ChemRegion or |
||
| 9401 | self.MusicRegion or |
||
| 9402 | self.AdvertRegion or |
||
| 9403 | self.NoiseRegion or |
||
| 9404 | self.UnknownRegion or |
||
| 9405 | self.CustomRegion |
||
| 9406 | ): |
||
| 9407 | return True |
||
| 9408 | else: |
||
| 9409 | return False |
||
| 9410 | def export(self, outfile, level, namespaceprefix_='', namespacedef_='xmlns:pc="http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15"', name_='RegionType', pretty_print=True): |
||
| 9411 | imported_ns_def_ = GenerateDSNamespaceDefs_.get('RegionType') |
||
| 9412 | if imported_ns_def_ is not None: |
||
| 9413 | namespacedef_ = imported_ns_def_ |
||
| 9414 | if pretty_print: |
||
| 9415 | eol_ = '\n' |
||
| 9416 | else: |
||
| 9417 | eol_ = '' |
||
| 9418 | if self.original_tagname_ is not None and name_ == 'RegionType': |
||
| 9419 | name_ = self.original_tagname_ |
||
| 9420 | if UseCapturedNS_ and self.ns_prefix_: |
||
| 9421 | namespaceprefix_ = self.ns_prefix_ + ':' |
||
| 9422 | showIndent(outfile, level, pretty_print) |
||
| 9423 | outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) |
||
| 9424 | already_processed = set() |
||
| 9425 | self.exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='RegionType') |
||
| 9426 | if self.hasContent_(): |
||
| 9427 | outfile.write('>%s' % (eol_, )) |
||
| 9428 | self.exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='RegionType', pretty_print=pretty_print) |
||
| 9429 | showIndent(outfile, level, pretty_print) |
||
| 9430 | outfile.write('</%s%s>%s' % (namespaceprefix_, name_, eol_)) |
||
| 9431 | else: |
||
| 9432 | outfile.write('/>%s' % (eol_, )) |
||
| 9433 | def exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='RegionType'): |
||
| 9434 | if self.id is not None and 'id' not in already_processed: |
||
| 9435 | already_processed.add('id') |
||
| 9436 | outfile.write(' id=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.id), input_name='id')), )) |
||
| 9437 | if self.custom is not None and 'custom' not in already_processed: |
||
| 9438 | already_processed.add('custom') |
||
| 9439 | outfile.write(' custom=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.custom), input_name='custom')), )) |
||
| 9440 | if self.comments is not None and 'comments' not in already_processed: |
||
| 9441 | already_processed.add('comments') |
||
| 9442 | outfile.write(' comments=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.comments), input_name='comments')), )) |
||
| 9443 | if self.continuation is not None and 'continuation' not in already_processed: |
||
| 9444 | already_processed.add('continuation') |
||
| 9445 | outfile.write(' continuation="%s"' % self.gds_format_boolean(self.continuation, input_name='continuation')) |
||
| 9446 | if self.extensiontype_ is not None and 'xsi:type' not in already_processed: |
||
| 9447 | already_processed.add('xsi:type') |
||
| 9448 | outfile.write(' xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"') |
||
| 9449 | if ":" not in self.extensiontype_: |
||
| 9450 | imported_ns_type_prefix_ = GenerateDSNamespaceTypePrefixes_.get(self.extensiontype_, '') |
||
| 9451 | outfile.write(' xsi:type="%s%s"' % (imported_ns_type_prefix_, self.extensiontype_)) |
||
| 9452 | else: |
||
| 9453 | outfile.write(' xsi:type="%s"' % self.extensiontype_) |
||
| 9454 | def exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='xmlns:pc="http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15"', name_='RegionType', fromsubclass_=False, pretty_print=True): |
||
| 9455 | if pretty_print: |
||
| 9456 | eol_ = '\n' |
||
| 9457 | else: |
||
| 9458 | eol_ = '' |
||
| 9459 | for AlternativeImage_ in self.AlternativeImage: |
||
| 9460 | namespaceprefix_ = self.AlternativeImage_nsprefix_ + ':' if (UseCapturedNS_ and self.AlternativeImage_nsprefix_) else '' |
||
| 9461 | AlternativeImage_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='AlternativeImage', pretty_print=pretty_print) |
||
| 9462 | if self.Coords is not None: |
||
| 9463 | namespaceprefix_ = self.Coords_nsprefix_ + ':' if (UseCapturedNS_ and self.Coords_nsprefix_) else '' |
||
| 9464 | self.Coords.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Coords', pretty_print=pretty_print) |
||
| 9465 | if self.UserDefined is not None: |
||
| 9466 | namespaceprefix_ = self.UserDefined_nsprefix_ + ':' if (UseCapturedNS_ and self.UserDefined_nsprefix_) else '' |
||
| 9467 | self.UserDefined.export(outfile, level, namespaceprefix_, namespacedef_='', name_='UserDefined', pretty_print=pretty_print) |
||
| 9468 | for Labels_ in self.Labels: |
||
| 9469 | namespaceprefix_ = self.Labels_nsprefix_ + ':' if (UseCapturedNS_ and self.Labels_nsprefix_) else '' |
||
| 9470 | Labels_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Labels', pretty_print=pretty_print) |
||
| 9471 | if self.Roles is not None: |
||
| 9472 | namespaceprefix_ = self.Roles_nsprefix_ + ':' if (UseCapturedNS_ and self.Roles_nsprefix_) else '' |
||
| 9473 | self.Roles.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Roles', pretty_print=pretty_print) |
||
| 9474 | for TextRegion_ in self.TextRegion: |
||
| 9475 | namespaceprefix_ = self.TextRegion_nsprefix_ + ':' if (UseCapturedNS_ and self.TextRegion_nsprefix_) else '' |
||
| 9476 | TextRegion_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='TextRegion', pretty_print=pretty_print) |
||
| 9477 | for ImageRegion_ in self.ImageRegion: |
||
| 9478 | namespaceprefix_ = self.ImageRegion_nsprefix_ + ':' if (UseCapturedNS_ and self.ImageRegion_nsprefix_) else '' |
||
| 9479 | ImageRegion_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='ImageRegion', pretty_print=pretty_print) |
||
| 9480 | for LineDrawingRegion_ in self.LineDrawingRegion: |
||
| 9481 | namespaceprefix_ = self.LineDrawingRegion_nsprefix_ + ':' if (UseCapturedNS_ and self.LineDrawingRegion_nsprefix_) else '' |
||
| 9482 | LineDrawingRegion_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='LineDrawingRegion', pretty_print=pretty_print) |
||
| 9483 | for GraphicRegion_ in self.GraphicRegion: |
||
| 9484 | namespaceprefix_ = self.GraphicRegion_nsprefix_ + ':' if (UseCapturedNS_ and self.GraphicRegion_nsprefix_) else '' |
||
| 9485 | GraphicRegion_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='GraphicRegion', pretty_print=pretty_print) |
||
| 9486 | for TableRegion_ in self.TableRegion: |
||
| 9487 | namespaceprefix_ = self.TableRegion_nsprefix_ + ':' if (UseCapturedNS_ and self.TableRegion_nsprefix_) else '' |
||
| 9488 | TableRegion_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='TableRegion', pretty_print=pretty_print) |
||
| 9489 | for ChartRegion_ in self.ChartRegion: |
||
| 9490 | namespaceprefix_ = self.ChartRegion_nsprefix_ + ':' if (UseCapturedNS_ and self.ChartRegion_nsprefix_) else '' |
||
| 9491 | ChartRegion_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='ChartRegion', pretty_print=pretty_print) |
||
| 9492 | for SeparatorRegion_ in self.SeparatorRegion: |
||
| 9493 | namespaceprefix_ = self.SeparatorRegion_nsprefix_ + ':' if (UseCapturedNS_ and self.SeparatorRegion_nsprefix_) else '' |
||
| 9494 | SeparatorRegion_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='SeparatorRegion', pretty_print=pretty_print) |
||
| 9495 | for MathsRegion_ in self.MathsRegion: |
||
| 9496 | namespaceprefix_ = self.MathsRegion_nsprefix_ + ':' if (UseCapturedNS_ and self.MathsRegion_nsprefix_) else '' |
||
| 9497 | MathsRegion_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='MathsRegion', pretty_print=pretty_print) |
||
| 9498 | for ChemRegion_ in self.ChemRegion: |
||
| 9499 | namespaceprefix_ = self.ChemRegion_nsprefix_ + ':' if (UseCapturedNS_ and self.ChemRegion_nsprefix_) else '' |
||
| 9500 | ChemRegion_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='ChemRegion', pretty_print=pretty_print) |
||
| 9501 | for MusicRegion_ in self.MusicRegion: |
||
| 9502 | namespaceprefix_ = self.MusicRegion_nsprefix_ + ':' if (UseCapturedNS_ and self.MusicRegion_nsprefix_) else '' |
||
| 9503 | MusicRegion_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='MusicRegion', pretty_print=pretty_print) |
||
| 9504 | for AdvertRegion_ in self.AdvertRegion: |
||
| 9505 | namespaceprefix_ = self.AdvertRegion_nsprefix_ + ':' if (UseCapturedNS_ and self.AdvertRegion_nsprefix_) else '' |
||
| 9506 | AdvertRegion_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='AdvertRegion', pretty_print=pretty_print) |
||
| 9507 | for NoiseRegion_ in self.NoiseRegion: |
||
| 9508 | namespaceprefix_ = self.NoiseRegion_nsprefix_ + ':' if (UseCapturedNS_ and self.NoiseRegion_nsprefix_) else '' |
||
| 9509 | NoiseRegion_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='NoiseRegion', pretty_print=pretty_print) |
||
| 9510 | for UnknownRegion_ in self.UnknownRegion: |
||
| 9511 | namespaceprefix_ = self.UnknownRegion_nsprefix_ + ':' if (UseCapturedNS_ and self.UnknownRegion_nsprefix_) else '' |
||
| 9512 | UnknownRegion_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='UnknownRegion', pretty_print=pretty_print) |
||
| 9513 | for CustomRegion_ in self.CustomRegion: |
||
| 9514 | namespaceprefix_ = self.CustomRegion_nsprefix_ + ':' if (UseCapturedNS_ and self.CustomRegion_nsprefix_) else '' |
||
| 9515 | CustomRegion_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='CustomRegion', pretty_print=pretty_print) |
||
| 9516 | def to_etree(self, parent_element=None, name_='RegionType', mapping_=None, nsmap_=None): |
||
| 9517 | if parent_element is None: |
||
| 9518 | element = etree_.Element('{http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15}' + name_, nsmap=nsmap_) |
||
| 9519 | else: |
||
| 9520 | element = etree_.SubElement(parent_element, '{http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15}' + name_, nsmap=nsmap_) |
||
| 9521 | if self.extensiontype_ is not None: |
||
| 9522 | element.set('{http://www.w3.org/2001/XMLSchema-instance}type', self.extensiontype_) |
||
| 9523 | if self.id is not None: |
||
| 9524 | element.set('id', self.gds_format_string(self.id)) |
||
| 9525 | if self.custom is not None: |
||
| 9526 | element.set('custom', self.gds_format_string(self.custom)) |
||
| 9527 | if self.comments is not None: |
||
| 9528 | element.set('comments', self.gds_format_string(self.comments)) |
||
| 9529 | if self.continuation is not None: |
||
| 9530 | element.set('continuation', self.gds_format_boolean(self.continuation)) |
||
| 9531 | for AlternativeImage_ in self.AlternativeImage: |
||
| 9532 | AlternativeImage_.to_etree(element, name_='AlternativeImage', mapping_=mapping_, nsmap_=nsmap_) |
||
| 9533 | if self.Coords is not None: |
||
| 9534 | Coords_ = self.Coords |
||
| 9535 | Coords_.to_etree(element, name_='Coords', mapping_=mapping_, nsmap_=nsmap_) |
||
| 9536 | if self.UserDefined is not None: |
||
| 9537 | UserDefined_ = self.UserDefined |
||
| 9538 | UserDefined_.to_etree(element, name_='UserDefined', mapping_=mapping_, nsmap_=nsmap_) |
||
| 9539 | for Labels_ in self.Labels: |
||
| 9540 | Labels_.to_etree(element, name_='Labels', mapping_=mapping_, nsmap_=nsmap_) |
||
| 9541 | if self.Roles is not None: |
||
| 9542 | Roles_ = self.Roles |
||
| 9543 | Roles_.to_etree(element, name_='Roles', mapping_=mapping_, nsmap_=nsmap_) |
||
| 9544 | for TextRegion_ in self.TextRegion: |
||
| 9545 | TextRegion_.to_etree(element, name_='TextRegion', mapping_=mapping_, nsmap_=nsmap_) |
||
| 9546 | for ImageRegion_ in self.ImageRegion: |
||
| 9547 | ImageRegion_.to_etree(element, name_='ImageRegion', mapping_=mapping_, nsmap_=nsmap_) |
||
| 9548 | for LineDrawingRegion_ in self.LineDrawingRegion: |
||
| 9549 | LineDrawingRegion_.to_etree(element, name_='LineDrawingRegion', mapping_=mapping_, nsmap_=nsmap_) |
||
| 9550 | for GraphicRegion_ in self.GraphicRegion: |
||
| 9551 | GraphicRegion_.to_etree(element, name_='GraphicRegion', mapping_=mapping_, nsmap_=nsmap_) |
||
| 9552 | for TableRegion_ in self.TableRegion: |
||
| 9553 | TableRegion_.to_etree(element, name_='TableRegion', mapping_=mapping_, nsmap_=nsmap_) |
||
| 9554 | for ChartRegion_ in self.ChartRegion: |
||
| 9555 | ChartRegion_.to_etree(element, name_='ChartRegion', mapping_=mapping_, nsmap_=nsmap_) |
||
| 9556 | for SeparatorRegion_ in self.SeparatorRegion: |
||
| 9557 | SeparatorRegion_.to_etree(element, name_='SeparatorRegion', mapping_=mapping_, nsmap_=nsmap_) |
||
| 9558 | for MathsRegion_ in self.MathsRegion: |
||
| 9559 | MathsRegion_.to_etree(element, name_='MathsRegion', mapping_=mapping_, nsmap_=nsmap_) |
||
| 9560 | for ChemRegion_ in self.ChemRegion: |
||
| 9561 | ChemRegion_.to_etree(element, name_='ChemRegion', mapping_=mapping_, nsmap_=nsmap_) |
||
| 9562 | for MusicRegion_ in self.MusicRegion: |
||
| 9563 | MusicRegion_.to_etree(element, name_='MusicRegion', mapping_=mapping_, nsmap_=nsmap_) |
||
| 9564 | for AdvertRegion_ in self.AdvertRegion: |
||
| 9565 | AdvertRegion_.to_etree(element, name_='AdvertRegion', mapping_=mapping_, nsmap_=nsmap_) |
||
| 9566 | for NoiseRegion_ in self.NoiseRegion: |
||
| 9567 | NoiseRegion_.to_etree(element, name_='NoiseRegion', mapping_=mapping_, nsmap_=nsmap_) |
||
| 9568 | for UnknownRegion_ in self.UnknownRegion: |
||
| 9569 | UnknownRegion_.to_etree(element, name_='UnknownRegion', mapping_=mapping_, nsmap_=nsmap_) |
||
| 9570 | for CustomRegion_ in self.CustomRegion: |
||
| 9571 | CustomRegion_.to_etree(element, name_='CustomRegion', mapping_=mapping_, nsmap_=nsmap_) |
||
| 9572 | if mapping_ is not None: |
||
| 9573 | mapping_[id(self)] = element |
||
| 9574 | return element |
||
| 9575 | def build(self, node, gds_collector_=None): |
||
| 9576 | self.gds_collector_ = gds_collector_ |
||
| 9577 | if SaveElementTreeNode: |
||
| 9578 | self.gds_elementtree_node_ = node |
||
| 9579 | already_processed = set() |
||
| 9580 | self.ns_prefix_ = node.prefix |
||
| 9581 | self.buildAttributes(node, node.attrib, already_processed) |
||
| 9582 | for child in node: |
||
| 9583 | nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] |
||
| 9584 | self.buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) |
||
| 9585 | return self |
||
| 9586 | def buildAttributes(self, node, attrs, already_processed): |
||
| 9587 | value = find_attr_value_('id', node) |
||
| 9588 | if value is not None and 'id' not in already_processed: |
||
| 9589 | already_processed.add('id') |
||
| 9590 | self.id = value |
||
| 9591 | value = find_attr_value_('custom', node) |
||
| 9592 | if value is not None and 'custom' not in already_processed: |
||
| 9593 | already_processed.add('custom') |
||
| 9594 | self.custom = value |
||
| 9595 | value = find_attr_value_('comments', node) |
||
| 9596 | if value is not None and 'comments' not in already_processed: |
||
| 9597 | already_processed.add('comments') |
||
| 9598 | self.comments = value |
||
| 9599 | value = find_attr_value_('continuation', node) |
||
| 9600 | if value is not None and 'continuation' not in already_processed: |
||
| 9601 | already_processed.add('continuation') |
||
| 9602 | if value in ('true', '1'): |
||
| 9603 | self.continuation = True |
||
| 9604 | elif value in ('false', '0'): |
||
| 9605 | self.continuation = False |
||
| 9606 | else: |
||
| 9607 | raise_parse_error(node, 'Bad boolean attribute') |
||
| 9608 | value = find_attr_value_('xsi:type', node) |
||
| 9609 | if value is not None and 'xsi:type' not in already_processed: |
||
| 9610 | already_processed.add('xsi:type') |
||
| 9611 | self.extensiontype_ = value |
||
| 9612 | def buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None): |
||
| 9613 | if nodeName_ == 'AlternativeImage': |
||
| 9614 | obj_ = AlternativeImageType.factory(parent_object_=self) |
||
| 9615 | obj_.build(child_, gds_collector_=gds_collector_) |
||
| 9616 | self.AlternativeImage.append(obj_) |
||
| 9617 | obj_.original_tagname_ = 'AlternativeImage' |
||
| 9618 | elif nodeName_ == 'Coords': |
||
| 9619 | obj_ = CoordsType.factory(parent_object_=self) |
||
| 9620 | obj_.build(child_, gds_collector_=gds_collector_) |
||
| 9621 | self.Coords = obj_ |
||
| 9622 | obj_.original_tagname_ = 'Coords' |
||
| 9623 | elif nodeName_ == 'UserDefined': |
||
| 9624 | obj_ = UserDefinedType.factory(parent_object_=self) |
||
| 9625 | obj_.build(child_, gds_collector_=gds_collector_) |
||
| 9626 | self.UserDefined = obj_ |
||
| 9627 | obj_.original_tagname_ = 'UserDefined' |
||
| 9628 | elif nodeName_ == 'Labels': |
||
| 9629 | obj_ = LabelsType.factory(parent_object_=self) |
||
| 9630 | obj_.build(child_, gds_collector_=gds_collector_) |
||
| 9631 | self.Labels.append(obj_) |
||
| 9632 | obj_.original_tagname_ = 'Labels' |
||
| 9633 | elif nodeName_ == 'Roles': |
||
| 9634 | obj_ = RolesType.factory(parent_object_=self) |
||
| 9635 | obj_.build(child_, gds_collector_=gds_collector_) |
||
| 9636 | self.Roles = obj_ |
||
| 9637 | obj_.original_tagname_ = 'Roles' |
||
| 9638 | elif nodeName_ == 'TextRegion': |
||
| 9639 | obj_ = TextRegionType.factory(parent_object_=self) |
||
| 9640 | obj_.build(child_, gds_collector_=gds_collector_) |
||
| 9641 | self.TextRegion.append(obj_) |
||
| 9642 | obj_.original_tagname_ = 'TextRegion' |
||
| 9643 | elif nodeName_ == 'ImageRegion': |
||
| 9644 | obj_ = ImageRegionType.factory(parent_object_=self) |
||
| 9645 | obj_.build(child_, gds_collector_=gds_collector_) |
||
| 9646 | self.ImageRegion.append(obj_) |
||
| 9647 | obj_.original_tagname_ = 'ImageRegion' |
||
| 9648 | elif nodeName_ == 'LineDrawingRegion': |
||
| 9649 | obj_ = LineDrawingRegionType.factory(parent_object_=self) |
||
| 9650 | obj_.build(child_, gds_collector_=gds_collector_) |
||
| 9651 | self.LineDrawingRegion.append(obj_) |
||
| 9652 | obj_.original_tagname_ = 'LineDrawingRegion' |
||
| 9653 | elif nodeName_ == 'GraphicRegion': |
||
| 9654 | obj_ = GraphicRegionType.factory(parent_object_=self) |
||
| 9655 | obj_.build(child_, gds_collector_=gds_collector_) |
||
| 9656 | self.GraphicRegion.append(obj_) |
||
| 9657 | obj_.original_tagname_ = 'GraphicRegion' |
||
| 9658 | elif nodeName_ == 'TableRegion': |
||
| 9659 | obj_ = TableRegionType.factory(parent_object_=self) |
||
| 9660 | obj_.build(child_, gds_collector_=gds_collector_) |
||
| 9661 | self.TableRegion.append(obj_) |
||
| 9662 | obj_.original_tagname_ = 'TableRegion' |
||
| 9663 | elif nodeName_ == 'ChartRegion': |
||
| 9664 | obj_ = ChartRegionType.factory(parent_object_=self) |
||
| 9665 | obj_.build(child_, gds_collector_=gds_collector_) |
||
| 9666 | self.ChartRegion.append(obj_) |
||
| 9667 | obj_.original_tagname_ = 'ChartRegion' |
||
| 9668 | elif nodeName_ == 'SeparatorRegion': |
||
| 9669 | obj_ = SeparatorRegionType.factory(parent_object_=self) |
||
| 9670 | obj_.build(child_, gds_collector_=gds_collector_) |
||
| 9671 | self.SeparatorRegion.append(obj_) |
||
| 9672 | obj_.original_tagname_ = 'SeparatorRegion' |
||
| 9673 | elif nodeName_ == 'MathsRegion': |
||
| 9674 | obj_ = MathsRegionType.factory(parent_object_=self) |
||
| 9675 | obj_.build(child_, gds_collector_=gds_collector_) |
||
| 9676 | self.MathsRegion.append(obj_) |
||
| 9677 | obj_.original_tagname_ = 'MathsRegion' |
||
| 9678 | elif nodeName_ == 'ChemRegion': |
||
| 9679 | obj_ = ChemRegionType.factory(parent_object_=self) |
||
| 9680 | obj_.build(child_, gds_collector_=gds_collector_) |
||
| 9681 | self.ChemRegion.append(obj_) |
||
| 9682 | obj_.original_tagname_ = 'ChemRegion' |
||
| 9683 | elif nodeName_ == 'MusicRegion': |
||
| 9684 | obj_ = MusicRegionType.factory(parent_object_=self) |
||
| 9685 | obj_.build(child_, gds_collector_=gds_collector_) |
||
| 9686 | self.MusicRegion.append(obj_) |
||
| 9687 | obj_.original_tagname_ = 'MusicRegion' |
||
| 9688 | elif nodeName_ == 'AdvertRegion': |
||
| 9689 | obj_ = AdvertRegionType.factory(parent_object_=self) |
||
| 9690 | obj_.build(child_, gds_collector_=gds_collector_) |
||
| 9691 | self.AdvertRegion.append(obj_) |
||
| 9692 | obj_.original_tagname_ = 'AdvertRegion' |
||
| 9693 | elif nodeName_ == 'NoiseRegion': |
||
| 9694 | obj_ = NoiseRegionType.factory(parent_object_=self) |
||
| 9695 | obj_.build(child_, gds_collector_=gds_collector_) |
||
| 9696 | self.NoiseRegion.append(obj_) |
||
| 9697 | obj_.original_tagname_ = 'NoiseRegion' |
||
| 9698 | elif nodeName_ == 'UnknownRegion': |
||
| 9699 | obj_ = UnknownRegionType.factory(parent_object_=self) |
||
| 9700 | obj_.build(child_, gds_collector_=gds_collector_) |
||
| 9701 | self.UnknownRegion.append(obj_) |
||
| 9702 | obj_.original_tagname_ = 'UnknownRegion' |
||
| 9703 | elif nodeName_ == 'CustomRegion': |
||
| 9704 | obj_ = CustomRegionType.factory(parent_object_=self) |
||
| 9705 | obj_.build(child_, gds_collector_=gds_collector_) |
||
| 9706 | self.CustomRegion.append(obj_) |
||
| 9707 | obj_.original_tagname_ = 'CustomRegion' |
||
| 9708 | def __hash__(self): |
||
| 9709 | return hash(self.id) |
||
| 9710 | View Code Duplication | def invalidate_AlternativeImage(self, feature_selector=None): |
|
| 9711 | """ |
||
| 9712 | Remove derived images from this segment (due to changed coordinates). |
||
| 9713 | |||
| 9714 | If `feature_selector` is not none, remove only images with |
||
| 9715 | matching ``@comments``, e.g. ``feature_selector=cropped,deskewed``. |
||
| 9716 | """ |
||
| 9717 | existing_images = self.AlternativeImage or [] |
||
| 9718 | removed_images = [] |
||
| 9719 | if feature_selector: |
||
| 9720 | new_images = [] |
||
| 9721 | for image in existing_images: |
||
| 9722 | features = image.get_comments() or '' |
||
| 9723 | if any(feature in features.split(',') |
||
| 9724 | for feature in feature_selector.split(',') if feature): |
||
| 9725 | removed_images.append(image) |
||
| 9726 | else: |
||
| 9727 | new_images.append(image) |
||
| 9728 | self.AlternativeImage = new_images |
||
| 9729 | else: |
||
| 9730 | removed_images = existing_images |
||
| 9731 | self.AlternativeImage = [] |
||
| 9732 | if hasattr(self, 'id'): |
||
| 9733 | name = self.id |
||
| 9734 | elif hasattr(self, 'parent_object_') and hasattr(self.parent_object_, 'pcGtsId'): |
||
| 9735 | name = self.parent_object_.pcGtsId |
||
| 9736 | else: |
||
| 9737 | name = '' |
||
| 9738 | for image in removed_images: |
||
| 9739 | self.gds_collector_.add_message('Removing AlternativeImage %s from "%s"' % ( |
||
| 9740 | image.get_comments() or '', name)) |
||
| 9741 | def set_Coords(self, Coords): |
||
| 9742 | """ |
||
| 9743 | Set coordinate polygon by given :py:class:`CoordsType` object. |
||
| 9744 | Moreover, invalidate self's ``pc:AlternativeImage``s |
||
| 9745 | (because they will have been cropped with a bbox |
||
| 9746 | of the previous polygon). |
||
| 9747 | """ |
||
| 9748 | if hasattr(self, 'invalidate_AlternativeImage'): |
||
| 9749 | # RegionType, TextLineType, WordType, GlyphType: |
||
| 9750 | self.invalidate_AlternativeImage() |
||
| 9751 | elif hasattr(self, 'parent_object_') and hasattr(self.parent_object_, 'invalidate_AlternativeImage'): |
||
| 9752 | # BorderType: |
||
| 9753 | self.parent_object_.invalidate_AlternativeImage(feature_selector='cropped') |
||
| 9754 | self.Coords = Coords |
||
| 9755 | # end class RegionType |
||
| 9756 | |||
| 9757 | |||
| 9758 | class AlternativeImageType(GeneratedsSuper): |
||
| 9759 | """Confidence value (between 0 and 1)""" |
||
| 9760 | __hash__ = GeneratedsSuper.__hash__ |
||
| 9761 | member_data_items_ = [ |
||
| 9762 | MemberSpec_('filename', 'string', 0, 0, {'use': 'required'}), |
||
| 9763 | MemberSpec_('comments', 'string', 0, 1, {'use': 'optional'}), |
||
| 9764 | MemberSpec_('conf', 'pc:ConfSimpleType', 0, 1, {'use': 'optional'}), |
||
| 9765 | ] |
||
| 9766 | subclass = None |
||
| 9767 | superclass = None |
||
| 9768 | def __init__(self, filename=None, comments=None, conf=None, gds_collector_=None, **kwargs_): |
||
| 9769 | self.gds_collector_ = gds_collector_ |
||
| 9770 | self.gds_elementtree_node_ = None |
||
| 9771 | self.original_tagname_ = None |
||
| 9772 | self.parent_object_ = kwargs_.get('parent_object_') |
||
| 9773 | self.ns_prefix_ = None |
||
| 9774 | self.filename = _cast(None, filename) |
||
| 9775 | self.filename_nsprefix_ = "pc" |
||
| 9776 | self.comments = _cast(None, comments) |
||
| 9777 | self.comments_nsprefix_ = "pc" |
||
| 9778 | self.conf = _cast(float, conf) |
||
| 9779 | self.conf_nsprefix_ = "pc" |
||
| 9780 | def factory(*args_, **kwargs_): |
||
| 9781 | if CurrentSubclassModule_ is not None: |
||
| 9782 | subclass = getSubclassFromModule_( |
||
| 9783 | CurrentSubclassModule_, AlternativeImageType) |
||
| 9784 | if subclass is not None: |
||
| 9785 | return subclass(*args_, **kwargs_) |
||
| 9786 | if AlternativeImageType.subclass: |
||
| 9787 | return AlternativeImageType.subclass(*args_, **kwargs_) |
||
| 9788 | else: |
||
| 9789 | return AlternativeImageType(*args_, **kwargs_) |
||
| 9790 | factory = staticmethod(factory) |
||
| 9791 | def get_ns_prefix_(self): |
||
| 9792 | return self.ns_prefix_ |
||
| 9793 | def set_ns_prefix_(self, ns_prefix): |
||
| 9794 | self.ns_prefix_ = ns_prefix |
||
| 9795 | def get_filename(self): |
||
| 9796 | return self.filename |
||
| 9797 | def set_filename(self, filename): |
||
| 9798 | self.filename = filename |
||
| 9799 | def get_comments(self): |
||
| 9800 | return self.comments |
||
| 9801 | def set_comments(self, comments): |
||
| 9802 | self.comments = comments |
||
| 9803 | def get_conf(self): |
||
| 9804 | return self.conf |
||
| 9805 | def set_conf(self, conf): |
||
| 9806 | self.conf = conf |
||
| 9807 | View Code Duplication | def validate_ConfSimpleType(self, value): |
|
| 9808 | # Validate type pc:ConfSimpleType, a restriction on float. |
||
| 9809 | if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None: |
||
| 9810 | if not isinstance(value, float): |
||
| 9811 | lineno = self.gds_get_node_lineno_() |
||
| 9812 | self.gds_collector_.add_message('Value "%(value)s"%(lineno)s is not of the correct base simple type (float)' % {"value": value, "lineno": lineno, }) |
||
| 9813 | return False |
||
| 9814 | if value < 0: |
||
| 9815 | lineno = self.gds_get_node_lineno_() |
||
| 9816 | self.gds_collector_.add_message('Value "%(value)s"%(lineno)s does not match xsd minInclusive restriction on ConfSimpleType' % {"value": value, "lineno": lineno} ) |
||
| 9817 | result = False |
||
| 9818 | if value > 1: |
||
| 9819 | lineno = self.gds_get_node_lineno_() |
||
| 9820 | self.gds_collector_.add_message('Value "%(value)s"%(lineno)s does not match xsd maxInclusive restriction on ConfSimpleType' % {"value": value, "lineno": lineno} ) |
||
| 9821 | result = False |
||
| 9822 | def hasContent_(self): |
||
| 9823 | if ( |
||
| 9824 | |||
| 9825 | ): |
||
| 9826 | return True |
||
| 9827 | else: |
||
| 9828 | return False |
||
| 9829 | def export(self, outfile, level, namespaceprefix_='', namespacedef_='xmlns:pc="http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15"', name_='AlternativeImageType', pretty_print=True): |
||
| 9830 | imported_ns_def_ = GenerateDSNamespaceDefs_.get('AlternativeImageType') |
||
| 9831 | if imported_ns_def_ is not None: |
||
| 9832 | namespacedef_ = imported_ns_def_ |
||
| 9833 | if pretty_print: |
||
| 9834 | eol_ = '\n' |
||
| 9835 | else: |
||
| 9836 | eol_ = '' |
||
| 9837 | if self.original_tagname_ is not None and name_ == 'AlternativeImageType': |
||
| 9838 | name_ = self.original_tagname_ |
||
| 9839 | if UseCapturedNS_ and self.ns_prefix_: |
||
| 9840 | namespaceprefix_ = self.ns_prefix_ + ':' |
||
| 9841 | showIndent(outfile, level, pretty_print) |
||
| 9842 | outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) |
||
| 9843 | already_processed = set() |
||
| 9844 | self.exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='AlternativeImageType') |
||
| 9845 | if self.hasContent_(): |
||
| 9846 | outfile.write('>%s' % (eol_, )) |
||
| 9847 | self.exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='AlternativeImageType', pretty_print=pretty_print) |
||
| 9848 | outfile.write('</%s%s>%s' % (namespaceprefix_, name_, eol_)) |
||
| 9849 | else: |
||
| 9850 | outfile.write('/>%s' % (eol_, )) |
||
| 9851 | View Code Duplication | def exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='AlternativeImageType'): |
|
| 9852 | if self.filename is not None and 'filename' not in already_processed: |
||
| 9853 | already_processed.add('filename') |
||
| 9854 | outfile.write(' filename=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.filename), input_name='filename')), )) |
||
| 9855 | if self.comments is not None and 'comments' not in already_processed: |
||
| 9856 | already_processed.add('comments') |
||
| 9857 | outfile.write(' comments=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.comments), input_name='comments')), )) |
||
| 9858 | if self.conf is not None and 'conf' not in already_processed: |
||
| 9859 | already_processed.add('conf') |
||
| 9860 | outfile.write(' conf="%s"' % self.gds_format_float(self.conf, input_name='conf')) |
||
| 9861 | def exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='xmlns:pc="http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15"', name_='AlternativeImageType', fromsubclass_=False, pretty_print=True): |
||
| 9862 | pass |
||
| 9863 | View Code Duplication | def to_etree(self, parent_element=None, name_='AlternativeImageType', mapping_=None, nsmap_=None): |
|
| 9864 | if parent_element is None: |
||
| 9865 | element = etree_.Element('{http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15}' + name_, nsmap=nsmap_) |
||
| 9866 | else: |
||
| 9867 | element = etree_.SubElement(parent_element, '{http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15}' + name_, nsmap=nsmap_) |
||
| 9868 | if self.filename is not None: |
||
| 9869 | element.set('filename', self.gds_format_string(self.filename)) |
||
| 9870 | if self.comments is not None: |
||
| 9871 | element.set('comments', self.gds_format_string(self.comments)) |
||
| 9872 | if self.conf is not None: |
||
| 9873 | element.set('conf', self.gds_format_float(self.conf)) |
||
| 9874 | if mapping_ is not None: |
||
| 9875 | mapping_[id(self)] = element |
||
| 9876 | return element |
||
| 9877 | def build(self, node, gds_collector_=None): |
||
| 9878 | self.gds_collector_ = gds_collector_ |
||
| 9879 | if SaveElementTreeNode: |
||
| 9880 | self.gds_elementtree_node_ = node |
||
| 9881 | already_processed = set() |
||
| 9882 | self.ns_prefix_ = node.prefix |
||
| 9883 | self.buildAttributes(node, node.attrib, already_processed) |
||
| 9884 | for child in node: |
||
| 9885 | nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] |
||
| 9886 | self.buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) |
||
| 9887 | return self |
||
| 9888 | def buildAttributes(self, node, attrs, already_processed): |
||
| 9889 | value = find_attr_value_('filename', node) |
||
| 9890 | if value is not None and 'filename' not in already_processed: |
||
| 9891 | already_processed.add('filename') |
||
| 9892 | self.filename = value |
||
| 9893 | value = find_attr_value_('comments', node) |
||
| 9894 | if value is not None and 'comments' not in already_processed: |
||
| 9895 | already_processed.add('comments') |
||
| 9896 | self.comments = value |
||
| 9897 | value = find_attr_value_('conf', node) |
||
| 9898 | if value is not None and 'conf' not in already_processed: |
||
| 9899 | already_processed.add('conf') |
||
| 9900 | value = self.gds_parse_float(value, node, 'conf') |
||
| 9901 | self.conf = value |
||
| 9902 | self.validate_ConfSimpleType(self.conf) # validate type ConfSimpleType |
||
| 9903 | def buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None): |
||
| 9904 | pass |
||
| 9905 | def __hash__(self): |
||
| 9906 | return hash(self.id) |
||
| 9907 | # end class AlternativeImageType |
||
| 9908 | |||
| 9909 | |||
| 9910 | class GraphemesType(GeneratedsSuper): |
||
| 9911 | """Container for graphemes, grapheme groups and |
||
| 9912 | non-printing characters.""" |
||
| 9913 | __hash__ = GeneratedsSuper.__hash__ |
||
| 9914 | member_data_items_ = [ |
||
| 9915 | MemberSpec_('Grapheme', 'GraphemeType', 1, 0, {'name': 'Grapheme', 'type': 'GraphemeType'}, 8), |
||
| 9916 | MemberSpec_('NonPrintingChar', 'NonPrintingCharType', 1, 0, {'name': 'NonPrintingChar', 'type': 'NonPrintingCharType'}, 8), |
||
| 9917 | MemberSpec_('GraphemeGroup', 'GraphemeGroupType', 1, 0, {'name': 'GraphemeGroup', 'type': 'GraphemeGroupType'}, 8), |
||
| 9918 | ] |
||
| 9919 | subclass = None |
||
| 9920 | superclass = None |
||
| 9921 | def __init__(self, Grapheme=None, NonPrintingChar=None, GraphemeGroup=None, gds_collector_=None, **kwargs_): |
||
| 9922 | self.gds_collector_ = gds_collector_ |
||
| 9923 | self.gds_elementtree_node_ = None |
||
| 9924 | self.original_tagname_ = None |
||
| 9925 | self.parent_object_ = kwargs_.get('parent_object_') |
||
| 9926 | self.ns_prefix_ = None |
||
| 9927 | if Grapheme is None: |
||
| 9928 | self.Grapheme = [] |
||
| 9929 | else: |
||
| 9930 | self.Grapheme = Grapheme |
||
| 9931 | self.Grapheme_nsprefix_ = "pc" |
||
| 9932 | if NonPrintingChar is None: |
||
| 9933 | self.NonPrintingChar = [] |
||
| 9934 | else: |
||
| 9935 | self.NonPrintingChar = NonPrintingChar |
||
| 9936 | self.NonPrintingChar_nsprefix_ = "pc" |
||
| 9937 | if GraphemeGroup is None: |
||
| 9938 | self.GraphemeGroup = [] |
||
| 9939 | else: |
||
| 9940 | self.GraphemeGroup = GraphemeGroup |
||
| 9941 | self.GraphemeGroup_nsprefix_ = "pc" |
||
| 9942 | def factory(*args_, **kwargs_): |
||
| 9943 | if CurrentSubclassModule_ is not None: |
||
| 9944 | subclass = getSubclassFromModule_( |
||
| 9945 | CurrentSubclassModule_, GraphemesType) |
||
| 9946 | if subclass is not None: |
||
| 9947 | return subclass(*args_, **kwargs_) |
||
| 9948 | if GraphemesType.subclass: |
||
| 9949 | return GraphemesType.subclass(*args_, **kwargs_) |
||
| 9950 | else: |
||
| 9951 | return GraphemesType(*args_, **kwargs_) |
||
| 9952 | factory = staticmethod(factory) |
||
| 9953 | def get_ns_prefix_(self): |
||
| 9954 | return self.ns_prefix_ |
||
| 9955 | def set_ns_prefix_(self, ns_prefix): |
||
| 9956 | self.ns_prefix_ = ns_prefix |
||
| 9957 | def get_Grapheme(self): |
||
| 9958 | return self.Grapheme |
||
| 9959 | def set_Grapheme(self, Grapheme): |
||
| 9960 | self.Grapheme = Grapheme |
||
| 9961 | def add_Grapheme(self, value): |
||
| 9962 | self.Grapheme.append(value) |
||
| 9963 | def insert_Grapheme_at(self, index, value): |
||
| 9964 | self.Grapheme.insert(index, value) |
||
| 9965 | def replace_Grapheme_at(self, index, value): |
||
| 9966 | self.Grapheme[index] = value |
||
| 9967 | def get_NonPrintingChar(self): |
||
| 9968 | return self.NonPrintingChar |
||
| 9969 | def set_NonPrintingChar(self, NonPrintingChar): |
||
| 9970 | self.NonPrintingChar = NonPrintingChar |
||
| 9971 | def add_NonPrintingChar(self, value): |
||
| 9972 | self.NonPrintingChar.append(value) |
||
| 9973 | def insert_NonPrintingChar_at(self, index, value): |
||
| 9974 | self.NonPrintingChar.insert(index, value) |
||
| 9975 | def replace_NonPrintingChar_at(self, index, value): |
||
| 9976 | self.NonPrintingChar[index] = value |
||
| 9977 | def get_GraphemeGroup(self): |
||
| 9978 | return self.GraphemeGroup |
||
| 9979 | def set_GraphemeGroup(self, GraphemeGroup): |
||
| 9980 | self.GraphemeGroup = GraphemeGroup |
||
| 9981 | def add_GraphemeGroup(self, value): |
||
| 9982 | self.GraphemeGroup.append(value) |
||
| 9983 | def insert_GraphemeGroup_at(self, index, value): |
||
| 9984 | self.GraphemeGroup.insert(index, value) |
||
| 9985 | def replace_GraphemeGroup_at(self, index, value): |
||
| 9986 | self.GraphemeGroup[index] = value |
||
| 9987 | def hasContent_(self): |
||
| 9988 | if ( |
||
| 9989 | self.Grapheme or |
||
| 9990 | self.NonPrintingChar or |
||
| 9991 | self.GraphemeGroup |
||
| 9992 | ): |
||
| 9993 | return True |
||
| 9994 | else: |
||
| 9995 | return False |
||
| 9996 | def export(self, outfile, level, namespaceprefix_='', namespacedef_='xmlns:pc="http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15"', name_='GraphemesType', pretty_print=True): |
||
| 9997 | imported_ns_def_ = GenerateDSNamespaceDefs_.get('GraphemesType') |
||
| 9998 | if imported_ns_def_ is not None: |
||
| 9999 | namespacedef_ = imported_ns_def_ |
||
| 10000 | if pretty_print: |
||
| 10001 | eol_ = '\n' |
||
| 10002 | else: |
||
| 10003 | eol_ = '' |
||
| 10004 | if self.original_tagname_ is not None and name_ == 'GraphemesType': |
||
| 10005 | name_ = self.original_tagname_ |
||
| 10006 | if UseCapturedNS_ and self.ns_prefix_: |
||
| 10007 | namespaceprefix_ = self.ns_prefix_ + ':' |
||
| 10008 | showIndent(outfile, level, pretty_print) |
||
| 10009 | outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) |
||
| 10010 | already_processed = set() |
||
| 10011 | self.exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='GraphemesType') |
||
| 10012 | if self.hasContent_(): |
||
| 10013 | outfile.write('>%s' % (eol_, )) |
||
| 10014 | self.exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='GraphemesType', pretty_print=pretty_print) |
||
| 10015 | showIndent(outfile, level, pretty_print) |
||
| 10016 | outfile.write('</%s%s>%s' % (namespaceprefix_, name_, eol_)) |
||
| 10017 | else: |
||
| 10018 | outfile.write('/>%s' % (eol_, )) |
||
| 10019 | def exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='GraphemesType'): |
||
| 10020 | pass |
||
| 10021 | def exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='xmlns:pc="http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15"', name_='GraphemesType', fromsubclass_=False, pretty_print=True): |
||
| 10022 | if pretty_print: |
||
| 10023 | eol_ = '\n' |
||
| 10024 | else: |
||
| 10025 | eol_ = '' |
||
| 10026 | for Grapheme_ in self.Grapheme: |
||
| 10027 | namespaceprefix_ = self.Grapheme_nsprefix_ + ':' if (UseCapturedNS_ and self.Grapheme_nsprefix_) else '' |
||
| 10028 | Grapheme_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Grapheme', pretty_print=pretty_print) |
||
| 10029 | for NonPrintingChar_ in self.NonPrintingChar: |
||
| 10030 | namespaceprefix_ = self.NonPrintingChar_nsprefix_ + ':' if (UseCapturedNS_ and self.NonPrintingChar_nsprefix_) else '' |
||
| 10031 | NonPrintingChar_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='NonPrintingChar', pretty_print=pretty_print) |
||
| 10032 | for GraphemeGroup_ in self.GraphemeGroup: |
||
| 10033 | namespaceprefix_ = self.GraphemeGroup_nsprefix_ + ':' if (UseCapturedNS_ and self.GraphemeGroup_nsprefix_) else '' |
||
| 10034 | GraphemeGroup_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='GraphemeGroup', pretty_print=pretty_print) |
||
| 10035 | def to_etree(self, parent_element=None, name_='GraphemesType', mapping_=None, nsmap_=None): |
||
| 10036 | if parent_element is None: |
||
| 10037 | element = etree_.Element('{http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15}' + name_, nsmap=nsmap_) |
||
| 10038 | else: |
||
| 10039 | element = etree_.SubElement(parent_element, '{http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15}' + name_, nsmap=nsmap_) |
||
| 10040 | for Grapheme_ in self.Grapheme: |
||
| 10041 | Grapheme_.to_etree(element, name_='Grapheme', mapping_=mapping_, nsmap_=nsmap_) |
||
| 10042 | for NonPrintingChar_ in self.NonPrintingChar: |
||
| 10043 | NonPrintingChar_.to_etree(element, name_='NonPrintingChar', mapping_=mapping_, nsmap_=nsmap_) |
||
| 10044 | for GraphemeGroup_ in self.GraphemeGroup: |
||
| 10045 | GraphemeGroup_.to_etree(element, name_='GraphemeGroup', mapping_=mapping_, nsmap_=nsmap_) |
||
| 10046 | if mapping_ is not None: |
||
| 10047 | mapping_[id(self)] = element |
||
| 10048 | return element |
||
| 10049 | def build(self, node, gds_collector_=None): |
||
| 10050 | self.gds_collector_ = gds_collector_ |
||
| 10051 | if SaveElementTreeNode: |
||
| 10052 | self.gds_elementtree_node_ = node |
||
| 10053 | already_processed = set() |
||
| 10054 | self.ns_prefix_ = node.prefix |
||
| 10055 | self.buildAttributes(node, node.attrib, already_processed) |
||
| 10056 | for child in node: |
||
| 10057 | nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] |
||
| 10058 | self.buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) |
||
| 10059 | return self |
||
| 10060 | def buildAttributes(self, node, attrs, already_processed): |
||
| 10061 | pass |
||
| 10062 | def buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None): |
||
| 10063 | if nodeName_ == 'Grapheme': |
||
| 10064 | obj_ = GraphemeType.factory(parent_object_=self) |
||
| 10065 | obj_.build(child_, gds_collector_=gds_collector_) |
||
| 10066 | self.Grapheme.append(obj_) |
||
| 10067 | obj_.original_tagname_ = 'Grapheme' |
||
| 10068 | elif nodeName_ == 'NonPrintingChar': |
||
| 10069 | obj_ = NonPrintingCharType.factory(parent_object_=self) |
||
| 10070 | obj_.build(child_, gds_collector_=gds_collector_) |
||
| 10071 | self.NonPrintingChar.append(obj_) |
||
| 10072 | obj_.original_tagname_ = 'NonPrintingChar' |
||
| 10073 | elif nodeName_ == 'GraphemeGroup': |
||
| 10074 | obj_ = GraphemeGroupType.factory(parent_object_=self) |
||
| 10075 | obj_.build(child_, gds_collector_=gds_collector_) |
||
| 10076 | self.GraphemeGroup.append(obj_) |
||
| 10077 | obj_.original_tagname_ = 'GraphemeGroup' |
||
| 10078 | def __hash__(self): |
||
| 10079 | return hash(self.id) |
||
| 10080 | # end class GraphemesType |
||
| 10081 | |||
| 10082 | |||
| 10083 | class GraphemeBaseType(GeneratedsSuper): |
||
| 10084 | """Base type for graphemes, grapheme groups and non-printing characters. |
||
| 10085 | Order index of grapheme, group, or non-printing character |
||
| 10086 | within the parent container (graphemes or glyph or grapheme group). |
||
| 10087 | Type of character represented by the |
||
| 10088 | grapheme, group, or non-printing character element. |
||
| 10089 | For generic useFor generic use""" |
||
| 10090 | __hash__ = GeneratedsSuper.__hash__ |
||
| 10091 | member_data_items_ = [ |
||
| 10092 | MemberSpec_('id', 'string', 0, 0, {'use': 'required'}), |
||
| 10093 | MemberSpec_('index', 'int', 0, 0, {'use': 'required'}), |
||
| 10094 | MemberSpec_('ligature', 'boolean', 0, 1, {'use': 'optional'}), |
||
| 10095 | MemberSpec_('charType', 'string', 0, 1, {'use': 'optional'}), |
||
| 10096 | MemberSpec_('custom', 'string', 0, 1, {'use': 'optional'}), |
||
| 10097 | MemberSpec_('comments', 'string', 0, 1, {'use': 'optional'}), |
||
| 10098 | MemberSpec_('TextEquiv', 'TextEquivType', 1, 1, {'maxOccurs': 'unbounded', 'minOccurs': '0', 'name': 'TextEquiv', 'type': 'TextEquivType'}, None), |
||
| 10099 | ] |
||
| 10100 | subclass = None |
||
| 10101 | superclass = None |
||
| 10102 | def __init__(self, id=None, index=None, ligature=None, charType=None, custom=None, comments=None, TextEquiv=None, extensiontype_=None, gds_collector_=None, **kwargs_): |
||
| 10103 | self.gds_collector_ = gds_collector_ |
||
| 10104 | self.gds_elementtree_node_ = None |
||
| 10105 | self.original_tagname_ = None |
||
| 10106 | self.parent_object_ = kwargs_.get('parent_object_') |
||
| 10107 | self.ns_prefix_ = None |
||
| 10108 | self.id = _cast(None, id) |
||
| 10109 | self.id_nsprefix_ = "pc" |
||
| 10110 | self.index = _cast(int, index) |
||
| 10111 | self.index_nsprefix_ = "pc" |
||
| 10112 | self.ligature = _cast(bool, ligature) |
||
| 10113 | self.ligature_nsprefix_ = "pc" |
||
| 10114 | self.charType = _cast(None, charType) |
||
| 10115 | self.charType_nsprefix_ = "pc" |
||
| 10116 | self.custom = _cast(None, custom) |
||
| 10117 | self.custom_nsprefix_ = "pc" |
||
| 10118 | self.comments = _cast(None, comments) |
||
| 10119 | self.comments_nsprefix_ = "pc" |
||
| 10120 | if TextEquiv is None: |
||
| 10121 | self.TextEquiv = [] |
||
| 10122 | else: |
||
| 10123 | self.TextEquiv = TextEquiv |
||
| 10124 | self.TextEquiv_nsprefix_ = "pc" |
||
| 10125 | self.extensiontype_ = extensiontype_ |
||
| 10126 | def factory(*args_, **kwargs_): |
||
| 10127 | if CurrentSubclassModule_ is not None: |
||
| 10128 | subclass = getSubclassFromModule_( |
||
| 10129 | CurrentSubclassModule_, GraphemeBaseType) |
||
| 10130 | if subclass is not None: |
||
| 10131 | return subclass(*args_, **kwargs_) |
||
| 10132 | if GraphemeBaseType.subclass: |
||
| 10133 | return GraphemeBaseType.subclass(*args_, **kwargs_) |
||
| 10134 | else: |
||
| 10135 | return GraphemeBaseType(*args_, **kwargs_) |
||
| 10136 | factory = staticmethod(factory) |
||
| 10137 | def get_ns_prefix_(self): |
||
| 10138 | return self.ns_prefix_ |
||
| 10139 | def set_ns_prefix_(self, ns_prefix): |
||
| 10140 | self.ns_prefix_ = ns_prefix |
||
| 10141 | def get_TextEquiv(self): |
||
| 10142 | return self.TextEquiv |
||
| 10143 | def set_TextEquiv(self, TextEquiv): |
||
| 10144 | self.TextEquiv = TextEquiv |
||
| 10145 | def add_TextEquiv(self, value): |
||
| 10146 | self.TextEquiv.append(value) |
||
| 10147 | def insert_TextEquiv_at(self, index, value): |
||
| 10148 | self.TextEquiv.insert(index, value) |
||
| 10149 | def replace_TextEquiv_at(self, index, value): |
||
| 10150 | self.TextEquiv[index] = value |
||
| 10151 | def get_id(self): |
||
| 10152 | return self.id |
||
| 10153 | def set_id(self, id): |
||
| 10154 | self.id = id |
||
| 10155 | def get_index(self): |
||
| 10156 | return self.index |
||
| 10157 | def set_index(self, index): |
||
| 10158 | self.index = index |
||
| 10159 | def get_ligature(self): |
||
| 10160 | return self.ligature |
||
| 10161 | def set_ligature(self, ligature): |
||
| 10162 | self.ligature = ligature |
||
| 10163 | def get_charType(self): |
||
| 10164 | return self.charType |
||
| 10165 | def set_charType(self, charType): |
||
| 10166 | self.charType = charType |
||
| 10167 | def get_custom(self): |
||
| 10168 | return self.custom |
||
| 10169 | def set_custom(self, custom): |
||
| 10170 | self.custom = custom |
||
| 10171 | def get_comments(self): |
||
| 10172 | return self.comments |
||
| 10173 | def set_comments(self, comments): |
||
| 10174 | self.comments = comments |
||
| 10175 | def get_extensiontype_(self): return self.extensiontype_ |
||
| 10176 | def set_extensiontype_(self, extensiontype_): self.extensiontype_ = extensiontype_ |
||
| 10177 | def hasContent_(self): |
||
| 10178 | if ( |
||
| 10179 | self.TextEquiv |
||
| 10180 | ): |
||
| 10181 | return True |
||
| 10182 | else: |
||
| 10183 | return False |
||
| 10184 | def export(self, outfile, level, namespaceprefix_='', namespacedef_='xmlns:pc="http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15"', name_='GraphemeBaseType', pretty_print=True): |
||
| 10185 | imported_ns_def_ = GenerateDSNamespaceDefs_.get('GraphemeBaseType') |
||
| 10186 | if imported_ns_def_ is not None: |
||
| 10187 | namespacedef_ = imported_ns_def_ |
||
| 10188 | if pretty_print: |
||
| 10189 | eol_ = '\n' |
||
| 10190 | else: |
||
| 10191 | eol_ = '' |
||
| 10192 | if self.original_tagname_ is not None and name_ == 'GraphemeBaseType': |
||
| 10193 | name_ = self.original_tagname_ |
||
| 10194 | if UseCapturedNS_ and self.ns_prefix_: |
||
| 10195 | namespaceprefix_ = self.ns_prefix_ + ':' |
||
| 10196 | showIndent(outfile, level, pretty_print) |
||
| 10197 | outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) |
||
| 10198 | already_processed = set() |
||
| 10199 | self.exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='GraphemeBaseType') |
||
| 10200 | if self.hasContent_(): |
||
| 10201 | outfile.write('>%s' % (eol_, )) |
||
| 10202 | self.exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='GraphemeBaseType', pretty_print=pretty_print) |
||
| 10203 | showIndent(outfile, level, pretty_print) |
||
| 10204 | outfile.write('</%s%s>%s' % (namespaceprefix_, name_, eol_)) |
||
| 10205 | else: |
||
| 10206 | outfile.write('/>%s' % (eol_, )) |
||
| 10207 | def exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='GraphemeBaseType'): |
||
| 10208 | if self.id is not None and 'id' not in already_processed: |
||
| 10209 | already_processed.add('id') |
||
| 10210 | outfile.write(' id=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.id), input_name='id')), )) |
||
| 10211 | if self.index is not None and 'index' not in already_processed: |
||
| 10212 | already_processed.add('index') |
||
| 10213 | outfile.write(' index="%s"' % self.gds_format_integer(self.index, input_name='index')) |
||
| 10214 | if self.ligature is not None and 'ligature' not in already_processed: |
||
| 10215 | already_processed.add('ligature') |
||
| 10216 | outfile.write(' ligature="%s"' % self.gds_format_boolean(self.ligature, input_name='ligature')) |
||
| 10217 | if self.charType is not None and 'charType' not in already_processed: |
||
| 10218 | already_processed.add('charType') |
||
| 10219 | outfile.write(' charType=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.charType), input_name='charType')), )) |
||
| 10220 | if self.custom is not None and 'custom' not in already_processed: |
||
| 10221 | already_processed.add('custom') |
||
| 10222 | outfile.write(' custom=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.custom), input_name='custom')), )) |
||
| 10223 | if self.comments is not None and 'comments' not in already_processed: |
||
| 10224 | already_processed.add('comments') |
||
| 10225 | outfile.write(' comments=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.comments), input_name='comments')), )) |
||
| 10226 | if self.extensiontype_ is not None and 'xsi:type' not in already_processed: |
||
| 10227 | already_processed.add('xsi:type') |
||
| 10228 | outfile.write(' xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"') |
||
| 10229 | if ":" not in self.extensiontype_: |
||
| 10230 | imported_ns_type_prefix_ = GenerateDSNamespaceTypePrefixes_.get(self.extensiontype_, '') |
||
| 10231 | outfile.write(' xsi:type="%s%s"' % (imported_ns_type_prefix_, self.extensiontype_)) |
||
| 10232 | else: |
||
| 10233 | outfile.write(' xsi:type="%s"' % self.extensiontype_) |
||
| 10234 | def exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='xmlns:pc="http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15"', name_='GraphemeBaseType', fromsubclass_=False, pretty_print=True): |
||
| 10235 | if pretty_print: |
||
| 10236 | eol_ = '\n' |
||
| 10237 | else: |
||
| 10238 | eol_ = '' |
||
| 10239 | for TextEquiv_ in self.TextEquiv: |
||
| 10240 | namespaceprefix_ = self.TextEquiv_nsprefix_ + ':' if (UseCapturedNS_ and self.TextEquiv_nsprefix_) else '' |
||
| 10241 | TextEquiv_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='TextEquiv', pretty_print=pretty_print) |
||
| 10242 | def to_etree(self, parent_element=None, name_='GraphemeBaseType', mapping_=None, nsmap_=None): |
||
| 10243 | if parent_element is None: |
||
| 10244 | element = etree_.Element('{http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15}' + name_, nsmap=nsmap_) |
||
| 10245 | else: |
||
| 10246 | element = etree_.SubElement(parent_element, '{http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15}' + name_, nsmap=nsmap_) |
||
| 10247 | if self.extensiontype_ is not None: |
||
| 10248 | element.set('{http://www.w3.org/2001/XMLSchema-instance}type', self.extensiontype_) |
||
| 10249 | if self.id is not None: |
||
| 10250 | element.set('id', self.gds_format_string(self.id)) |
||
| 10251 | if self.index is not None: |
||
| 10252 | element.set('index', self.gds_format_integer(self.index)) |
||
| 10253 | if self.ligature is not None: |
||
| 10254 | element.set('ligature', self.gds_format_boolean(self.ligature)) |
||
| 10255 | if self.charType is not None: |
||
| 10256 | element.set('charType', self.gds_format_string(self.charType)) |
||
| 10257 | if self.custom is not None: |
||
| 10258 | element.set('custom', self.gds_format_string(self.custom)) |
||
| 10259 | if self.comments is not None: |
||
| 10260 | element.set('comments', self.gds_format_string(self.comments)) |
||
| 10261 | for TextEquiv_ in self.TextEquiv: |
||
| 10262 | TextEquiv_.to_etree(element, name_='TextEquiv', mapping_=mapping_, nsmap_=nsmap_) |
||
| 10263 | if mapping_ is not None: |
||
| 10264 | mapping_[id(self)] = element |
||
| 10265 | return element |
||
| 10266 | def build(self, node, gds_collector_=None): |
||
| 10267 | self.gds_collector_ = gds_collector_ |
||
| 10268 | if SaveElementTreeNode: |
||
| 10269 | self.gds_elementtree_node_ = node |
||
| 10270 | already_processed = set() |
||
| 10271 | self.ns_prefix_ = node.prefix |
||
| 10272 | self.buildAttributes(node, node.attrib, already_processed) |
||
| 10273 | for child in node: |
||
| 10274 | nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] |
||
| 10275 | self.buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) |
||
| 10276 | return self |
||
| 10277 | def buildAttributes(self, node, attrs, already_processed): |
||
| 10278 | value = find_attr_value_('id', node) |
||
| 10279 | if value is not None and 'id' not in already_processed: |
||
| 10280 | already_processed.add('id') |
||
| 10281 | self.id = value |
||
| 10282 | value = find_attr_value_('index', node) |
||
| 10283 | if value is not None and 'index' not in already_processed: |
||
| 10284 | already_processed.add('index') |
||
| 10285 | self.index = self.gds_parse_integer(value, node, 'index') |
||
| 10286 | value = find_attr_value_('ligature', node) |
||
| 10287 | if value is not None and 'ligature' not in already_processed: |
||
| 10288 | already_processed.add('ligature') |
||
| 10289 | if value in ('true', '1'): |
||
| 10290 | self.ligature = True |
||
| 10291 | elif value in ('false', '0'): |
||
| 10292 | self.ligature = False |
||
| 10293 | else: |
||
| 10294 | raise_parse_error(node, 'Bad boolean attribute') |
||
| 10295 | value = find_attr_value_('charType', node) |
||
| 10296 | if value is not None and 'charType' not in already_processed: |
||
| 10297 | already_processed.add('charType') |
||
| 10298 | self.charType = value |
||
| 10299 | value = find_attr_value_('custom', node) |
||
| 10300 | if value is not None and 'custom' not in already_processed: |
||
| 10301 | already_processed.add('custom') |
||
| 10302 | self.custom = value |
||
| 10303 | value = find_attr_value_('comments', node) |
||
| 10304 | if value is not None and 'comments' not in already_processed: |
||
| 10305 | already_processed.add('comments') |
||
| 10306 | self.comments = value |
||
| 10307 | value = find_attr_value_('xsi:type', node) |
||
| 10308 | if value is not None and 'xsi:type' not in already_processed: |
||
| 10309 | already_processed.add('xsi:type') |
||
| 10310 | self.extensiontype_ = value |
||
| 10311 | def buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None): |
||
| 10312 | if nodeName_ == 'TextEquiv': |
||
| 10313 | obj_ = TextEquivType.factory(parent_object_=self) |
||
| 10314 | obj_.build(child_, gds_collector_=gds_collector_) |
||
| 10315 | self.TextEquiv.append(obj_) |
||
| 10316 | obj_.original_tagname_ = 'TextEquiv' |
||
| 10317 | def __hash__(self): |
||
| 10318 | return hash(self.id) |
||
| 10319 | # end class GraphemeBaseType |
||
| 10320 | |||
| 10321 | |||
| 10322 | class GraphemeType(GraphemeBaseType): |
||
| 10323 | """Represents a sub-element of a glyph. |
||
| 10324 | Smallest graphical unit that can be |
||
| 10325 | assigned a Unicode code point.""" |
||
| 10326 | __hash__ = GeneratedsSuper.__hash__ |
||
| 10327 | member_data_items_ = [ |
||
| 10328 | MemberSpec_('Coords', 'CoordsType', 0, 0, {'name': 'Coords', 'type': 'CoordsType'}, None), |
||
| 10329 | ] |
||
| 10330 | subclass = None |
||
| 10331 | superclass = GraphemeBaseType |
||
| 10332 | def __init__(self, id=None, index=None, ligature=None, charType=None, custom=None, comments=None, TextEquiv=None, Coords=None, gds_collector_=None, **kwargs_): |
||
| 10333 | self.gds_collector_ = gds_collector_ |
||
| 10334 | self.gds_elementtree_node_ = None |
||
| 10335 | self.original_tagname_ = None |
||
| 10336 | self.parent_object_ = kwargs_.get('parent_object_') |
||
| 10337 | self.ns_prefix_ = None |
||
| 10338 | super(GraphemeType, self).__init__(id, index, ligature, charType, custom, comments, TextEquiv, **kwargs_) |
||
| 10339 | self.Coords = Coords |
||
| 10340 | self.Coords_nsprefix_ = "pc" |
||
| 10341 | def factory(*args_, **kwargs_): |
||
| 10342 | if CurrentSubclassModule_ is not None: |
||
| 10343 | subclass = getSubclassFromModule_( |
||
| 10344 | CurrentSubclassModule_, GraphemeType) |
||
| 10345 | if subclass is not None: |
||
| 10346 | return subclass(*args_, **kwargs_) |
||
| 10347 | if GraphemeType.subclass: |
||
| 10348 | return GraphemeType.subclass(*args_, **kwargs_) |
||
| 10349 | else: |
||
| 10350 | return GraphemeType(*args_, **kwargs_) |
||
| 10351 | factory = staticmethod(factory) |
||
| 10352 | def get_ns_prefix_(self): |
||
| 10353 | return self.ns_prefix_ |
||
| 10354 | def set_ns_prefix_(self, ns_prefix): |
||
| 10355 | self.ns_prefix_ = ns_prefix |
||
| 10356 | def get_Coords(self): |
||
| 10357 | return self.Coords |
||
| 10358 | def set_Coords(self, Coords): |
||
| 10359 | self.Coords = Coords |
||
| 10360 | def hasContent_(self): |
||
| 10361 | if ( |
||
| 10362 | self.Coords is not None or |
||
| 10363 | super(GraphemeType, self).hasContent_() |
||
| 10364 | ): |
||
| 10365 | return True |
||
| 10366 | else: |
||
| 10367 | return False |
||
| 10368 | def export(self, outfile, level, namespaceprefix_='', namespacedef_='xmlns:pc="http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15"', name_='GraphemeType', pretty_print=True): |
||
| 10369 | imported_ns_def_ = GenerateDSNamespaceDefs_.get('GraphemeType') |
||
| 10370 | if imported_ns_def_ is not None: |
||
| 10371 | namespacedef_ = imported_ns_def_ |
||
| 10372 | if pretty_print: |
||
| 10373 | eol_ = '\n' |
||
| 10374 | else: |
||
| 10375 | eol_ = '' |
||
| 10376 | if self.original_tagname_ is not None and name_ == 'GraphemeType': |
||
| 10377 | name_ = self.original_tagname_ |
||
| 10378 | if UseCapturedNS_ and self.ns_prefix_: |
||
| 10379 | namespaceprefix_ = self.ns_prefix_ + ':' |
||
| 10380 | showIndent(outfile, level, pretty_print) |
||
| 10381 | outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) |
||
| 10382 | already_processed = set() |
||
| 10383 | self.exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='GraphemeType') |
||
| 10384 | if self.hasContent_(): |
||
| 10385 | outfile.write('>%s' % (eol_, )) |
||
| 10386 | self.exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='GraphemeType', pretty_print=pretty_print) |
||
| 10387 | showIndent(outfile, level, pretty_print) |
||
| 10388 | outfile.write('</%s%s>%s' % (namespaceprefix_, name_, eol_)) |
||
| 10389 | else: |
||
| 10390 | outfile.write('/>%s' % (eol_, )) |
||
| 10391 | def exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='GraphemeType'): |
||
| 10392 | super(GraphemeType, self).exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='GraphemeType') |
||
| 10393 | def exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='xmlns:pc="http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15"', name_='GraphemeType', fromsubclass_=False, pretty_print=True): |
||
| 10394 | super(GraphemeType, self).exportChildren(outfile, level, namespaceprefix_, namespacedef_, name_, True, pretty_print=pretty_print) |
||
| 10395 | if pretty_print: |
||
| 10396 | eol_ = '\n' |
||
| 10397 | else: |
||
| 10398 | eol_ = '' |
||
| 10399 | if self.Coords is not None: |
||
| 10400 | namespaceprefix_ = self.Coords_nsprefix_ + ':' if (UseCapturedNS_ and self.Coords_nsprefix_) else '' |
||
| 10401 | self.Coords.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Coords', pretty_print=pretty_print) |
||
| 10402 | def to_etree(self, parent_element=None, name_='GraphemeType', mapping_=None, nsmap_=None): |
||
| 10403 | element = super(GraphemeType, self).to_etree(parent_element, name_, mapping_) |
||
| 10404 | if self.Coords is not None: |
||
| 10405 | Coords_ = self.Coords |
||
| 10406 | Coords_.to_etree(element, name_='Coords', mapping_=mapping_, nsmap_=nsmap_) |
||
| 10407 | if mapping_ is not None: |
||
| 10408 | mapping_[id(self)] = element |
||
| 10409 | return element |
||
| 10410 | def build(self, node, gds_collector_=None): |
||
| 10411 | self.gds_collector_ = gds_collector_ |
||
| 10412 | if SaveElementTreeNode: |
||
| 10413 | self.gds_elementtree_node_ = node |
||
| 10414 | already_processed = set() |
||
| 10415 | self.ns_prefix_ = node.prefix |
||
| 10416 | self.buildAttributes(node, node.attrib, already_processed) |
||
| 10417 | for child in node: |
||
| 10418 | nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] |
||
| 10419 | self.buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) |
||
| 10420 | return self |
||
| 10421 | def buildAttributes(self, node, attrs, already_processed): |
||
| 10422 | super(GraphemeType, self).buildAttributes(node, attrs, already_processed) |
||
| 10423 | def buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None): |
||
| 10424 | if nodeName_ == 'Coords': |
||
| 10425 | obj_ = CoordsType.factory(parent_object_=self) |
||
| 10426 | obj_.build(child_, gds_collector_=gds_collector_) |
||
| 10427 | self.Coords = obj_ |
||
| 10428 | obj_.original_tagname_ = 'Coords' |
||
| 10429 | super(GraphemeType, self).buildChildren(child_, node, nodeName_, True) |
||
| 10430 | def __hash__(self): |
||
| 10431 | return hash(self.id) |
||
| 10432 | # end class GraphemeType |
||
| 10433 | |||
| 10434 | |||
| 10435 | class NonPrintingCharType(GraphemeBaseType): |
||
| 10436 | """A glyph component without visual representation |
||
| 10437 | but with Unicode code point. |
||
| 10438 | Non-visual / non-printing / control character. |
||
| 10439 | Part of grapheme container (of glyph) or grapheme sub group.""" |
||
| 10440 | __hash__ = GeneratedsSuper.__hash__ |
||
| 10441 | member_data_items_ = [ |
||
| 10442 | ] |
||
| 10443 | subclass = None |
||
| 10444 | superclass = GraphemeBaseType |
||
| 10445 | def __init__(self, id=None, index=None, ligature=None, charType=None, custom=None, comments=None, TextEquiv=None, gds_collector_=None, **kwargs_): |
||
| 10446 | self.gds_collector_ = gds_collector_ |
||
| 10447 | self.gds_elementtree_node_ = None |
||
| 10448 | self.original_tagname_ = None |
||
| 10449 | self.parent_object_ = kwargs_.get('parent_object_') |
||
| 10450 | self.ns_prefix_ = None |
||
| 10451 | super(NonPrintingCharType, self).__init__(id, index, ligature, charType, custom, comments, TextEquiv, **kwargs_) |
||
| 10452 | def factory(*args_, **kwargs_): |
||
| 10453 | if CurrentSubclassModule_ is not None: |
||
| 10454 | subclass = getSubclassFromModule_( |
||
| 10455 | CurrentSubclassModule_, NonPrintingCharType) |
||
| 10456 | if subclass is not None: |
||
| 10457 | return subclass(*args_, **kwargs_) |
||
| 10458 | if NonPrintingCharType.subclass: |
||
| 10459 | return NonPrintingCharType.subclass(*args_, **kwargs_) |
||
| 10460 | else: |
||
| 10461 | return NonPrintingCharType(*args_, **kwargs_) |
||
| 10462 | factory = staticmethod(factory) |
||
| 10463 | def get_ns_prefix_(self): |
||
| 10464 | return self.ns_prefix_ |
||
| 10465 | def set_ns_prefix_(self, ns_prefix): |
||
| 10466 | self.ns_prefix_ = ns_prefix |
||
| 10467 | def hasContent_(self): |
||
| 10468 | if ( |
||
| 10469 | super(NonPrintingCharType, self).hasContent_() |
||
| 10470 | ): |
||
| 10471 | return True |
||
| 10472 | else: |
||
| 10473 | return False |
||
| 10474 | def export(self, outfile, level, namespaceprefix_='', namespacedef_='xmlns:pc="http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15"', name_='NonPrintingCharType', pretty_print=True): |
||
| 10475 | imported_ns_def_ = GenerateDSNamespaceDefs_.get('NonPrintingCharType') |
||
| 10476 | if imported_ns_def_ is not None: |
||
| 10477 | namespacedef_ = imported_ns_def_ |
||
| 10478 | if pretty_print: |
||
| 10479 | eol_ = '\n' |
||
| 10480 | else: |
||
| 10481 | eol_ = '' |
||
| 10482 | if self.original_tagname_ is not None and name_ == 'NonPrintingCharType': |
||
| 10483 | name_ = self.original_tagname_ |
||
| 10484 | if UseCapturedNS_ and self.ns_prefix_: |
||
| 10485 | namespaceprefix_ = self.ns_prefix_ + ':' |
||
| 10486 | showIndent(outfile, level, pretty_print) |
||
| 10487 | outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) |
||
| 10488 | already_processed = set() |
||
| 10489 | self.exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='NonPrintingCharType') |
||
| 10490 | if self.hasContent_(): |
||
| 10491 | outfile.write('>%s' % (eol_, )) |
||
| 10492 | self.exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='NonPrintingCharType', pretty_print=pretty_print) |
||
| 10493 | showIndent(outfile, level, pretty_print) |
||
| 10494 | outfile.write('</%s%s>%s' % (namespaceprefix_, name_, eol_)) |
||
| 10495 | else: |
||
| 10496 | outfile.write('/>%s' % (eol_, )) |
||
| 10497 | def exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='NonPrintingCharType'): |
||
| 10498 | super(NonPrintingCharType, self).exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='NonPrintingCharType') |
||
| 10499 | def exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='xmlns:pc="http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15"', name_='NonPrintingCharType', fromsubclass_=False, pretty_print=True): |
||
| 10500 | super(NonPrintingCharType, self).exportChildren(outfile, level, namespaceprefix_, namespacedef_, name_, True, pretty_print=pretty_print) |
||
| 10501 | def to_etree(self, parent_element=None, name_='NonPrintingCharType', mapping_=None, nsmap_=None): |
||
| 10502 | element = super(NonPrintingCharType, self).to_etree(parent_element, name_, mapping_) |
||
| 10503 | if mapping_ is not None: |
||
| 10504 | mapping_[id(self)] = element |
||
| 10505 | return element |
||
| 10506 | def build(self, node, gds_collector_=None): |
||
| 10507 | self.gds_collector_ = gds_collector_ |
||
| 10508 | if SaveElementTreeNode: |
||
| 10509 | self.gds_elementtree_node_ = node |
||
| 10510 | already_processed = set() |
||
| 10511 | self.ns_prefix_ = node.prefix |
||
| 10512 | self.buildAttributes(node, node.attrib, already_processed) |
||
| 10513 | for child in node: |
||
| 10514 | nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] |
||
| 10515 | self.buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) |
||
| 10516 | return self |
||
| 10517 | def buildAttributes(self, node, attrs, already_processed): |
||
| 10518 | super(NonPrintingCharType, self).buildAttributes(node, attrs, already_processed) |
||
| 10519 | def buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None): |
||
| 10520 | super(NonPrintingCharType, self).buildChildren(child_, node, nodeName_, True) |
||
| 10521 | pass |
||
| 10522 | def __hash__(self): |
||
| 10523 | return hash(self.id) |
||
| 10524 | # end class NonPrintingCharType |
||
| 10525 | |||
| 10526 | |||
| 10527 | class GraphemeGroupType(GraphemeBaseType): |
||
| 10528 | __hash__ = GeneratedsSuper.__hash__ |
||
| 10529 | member_data_items_ = [ |
||
| 10530 | MemberSpec_('Grapheme', 'GraphemeType', 1, 1, {'name': 'Grapheme', 'type': 'GraphemeType'}, 9), |
||
| 10531 | MemberSpec_('NonPrintingChar', 'NonPrintingCharType', 1, 1, {'name': 'NonPrintingChar', 'type': 'NonPrintingCharType'}, 9), |
||
| 10532 | ] |
||
| 10533 | subclass = None |
||
| 10534 | superclass = GraphemeBaseType |
||
| 10535 | def __init__(self, id=None, index=None, ligature=None, charType=None, custom=None, comments=None, TextEquiv=None, Grapheme=None, NonPrintingChar=None, gds_collector_=None, **kwargs_): |
||
| 10536 | self.gds_collector_ = gds_collector_ |
||
| 10537 | self.gds_elementtree_node_ = None |
||
| 10538 | self.original_tagname_ = None |
||
| 10539 | self.parent_object_ = kwargs_.get('parent_object_') |
||
| 10540 | self.ns_prefix_ = None |
||
| 10541 | super(GraphemeGroupType, self).__init__(id, index, ligature, charType, custom, comments, TextEquiv, **kwargs_) |
||
| 10542 | if Grapheme is None: |
||
| 10543 | self.Grapheme = [] |
||
| 10544 | else: |
||
| 10545 | self.Grapheme = Grapheme |
||
| 10546 | self.Grapheme_nsprefix_ = "pc" |
||
| 10547 | if NonPrintingChar is None: |
||
| 10548 | self.NonPrintingChar = [] |
||
| 10549 | else: |
||
| 10550 | self.NonPrintingChar = NonPrintingChar |
||
| 10551 | self.NonPrintingChar_nsprefix_ = "pc" |
||
| 10552 | def factory(*args_, **kwargs_): |
||
| 10553 | if CurrentSubclassModule_ is not None: |
||
| 10554 | subclass = getSubclassFromModule_( |
||
| 10555 | CurrentSubclassModule_, GraphemeGroupType) |
||
| 10556 | if subclass is not None: |
||
| 10557 | return subclass(*args_, **kwargs_) |
||
| 10558 | if GraphemeGroupType.subclass: |
||
| 10559 | return GraphemeGroupType.subclass(*args_, **kwargs_) |
||
| 10560 | else: |
||
| 10561 | return GraphemeGroupType(*args_, **kwargs_) |
||
| 10562 | factory = staticmethod(factory) |
||
| 10563 | def get_ns_prefix_(self): |
||
| 10564 | return self.ns_prefix_ |
||
| 10565 | def set_ns_prefix_(self, ns_prefix): |
||
| 10566 | self.ns_prefix_ = ns_prefix |
||
| 10567 | def get_Grapheme(self): |
||
| 10568 | return self.Grapheme |
||
| 10569 | def set_Grapheme(self, Grapheme): |
||
| 10570 | self.Grapheme = Grapheme |
||
| 10571 | def add_Grapheme(self, value): |
||
| 10572 | self.Grapheme.append(value) |
||
| 10573 | def insert_Grapheme_at(self, index, value): |
||
| 10574 | self.Grapheme.insert(index, value) |
||
| 10575 | def replace_Grapheme_at(self, index, value): |
||
| 10576 | self.Grapheme[index] = value |
||
| 10577 | def get_NonPrintingChar(self): |
||
| 10578 | return self.NonPrintingChar |
||
| 10579 | def set_NonPrintingChar(self, NonPrintingChar): |
||
| 10580 | self.NonPrintingChar = NonPrintingChar |
||
| 10581 | def add_NonPrintingChar(self, value): |
||
| 10582 | self.NonPrintingChar.append(value) |
||
| 10583 | def insert_NonPrintingChar_at(self, index, value): |
||
| 10584 | self.NonPrintingChar.insert(index, value) |
||
| 10585 | def replace_NonPrintingChar_at(self, index, value): |
||
| 10586 | self.NonPrintingChar[index] = value |
||
| 10587 | def hasContent_(self): |
||
| 10588 | if ( |
||
| 10589 | self.Grapheme or |
||
| 10590 | self.NonPrintingChar or |
||
| 10591 | super(GraphemeGroupType, self).hasContent_() |
||
| 10592 | ): |
||
| 10593 | return True |
||
| 10594 | else: |
||
| 10595 | return False |
||
| 10596 | def export(self, outfile, level, namespaceprefix_='', namespacedef_='xmlns:pc="http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15"', name_='GraphemeGroupType', pretty_print=True): |
||
| 10597 | imported_ns_def_ = GenerateDSNamespaceDefs_.get('GraphemeGroupType') |
||
| 10598 | if imported_ns_def_ is not None: |
||
| 10599 | namespacedef_ = imported_ns_def_ |
||
| 10600 | if pretty_print: |
||
| 10601 | eol_ = '\n' |
||
| 10602 | else: |
||
| 10603 | eol_ = '' |
||
| 10604 | if self.original_tagname_ is not None and name_ == 'GraphemeGroupType': |
||
| 10605 | name_ = self.original_tagname_ |
||
| 10606 | if UseCapturedNS_ and self.ns_prefix_: |
||
| 10607 | namespaceprefix_ = self.ns_prefix_ + ':' |
||
| 10608 | showIndent(outfile, level, pretty_print) |
||
| 10609 | outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) |
||
| 10610 | already_processed = set() |
||
| 10611 | self.exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='GraphemeGroupType') |
||
| 10612 | if self.hasContent_(): |
||
| 10613 | outfile.write('>%s' % (eol_, )) |
||
| 10614 | self.exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='GraphemeGroupType', pretty_print=pretty_print) |
||
| 10615 | showIndent(outfile, level, pretty_print) |
||
| 10616 | outfile.write('</%s%s>%s' % (namespaceprefix_, name_, eol_)) |
||
| 10617 | else: |
||
| 10618 | outfile.write('/>%s' % (eol_, )) |
||
| 10619 | def exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='GraphemeGroupType'): |
||
| 10620 | super(GraphemeGroupType, self).exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='GraphemeGroupType') |
||
| 10621 | def exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='xmlns:pc="http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15"', name_='GraphemeGroupType', fromsubclass_=False, pretty_print=True): |
||
| 10622 | super(GraphemeGroupType, self).exportChildren(outfile, level, namespaceprefix_, namespacedef_, name_, True, pretty_print=pretty_print) |
||
| 10623 | if pretty_print: |
||
| 10624 | eol_ = '\n' |
||
| 10625 | else: |
||
| 10626 | eol_ = '' |
||
| 10627 | for Grapheme_ in self.Grapheme: |
||
| 10628 | namespaceprefix_ = self.Grapheme_nsprefix_ + ':' if (UseCapturedNS_ and self.Grapheme_nsprefix_) else '' |
||
| 10629 | Grapheme_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Grapheme', pretty_print=pretty_print) |
||
| 10630 | for NonPrintingChar_ in self.NonPrintingChar: |
||
| 10631 | namespaceprefix_ = self.NonPrintingChar_nsprefix_ + ':' if (UseCapturedNS_ and self.NonPrintingChar_nsprefix_) else '' |
||
| 10632 | NonPrintingChar_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='NonPrintingChar', pretty_print=pretty_print) |
||
| 10633 | def to_etree(self, parent_element=None, name_='GraphemeGroupType', mapping_=None, nsmap_=None): |
||
| 10634 | element = super(GraphemeGroupType, self).to_etree(parent_element, name_, mapping_) |
||
| 10635 | for Grapheme_ in self.Grapheme: |
||
| 10636 | Grapheme_.to_etree(element, name_='Grapheme', mapping_=mapping_, nsmap_=nsmap_) |
||
| 10637 | for NonPrintingChar_ in self.NonPrintingChar: |
||
| 10638 | NonPrintingChar_.to_etree(element, name_='NonPrintingChar', mapping_=mapping_, nsmap_=nsmap_) |
||
| 10639 | if mapping_ is not None: |
||
| 10640 | mapping_[id(self)] = element |
||
| 10641 | return element |
||
| 10642 | def build(self, node, gds_collector_=None): |
||
| 10643 | self.gds_collector_ = gds_collector_ |
||
| 10644 | if SaveElementTreeNode: |
||
| 10645 | self.gds_elementtree_node_ = node |
||
| 10646 | already_processed = set() |
||
| 10647 | self.ns_prefix_ = node.prefix |
||
| 10648 | self.buildAttributes(node, node.attrib, already_processed) |
||
| 10649 | for child in node: |
||
| 10650 | nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] |
||
| 10651 | self.buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) |
||
| 10652 | return self |
||
| 10653 | def buildAttributes(self, node, attrs, already_processed): |
||
| 10654 | super(GraphemeGroupType, self).buildAttributes(node, attrs, already_processed) |
||
| 10655 | def buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None): |
||
| 10656 | if nodeName_ == 'Grapheme': |
||
| 10657 | obj_ = GraphemeType.factory(parent_object_=self) |
||
| 10658 | obj_.build(child_, gds_collector_=gds_collector_) |
||
| 10659 | self.Grapheme.append(obj_) |
||
| 10660 | obj_.original_tagname_ = 'Grapheme' |
||
| 10661 | elif nodeName_ == 'NonPrintingChar': |
||
| 10662 | obj_ = NonPrintingCharType.factory(parent_object_=self) |
||
| 10663 | obj_.build(child_, gds_collector_=gds_collector_) |
||
| 10664 | self.NonPrintingChar.append(obj_) |
||
| 10665 | obj_.original_tagname_ = 'NonPrintingChar' |
||
| 10666 | super(GraphemeGroupType, self).buildChildren(child_, node, nodeName_, True) |
||
| 10667 | def __hash__(self): |
||
| 10668 | return hash(self.id) |
||
| 10669 | # end class GraphemeGroupType |
||
| 10670 | |||
| 10671 | |||
| 10672 | View Code Duplication | class UserDefinedType(GeneratedsSuper): |
|
| 10673 | """Container for user-defined attributes""" |
||
| 10674 | __hash__ = GeneratedsSuper.__hash__ |
||
| 10675 | member_data_items_ = [ |
||
| 10676 | MemberSpec_('UserAttribute', 'UserAttributeType', 1, 0, {'maxOccurs': 'unbounded', 'minOccurs': '1', 'name': 'UserAttribute', 'type': 'UserAttributeType'}, None), |
||
| 10677 | ] |
||
| 10678 | subclass = None |
||
| 10679 | superclass = None |
||
| 10680 | def __init__(self, UserAttribute=None, gds_collector_=None, **kwargs_): |
||
| 10681 | self.gds_collector_ = gds_collector_ |
||
| 10682 | self.gds_elementtree_node_ = None |
||
| 10683 | self.original_tagname_ = None |
||
| 10684 | self.parent_object_ = kwargs_.get('parent_object_') |
||
| 10685 | self.ns_prefix_ = None |
||
| 10686 | if UserAttribute is None: |
||
| 10687 | self.UserAttribute = [] |
||
| 10688 | else: |
||
| 10689 | self.UserAttribute = UserAttribute |
||
| 10690 | self.UserAttribute_nsprefix_ = "pc" |
||
| 10691 | def factory(*args_, **kwargs_): |
||
| 10692 | if CurrentSubclassModule_ is not None: |
||
| 10693 | subclass = getSubclassFromModule_( |
||
| 10694 | CurrentSubclassModule_, UserDefinedType) |
||
| 10695 | if subclass is not None: |
||
| 10696 | return subclass(*args_, **kwargs_) |
||
| 10697 | if UserDefinedType.subclass: |
||
| 10698 | return UserDefinedType.subclass(*args_, **kwargs_) |
||
| 10699 | else: |
||
| 10700 | return UserDefinedType(*args_, **kwargs_) |
||
| 10701 | factory = staticmethod(factory) |
||
| 10702 | def get_ns_prefix_(self): |
||
| 10703 | return self.ns_prefix_ |
||
| 10704 | def set_ns_prefix_(self, ns_prefix): |
||
| 10705 | self.ns_prefix_ = ns_prefix |
||
| 10706 | def get_UserAttribute(self): |
||
| 10707 | return self.UserAttribute |
||
| 10708 | def set_UserAttribute(self, UserAttribute): |
||
| 10709 | self.UserAttribute = UserAttribute |
||
| 10710 | def add_UserAttribute(self, value): |
||
| 10711 | self.UserAttribute.append(value) |
||
| 10712 | def insert_UserAttribute_at(self, index, value): |
||
| 10713 | self.UserAttribute.insert(index, value) |
||
| 10714 | def replace_UserAttribute_at(self, index, value): |
||
| 10715 | self.UserAttribute[index] = value |
||
| 10716 | def hasContent_(self): |
||
| 10717 | if ( |
||
| 10718 | self.UserAttribute |
||
| 10719 | ): |
||
| 10720 | return True |
||
| 10721 | else: |
||
| 10722 | return False |
||
| 10723 | def export(self, outfile, level, namespaceprefix_='', namespacedef_='xmlns:pc="http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15"', name_='UserDefinedType', pretty_print=True): |
||
| 10724 | imported_ns_def_ = GenerateDSNamespaceDefs_.get('UserDefinedType') |
||
| 10725 | if imported_ns_def_ is not None: |
||
| 10726 | namespacedef_ = imported_ns_def_ |
||
| 10727 | if pretty_print: |
||
| 10728 | eol_ = '\n' |
||
| 10729 | else: |
||
| 10730 | eol_ = '' |
||
| 10731 | if self.original_tagname_ is not None and name_ == 'UserDefinedType': |
||
| 10732 | name_ = self.original_tagname_ |
||
| 10733 | if UseCapturedNS_ and self.ns_prefix_: |
||
| 10734 | namespaceprefix_ = self.ns_prefix_ + ':' |
||
| 10735 | showIndent(outfile, level, pretty_print) |
||
| 10736 | outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) |
||
| 10737 | already_processed = set() |
||
| 10738 | self.exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='UserDefinedType') |
||
| 10739 | if self.hasContent_(): |
||
| 10740 | outfile.write('>%s' % (eol_, )) |
||
| 10741 | self.exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='UserDefinedType', pretty_print=pretty_print) |
||
| 10742 | showIndent(outfile, level, pretty_print) |
||
| 10743 | outfile.write('</%s%s>%s' % (namespaceprefix_, name_, eol_)) |
||
| 10744 | else: |
||
| 10745 | outfile.write('/>%s' % (eol_, )) |
||
| 10746 | def exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='UserDefinedType'): |
||
| 10747 | pass |
||
| 10748 | 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): |
||
| 10749 | if pretty_print: |
||
| 10750 | eol_ = '\n' |
||
| 10751 | else: |
||
| 10752 | eol_ = '' |
||
| 10753 | for UserAttribute_ in self.UserAttribute: |
||
| 10754 | namespaceprefix_ = self.UserAttribute_nsprefix_ + ':' if (UseCapturedNS_ and self.UserAttribute_nsprefix_) else '' |
||
| 10755 | UserAttribute_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='UserAttribute', pretty_print=pretty_print) |
||
| 10756 | def to_etree(self, parent_element=None, name_='UserDefinedType', mapping_=None, nsmap_=None): |
||
| 10757 | if parent_element is None: |
||
| 10758 | element = etree_.Element('{http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15}' + name_, nsmap=nsmap_) |
||
| 10759 | else: |
||
| 10760 | element = etree_.SubElement(parent_element, '{http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15}' + name_, nsmap=nsmap_) |
||
| 10761 | for UserAttribute_ in self.UserAttribute: |
||
| 10762 | UserAttribute_.to_etree(element, name_='UserAttribute', mapping_=mapping_, nsmap_=nsmap_) |
||
| 10763 | if mapping_ is not None: |
||
| 10764 | mapping_[id(self)] = element |
||
| 10765 | return element |
||
| 10766 | def build(self, node, gds_collector_=None): |
||
| 10767 | self.gds_collector_ = gds_collector_ |
||
| 10768 | if SaveElementTreeNode: |
||
| 10769 | self.gds_elementtree_node_ = node |
||
| 10770 | already_processed = set() |
||
| 10771 | self.ns_prefix_ = node.prefix |
||
| 10772 | self.buildAttributes(node, node.attrib, already_processed) |
||
| 10773 | for child in node: |
||
| 10774 | nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] |
||
| 10775 | self.buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) |
||
| 10776 | return self |
||
| 10777 | def buildAttributes(self, node, attrs, already_processed): |
||
| 10778 | pass |
||
| 10779 | def buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None): |
||
| 10780 | if nodeName_ == 'UserAttribute': |
||
| 10781 | obj_ = UserAttributeType.factory(parent_object_=self) |
||
| 10782 | obj_.build(child_, gds_collector_=gds_collector_) |
||
| 10783 | self.UserAttribute.append(obj_) |
||
| 10784 | obj_.original_tagname_ = 'UserAttribute' |
||
| 10785 | def __hash__(self): |
||
| 10786 | return hash(self.id) |
||
| 10787 | # end class UserDefinedType |
||
| 10788 | |||
| 10789 | |||
| 10790 | class UserAttributeType(GeneratedsSuper): |
||
| 10791 | """Structured custom data defined by name, type and value.""" |
||
| 10792 | __hash__ = GeneratedsSuper.__hash__ |
||
| 10793 | member_data_items_ = [ |
||
| 10794 | MemberSpec_('name', 'string', 0, 1, {'use': 'optional'}), |
||
| 10795 | MemberSpec_('description', 'string', 0, 1, {'use': 'optional'}), |
||
| 10796 | MemberSpec_('type_', 'string', 0, 1, {'use': 'optional'}), |
||
| 10797 | MemberSpec_('value', 'string', 0, 1, {'use': 'optional'}), |
||
| 10798 | ] |
||
| 10799 | subclass = None |
||
| 10800 | superclass = None |
||
| 10801 | def __init__(self, name=None, description=None, type_=None, value=None, gds_collector_=None, **kwargs_): |
||
| 10802 | self.gds_collector_ = gds_collector_ |
||
| 10803 | self.gds_elementtree_node_ = None |
||
| 10804 | self.original_tagname_ = None |
||
| 10805 | self.parent_object_ = kwargs_.get('parent_object_') |
||
| 10806 | self.ns_prefix_ = None |
||
| 10807 | self.name = _cast(None, name) |
||
| 10808 | self.name_nsprefix_ = "pc" |
||
| 10809 | self.description = _cast(None, description) |
||
| 10810 | self.description_nsprefix_ = "pc" |
||
| 10811 | self.type_ = _cast(None, type_) |
||
| 10812 | self.type__nsprefix_ = "pc" |
||
| 10813 | self.value = _cast(None, value) |
||
| 10814 | self.value_nsprefix_ = "pc" |
||
| 10815 | def factory(*args_, **kwargs_): |
||
| 10816 | if CurrentSubclassModule_ is not None: |
||
| 10817 | subclass = getSubclassFromModule_( |
||
| 10818 | CurrentSubclassModule_, UserAttributeType) |
||
| 10819 | if subclass is not None: |
||
| 10820 | return subclass(*args_, **kwargs_) |
||
| 10821 | if UserAttributeType.subclass: |
||
| 10822 | return UserAttributeType.subclass(*args_, **kwargs_) |
||
| 10823 | else: |
||
| 10824 | return UserAttributeType(*args_, **kwargs_) |
||
| 10825 | factory = staticmethod(factory) |
||
| 10826 | def get_ns_prefix_(self): |
||
| 10827 | return self.ns_prefix_ |
||
| 10828 | def set_ns_prefix_(self, ns_prefix): |
||
| 10829 | self.ns_prefix_ = ns_prefix |
||
| 10830 | def get_name(self): |
||
| 10831 | return self.name |
||
| 10832 | def set_name(self, name): |
||
| 10833 | self.name = name |
||
| 10834 | def get_description(self): |
||
| 10835 | return self.description |
||
| 10836 | def set_description(self, description): |
||
| 10837 | self.description = description |
||
| 10838 | def get_type(self): |
||
| 10839 | return self.type_ |
||
| 10840 | def set_type(self, type_): |
||
| 10841 | self.type_ = type_ |
||
| 10842 | def get_value(self): |
||
| 10843 | return self.value |
||
| 10844 | def set_value(self, value): |
||
| 10845 | self.value = value |
||
| 10846 | def hasContent_(self): |
||
| 10847 | if ( |
||
| 10848 | |||
| 10849 | ): |
||
| 10850 | return True |
||
| 10851 | else: |
||
| 10852 | return False |
||
| 10853 | def export(self, outfile, level, namespaceprefix_='', namespacedef_='xmlns:pc="http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15"', name_='UserAttributeType', pretty_print=True): |
||
| 10854 | imported_ns_def_ = GenerateDSNamespaceDefs_.get('UserAttributeType') |
||
| 10855 | if imported_ns_def_ is not None: |
||
| 10856 | namespacedef_ = imported_ns_def_ |
||
| 10857 | if pretty_print: |
||
| 10858 | eol_ = '\n' |
||
| 10859 | else: |
||
| 10860 | eol_ = '' |
||
| 10861 | if self.original_tagname_ is not None and name_ == 'UserAttributeType': |
||
| 10862 | name_ = self.original_tagname_ |
||
| 10863 | if UseCapturedNS_ and self.ns_prefix_: |
||
| 10864 | namespaceprefix_ = self.ns_prefix_ + ':' |
||
| 10865 | showIndent(outfile, level, pretty_print) |
||
| 10866 | outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) |
||
| 10867 | already_processed = set() |
||
| 10868 | self.exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='UserAttributeType') |
||
| 10869 | if self.hasContent_(): |
||
| 10870 | outfile.write('>%s' % (eol_, )) |
||
| 10871 | self.exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='UserAttributeType', pretty_print=pretty_print) |
||
| 10872 | outfile.write('</%s%s>%s' % (namespaceprefix_, name_, eol_)) |
||
| 10873 | else: |
||
| 10874 | outfile.write('/>%s' % (eol_, )) |
||
| 10875 | View Code Duplication | def exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='UserAttributeType'): |
|
| 10876 | if self.name is not None and 'name' not in already_processed: |
||
| 10877 | already_processed.add('name') |
||
| 10878 | outfile.write(' name=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.name), input_name='name')), )) |
||
| 10879 | if self.description is not None and 'description' not in already_processed: |
||
| 10880 | already_processed.add('description') |
||
| 10881 | outfile.write(' description=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.description), input_name='description')), )) |
||
| 10882 | if self.type_ is not None and 'type_' not in already_processed: |
||
| 10883 | already_processed.add('type_') |
||
| 10884 | outfile.write(' type=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.type_), input_name='type')), )) |
||
| 10885 | if self.value is not None and 'value' not in already_processed: |
||
| 10886 | already_processed.add('value') |
||
| 10887 | outfile.write(' value=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.value), input_name='value')), )) |
||
| 10888 | def exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='xmlns:pc="http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15"', name_='UserAttributeType', fromsubclass_=False, pretty_print=True): |
||
| 10889 | pass |
||
| 10890 | def to_etree(self, parent_element=None, name_='UserAttributeType', mapping_=None, nsmap_=None): |
||
| 10891 | if parent_element is None: |
||
| 10892 | element = etree_.Element('{http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15}' + name_, nsmap=nsmap_) |
||
| 10893 | else: |
||
| 10894 | element = etree_.SubElement(parent_element, '{http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15}' + name_, nsmap=nsmap_) |
||
| 10895 | if self.name is not None: |
||
| 10896 | element.set('name', self.gds_format_string(self.name)) |
||
| 10897 | if self.description is not None: |
||
| 10898 | element.set('description', self.gds_format_string(self.description)) |
||
| 10899 | if self.type_ is not None: |
||
| 10900 | element.set('type', self.gds_format_string(self.type_)) |
||
| 10901 | if self.value is not None: |
||
| 10902 | element.set('value', self.gds_format_string(self.value)) |
||
| 10903 | if mapping_ is not None: |
||
| 10904 | mapping_[id(self)] = element |
||
| 10905 | return element |
||
| 10906 | def build(self, node, gds_collector_=None): |
||
| 10907 | self.gds_collector_ = gds_collector_ |
||
| 10908 | if SaveElementTreeNode: |
||
| 10909 | self.gds_elementtree_node_ = node |
||
| 10910 | already_processed = set() |
||
| 10911 | self.ns_prefix_ = node.prefix |
||
| 10912 | self.buildAttributes(node, node.attrib, already_processed) |
||
| 10913 | for child in node: |
||
| 10914 | nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] |
||
| 10915 | self.buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) |
||
| 10916 | return self |
||
| 10917 | View Code Duplication | def buildAttributes(self, node, attrs, already_processed): |
|
| 10918 | value = find_attr_value_('name', node) |
||
| 10919 | if value is not None and 'name' not in already_processed: |
||
| 10920 | already_processed.add('name') |
||
| 10921 | self.name = value |
||
| 10922 | value = find_attr_value_('description', node) |
||
| 10923 | if value is not None and 'description' not in already_processed: |
||
| 10924 | already_processed.add('description') |
||
| 10925 | self.description = value |
||
| 10926 | value = find_attr_value_('type', node) |
||
| 10927 | if value is not None and 'type' not in already_processed: |
||
| 10928 | already_processed.add('type') |
||
| 10929 | self.type_ = value |
||
| 10930 | value = find_attr_value_('value', node) |
||
| 10931 | if value is not None and 'value' not in already_processed: |
||
| 10932 | already_processed.add('value') |
||
| 10933 | self.value = value |
||
| 10934 | def buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None): |
||
| 10935 | pass |
||
| 10936 | def __hash__(self): |
||
| 10937 | return hash(self.id) |
||
| 10938 | # end class UserAttributeType |
||
| 10939 | |||
| 10940 | |||
| 10941 | class TableCellRoleType(GeneratedsSuper): |
||
| 10942 | """Cell position in table starting with row 0Cell position in table |
||
| 10943 | starting with column 0Number of rows the cell spans (optional; default |
||
| 10944 | is 1)Number of columns the cell spans (optional; default is 1) |
||
| 10945 | Is the cell a column or row header?""" |
||
| 10946 | __hash__ = GeneratedsSuper.__hash__ |
||
| 10947 | member_data_items_ = [ |
||
| 10948 | MemberSpec_('rowIndex', 'int', 0, 0, {'use': 'required'}), |
||
| 10949 | MemberSpec_('columnIndex', 'int', 0, 0, {'use': 'required'}), |
||
| 10950 | MemberSpec_('rowSpan', 'int', 0, 1, {'use': 'optional'}), |
||
| 10951 | MemberSpec_('colSpan', 'int', 0, 1, {'use': 'optional'}), |
||
| 10952 | MemberSpec_('header', 'boolean', 0, 1, {'use': 'optional'}), |
||
| 10953 | ] |
||
| 10954 | subclass = None |
||
| 10955 | superclass = None |
||
| 10956 | def __init__(self, rowIndex=None, columnIndex=None, rowSpan=None, colSpan=None, header=None, gds_collector_=None, **kwargs_): |
||
| 10957 | self.gds_collector_ = gds_collector_ |
||
| 10958 | self.gds_elementtree_node_ = None |
||
| 10959 | self.original_tagname_ = None |
||
| 10960 | self.parent_object_ = kwargs_.get('parent_object_') |
||
| 10961 | self.ns_prefix_ = None |
||
| 10962 | self.rowIndex = _cast(int, rowIndex) |
||
| 10963 | self.rowIndex_nsprefix_ = "pc" |
||
| 10964 | self.columnIndex = _cast(int, columnIndex) |
||
| 10965 | self.columnIndex_nsprefix_ = "pc" |
||
| 10966 | self.rowSpan = _cast(int, rowSpan) |
||
| 10967 | self.rowSpan_nsprefix_ = "pc" |
||
| 10968 | self.colSpan = _cast(int, colSpan) |
||
| 10969 | self.colSpan_nsprefix_ = "pc" |
||
| 10970 | self.header = _cast(bool, header) |
||
| 10971 | self.header_nsprefix_ = "pc" |
||
| 10972 | def factory(*args_, **kwargs_): |
||
| 10973 | if CurrentSubclassModule_ is not None: |
||
| 10974 | subclass = getSubclassFromModule_( |
||
| 10975 | CurrentSubclassModule_, TableCellRoleType) |
||
| 10976 | if subclass is not None: |
||
| 10977 | return subclass(*args_, **kwargs_) |
||
| 10978 | if TableCellRoleType.subclass: |
||
| 10979 | return TableCellRoleType.subclass(*args_, **kwargs_) |
||
| 10980 | else: |
||
| 10981 | return TableCellRoleType(*args_, **kwargs_) |
||
| 10982 | factory = staticmethod(factory) |
||
| 10983 | def get_ns_prefix_(self): |
||
| 10984 | return self.ns_prefix_ |
||
| 10985 | def set_ns_prefix_(self, ns_prefix): |
||
| 10986 | self.ns_prefix_ = ns_prefix |
||
| 10987 | def get_rowIndex(self): |
||
| 10988 | return self.rowIndex |
||
| 10989 | def set_rowIndex(self, rowIndex): |
||
| 10990 | self.rowIndex = rowIndex |
||
| 10991 | def get_columnIndex(self): |
||
| 10992 | return self.columnIndex |
||
| 10993 | def set_columnIndex(self, columnIndex): |
||
| 10994 | self.columnIndex = columnIndex |
||
| 10995 | def get_rowSpan(self): |
||
| 10996 | return self.rowSpan |
||
| 10997 | def set_rowSpan(self, rowSpan): |
||
| 10998 | self.rowSpan = rowSpan |
||
| 10999 | def get_colSpan(self): |
||
| 11000 | return self.colSpan |
||
| 11001 | def set_colSpan(self, colSpan): |
||
| 11002 | self.colSpan = colSpan |
||
| 11003 | def get_header(self): |
||
| 11004 | return self.header |
||
| 11005 | def set_header(self, header): |
||
| 11006 | self.header = header |
||
| 11007 | def hasContent_(self): |
||
| 11008 | if ( |
||
| 11009 | |||
| 11010 | ): |
||
| 11011 | return True |
||
| 11012 | else: |
||
| 11013 | return False |
||
| 11014 | def export(self, outfile, level, namespaceprefix_='', namespacedef_='xmlns:pc="http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15"', name_='TableCellRoleType', pretty_print=True): |
||
| 11015 | imported_ns_def_ = GenerateDSNamespaceDefs_.get('TableCellRoleType') |
||
| 11016 | if imported_ns_def_ is not None: |
||
| 11017 | namespacedef_ = imported_ns_def_ |
||
| 11018 | if pretty_print: |
||
| 11019 | eol_ = '\n' |
||
| 11020 | else: |
||
| 11021 | eol_ = '' |
||
| 11022 | if self.original_tagname_ is not None and name_ == 'TableCellRoleType': |
||
| 11023 | name_ = self.original_tagname_ |
||
| 11024 | if UseCapturedNS_ and self.ns_prefix_: |
||
| 11025 | namespaceprefix_ = self.ns_prefix_ + ':' |
||
| 11026 | showIndent(outfile, level, pretty_print) |
||
| 11027 | outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) |
||
| 11028 | already_processed = set() |
||
| 11029 | self.exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='TableCellRoleType') |
||
| 11030 | if self.hasContent_(): |
||
| 11031 | outfile.write('>%s' % (eol_, )) |
||
| 11032 | self.exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='TableCellRoleType', pretty_print=pretty_print) |
||
| 11033 | outfile.write('</%s%s>%s' % (namespaceprefix_, name_, eol_)) |
||
| 11034 | else: |
||
| 11035 | outfile.write('/>%s' % (eol_, )) |
||
| 11036 | def exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='TableCellRoleType'): |
||
| 11037 | if self.rowIndex is not None and 'rowIndex' not in already_processed: |
||
| 11038 | already_processed.add('rowIndex') |
||
| 11039 | outfile.write(' rowIndex="%s"' % self.gds_format_integer(self.rowIndex, input_name='rowIndex')) |
||
| 11040 | if self.columnIndex is not None and 'columnIndex' not in already_processed: |
||
| 11041 | already_processed.add('columnIndex') |
||
| 11042 | outfile.write(' columnIndex="%s"' % self.gds_format_integer(self.columnIndex, input_name='columnIndex')) |
||
| 11043 | if self.rowSpan is not None and 'rowSpan' not in already_processed: |
||
| 11044 | already_processed.add('rowSpan') |
||
| 11045 | outfile.write(' rowSpan="%s"' % self.gds_format_integer(self.rowSpan, input_name='rowSpan')) |
||
| 11046 | if self.colSpan is not None and 'colSpan' not in already_processed: |
||
| 11047 | already_processed.add('colSpan') |
||
| 11048 | outfile.write(' colSpan="%s"' % self.gds_format_integer(self.colSpan, input_name='colSpan')) |
||
| 11049 | if self.header is not None and 'header' not in already_processed: |
||
| 11050 | already_processed.add('header') |
||
| 11051 | outfile.write(' header="%s"' % self.gds_format_boolean(self.header, input_name='header')) |
||
| 11052 | def exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='xmlns:pc="http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15"', name_='TableCellRoleType', fromsubclass_=False, pretty_print=True): |
||
| 11053 | pass |
||
| 11054 | def to_etree(self, parent_element=None, name_='TableCellRoleType', mapping_=None, nsmap_=None): |
||
| 11055 | if parent_element is None: |
||
| 11056 | element = etree_.Element('{http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15}' + name_, nsmap=nsmap_) |
||
| 11057 | else: |
||
| 11058 | element = etree_.SubElement(parent_element, '{http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15}' + name_, nsmap=nsmap_) |
||
| 11059 | if self.rowIndex is not None: |
||
| 11060 | element.set('rowIndex', self.gds_format_integer(self.rowIndex)) |
||
| 11061 | if self.columnIndex is not None: |
||
| 11062 | element.set('columnIndex', self.gds_format_integer(self.columnIndex)) |
||
| 11063 | if self.rowSpan is not None: |
||
| 11064 | element.set('rowSpan', self.gds_format_integer(self.rowSpan)) |
||
| 11065 | if self.colSpan is not None: |
||
| 11066 | element.set('colSpan', self.gds_format_integer(self.colSpan)) |
||
| 11067 | if self.header is not None: |
||
| 11068 | element.set('header', self.gds_format_boolean(self.header)) |
||
| 11069 | if mapping_ is not None: |
||
| 11070 | mapping_[id(self)] = element |
||
| 11071 | return element |
||
| 11072 | def build(self, node, gds_collector_=None): |
||
| 11073 | self.gds_collector_ = gds_collector_ |
||
| 11074 | if SaveElementTreeNode: |
||
| 11075 | self.gds_elementtree_node_ = node |
||
| 11076 | already_processed = set() |
||
| 11077 | self.ns_prefix_ = node.prefix |
||
| 11078 | self.buildAttributes(node, node.attrib, already_processed) |
||
| 11079 | for child in node: |
||
| 11080 | nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] |
||
| 11081 | self.buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) |
||
| 11082 | return self |
||
| 11083 | def buildAttributes(self, node, attrs, already_processed): |
||
| 11084 | value = find_attr_value_('rowIndex', node) |
||
| 11085 | if value is not None and 'rowIndex' not in already_processed: |
||
| 11086 | already_processed.add('rowIndex') |
||
| 11087 | self.rowIndex = self.gds_parse_integer(value, node, 'rowIndex') |
||
| 11088 | value = find_attr_value_('columnIndex', node) |
||
| 11089 | if value is not None and 'columnIndex' not in already_processed: |
||
| 11090 | already_processed.add('columnIndex') |
||
| 11091 | self.columnIndex = self.gds_parse_integer(value, node, 'columnIndex') |
||
| 11092 | value = find_attr_value_('rowSpan', node) |
||
| 11093 | if value is not None and 'rowSpan' not in already_processed: |
||
| 11094 | already_processed.add('rowSpan') |
||
| 11095 | self.rowSpan = self.gds_parse_integer(value, node, 'rowSpan') |
||
| 11096 | value = find_attr_value_('colSpan', node) |
||
| 11097 | if value is not None and 'colSpan' not in already_processed: |
||
| 11098 | already_processed.add('colSpan') |
||
| 11099 | self.colSpan = self.gds_parse_integer(value, node, 'colSpan') |
||
| 11100 | value = find_attr_value_('header', node) |
||
| 11101 | if value is not None and 'header' not in already_processed: |
||
| 11102 | already_processed.add('header') |
||
| 11103 | if value in ('true', '1'): |
||
| 11104 | self.header = True |
||
| 11105 | elif value in ('false', '0'): |
||
| 11106 | self.header = False |
||
| 11107 | else: |
||
| 11108 | raise_parse_error(node, 'Bad boolean attribute') |
||
| 11109 | def buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None): |
||
| 11110 | pass |
||
| 11111 | def __hash__(self): |
||
| 11112 | return hash(self.id) |
||
| 11113 | # end class TableCellRoleType |
||
| 11114 | |||
| 11115 | |||
| 11116 | View Code Duplication | class RolesType(GeneratedsSuper): |
|
| 11117 | __hash__ = GeneratedsSuper.__hash__ |
||
| 11118 | member_data_items_ = [ |
||
| 11119 | MemberSpec_('TableCellRole', 'TableCellRoleType', 0, 1, {'maxOccurs': '1', 'minOccurs': '0', 'name': 'TableCellRole', 'type': 'TableCellRoleType'}, None), |
||
| 11120 | ] |
||
| 11121 | subclass = None |
||
| 11122 | superclass = None |
||
| 11123 | def __init__(self, TableCellRole=None, gds_collector_=None, **kwargs_): |
||
| 11124 | self.gds_collector_ = gds_collector_ |
||
| 11125 | self.gds_elementtree_node_ = None |
||
| 11126 | self.original_tagname_ = None |
||
| 11127 | self.parent_object_ = kwargs_.get('parent_object_') |
||
| 11128 | self.ns_prefix_ = None |
||
| 11129 | self.TableCellRole = TableCellRole |
||
| 11130 | self.TableCellRole_nsprefix_ = "pc" |
||
| 11131 | def factory(*args_, **kwargs_): |
||
| 11132 | if CurrentSubclassModule_ is not None: |
||
| 11133 | subclass = getSubclassFromModule_( |
||
| 11134 | CurrentSubclassModule_, RolesType) |
||
| 11135 | if subclass is not None: |
||
| 11136 | return subclass(*args_, **kwargs_) |
||
| 11137 | if RolesType.subclass: |
||
| 11138 | return RolesType.subclass(*args_, **kwargs_) |
||
| 11139 | else: |
||
| 11140 | return RolesType(*args_, **kwargs_) |
||
| 11141 | factory = staticmethod(factory) |
||
| 11142 | def get_ns_prefix_(self): |
||
| 11143 | return self.ns_prefix_ |
||
| 11144 | def set_ns_prefix_(self, ns_prefix): |
||
| 11145 | self.ns_prefix_ = ns_prefix |
||
| 11146 | def get_TableCellRole(self): |
||
| 11147 | return self.TableCellRole |
||
| 11148 | def set_TableCellRole(self, TableCellRole): |
||
| 11149 | self.TableCellRole = TableCellRole |
||
| 11150 | def hasContent_(self): |
||
| 11151 | if ( |
||
| 11152 | self.TableCellRole is not None |
||
| 11153 | ): |
||
| 11154 | return True |
||
| 11155 | else: |
||
| 11156 | return False |
||
| 11157 | def export(self, outfile, level, namespaceprefix_='', namespacedef_='xmlns:pc="http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15"', name_='RolesType', pretty_print=True): |
||
| 11158 | imported_ns_def_ = GenerateDSNamespaceDefs_.get('RolesType') |
||
| 11159 | if imported_ns_def_ is not None: |
||
| 11160 | namespacedef_ = imported_ns_def_ |
||
| 11161 | if pretty_print: |
||
| 11162 | eol_ = '\n' |
||
| 11163 | else: |
||
| 11164 | eol_ = '' |
||
| 11165 | if self.original_tagname_ is not None and name_ == 'RolesType': |
||
| 11166 | name_ = self.original_tagname_ |
||
| 11167 | if UseCapturedNS_ and self.ns_prefix_: |
||
| 11168 | namespaceprefix_ = self.ns_prefix_ + ':' |
||
| 11169 | showIndent(outfile, level, pretty_print) |
||
| 11170 | outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) |
||
| 11171 | already_processed = set() |
||
| 11172 | self.exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='RolesType') |
||
| 11173 | if self.hasContent_(): |
||
| 11174 | outfile.write('>%s' % (eol_, )) |
||
| 11175 | self.exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='RolesType', pretty_print=pretty_print) |
||
| 11176 | showIndent(outfile, level, pretty_print) |
||
| 11177 | outfile.write('</%s%s>%s' % (namespaceprefix_, name_, eol_)) |
||
| 11178 | else: |
||
| 11179 | outfile.write('/>%s' % (eol_, )) |
||
| 11180 | def exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='RolesType'): |
||
| 11181 | pass |
||
| 11182 | def exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='xmlns:pc="http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15"', name_='RolesType', fromsubclass_=False, pretty_print=True): |
||
| 11183 | if pretty_print: |
||
| 11184 | eol_ = '\n' |
||
| 11185 | else: |
||
| 11186 | eol_ = '' |
||
| 11187 | if self.TableCellRole is not None: |
||
| 11188 | namespaceprefix_ = self.TableCellRole_nsprefix_ + ':' if (UseCapturedNS_ and self.TableCellRole_nsprefix_) else '' |
||
| 11189 | self.TableCellRole.export(outfile, level, namespaceprefix_, namespacedef_='', name_='TableCellRole', pretty_print=pretty_print) |
||
| 11190 | def to_etree(self, parent_element=None, name_='RolesType', mapping_=None, nsmap_=None): |
||
| 11191 | if parent_element is None: |
||
| 11192 | element = etree_.Element('{http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15}' + name_, nsmap=nsmap_) |
||
| 11193 | else: |
||
| 11194 | element = etree_.SubElement(parent_element, '{http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15}' + name_, nsmap=nsmap_) |
||
| 11195 | if self.TableCellRole is not None: |
||
| 11196 | TableCellRole_ = self.TableCellRole |
||
| 11197 | TableCellRole_.to_etree(element, name_='TableCellRole', mapping_=mapping_, nsmap_=nsmap_) |
||
| 11198 | if mapping_ is not None: |
||
| 11199 | mapping_[id(self)] = element |
||
| 11200 | return element |
||
| 11201 | def build(self, node, gds_collector_=None): |
||
| 11202 | self.gds_collector_ = gds_collector_ |
||
| 11203 | if SaveElementTreeNode: |
||
| 11204 | self.gds_elementtree_node_ = node |
||
| 11205 | already_processed = set() |
||
| 11206 | self.ns_prefix_ = node.prefix |
||
| 11207 | self.buildAttributes(node, node.attrib, already_processed) |
||
| 11208 | for child in node: |
||
| 11209 | nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] |
||
| 11210 | self.buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) |
||
| 11211 | return self |
||
| 11212 | def buildAttributes(self, node, attrs, already_processed): |
||
| 11213 | pass |
||
| 11214 | def buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None): |
||
| 11215 | if nodeName_ == 'TableCellRole': |
||
| 11216 | obj_ = TableCellRoleType.factory(parent_object_=self) |
||
| 11217 | obj_.build(child_, gds_collector_=gds_collector_) |
||
| 11218 | self.TableCellRole = obj_ |
||
| 11219 | obj_.original_tagname_ = 'TableCellRole' |
||
| 11220 | def __hash__(self): |
||
| 11221 | return hash(self.id) |
||
| 11222 | # end class RolesType |
||
| 11223 | |||
| 11224 | |||
| 11225 | class CustomRegionType(RegionType): |
||
| 11226 | """Regions containing content that is not covered |
||
| 11227 | by the default types (text, graphic, image, |
||
| 11228 | line drawing, chart, table, separator, maths, |
||
| 11229 | map, music, chem, advert, noise, unknown). |
||
| 11230 | Information on the type of content represented by this region""" |
||
| 11231 | __hash__ = GeneratedsSuper.__hash__ |
||
| 11232 | member_data_items_ = [ |
||
| 11233 | MemberSpec_('type_', 'string', 0, 1, {'use': 'optional'}), |
||
| 11234 | ] |
||
| 11235 | subclass = None |
||
| 11236 | superclass = RegionType |
||
| 11237 | def __init__(self, id=None, custom=None, comments=None, continuation=None, AlternativeImage=None, Coords=None, UserDefined=None, Labels=None, Roles=None, TextRegion=None, ImageRegion=None, LineDrawingRegion=None, GraphicRegion=None, TableRegion=None, ChartRegion=None, SeparatorRegion=None, MathsRegion=None, ChemRegion=None, MusicRegion=None, AdvertRegion=None, NoiseRegion=None, UnknownRegion=None, CustomRegion=None, type_=None, gds_collector_=None, **kwargs_): |
||
| 11238 | self.gds_collector_ = gds_collector_ |
||
| 11239 | self.gds_elementtree_node_ = None |
||
| 11240 | self.original_tagname_ = None |
||
| 11241 | self.parent_object_ = kwargs_.get('parent_object_') |
||
| 11242 | self.ns_prefix_ = None |
||
| 11243 | super(CustomRegionType, self).__init__(id, custom, comments, continuation, AlternativeImage, Coords, UserDefined, Labels, Roles, TextRegion, ImageRegion, LineDrawingRegion, GraphicRegion, TableRegion, ChartRegion, SeparatorRegion, MathsRegion, ChemRegion, MusicRegion, AdvertRegion, NoiseRegion, UnknownRegion, CustomRegion, **kwargs_) |
||
| 11244 | self.type_ = _cast(None, type_) |
||
| 11245 | self.type__nsprefix_ = "pc" |
||
| 11246 | def factory(*args_, **kwargs_): |
||
| 11247 | if CurrentSubclassModule_ is not None: |
||
| 11248 | subclass = getSubclassFromModule_( |
||
| 11249 | CurrentSubclassModule_, CustomRegionType) |
||
| 11250 | if subclass is not None: |
||
| 11251 | return subclass(*args_, **kwargs_) |
||
| 11252 | if CustomRegionType.subclass: |
||
| 11253 | return CustomRegionType.subclass(*args_, **kwargs_) |
||
| 11254 | else: |
||
| 11255 | return CustomRegionType(*args_, **kwargs_) |
||
| 11256 | factory = staticmethod(factory) |
||
| 11257 | def get_ns_prefix_(self): |
||
| 11258 | return self.ns_prefix_ |
||
| 11259 | def set_ns_prefix_(self, ns_prefix): |
||
| 11260 | self.ns_prefix_ = ns_prefix |
||
| 11261 | def get_type(self): |
||
| 11262 | return self.type_ |
||
| 11263 | def set_type(self, type_): |
||
| 11264 | self.type_ = type_ |
||
| 11265 | def hasContent_(self): |
||
| 11266 | if ( |
||
| 11267 | super(CustomRegionType, self).hasContent_() |
||
| 11268 | ): |
||
| 11269 | return True |
||
| 11270 | else: |
||
| 11271 | return False |
||
| 11272 | def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='CustomRegionType', pretty_print=True): |
||
| 11273 | imported_ns_def_ = GenerateDSNamespaceDefs_.get('CustomRegionType') |
||
| 11274 | if imported_ns_def_ is not None: |
||
| 11275 | namespacedef_ = imported_ns_def_ |
||
| 11276 | if pretty_print: |
||
| 11277 | eol_ = '\n' |
||
| 11278 | else: |
||
| 11279 | eol_ = '' |
||
| 11280 | if self.original_tagname_ is not None and name_ == 'CustomRegionType': |
||
| 11281 | name_ = self.original_tagname_ |
||
| 11282 | if UseCapturedNS_ and self.ns_prefix_: |
||
| 11283 | namespaceprefix_ = self.ns_prefix_ + ':' |
||
| 11284 | showIndent(outfile, level, pretty_print) |
||
| 11285 | outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) |
||
| 11286 | already_processed = set() |
||
| 11287 | self.exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='CustomRegionType') |
||
| 11288 | if self.hasContent_(): |
||
| 11289 | outfile.write('>%s' % (eol_, )) |
||
| 11290 | self.exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='CustomRegionType', pretty_print=pretty_print) |
||
| 11291 | showIndent(outfile, level, pretty_print) |
||
| 11292 | outfile.write('</%s%s>%s' % (namespaceprefix_, name_, eol_)) |
||
| 11293 | else: |
||
| 11294 | outfile.write('/>%s' % (eol_, )) |
||
| 11295 | def exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='CustomRegionType'): |
||
| 11296 | super(CustomRegionType, self).exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='CustomRegionType') |
||
| 11297 | if self.type_ is not None and 'type_' not in already_processed: |
||
| 11298 | already_processed.add('type_') |
||
| 11299 | outfile.write(' type=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.type_), input_name='type')), )) |
||
| 11300 | def exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='CustomRegionType', fromsubclass_=False, pretty_print=True): |
||
| 11301 | super(CustomRegionType, self).exportChildren(outfile, level, namespaceprefix_, namespacedef_, name_, True, pretty_print=pretty_print) |
||
| 11302 | def to_etree(self, parent_element=None, name_='CustomRegionType', mapping_=None, nsmap_=None): |
||
| 11303 | element = super(CustomRegionType, self).to_etree(parent_element, name_, mapping_) |
||
| 11304 | if self.type_ is not None: |
||
| 11305 | element.set('type', self.gds_format_string(self.type_)) |
||
| 11306 | if mapping_ is not None: |
||
| 11307 | mapping_[id(self)] = element |
||
| 11308 | return element |
||
| 11309 | def build(self, node, gds_collector_=None): |
||
| 11310 | self.gds_collector_ = gds_collector_ |
||
| 11311 | if SaveElementTreeNode: |
||
| 11312 | self.gds_elementtree_node_ = node |
||
| 11313 | already_processed = set() |
||
| 11314 | self.ns_prefix_ = node.prefix |
||
| 11315 | self.buildAttributes(node, node.attrib, already_processed) |
||
| 11316 | for child in node: |
||
| 11317 | nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] |
||
| 11318 | self.buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) |
||
| 11319 | return self |
||
| 11320 | def buildAttributes(self, node, attrs, already_processed): |
||
| 11321 | value = find_attr_value_('type', node) |
||
| 11322 | if value is not None and 'type' not in already_processed: |
||
| 11323 | already_processed.add('type') |
||
| 11324 | self.type_ = value |
||
| 11325 | super(CustomRegionType, self).buildAttributes(node, attrs, already_processed) |
||
| 11326 | def buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None): |
||
| 11327 | super(CustomRegionType, self).buildChildren(child_, node, nodeName_, True) |
||
| 11328 | pass |
||
| 11329 | def __hash__(self): |
||
| 11330 | return hash(self.id) |
||
| 11331 | # end class CustomRegionType |
||
| 11332 | |||
| 11333 | |||
| 11334 | View Code Duplication | class UnknownRegionType(RegionType): |
|
| 11335 | """To be used if the region type cannot be ascertained.""" |
||
| 11336 | __hash__ = GeneratedsSuper.__hash__ |
||
| 11337 | member_data_items_ = [ |
||
| 11338 | ] |
||
| 11339 | subclass = None |
||
| 11340 | superclass = RegionType |
||
| 11341 | def __init__(self, id=None, custom=None, comments=None, continuation=None, AlternativeImage=None, Coords=None, UserDefined=None, Labels=None, Roles=None, TextRegion=None, ImageRegion=None, LineDrawingRegion=None, GraphicRegion=None, TableRegion=None, ChartRegion=None, SeparatorRegion=None, MathsRegion=None, ChemRegion=None, MusicRegion=None, AdvertRegion=None, NoiseRegion=None, UnknownRegion=None, CustomRegion=None, gds_collector_=None, **kwargs_): |
||
| 11342 | self.gds_collector_ = gds_collector_ |
||
| 11343 | self.gds_elementtree_node_ = None |
||
| 11344 | self.original_tagname_ = None |
||
| 11345 | self.parent_object_ = kwargs_.get('parent_object_') |
||
| 11346 | self.ns_prefix_ = None |
||
| 11347 | super(UnknownRegionType, self).__init__(id, custom, comments, continuation, AlternativeImage, Coords, UserDefined, Labels, Roles, TextRegion, ImageRegion, LineDrawingRegion, GraphicRegion, TableRegion, ChartRegion, SeparatorRegion, MathsRegion, ChemRegion, MusicRegion, AdvertRegion, NoiseRegion, UnknownRegion, CustomRegion, **kwargs_) |
||
| 11348 | def factory(*args_, **kwargs_): |
||
| 11349 | if CurrentSubclassModule_ is not None: |
||
| 11350 | subclass = getSubclassFromModule_( |
||
| 11351 | CurrentSubclassModule_, UnknownRegionType) |
||
| 11352 | if subclass is not None: |
||
| 11353 | return subclass(*args_, **kwargs_) |
||
| 11354 | if UnknownRegionType.subclass: |
||
| 11355 | return UnknownRegionType.subclass(*args_, **kwargs_) |
||
| 11356 | else: |
||
| 11357 | return UnknownRegionType(*args_, **kwargs_) |
||
| 11358 | factory = staticmethod(factory) |
||
| 11359 | def get_ns_prefix_(self): |
||
| 11360 | return self.ns_prefix_ |
||
| 11361 | def set_ns_prefix_(self, ns_prefix): |
||
| 11362 | self.ns_prefix_ = ns_prefix |
||
| 11363 | def hasContent_(self): |
||
| 11364 | if ( |
||
| 11365 | super(UnknownRegionType, self).hasContent_() |
||
| 11366 | ): |
||
| 11367 | return True |
||
| 11368 | else: |
||
| 11369 | return False |
||
| 11370 | def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='UnknownRegionType', pretty_print=True): |
||
| 11371 | imported_ns_def_ = GenerateDSNamespaceDefs_.get('UnknownRegionType') |
||
| 11372 | if imported_ns_def_ is not None: |
||
| 11373 | namespacedef_ = imported_ns_def_ |
||
| 11374 | if pretty_print: |
||
| 11375 | eol_ = '\n' |
||
| 11376 | else: |
||
| 11377 | eol_ = '' |
||
| 11378 | if self.original_tagname_ is not None and name_ == 'UnknownRegionType': |
||
| 11379 | name_ = self.original_tagname_ |
||
| 11380 | if UseCapturedNS_ and self.ns_prefix_: |
||
| 11381 | namespaceprefix_ = self.ns_prefix_ + ':' |
||
| 11382 | showIndent(outfile, level, pretty_print) |
||
| 11383 | outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) |
||
| 11384 | already_processed = set() |
||
| 11385 | self.exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='UnknownRegionType') |
||
| 11386 | if self.hasContent_(): |
||
| 11387 | outfile.write('>%s' % (eol_, )) |
||
| 11388 | self.exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='UnknownRegionType', pretty_print=pretty_print) |
||
| 11389 | showIndent(outfile, level, pretty_print) |
||
| 11390 | outfile.write('</%s%s>%s' % (namespaceprefix_, name_, eol_)) |
||
| 11391 | else: |
||
| 11392 | outfile.write('/>%s' % (eol_, )) |
||
| 11393 | def exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='UnknownRegionType'): |
||
| 11394 | super(UnknownRegionType, self).exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='UnknownRegionType') |
||
| 11395 | def exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='UnknownRegionType', fromsubclass_=False, pretty_print=True): |
||
| 11396 | super(UnknownRegionType, self).exportChildren(outfile, level, namespaceprefix_, namespacedef_, name_, True, pretty_print=pretty_print) |
||
| 11397 | def to_etree(self, parent_element=None, name_='UnknownRegionType', mapping_=None, nsmap_=None): |
||
| 11398 | element = super(UnknownRegionType, self).to_etree(parent_element, name_, mapping_) |
||
| 11399 | if mapping_ is not None: |
||
| 11400 | mapping_[id(self)] = element |
||
| 11401 | return element |
||
| 11402 | def build(self, node, gds_collector_=None): |
||
| 11403 | self.gds_collector_ = gds_collector_ |
||
| 11404 | if SaveElementTreeNode: |
||
| 11405 | self.gds_elementtree_node_ = node |
||
| 11406 | already_processed = set() |
||
| 11407 | self.ns_prefix_ = node.prefix |
||
| 11408 | self.buildAttributes(node, node.attrib, already_processed) |
||
| 11409 | for child in node: |
||
| 11410 | nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] |
||
| 11411 | self.buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) |
||
| 11412 | return self |
||
| 11413 | def buildAttributes(self, node, attrs, already_processed): |
||
| 11414 | super(UnknownRegionType, self).buildAttributes(node, attrs, already_processed) |
||
| 11415 | def buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None): |
||
| 11416 | super(UnknownRegionType, self).buildChildren(child_, node, nodeName_, True) |
||
| 11417 | pass |
||
| 11418 | def __hash__(self): |
||
| 11419 | return hash(self.id) |
||
| 11420 | # end class UnknownRegionType |
||
| 11421 | |||
| 11422 | |||
| 11423 | View Code Duplication | class NoiseRegionType(RegionType): |
|
| 11424 | """Noise regions are regions where no real data lies, only |
||
| 11425 | false data created by artifacts on the document or |
||
| 11426 | scanner noise.""" |
||
| 11427 | __hash__ = GeneratedsSuper.__hash__ |
||
| 11428 | member_data_items_ = [ |
||
| 11429 | ] |
||
| 11430 | subclass = None |
||
| 11431 | superclass = RegionType |
||
| 11432 | def __init__(self, id=None, custom=None, comments=None, continuation=None, AlternativeImage=None, Coords=None, UserDefined=None, Labels=None, Roles=None, TextRegion=None, ImageRegion=None, LineDrawingRegion=None, GraphicRegion=None, TableRegion=None, ChartRegion=None, SeparatorRegion=None, MathsRegion=None, ChemRegion=None, MusicRegion=None, AdvertRegion=None, NoiseRegion=None, UnknownRegion=None, CustomRegion=None, gds_collector_=None, **kwargs_): |
||
| 11433 | self.gds_collector_ = gds_collector_ |
||
| 11434 | self.gds_elementtree_node_ = None |
||
| 11435 | self.original_tagname_ = None |
||
| 11436 | self.parent_object_ = kwargs_.get('parent_object_') |
||
| 11437 | self.ns_prefix_ = None |
||
| 11438 | super(NoiseRegionType, self).__init__(id, custom, comments, continuation, AlternativeImage, Coords, UserDefined, Labels, Roles, TextRegion, ImageRegion, LineDrawingRegion, GraphicRegion, TableRegion, ChartRegion, SeparatorRegion, MathsRegion, ChemRegion, MusicRegion, AdvertRegion, NoiseRegion, UnknownRegion, CustomRegion, **kwargs_) |
||
| 11439 | def factory(*args_, **kwargs_): |
||
| 11440 | if CurrentSubclassModule_ is not None: |
||
| 11441 | subclass = getSubclassFromModule_( |
||
| 11442 | CurrentSubclassModule_, NoiseRegionType) |
||
| 11443 | if subclass is not None: |
||
| 11444 | return subclass(*args_, **kwargs_) |
||
| 11445 | if NoiseRegionType.subclass: |
||
| 11446 | return NoiseRegionType.subclass(*args_, **kwargs_) |
||
| 11447 | else: |
||
| 11448 | return NoiseRegionType(*args_, **kwargs_) |
||
| 11449 | factory = staticmethod(factory) |
||
| 11450 | def get_ns_prefix_(self): |
||
| 11451 | return self.ns_prefix_ |
||
| 11452 | def set_ns_prefix_(self, ns_prefix): |
||
| 11453 | self.ns_prefix_ = ns_prefix |
||
| 11454 | def hasContent_(self): |
||
| 11455 | if ( |
||
| 11456 | super(NoiseRegionType, self).hasContent_() |
||
| 11457 | ): |
||
| 11458 | return True |
||
| 11459 | else: |
||
| 11460 | return False |
||
| 11461 | def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='NoiseRegionType', pretty_print=True): |
||
| 11462 | imported_ns_def_ = GenerateDSNamespaceDefs_.get('NoiseRegionType') |
||
| 11463 | if imported_ns_def_ is not None: |
||
| 11464 | namespacedef_ = imported_ns_def_ |
||
| 11465 | if pretty_print: |
||
| 11466 | eol_ = '\n' |
||
| 11467 | else: |
||
| 11468 | eol_ = '' |
||
| 11469 | if self.original_tagname_ is not None and name_ == 'NoiseRegionType': |
||
| 11470 | name_ = self.original_tagname_ |
||
| 11471 | if UseCapturedNS_ and self.ns_prefix_: |
||
| 11472 | namespaceprefix_ = self.ns_prefix_ + ':' |
||
| 11473 | showIndent(outfile, level, pretty_print) |
||
| 11474 | outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) |
||
| 11475 | already_processed = set() |
||
| 11476 | self.exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='NoiseRegionType') |
||
| 11477 | if self.hasContent_(): |
||
| 11478 | outfile.write('>%s' % (eol_, )) |
||
| 11479 | self.exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='NoiseRegionType', pretty_print=pretty_print) |
||
| 11480 | showIndent(outfile, level, pretty_print) |
||
| 11481 | outfile.write('</%s%s>%s' % (namespaceprefix_, name_, eol_)) |
||
| 11482 | else: |
||
| 11483 | outfile.write('/>%s' % (eol_, )) |
||
| 11484 | def exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='NoiseRegionType'): |
||
| 11485 | super(NoiseRegionType, self).exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='NoiseRegionType') |
||
| 11486 | def exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='NoiseRegionType', fromsubclass_=False, pretty_print=True): |
||
| 11487 | super(NoiseRegionType, self).exportChildren(outfile, level, namespaceprefix_, namespacedef_, name_, True, pretty_print=pretty_print) |
||
| 11488 | def to_etree(self, parent_element=None, name_='NoiseRegionType', mapping_=None, nsmap_=None): |
||
| 11489 | element = super(NoiseRegionType, self).to_etree(parent_element, name_, mapping_) |
||
| 11490 | if mapping_ is not None: |
||
| 11491 | mapping_[id(self)] = element |
||
| 11492 | return element |
||
| 11493 | def build(self, node, gds_collector_=None): |
||
| 11494 | self.gds_collector_ = gds_collector_ |
||
| 11495 | if SaveElementTreeNode: |
||
| 11496 | self.gds_elementtree_node_ = node |
||
| 11497 | already_processed = set() |
||
| 11498 | self.ns_prefix_ = node.prefix |
||
| 11499 | self.buildAttributes(node, node.attrib, already_processed) |
||
| 11500 | for child in node: |
||
| 11501 | nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] |
||
| 11502 | self.buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) |
||
| 11503 | return self |
||
| 11504 | def buildAttributes(self, node, attrs, already_processed): |
||
| 11505 | super(NoiseRegionType, self).buildAttributes(node, attrs, already_processed) |
||
| 11506 | def buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None): |
||
| 11507 | super(NoiseRegionType, self).buildChildren(child_, node, nodeName_, True) |
||
| 11508 | pass |
||
| 11509 | def __hash__(self): |
||
| 11510 | return hash(self.id) |
||
| 11511 | # end class NoiseRegionType |
||
| 11512 | |||
| 11513 | |||
| 11514 | View Code Duplication | class AdvertRegionType(RegionType): |
|
| 11515 | """Regions containing advertisements. |
||
| 11516 | The angle the rectangle encapsulating a region |
||
| 11517 | has to be rotated in clockwise direction |
||
| 11518 | in order to correct the present skew |
||
| 11519 | (negative values indicate anti-clockwise rotation). |
||
| 11520 | Range: -179.999,180 |
||
| 11521 | The background colour of the region""" |
||
| 11522 | __hash__ = GeneratedsSuper.__hash__ |
||
| 11523 | member_data_items_ = [ |
||
| 11524 | MemberSpec_('orientation', 'float', 0, 1, {'use': 'optional'}), |
||
| 11525 | MemberSpec_('bgColour', 'pc:ColourSimpleType', 0, 1, {'use': 'optional'}), |
||
| 11526 | ] |
||
| 11527 | subclass = None |
||
| 11528 | superclass = RegionType |
||
| 11529 | def __init__(self, id=None, custom=None, comments=None, continuation=None, AlternativeImage=None, Coords=None, UserDefined=None, Labels=None, Roles=None, TextRegion=None, ImageRegion=None, LineDrawingRegion=None, GraphicRegion=None, TableRegion=None, ChartRegion=None, SeparatorRegion=None, MathsRegion=None, ChemRegion=None, MusicRegion=None, AdvertRegion=None, NoiseRegion=None, UnknownRegion=None, CustomRegion=None, orientation=None, bgColour=None, gds_collector_=None, **kwargs_): |
||
| 11530 | self.gds_collector_ = gds_collector_ |
||
| 11531 | self.gds_elementtree_node_ = None |
||
| 11532 | self.original_tagname_ = None |
||
| 11533 | self.parent_object_ = kwargs_.get('parent_object_') |
||
| 11534 | self.ns_prefix_ = None |
||
| 11535 | super(AdvertRegionType, self).__init__(id, custom, comments, continuation, AlternativeImage, Coords, UserDefined, Labels, Roles, TextRegion, ImageRegion, LineDrawingRegion, GraphicRegion, TableRegion, ChartRegion, SeparatorRegion, MathsRegion, ChemRegion, MusicRegion, AdvertRegion, NoiseRegion, UnknownRegion, CustomRegion, **kwargs_) |
||
| 11536 | self.orientation = _cast(float, orientation) |
||
| 11537 | self.orientation_nsprefix_ = "pc" |
||
| 11538 | self.bgColour = _cast(None, bgColour) |
||
| 11539 | self.bgColour_nsprefix_ = "pc" |
||
| 11540 | def factory(*args_, **kwargs_): |
||
| 11541 | if CurrentSubclassModule_ is not None: |
||
| 11542 | subclass = getSubclassFromModule_( |
||
| 11543 | CurrentSubclassModule_, AdvertRegionType) |
||
| 11544 | if subclass is not None: |
||
| 11545 | return subclass(*args_, **kwargs_) |
||
| 11546 | if AdvertRegionType.subclass: |
||
| 11547 | return AdvertRegionType.subclass(*args_, **kwargs_) |
||
| 11548 | else: |
||
| 11549 | return AdvertRegionType(*args_, **kwargs_) |
||
| 11550 | factory = staticmethod(factory) |
||
| 11551 | def get_ns_prefix_(self): |
||
| 11552 | return self.ns_prefix_ |
||
| 11553 | def set_ns_prefix_(self, ns_prefix): |
||
| 11554 | self.ns_prefix_ = ns_prefix |
||
| 11555 | def get_orientation(self): |
||
| 11556 | return self.orientation |
||
| 11557 | def set_orientation(self, orientation): |
||
| 11558 | self.orientation = orientation |
||
| 11559 | def get_bgColour(self): |
||
| 11560 | return self.bgColour |
||
| 11561 | def set_bgColour(self, bgColour): |
||
| 11562 | self.bgColour = bgColour |
||
| 11563 | def validate_ColourSimpleType(self, value): |
||
| 11564 | # Validate type pc:ColourSimpleType, a restriction on string. |
||
| 11565 | if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None: |
||
| 11566 | if not isinstance(value, str): |
||
| 11567 | lineno = self.gds_get_node_lineno_() |
||
| 11568 | self.gds_collector_.add_message('Value "%(value)s"%(lineno)s is not of the correct base simple type (str)' % {"value": value, "lineno": lineno, }) |
||
| 11569 | return False |
||
| 11570 | value = value |
||
| 11571 | enumerations = ['black', 'blue', 'brown', 'cyan', 'green', 'grey', 'indigo', 'magenta', 'orange', 'pink', 'red', 'turquoise', 'violet', 'white', 'yellow', 'other'] |
||
| 11572 | if value not in enumerations: |
||
| 11573 | lineno = self.gds_get_node_lineno_() |
||
| 11574 | self.gds_collector_.add_message('Value "%(value)s"%(lineno)s does not match xsd enumeration restriction on ColourSimpleType' % {"value" : encode_str_2_3(value), "lineno": lineno} ) |
||
| 11575 | result = False |
||
| 11576 | def hasContent_(self): |
||
| 11577 | if ( |
||
| 11578 | super(AdvertRegionType, self).hasContent_() |
||
| 11579 | ): |
||
| 11580 | return True |
||
| 11581 | else: |
||
| 11582 | return False |
||
| 11583 | def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='AdvertRegionType', pretty_print=True): |
||
| 11584 | imported_ns_def_ = GenerateDSNamespaceDefs_.get('AdvertRegionType') |
||
| 11585 | if imported_ns_def_ is not None: |
||
| 11586 | namespacedef_ = imported_ns_def_ |
||
| 11587 | if pretty_print: |
||
| 11588 | eol_ = '\n' |
||
| 11589 | else: |
||
| 11590 | eol_ = '' |
||
| 11591 | if self.original_tagname_ is not None and name_ == 'AdvertRegionType': |
||
| 11592 | name_ = self.original_tagname_ |
||
| 11593 | if UseCapturedNS_ and self.ns_prefix_: |
||
| 11594 | namespaceprefix_ = self.ns_prefix_ + ':' |
||
| 11595 | showIndent(outfile, level, pretty_print) |
||
| 11596 | outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) |
||
| 11597 | already_processed = set() |
||
| 11598 | self.exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='AdvertRegionType') |
||
| 11599 | if self.hasContent_(): |
||
| 11600 | outfile.write('>%s' % (eol_, )) |
||
| 11601 | self.exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='AdvertRegionType', pretty_print=pretty_print) |
||
| 11602 | showIndent(outfile, level, pretty_print) |
||
| 11603 | outfile.write('</%s%s>%s' % (namespaceprefix_, name_, eol_)) |
||
| 11604 | else: |
||
| 11605 | outfile.write('/>%s' % (eol_, )) |
||
| 11606 | def exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='AdvertRegionType'): |
||
| 11607 | super(AdvertRegionType, self).exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='AdvertRegionType') |
||
| 11608 | if self.orientation is not None and 'orientation' not in already_processed: |
||
| 11609 | already_processed.add('orientation') |
||
| 11610 | outfile.write(' orientation="%s"' % self.gds_format_float(self.orientation, input_name='orientation')) |
||
| 11611 | if self.bgColour is not None and 'bgColour' not in already_processed: |
||
| 11612 | already_processed.add('bgColour') |
||
| 11613 | outfile.write(' bgColour=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.bgColour), input_name='bgColour')), )) |
||
| 11614 | def exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='AdvertRegionType', fromsubclass_=False, pretty_print=True): |
||
| 11615 | super(AdvertRegionType, self).exportChildren(outfile, level, namespaceprefix_, namespacedef_, name_, True, pretty_print=pretty_print) |
||
| 11616 | def to_etree(self, parent_element=None, name_='AdvertRegionType', mapping_=None, nsmap_=None): |
||
| 11617 | element = super(AdvertRegionType, self).to_etree(parent_element, name_, mapping_) |
||
| 11618 | if self.orientation is not None: |
||
| 11619 | element.set('orientation', self.gds_format_float(self.orientation)) |
||
| 11620 | if self.bgColour is not None: |
||
| 11621 | element.set('bgColour', self.gds_format_string(self.bgColour)) |
||
| 11622 | if mapping_ is not None: |
||
| 11623 | mapping_[id(self)] = element |
||
| 11624 | return element |
||
| 11625 | def build(self, node, gds_collector_=None): |
||
| 11626 | self.gds_collector_ = gds_collector_ |
||
| 11627 | if SaveElementTreeNode: |
||
| 11628 | self.gds_elementtree_node_ = node |
||
| 11629 | already_processed = set() |
||
| 11630 | self.ns_prefix_ = node.prefix |
||
| 11631 | self.buildAttributes(node, node.attrib, already_processed) |
||
| 11632 | for child in node: |
||
| 11633 | nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] |
||
| 11634 | self.buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) |
||
| 11635 | return self |
||
| 11636 | def buildAttributes(self, node, attrs, already_processed): |
||
| 11637 | value = find_attr_value_('orientation', node) |
||
| 11638 | if value is not None and 'orientation' not in already_processed: |
||
| 11639 | already_processed.add('orientation') |
||
| 11640 | value = self.gds_parse_float(value, node, 'orientation') |
||
| 11641 | self.orientation = value |
||
| 11642 | value = find_attr_value_('bgColour', node) |
||
| 11643 | if value is not None and 'bgColour' not in already_processed: |
||
| 11644 | already_processed.add('bgColour') |
||
| 11645 | self.bgColour = value |
||
| 11646 | self.validate_ColourSimpleType(self.bgColour) # validate type ColourSimpleType |
||
| 11647 | super(AdvertRegionType, self).buildAttributes(node, attrs, already_processed) |
||
| 11648 | def buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None): |
||
| 11649 | super(AdvertRegionType, self).buildChildren(child_, node, nodeName_, True) |
||
| 11650 | pass |
||
| 11651 | def __hash__(self): |
||
| 11652 | return hash(self.id) |
||
| 11653 | def set_orientation(self, orientation): |
||
| 11654 | """ |
||
| 11655 | Set deskewing angle to given `orientation` number. |
||
| 11656 | Moreover, invalidate self's ``pc:AlternativeImage``s |
||
| 11657 | (because they will have been rotated and enlarged |
||
| 11658 | with the angle of the previous value). |
||
| 11659 | """ |
||
| 11660 | if hasattr(self, 'invalidate_AlternativeImage'): |
||
| 11661 | # PageType, RegionType: |
||
| 11662 | self.invalidate_AlternativeImage(feature_selector='deskewed') |
||
| 11663 | self.orientation = orientation |
||
| 11664 | # end class AdvertRegionType |
||
| 11665 | |||
| 11666 | |||
| 11667 | View Code Duplication | class MusicRegionType(RegionType): |
|
| 11668 | """Regions containing musical notations. |
||
| 11669 | The angle the rectangle encapsulating a region |
||
| 11670 | has to be rotated in clockwise direction |
||
| 11671 | in order to correct the present skew |
||
| 11672 | (negative values indicate anti-clockwise rotation). |
||
| 11673 | Range: -179.999,180 |
||
| 11674 | The background colour of the region""" |
||
| 11675 | __hash__ = GeneratedsSuper.__hash__ |
||
| 11676 | member_data_items_ = [ |
||
| 11677 | MemberSpec_('orientation', 'float', 0, 1, {'use': 'optional'}), |
||
| 11678 | MemberSpec_('bgColour', 'pc:ColourSimpleType', 0, 1, {'use': 'optional'}), |
||
| 11679 | ] |
||
| 11680 | subclass = None |
||
| 11681 | superclass = RegionType |
||
| 11682 | def __init__(self, id=None, custom=None, comments=None, continuation=None, AlternativeImage=None, Coords=None, UserDefined=None, Labels=None, Roles=None, TextRegion=None, ImageRegion=None, LineDrawingRegion=None, GraphicRegion=None, TableRegion=None, ChartRegion=None, SeparatorRegion=None, MathsRegion=None, ChemRegion=None, MusicRegion=None, AdvertRegion=None, NoiseRegion=None, UnknownRegion=None, CustomRegion=None, orientation=None, bgColour=None, gds_collector_=None, **kwargs_): |
||
| 11683 | self.gds_collector_ = gds_collector_ |
||
| 11684 | self.gds_elementtree_node_ = None |
||
| 11685 | self.original_tagname_ = None |
||
| 11686 | self.parent_object_ = kwargs_.get('parent_object_') |
||
| 11687 | self.ns_prefix_ = None |
||
| 11688 | super(MusicRegionType, self).__init__(id, custom, comments, continuation, AlternativeImage, Coords, UserDefined, Labels, Roles, TextRegion, ImageRegion, LineDrawingRegion, GraphicRegion, TableRegion, ChartRegion, SeparatorRegion, MathsRegion, ChemRegion, MusicRegion, AdvertRegion, NoiseRegion, UnknownRegion, CustomRegion, **kwargs_) |
||
| 11689 | self.orientation = _cast(float, orientation) |
||
| 11690 | self.orientation_nsprefix_ = "pc" |
||
| 11691 | self.bgColour = _cast(None, bgColour) |
||
| 11692 | self.bgColour_nsprefix_ = "pc" |
||
| 11693 | def factory(*args_, **kwargs_): |
||
| 11694 | if CurrentSubclassModule_ is not None: |
||
| 11695 | subclass = getSubclassFromModule_( |
||
| 11696 | CurrentSubclassModule_, MusicRegionType) |
||
| 11697 | if subclass is not None: |
||
| 11698 | return subclass(*args_, **kwargs_) |
||
| 11699 | if MusicRegionType.subclass: |
||
| 11700 | return MusicRegionType.subclass(*args_, **kwargs_) |
||
| 11701 | else: |
||
| 11702 | return MusicRegionType(*args_, **kwargs_) |
||
| 11703 | factory = staticmethod(factory) |
||
| 11704 | def get_ns_prefix_(self): |
||
| 11705 | return self.ns_prefix_ |
||
| 11706 | def set_ns_prefix_(self, ns_prefix): |
||
| 11707 | self.ns_prefix_ = ns_prefix |
||
| 11708 | def get_orientation(self): |
||
| 11709 | return self.orientation |
||
| 11710 | def set_orientation(self, orientation): |
||
| 11711 | self.orientation = orientation |
||
| 11712 | def get_bgColour(self): |
||
| 11713 | return self.bgColour |
||
| 11714 | def set_bgColour(self, bgColour): |
||
| 11715 | self.bgColour = bgColour |
||
| 11716 | def validate_ColourSimpleType(self, value): |
||
| 11717 | # Validate type pc:ColourSimpleType, a restriction on string. |
||
| 11718 | if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None: |
||
| 11719 | if not isinstance(value, str): |
||
| 11720 | lineno = self.gds_get_node_lineno_() |
||
| 11721 | self.gds_collector_.add_message('Value "%(value)s"%(lineno)s is not of the correct base simple type (str)' % {"value": value, "lineno": lineno, }) |
||
| 11722 | return False |
||
| 11723 | value = value |
||
| 11724 | enumerations = ['black', 'blue', 'brown', 'cyan', 'green', 'grey', 'indigo', 'magenta', 'orange', 'pink', 'red', 'turquoise', 'violet', 'white', 'yellow', 'other'] |
||
| 11725 | if value not in enumerations: |
||
| 11726 | lineno = self.gds_get_node_lineno_() |
||
| 11727 | self.gds_collector_.add_message('Value "%(value)s"%(lineno)s does not match xsd enumeration restriction on ColourSimpleType' % {"value" : encode_str_2_3(value), "lineno": lineno} ) |
||
| 11728 | result = False |
||
| 11729 | def hasContent_(self): |
||
| 11730 | if ( |
||
| 11731 | super(MusicRegionType, self).hasContent_() |
||
| 11732 | ): |
||
| 11733 | return True |
||
| 11734 | else: |
||
| 11735 | return False |
||
| 11736 | def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='MusicRegionType', pretty_print=True): |
||
| 11737 | imported_ns_def_ = GenerateDSNamespaceDefs_.get('MusicRegionType') |
||
| 11738 | if imported_ns_def_ is not None: |
||
| 11739 | namespacedef_ = imported_ns_def_ |
||
| 11740 | if pretty_print: |
||
| 11741 | eol_ = '\n' |
||
| 11742 | else: |
||
| 11743 | eol_ = '' |
||
| 11744 | if self.original_tagname_ is not None and name_ == 'MusicRegionType': |
||
| 11745 | name_ = self.original_tagname_ |
||
| 11746 | if UseCapturedNS_ and self.ns_prefix_: |
||
| 11747 | namespaceprefix_ = self.ns_prefix_ + ':' |
||
| 11748 | showIndent(outfile, level, pretty_print) |
||
| 11749 | outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) |
||
| 11750 | already_processed = set() |
||
| 11751 | self.exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='MusicRegionType') |
||
| 11752 | if self.hasContent_(): |
||
| 11753 | outfile.write('>%s' % (eol_, )) |
||
| 11754 | self.exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='MusicRegionType', pretty_print=pretty_print) |
||
| 11755 | showIndent(outfile, level, pretty_print) |
||
| 11756 | outfile.write('</%s%s>%s' % (namespaceprefix_, name_, eol_)) |
||
| 11757 | else: |
||
| 11758 | outfile.write('/>%s' % (eol_, )) |
||
| 11759 | def exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='MusicRegionType'): |
||
| 11760 | super(MusicRegionType, self).exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='MusicRegionType') |
||
| 11761 | if self.orientation is not None and 'orientation' not in already_processed: |
||
| 11762 | already_processed.add('orientation') |
||
| 11763 | outfile.write(' orientation="%s"' % self.gds_format_float(self.orientation, input_name='orientation')) |
||
| 11764 | if self.bgColour is not None and 'bgColour' not in already_processed: |
||
| 11765 | already_processed.add('bgColour') |
||
| 11766 | outfile.write(' bgColour=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.bgColour), input_name='bgColour')), )) |
||
| 11767 | def exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='MusicRegionType', fromsubclass_=False, pretty_print=True): |
||
| 11768 | super(MusicRegionType, self).exportChildren(outfile, level, namespaceprefix_, namespacedef_, name_, True, pretty_print=pretty_print) |
||
| 11769 | def to_etree(self, parent_element=None, name_='MusicRegionType', mapping_=None, nsmap_=None): |
||
| 11770 | element = super(MusicRegionType, self).to_etree(parent_element, name_, mapping_) |
||
| 11771 | if self.orientation is not None: |
||
| 11772 | element.set('orientation', self.gds_format_float(self.orientation)) |
||
| 11773 | if self.bgColour is not None: |
||
| 11774 | element.set('bgColour', self.gds_format_string(self.bgColour)) |
||
| 11775 | if mapping_ is not None: |
||
| 11776 | mapping_[id(self)] = element |
||
| 11777 | return element |
||
| 11778 | def build(self, node, gds_collector_=None): |
||
| 11779 | self.gds_collector_ = gds_collector_ |
||
| 11780 | if SaveElementTreeNode: |
||
| 11781 | self.gds_elementtree_node_ = node |
||
| 11782 | already_processed = set() |
||
| 11783 | self.ns_prefix_ = node.prefix |
||
| 11784 | self.buildAttributes(node, node.attrib, already_processed) |
||
| 11785 | for child in node: |
||
| 11786 | nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] |
||
| 11787 | self.buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) |
||
| 11788 | return self |
||
| 11789 | def buildAttributes(self, node, attrs, already_processed): |
||
| 11790 | value = find_attr_value_('orientation', node) |
||
| 11791 | if value is not None and 'orientation' not in already_processed: |
||
| 11792 | already_processed.add('orientation') |
||
| 11793 | value = self.gds_parse_float(value, node, 'orientation') |
||
| 11794 | self.orientation = value |
||
| 11795 | value = find_attr_value_('bgColour', node) |
||
| 11796 | if value is not None and 'bgColour' not in already_processed: |
||
| 11797 | already_processed.add('bgColour') |
||
| 11798 | self.bgColour = value |
||
| 11799 | self.validate_ColourSimpleType(self.bgColour) # validate type ColourSimpleType |
||
| 11800 | super(MusicRegionType, self).buildAttributes(node, attrs, already_processed) |
||
| 11801 | def buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None): |
||
| 11802 | super(MusicRegionType, self).buildChildren(child_, node, nodeName_, True) |
||
| 11803 | pass |
||
| 11804 | def __hash__(self): |
||
| 11805 | return hash(self.id) |
||
| 11806 | def set_orientation(self, orientation): |
||
| 11807 | """ |
||
| 11808 | Set deskewing angle to given `orientation` number. |
||
| 11809 | Moreover, invalidate self's ``pc:AlternativeImage``s |
||
| 11810 | (because they will have been rotated and enlarged |
||
| 11811 | with the angle of the previous value). |
||
| 11812 | """ |
||
| 11813 | if hasattr(self, 'invalidate_AlternativeImage'): |
||
| 11814 | # PageType, RegionType: |
||
| 11815 | self.invalidate_AlternativeImage(feature_selector='deskewed') |
||
| 11816 | self.orientation = orientation |
||
| 11817 | # end class MusicRegionType |
||
| 11818 | |||
| 11819 | |||
| 11820 | class MapRegionType(RegionType): |
||
| 11821 | """Regions containing maps. |
||
| 11822 | The angle the rectangle encapsulating a |
||
| 11823 | region has to be rotated in clockwise |
||
| 11824 | direction in order to correct the present |
||
| 11825 | skew (negative values indicate |
||
| 11826 | anti-clockwise rotation). Range: |
||
| 11827 | -179.999,180""" |
||
| 11828 | __hash__ = GeneratedsSuper.__hash__ |
||
| 11829 | member_data_items_ = [ |
||
| 11830 | MemberSpec_('orientation', 'float', 0, 1, {'use': 'optional'}), |
||
| 11831 | ] |
||
| 11832 | subclass = None |
||
| 11833 | superclass = RegionType |
||
| 11834 | def __init__(self, id=None, custom=None, comments=None, continuation=None, AlternativeImage=None, Coords=None, UserDefined=None, Labels=None, Roles=None, TextRegion=None, ImageRegion=None, LineDrawingRegion=None, GraphicRegion=None, TableRegion=None, ChartRegion=None, SeparatorRegion=None, MathsRegion=None, ChemRegion=None, MusicRegion=None, AdvertRegion=None, NoiseRegion=None, UnknownRegion=None, CustomRegion=None, orientation=None, gds_collector_=None, **kwargs_): |
||
| 11835 | self.gds_collector_ = gds_collector_ |
||
| 11836 | self.gds_elementtree_node_ = None |
||
| 11837 | self.original_tagname_ = None |
||
| 11838 | self.parent_object_ = kwargs_.get('parent_object_') |
||
| 11839 | self.ns_prefix_ = None |
||
| 11840 | super(MapRegionType, self).__init__(id, custom, comments, continuation, AlternativeImage, Coords, UserDefined, Labels, Roles, TextRegion, ImageRegion, LineDrawingRegion, GraphicRegion, TableRegion, ChartRegion, SeparatorRegion, MathsRegion, ChemRegion, MusicRegion, AdvertRegion, NoiseRegion, UnknownRegion, CustomRegion, **kwargs_) |
||
| 11841 | self.orientation = _cast(float, orientation) |
||
| 11842 | self.orientation_nsprefix_ = "pc" |
||
| 11843 | def factory(*args_, **kwargs_): |
||
| 11844 | if CurrentSubclassModule_ is not None: |
||
| 11845 | subclass = getSubclassFromModule_( |
||
| 11846 | CurrentSubclassModule_, MapRegionType) |
||
| 11847 | if subclass is not None: |
||
| 11848 | return subclass(*args_, **kwargs_) |
||
| 11849 | if MapRegionType.subclass: |
||
| 11850 | return MapRegionType.subclass(*args_, **kwargs_) |
||
| 11851 | else: |
||
| 11852 | return MapRegionType(*args_, **kwargs_) |
||
| 11853 | factory = staticmethod(factory) |
||
| 11854 | def get_ns_prefix_(self): |
||
| 11855 | return self.ns_prefix_ |
||
| 11856 | def set_ns_prefix_(self, ns_prefix): |
||
| 11857 | self.ns_prefix_ = ns_prefix |
||
| 11858 | def get_orientation(self): |
||
| 11859 | return self.orientation |
||
| 11860 | def set_orientation(self, orientation): |
||
| 11861 | self.orientation = orientation |
||
| 11862 | def hasContent_(self): |
||
| 11863 | if ( |
||
| 11864 | super(MapRegionType, self).hasContent_() |
||
| 11865 | ): |
||
| 11866 | return True |
||
| 11867 | else: |
||
| 11868 | return False |
||
| 11869 | def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='MapRegionType', pretty_print=True): |
||
| 11870 | imported_ns_def_ = GenerateDSNamespaceDefs_.get('MapRegionType') |
||
| 11871 | if imported_ns_def_ is not None: |
||
| 11872 | namespacedef_ = imported_ns_def_ |
||
| 11873 | if pretty_print: |
||
| 11874 | eol_ = '\n' |
||
| 11875 | else: |
||
| 11876 | eol_ = '' |
||
| 11877 | if self.original_tagname_ is not None and name_ == 'MapRegionType': |
||
| 11878 | name_ = self.original_tagname_ |
||
| 11879 | if UseCapturedNS_ and self.ns_prefix_: |
||
| 11880 | namespaceprefix_ = self.ns_prefix_ + ':' |
||
| 11881 | showIndent(outfile, level, pretty_print) |
||
| 11882 | outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) |
||
| 11883 | already_processed = set() |
||
| 11884 | self.exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='MapRegionType') |
||
| 11885 | if self.hasContent_(): |
||
| 11886 | outfile.write('>%s' % (eol_, )) |
||
| 11887 | self.exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='MapRegionType', pretty_print=pretty_print) |
||
| 11888 | showIndent(outfile, level, pretty_print) |
||
| 11889 | outfile.write('</%s%s>%s' % (namespaceprefix_, name_, eol_)) |
||
| 11890 | else: |
||
| 11891 | outfile.write('/>%s' % (eol_, )) |
||
| 11892 | def exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='MapRegionType'): |
||
| 11893 | super(MapRegionType, self).exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='MapRegionType') |
||
| 11894 | if self.orientation is not None and 'orientation' not in already_processed: |
||
| 11895 | already_processed.add('orientation') |
||
| 11896 | outfile.write(' orientation="%s"' % self.gds_format_float(self.orientation, input_name='orientation')) |
||
| 11897 | def exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='MapRegionType', fromsubclass_=False, pretty_print=True): |
||
| 11898 | super(MapRegionType, self).exportChildren(outfile, level, namespaceprefix_, namespacedef_, name_, True, pretty_print=pretty_print) |
||
| 11899 | def to_etree(self, parent_element=None, name_='MapRegionType', mapping_=None, nsmap_=None): |
||
| 11900 | element = super(MapRegionType, self).to_etree(parent_element, name_, mapping_) |
||
| 11901 | if self.orientation is not None: |
||
| 11902 | element.set('orientation', self.gds_format_float(self.orientation)) |
||
| 11903 | if mapping_ is not None: |
||
| 11904 | mapping_[id(self)] = element |
||
| 11905 | return element |
||
| 11906 | def build(self, node, gds_collector_=None): |
||
| 11907 | self.gds_collector_ = gds_collector_ |
||
| 11908 | if SaveElementTreeNode: |
||
| 11909 | self.gds_elementtree_node_ = node |
||
| 11910 | already_processed = set() |
||
| 11911 | self.ns_prefix_ = node.prefix |
||
| 11912 | self.buildAttributes(node, node.attrib, already_processed) |
||
| 11913 | for child in node: |
||
| 11914 | nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] |
||
| 11915 | self.buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) |
||
| 11916 | return self |
||
| 11917 | def buildAttributes(self, node, attrs, already_processed): |
||
| 11918 | value = find_attr_value_('orientation', node) |
||
| 11919 | if value is not None and 'orientation' not in already_processed: |
||
| 11920 | already_processed.add('orientation') |
||
| 11921 | value = self.gds_parse_float(value, node, 'orientation') |
||
| 11922 | self.orientation = value |
||
| 11923 | super(MapRegionType, self).buildAttributes(node, attrs, already_processed) |
||
| 11924 | def buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None): |
||
| 11925 | super(MapRegionType, self).buildChildren(child_, node, nodeName_, True) |
||
| 11926 | pass |
||
| 11927 | def __hash__(self): |
||
| 11928 | return hash(self.id) |
||
| 11929 | def set_orientation(self, orientation): |
||
| 11930 | """ |
||
| 11931 | Set deskewing angle to given `orientation` number. |
||
| 11932 | Moreover, invalidate self's ``pc:AlternativeImage``s |
||
| 11933 | (because they will have been rotated and enlarged |
||
| 11934 | with the angle of the previous value). |
||
| 11935 | """ |
||
| 11936 | if hasattr(self, 'invalidate_AlternativeImage'): |
||
| 11937 | # PageType, RegionType: |
||
| 11938 | self.invalidate_AlternativeImage(feature_selector='deskewed') |
||
| 11939 | self.orientation = orientation |
||
| 11940 | # end class MapRegionType |
||
| 11941 | |||
| 11942 | |||
| 11943 | View Code Duplication | class ChemRegionType(RegionType): |
|
| 11944 | """Regions containing chemical formulas. |
||
| 11945 | The angle the rectangle encapsulating a |
||
| 11946 | region has to be rotated in clockwise |
||
| 11947 | direction in order to correct the present |
||
| 11948 | skew (negative values indicate |
||
| 11949 | anti-clockwise rotation). Range: |
||
| 11950 | -179.999,180 |
||
| 11951 | The background colour of the region""" |
||
| 11952 | __hash__ = GeneratedsSuper.__hash__ |
||
| 11953 | member_data_items_ = [ |
||
| 11954 | MemberSpec_('orientation', 'float', 0, 1, {'use': 'optional'}), |
||
| 11955 | MemberSpec_('bgColour', 'pc:ColourSimpleType', 0, 1, {'use': 'optional'}), |
||
| 11956 | ] |
||
| 11957 | subclass = None |
||
| 11958 | superclass = RegionType |
||
| 11959 | def __init__(self, id=None, custom=None, comments=None, continuation=None, AlternativeImage=None, Coords=None, UserDefined=None, Labels=None, Roles=None, TextRegion=None, ImageRegion=None, LineDrawingRegion=None, GraphicRegion=None, TableRegion=None, ChartRegion=None, SeparatorRegion=None, MathsRegion=None, ChemRegion=None, MusicRegion=None, AdvertRegion=None, NoiseRegion=None, UnknownRegion=None, CustomRegion=None, orientation=None, bgColour=None, gds_collector_=None, **kwargs_): |
||
| 11960 | self.gds_collector_ = gds_collector_ |
||
| 11961 | self.gds_elementtree_node_ = None |
||
| 11962 | self.original_tagname_ = None |
||
| 11963 | self.parent_object_ = kwargs_.get('parent_object_') |
||
| 11964 | self.ns_prefix_ = None |
||
| 11965 | super(ChemRegionType, self).__init__(id, custom, comments, continuation, AlternativeImage, Coords, UserDefined, Labels, Roles, TextRegion, ImageRegion, LineDrawingRegion, GraphicRegion, TableRegion, ChartRegion, SeparatorRegion, MathsRegion, ChemRegion, MusicRegion, AdvertRegion, NoiseRegion, UnknownRegion, CustomRegion, **kwargs_) |
||
| 11966 | self.orientation = _cast(float, orientation) |
||
| 11967 | self.orientation_nsprefix_ = "pc" |
||
| 11968 | self.bgColour = _cast(None, bgColour) |
||
| 11969 | self.bgColour_nsprefix_ = "pc" |
||
| 11970 | def factory(*args_, **kwargs_): |
||
| 11971 | if CurrentSubclassModule_ is not None: |
||
| 11972 | subclass = getSubclassFromModule_( |
||
| 11973 | CurrentSubclassModule_, ChemRegionType) |
||
| 11974 | if subclass is not None: |
||
| 11975 | return subclass(*args_, **kwargs_) |
||
| 11976 | if ChemRegionType.subclass: |
||
| 11977 | return ChemRegionType.subclass(*args_, **kwargs_) |
||
| 11978 | else: |
||
| 11979 | return ChemRegionType(*args_, **kwargs_) |
||
| 11980 | factory = staticmethod(factory) |
||
| 11981 | def get_ns_prefix_(self): |
||
| 11982 | return self.ns_prefix_ |
||
| 11983 | def set_ns_prefix_(self, ns_prefix): |
||
| 11984 | self.ns_prefix_ = ns_prefix |
||
| 11985 | def get_orientation(self): |
||
| 11986 | return self.orientation |
||
| 11987 | def set_orientation(self, orientation): |
||
| 11988 | self.orientation = orientation |
||
| 11989 | def get_bgColour(self): |
||
| 11990 | return self.bgColour |
||
| 11991 | def set_bgColour(self, bgColour): |
||
| 11992 | self.bgColour = bgColour |
||
| 11993 | def validate_ColourSimpleType(self, value): |
||
| 11994 | # Validate type pc:ColourSimpleType, a restriction on string. |
||
| 11995 | if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None: |
||
| 11996 | if not isinstance(value, str): |
||
| 11997 | lineno = self.gds_get_node_lineno_() |
||
| 11998 | self.gds_collector_.add_message('Value "%(value)s"%(lineno)s is not of the correct base simple type (str)' % {"value": value, "lineno": lineno, }) |
||
| 11999 | return False |
||
| 12000 | value = value |
||
| 12001 | enumerations = ['black', 'blue', 'brown', 'cyan', 'green', 'grey', 'indigo', 'magenta', 'orange', 'pink', 'red', 'turquoise', 'violet', 'white', 'yellow', 'other'] |
||
| 12002 | if value not in enumerations: |
||
| 12003 | lineno = self.gds_get_node_lineno_() |
||
| 12004 | self.gds_collector_.add_message('Value "%(value)s"%(lineno)s does not match xsd enumeration restriction on ColourSimpleType' % {"value" : encode_str_2_3(value), "lineno": lineno} ) |
||
| 12005 | result = False |
||
| 12006 | def hasContent_(self): |
||
| 12007 | if ( |
||
| 12008 | super(ChemRegionType, self).hasContent_() |
||
| 12009 | ): |
||
| 12010 | return True |
||
| 12011 | else: |
||
| 12012 | return False |
||
| 12013 | def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='ChemRegionType', pretty_print=True): |
||
| 12014 | imported_ns_def_ = GenerateDSNamespaceDefs_.get('ChemRegionType') |
||
| 12015 | if imported_ns_def_ is not None: |
||
| 12016 | namespacedef_ = imported_ns_def_ |
||
| 12017 | if pretty_print: |
||
| 12018 | eol_ = '\n' |
||
| 12019 | else: |
||
| 12020 | eol_ = '' |
||
| 12021 | if self.original_tagname_ is not None and name_ == 'ChemRegionType': |
||
| 12022 | name_ = self.original_tagname_ |
||
| 12023 | if UseCapturedNS_ and self.ns_prefix_: |
||
| 12024 | namespaceprefix_ = self.ns_prefix_ + ':' |
||
| 12025 | showIndent(outfile, level, pretty_print) |
||
| 12026 | outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) |
||
| 12027 | already_processed = set() |
||
| 12028 | self.exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='ChemRegionType') |
||
| 12029 | if self.hasContent_(): |
||
| 12030 | outfile.write('>%s' % (eol_, )) |
||
| 12031 | self.exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='ChemRegionType', pretty_print=pretty_print) |
||
| 12032 | showIndent(outfile, level, pretty_print) |
||
| 12033 | outfile.write('</%s%s>%s' % (namespaceprefix_, name_, eol_)) |
||
| 12034 | else: |
||
| 12035 | outfile.write('/>%s' % (eol_, )) |
||
| 12036 | def exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='ChemRegionType'): |
||
| 12037 | super(ChemRegionType, self).exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='ChemRegionType') |
||
| 12038 | if self.orientation is not None and 'orientation' not in already_processed: |
||
| 12039 | already_processed.add('orientation') |
||
| 12040 | outfile.write(' orientation="%s"' % self.gds_format_float(self.orientation, input_name='orientation')) |
||
| 12041 | if self.bgColour is not None and 'bgColour' not in already_processed: |
||
| 12042 | already_processed.add('bgColour') |
||
| 12043 | outfile.write(' bgColour=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.bgColour), input_name='bgColour')), )) |
||
| 12044 | def exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='ChemRegionType', fromsubclass_=False, pretty_print=True): |
||
| 12045 | super(ChemRegionType, self).exportChildren(outfile, level, namespaceprefix_, namespacedef_, name_, True, pretty_print=pretty_print) |
||
| 12046 | def to_etree(self, parent_element=None, name_='ChemRegionType', mapping_=None, nsmap_=None): |
||
| 12047 | element = super(ChemRegionType, self).to_etree(parent_element, name_, mapping_) |
||
| 12048 | if self.orientation is not None: |
||
| 12049 | element.set('orientation', self.gds_format_float(self.orientation)) |
||
| 12050 | if self.bgColour is not None: |
||
| 12051 | element.set('bgColour', self.gds_format_string(self.bgColour)) |
||
| 12052 | if mapping_ is not None: |
||
| 12053 | mapping_[id(self)] = element |
||
| 12054 | return element |
||
| 12055 | def build(self, node, gds_collector_=None): |
||
| 12056 | self.gds_collector_ = gds_collector_ |
||
| 12057 | if SaveElementTreeNode: |
||
| 12058 | self.gds_elementtree_node_ = node |
||
| 12059 | already_processed = set() |
||
| 12060 | self.ns_prefix_ = node.prefix |
||
| 12061 | self.buildAttributes(node, node.attrib, already_processed) |
||
| 12062 | for child in node: |
||
| 12063 | nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] |
||
| 12064 | self.buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) |
||
| 12065 | return self |
||
| 12066 | def buildAttributes(self, node, attrs, already_processed): |
||
| 12067 | value = find_attr_value_('orientation', node) |
||
| 12068 | if value is not None and 'orientation' not in already_processed: |
||
| 12069 | already_processed.add('orientation') |
||
| 12070 | value = self.gds_parse_float(value, node, 'orientation') |
||
| 12071 | self.orientation = value |
||
| 12072 | value = find_attr_value_('bgColour', node) |
||
| 12073 | if value is not None and 'bgColour' not in already_processed: |
||
| 12074 | already_processed.add('bgColour') |
||
| 12075 | self.bgColour = value |
||
| 12076 | self.validate_ColourSimpleType(self.bgColour) # validate type ColourSimpleType |
||
| 12077 | super(ChemRegionType, self).buildAttributes(node, attrs, already_processed) |
||
| 12078 | def buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None): |
||
| 12079 | super(ChemRegionType, self).buildChildren(child_, node, nodeName_, True) |
||
| 12080 | pass |
||
| 12081 | def __hash__(self): |
||
| 12082 | return hash(self.id) |
||
| 12083 | def set_orientation(self, orientation): |
||
| 12084 | """ |
||
| 12085 | Set deskewing angle to given `orientation` number. |
||
| 12086 | Moreover, invalidate self's ``pc:AlternativeImage``s |
||
| 12087 | (because they will have been rotated and enlarged |
||
| 12088 | with the angle of the previous value). |
||
| 12089 | """ |
||
| 12090 | if hasattr(self, 'invalidate_AlternativeImage'): |
||
| 12091 | # PageType, RegionType: |
||
| 12092 | self.invalidate_AlternativeImage(feature_selector='deskewed') |
||
| 12093 | self.orientation = orientation |
||
| 12094 | # end class ChemRegionType |
||
| 12095 | |||
| 12096 | |||
| 12097 | View Code Duplication | class MathsRegionType(RegionType): |
|
| 12098 | """Regions containing equations and mathematical symbols |
||
| 12099 | should be marked as maths regions. |
||
| 12100 | The angle the rectangle encapsulating a region |
||
| 12101 | has to be rotated in clockwise direction |
||
| 12102 | in order to correct the present skew |
||
| 12103 | (negative values indicate anti-clockwise rotation). |
||
| 12104 | Range: -179.999,180 |
||
| 12105 | The background colour of the region""" |
||
| 12106 | __hash__ = GeneratedsSuper.__hash__ |
||
| 12107 | member_data_items_ = [ |
||
| 12108 | MemberSpec_('orientation', 'float', 0, 1, {'use': 'optional'}), |
||
| 12109 | MemberSpec_('bgColour', 'pc:ColourSimpleType', 0, 1, {'use': 'optional'}), |
||
| 12110 | ] |
||
| 12111 | subclass = None |
||
| 12112 | superclass = RegionType |
||
| 12113 | def __init__(self, id=None, custom=None, comments=None, continuation=None, AlternativeImage=None, Coords=None, UserDefined=None, Labels=None, Roles=None, TextRegion=None, ImageRegion=None, LineDrawingRegion=None, GraphicRegion=None, TableRegion=None, ChartRegion=None, SeparatorRegion=None, MathsRegion=None, ChemRegion=None, MusicRegion=None, AdvertRegion=None, NoiseRegion=None, UnknownRegion=None, CustomRegion=None, orientation=None, bgColour=None, gds_collector_=None, **kwargs_): |
||
| 12114 | self.gds_collector_ = gds_collector_ |
||
| 12115 | self.gds_elementtree_node_ = None |
||
| 12116 | self.original_tagname_ = None |
||
| 12117 | self.parent_object_ = kwargs_.get('parent_object_') |
||
| 12118 | self.ns_prefix_ = None |
||
| 12119 | super(MathsRegionType, self).__init__(id, custom, comments, continuation, AlternativeImage, Coords, UserDefined, Labels, Roles, TextRegion, ImageRegion, LineDrawingRegion, GraphicRegion, TableRegion, ChartRegion, SeparatorRegion, MathsRegion, ChemRegion, MusicRegion, AdvertRegion, NoiseRegion, UnknownRegion, CustomRegion, **kwargs_) |
||
| 12120 | self.orientation = _cast(float, orientation) |
||
| 12121 | self.orientation_nsprefix_ = "pc" |
||
| 12122 | self.bgColour = _cast(None, bgColour) |
||
| 12123 | self.bgColour_nsprefix_ = "pc" |
||
| 12124 | def factory(*args_, **kwargs_): |
||
| 12125 | if CurrentSubclassModule_ is not None: |
||
| 12126 | subclass = getSubclassFromModule_( |
||
| 12127 | CurrentSubclassModule_, MathsRegionType) |
||
| 12128 | if subclass is not None: |
||
| 12129 | return subclass(*args_, **kwargs_) |
||
| 12130 | if MathsRegionType.subclass: |
||
| 12131 | return MathsRegionType.subclass(*args_, **kwargs_) |
||
| 12132 | else: |
||
| 12133 | return MathsRegionType(*args_, **kwargs_) |
||
| 12134 | factory = staticmethod(factory) |
||
| 12135 | def get_ns_prefix_(self): |
||
| 12136 | return self.ns_prefix_ |
||
| 12137 | def set_ns_prefix_(self, ns_prefix): |
||
| 12138 | self.ns_prefix_ = ns_prefix |
||
| 12139 | def get_orientation(self): |
||
| 12140 | return self.orientation |
||
| 12141 | def set_orientation(self, orientation): |
||
| 12142 | self.orientation = orientation |
||
| 12143 | def get_bgColour(self): |
||
| 12144 | return self.bgColour |
||
| 12145 | def set_bgColour(self, bgColour): |
||
| 12146 | self.bgColour = bgColour |
||
| 12147 | def validate_ColourSimpleType(self, value): |
||
| 12148 | # Validate type pc:ColourSimpleType, a restriction on string. |
||
| 12149 | if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None: |
||
| 12150 | if not isinstance(value, str): |
||
| 12151 | lineno = self.gds_get_node_lineno_() |
||
| 12152 | self.gds_collector_.add_message('Value "%(value)s"%(lineno)s is not of the correct base simple type (str)' % {"value": value, "lineno": lineno, }) |
||
| 12153 | return False |
||
| 12154 | value = value |
||
| 12155 | enumerations = ['black', 'blue', 'brown', 'cyan', 'green', 'grey', 'indigo', 'magenta', 'orange', 'pink', 'red', 'turquoise', 'violet', 'white', 'yellow', 'other'] |
||
| 12156 | if value not in enumerations: |
||
| 12157 | lineno = self.gds_get_node_lineno_() |
||
| 12158 | self.gds_collector_.add_message('Value "%(value)s"%(lineno)s does not match xsd enumeration restriction on ColourSimpleType' % {"value" : encode_str_2_3(value), "lineno": lineno} ) |
||
| 12159 | result = False |
||
| 12160 | def hasContent_(self): |
||
| 12161 | if ( |
||
| 12162 | super(MathsRegionType, self).hasContent_() |
||
| 12163 | ): |
||
| 12164 | return True |
||
| 12165 | else: |
||
| 12166 | return False |
||
| 12167 | def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='MathsRegionType', pretty_print=True): |
||
| 12168 | imported_ns_def_ = GenerateDSNamespaceDefs_.get('MathsRegionType') |
||
| 12169 | if imported_ns_def_ is not None: |
||
| 12170 | namespacedef_ = imported_ns_def_ |
||
| 12171 | if pretty_print: |
||
| 12172 | eol_ = '\n' |
||
| 12173 | else: |
||
| 12174 | eol_ = '' |
||
| 12175 | if self.original_tagname_ is not None and name_ == 'MathsRegionType': |
||
| 12176 | name_ = self.original_tagname_ |
||
| 12177 | if UseCapturedNS_ and self.ns_prefix_: |
||
| 12178 | namespaceprefix_ = self.ns_prefix_ + ':' |
||
| 12179 | showIndent(outfile, level, pretty_print) |
||
| 12180 | outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) |
||
| 12181 | already_processed = set() |
||
| 12182 | self.exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='MathsRegionType') |
||
| 12183 | if self.hasContent_(): |
||
| 12184 | outfile.write('>%s' % (eol_, )) |
||
| 12185 | self.exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='MathsRegionType', pretty_print=pretty_print) |
||
| 12186 | showIndent(outfile, level, pretty_print) |
||
| 12187 | outfile.write('</%s%s>%s' % (namespaceprefix_, name_, eol_)) |
||
| 12188 | else: |
||
| 12189 | outfile.write('/>%s' % (eol_, )) |
||
| 12190 | def exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='MathsRegionType'): |
||
| 12191 | super(MathsRegionType, self).exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='MathsRegionType') |
||
| 12192 | if self.orientation is not None and 'orientation' not in already_processed: |
||
| 12193 | already_processed.add('orientation') |
||
| 12194 | outfile.write(' orientation="%s"' % self.gds_format_float(self.orientation, input_name='orientation')) |
||
| 12195 | if self.bgColour is not None and 'bgColour' not in already_processed: |
||
| 12196 | already_processed.add('bgColour') |
||
| 12197 | outfile.write(' bgColour=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.bgColour), input_name='bgColour')), )) |
||
| 12198 | def exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='MathsRegionType', fromsubclass_=False, pretty_print=True): |
||
| 12199 | super(MathsRegionType, self).exportChildren(outfile, level, namespaceprefix_, namespacedef_, name_, True, pretty_print=pretty_print) |
||
| 12200 | def to_etree(self, parent_element=None, name_='MathsRegionType', mapping_=None, nsmap_=None): |
||
| 12201 | element = super(MathsRegionType, self).to_etree(parent_element, name_, mapping_) |
||
| 12202 | if self.orientation is not None: |
||
| 12203 | element.set('orientation', self.gds_format_float(self.orientation)) |
||
| 12204 | if self.bgColour is not None: |
||
| 12205 | element.set('bgColour', self.gds_format_string(self.bgColour)) |
||
| 12206 | if mapping_ is not None: |
||
| 12207 | mapping_[id(self)] = element |
||
| 12208 | return element |
||
| 12209 | def build(self, node, gds_collector_=None): |
||
| 12210 | self.gds_collector_ = gds_collector_ |
||
| 12211 | if SaveElementTreeNode: |
||
| 12212 | self.gds_elementtree_node_ = node |
||
| 12213 | already_processed = set() |
||
| 12214 | self.ns_prefix_ = node.prefix |
||
| 12215 | self.buildAttributes(node, node.attrib, already_processed) |
||
| 12216 | for child in node: |
||
| 12217 | nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] |
||
| 12218 | self.buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) |
||
| 12219 | return self |
||
| 12220 | def buildAttributes(self, node, attrs, already_processed): |
||
| 12221 | value = find_attr_value_('orientation', node) |
||
| 12222 | if value is not None and 'orientation' not in already_processed: |
||
| 12223 | already_processed.add('orientation') |
||
| 12224 | value = self.gds_parse_float(value, node, 'orientation') |
||
| 12225 | self.orientation = value |
||
| 12226 | value = find_attr_value_('bgColour', node) |
||
| 12227 | if value is not None and 'bgColour' not in already_processed: |
||
| 12228 | already_processed.add('bgColour') |
||
| 12229 | self.bgColour = value |
||
| 12230 | self.validate_ColourSimpleType(self.bgColour) # validate type ColourSimpleType |
||
| 12231 | super(MathsRegionType, self).buildAttributes(node, attrs, already_processed) |
||
| 12232 | def buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None): |
||
| 12233 | super(MathsRegionType, self).buildChildren(child_, node, nodeName_, True) |
||
| 12234 | pass |
||
| 12235 | def __hash__(self): |
||
| 12236 | return hash(self.id) |
||
| 12237 | def set_orientation(self, orientation): |
||
| 12238 | """ |
||
| 12239 | Set deskewing angle to given `orientation` number. |
||
| 12240 | Moreover, invalidate self's ``pc:AlternativeImage``s |
||
| 12241 | (because they will have been rotated and enlarged |
||
| 12242 | with the angle of the previous value). |
||
| 12243 | """ |
||
| 12244 | if hasattr(self, 'invalidate_AlternativeImage'): |
||
| 12245 | # PageType, RegionType: |
||
| 12246 | self.invalidate_AlternativeImage(feature_selector='deskewed') |
||
| 12247 | self.orientation = orientation |
||
| 12248 | # end class MathsRegionType |
||
| 12249 | |||
| 12250 | |||
| 12251 | View Code Duplication | class SeparatorRegionType(RegionType): |
|
| 12252 | """Separators are lines that lie between columns and |
||
| 12253 | paragraphs and can be used to logically separate |
||
| 12254 | different articles from each other. |
||
| 12255 | The angle the rectangle encapsulating a region |
||
| 12256 | has to be rotated in clockwise direction |
||
| 12257 | in order to correct the present skew |
||
| 12258 | (negative values indicate anti-clockwise rotation). |
||
| 12259 | Range: -179.999,180 |
||
| 12260 | The colour of the separator""" |
||
| 12261 | __hash__ = GeneratedsSuper.__hash__ |
||
| 12262 | member_data_items_ = [ |
||
| 12263 | MemberSpec_('orientation', 'float', 0, 1, {'use': 'optional'}), |
||
| 12264 | MemberSpec_('colour', 'pc:ColourSimpleType', 0, 1, {'use': 'optional'}), |
||
| 12265 | ] |
||
| 12266 | subclass = None |
||
| 12267 | superclass = RegionType |
||
| 12268 | def __init__(self, id=None, custom=None, comments=None, continuation=None, AlternativeImage=None, Coords=None, UserDefined=None, Labels=None, Roles=None, TextRegion=None, ImageRegion=None, LineDrawingRegion=None, GraphicRegion=None, TableRegion=None, ChartRegion=None, SeparatorRegion=None, MathsRegion=None, ChemRegion=None, MusicRegion=None, AdvertRegion=None, NoiseRegion=None, UnknownRegion=None, CustomRegion=None, orientation=None, colour=None, gds_collector_=None, **kwargs_): |
||
| 12269 | self.gds_collector_ = gds_collector_ |
||
| 12270 | self.gds_elementtree_node_ = None |
||
| 12271 | self.original_tagname_ = None |
||
| 12272 | self.parent_object_ = kwargs_.get('parent_object_') |
||
| 12273 | self.ns_prefix_ = None |
||
| 12274 | super(SeparatorRegionType, self).__init__(id, custom, comments, continuation, AlternativeImage, Coords, UserDefined, Labels, Roles, TextRegion, ImageRegion, LineDrawingRegion, GraphicRegion, TableRegion, ChartRegion, SeparatorRegion, MathsRegion, ChemRegion, MusicRegion, AdvertRegion, NoiseRegion, UnknownRegion, CustomRegion, **kwargs_) |
||
| 12275 | self.orientation = _cast(float, orientation) |
||
| 12276 | self.orientation_nsprefix_ = "pc" |
||
| 12277 | self.colour = _cast(None, colour) |
||
| 12278 | self.colour_nsprefix_ = "pc" |
||
| 12279 | def factory(*args_, **kwargs_): |
||
| 12280 | if CurrentSubclassModule_ is not None: |
||
| 12281 | subclass = getSubclassFromModule_( |
||
| 12282 | CurrentSubclassModule_, SeparatorRegionType) |
||
| 12283 | if subclass is not None: |
||
| 12284 | return subclass(*args_, **kwargs_) |
||
| 12285 | if SeparatorRegionType.subclass: |
||
| 12286 | return SeparatorRegionType.subclass(*args_, **kwargs_) |
||
| 12287 | else: |
||
| 12288 | return SeparatorRegionType(*args_, **kwargs_) |
||
| 12289 | factory = staticmethod(factory) |
||
| 12290 | def get_ns_prefix_(self): |
||
| 12291 | return self.ns_prefix_ |
||
| 12292 | def set_ns_prefix_(self, ns_prefix): |
||
| 12293 | self.ns_prefix_ = ns_prefix |
||
| 12294 | def get_orientation(self): |
||
| 12295 | return self.orientation |
||
| 12296 | def set_orientation(self, orientation): |
||
| 12297 | self.orientation = orientation |
||
| 12298 | def get_colour(self): |
||
| 12299 | return self.colour |
||
| 12300 | def set_colour(self, colour): |
||
| 12301 | self.colour = colour |
||
| 12302 | def validate_ColourSimpleType(self, value): |
||
| 12303 | # Validate type pc:ColourSimpleType, a restriction on string. |
||
| 12304 | if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None: |
||
| 12305 | if not isinstance(value, str): |
||
| 12306 | lineno = self.gds_get_node_lineno_() |
||
| 12307 | self.gds_collector_.add_message('Value "%(value)s"%(lineno)s is not of the correct base simple type (str)' % {"value": value, "lineno": lineno, }) |
||
| 12308 | return False |
||
| 12309 | value = value |
||
| 12310 | enumerations = ['black', 'blue', 'brown', 'cyan', 'green', 'grey', 'indigo', 'magenta', 'orange', 'pink', 'red', 'turquoise', 'violet', 'white', 'yellow', 'other'] |
||
| 12311 | if value not in enumerations: |
||
| 12312 | lineno = self.gds_get_node_lineno_() |
||
| 12313 | self.gds_collector_.add_message('Value "%(value)s"%(lineno)s does not match xsd enumeration restriction on ColourSimpleType' % {"value" : encode_str_2_3(value), "lineno": lineno} ) |
||
| 12314 | result = False |
||
| 12315 | def hasContent_(self): |
||
| 12316 | if ( |
||
| 12317 | super(SeparatorRegionType, self).hasContent_() |
||
| 12318 | ): |
||
| 12319 | return True |
||
| 12320 | else: |
||
| 12321 | return False |
||
| 12322 | def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='SeparatorRegionType', pretty_print=True): |
||
| 12323 | imported_ns_def_ = GenerateDSNamespaceDefs_.get('SeparatorRegionType') |
||
| 12324 | if imported_ns_def_ is not None: |
||
| 12325 | namespacedef_ = imported_ns_def_ |
||
| 12326 | if pretty_print: |
||
| 12327 | eol_ = '\n' |
||
| 12328 | else: |
||
| 12329 | eol_ = '' |
||
| 12330 | if self.original_tagname_ is not None and name_ == 'SeparatorRegionType': |
||
| 12331 | name_ = self.original_tagname_ |
||
| 12332 | if UseCapturedNS_ and self.ns_prefix_: |
||
| 12333 | namespaceprefix_ = self.ns_prefix_ + ':' |
||
| 12334 | showIndent(outfile, level, pretty_print) |
||
| 12335 | outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) |
||
| 12336 | already_processed = set() |
||
| 12337 | self.exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='SeparatorRegionType') |
||
| 12338 | if self.hasContent_(): |
||
| 12339 | outfile.write('>%s' % (eol_, )) |
||
| 12340 | self.exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='SeparatorRegionType', pretty_print=pretty_print) |
||
| 12341 | showIndent(outfile, level, pretty_print) |
||
| 12342 | outfile.write('</%s%s>%s' % (namespaceprefix_, name_, eol_)) |
||
| 12343 | else: |
||
| 12344 | outfile.write('/>%s' % (eol_, )) |
||
| 12345 | def exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='SeparatorRegionType'): |
||
| 12346 | super(SeparatorRegionType, self).exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='SeparatorRegionType') |
||
| 12347 | if self.orientation is not None and 'orientation' not in already_processed: |
||
| 12348 | already_processed.add('orientation') |
||
| 12349 | outfile.write(' orientation="%s"' % self.gds_format_float(self.orientation, input_name='orientation')) |
||
| 12350 | if self.colour is not None and 'colour' not in already_processed: |
||
| 12351 | already_processed.add('colour') |
||
| 12352 | outfile.write(' colour=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.colour), input_name='colour')), )) |
||
| 12353 | def exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='SeparatorRegionType', fromsubclass_=False, pretty_print=True): |
||
| 12354 | super(SeparatorRegionType, self).exportChildren(outfile, level, namespaceprefix_, namespacedef_, name_, True, pretty_print=pretty_print) |
||
| 12355 | def to_etree(self, parent_element=None, name_='SeparatorRegionType', mapping_=None, nsmap_=None): |
||
| 12356 | element = super(SeparatorRegionType, self).to_etree(parent_element, name_, mapping_) |
||
| 12357 | if self.orientation is not None: |
||
| 12358 | element.set('orientation', self.gds_format_float(self.orientation)) |
||
| 12359 | if self.colour is not None: |
||
| 12360 | element.set('colour', self.gds_format_string(self.colour)) |
||
| 12361 | if mapping_ is not None: |
||
| 12362 | mapping_[id(self)] = element |
||
| 12363 | return element |
||
| 12364 | def build(self, node, gds_collector_=None): |
||
| 12365 | self.gds_collector_ = gds_collector_ |
||
| 12366 | if SaveElementTreeNode: |
||
| 12367 | self.gds_elementtree_node_ = node |
||
| 12368 | already_processed = set() |
||
| 12369 | self.ns_prefix_ = node.prefix |
||
| 12370 | self.buildAttributes(node, node.attrib, already_processed) |
||
| 12371 | for child in node: |
||
| 12372 | nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] |
||
| 12373 | self.buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) |
||
| 12374 | return self |
||
| 12375 | def buildAttributes(self, node, attrs, already_processed): |
||
| 12376 | value = find_attr_value_('orientation', node) |
||
| 12377 | if value is not None and 'orientation' not in already_processed: |
||
| 12378 | already_processed.add('orientation') |
||
| 12379 | value = self.gds_parse_float(value, node, 'orientation') |
||
| 12380 | self.orientation = value |
||
| 12381 | value = find_attr_value_('colour', node) |
||
| 12382 | if value is not None and 'colour' not in already_processed: |
||
| 12383 | already_processed.add('colour') |
||
| 12384 | self.colour = value |
||
| 12385 | self.validate_ColourSimpleType(self.colour) # validate type ColourSimpleType |
||
| 12386 | super(SeparatorRegionType, self).buildAttributes(node, attrs, already_processed) |
||
| 12387 | def buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None): |
||
| 12388 | super(SeparatorRegionType, self).buildChildren(child_, node, nodeName_, True) |
||
| 12389 | pass |
||
| 12390 | def __hash__(self): |
||
| 12391 | return hash(self.id) |
||
| 12392 | def set_orientation(self, orientation): |
||
| 12393 | """ |
||
| 12394 | Set deskewing angle to given `orientation` number. |
||
| 12395 | Moreover, invalidate self's ``pc:AlternativeImage``s |
||
| 12396 | (because they will have been rotated and enlarged |
||
| 12397 | with the angle of the previous value). |
||
| 12398 | """ |
||
| 12399 | if hasattr(self, 'invalidate_AlternativeImage'): |
||
| 12400 | # PageType, RegionType: |
||
| 12401 | self.invalidate_AlternativeImage(feature_selector='deskewed') |
||
| 12402 | self.orientation = orientation |
||
| 12403 | # end class SeparatorRegionType |
||
| 12404 | |||
| 12405 | |||
| 12406 | class ChartRegionType(RegionType): |
||
| 12407 | """Regions containing charts or graphs of any type, should |
||
| 12408 | be marked as chart regions. |
||
| 12409 | The angle the rectangle encapsulating a region |
||
| 12410 | has to be rotated in clockwise direction |
||
| 12411 | in order to correct the present skew |
||
| 12412 | (negative values indicate anti-clockwise rotation). |
||
| 12413 | Range: -179.999,180 |
||
| 12414 | The type of chart in the region |
||
| 12415 | An approximation of the number of colours |
||
| 12416 | used in the region |
||
| 12417 | The background colour of the region |
||
| 12418 | Specifies whether the region also contains |
||
| 12419 | text""" |
||
| 12420 | __hash__ = GeneratedsSuper.__hash__ |
||
| 12421 | member_data_items_ = [ |
||
| 12422 | MemberSpec_('orientation', 'float', 0, 1, {'use': 'optional'}), |
||
| 12423 | MemberSpec_('type_', 'pc:ChartTypeSimpleType', 0, 1, {'use': 'optional'}), |
||
| 12424 | MemberSpec_('numColours', 'int', 0, 1, {'use': 'optional'}), |
||
| 12425 | MemberSpec_('bgColour', 'pc:ColourSimpleType', 0, 1, {'use': 'optional'}), |
||
| 12426 | MemberSpec_('embText', 'boolean', 0, 1, {'use': 'optional'}), |
||
| 12427 | ] |
||
| 12428 | subclass = None |
||
| 12429 | superclass = RegionType |
||
| 12430 | def __init__(self, id=None, custom=None, comments=None, continuation=None, AlternativeImage=None, Coords=None, UserDefined=None, Labels=None, Roles=None, TextRegion=None, ImageRegion=None, LineDrawingRegion=None, GraphicRegion=None, TableRegion=None, ChartRegion=None, SeparatorRegion=None, MathsRegion=None, ChemRegion=None, MusicRegion=None, AdvertRegion=None, NoiseRegion=None, UnknownRegion=None, CustomRegion=None, orientation=None, type_=None, numColours=None, bgColour=None, embText=None, gds_collector_=None, **kwargs_): |
||
| 12431 | self.gds_collector_ = gds_collector_ |
||
| 12432 | self.gds_elementtree_node_ = None |
||
| 12433 | self.original_tagname_ = None |
||
| 12434 | self.parent_object_ = kwargs_.get('parent_object_') |
||
| 12435 | self.ns_prefix_ = None |
||
| 12436 | super(ChartRegionType, self).__init__(id, custom, comments, continuation, AlternativeImage, Coords, UserDefined, Labels, Roles, TextRegion, ImageRegion, LineDrawingRegion, GraphicRegion, TableRegion, ChartRegion, SeparatorRegion, MathsRegion, ChemRegion, MusicRegion, AdvertRegion, NoiseRegion, UnknownRegion, CustomRegion, **kwargs_) |
||
| 12437 | self.orientation = _cast(float, orientation) |
||
| 12438 | self.orientation_nsprefix_ = "pc" |
||
| 12439 | self.type_ = _cast(None, type_) |
||
| 12440 | self.type__nsprefix_ = "pc" |
||
| 12441 | self.numColours = _cast(int, numColours) |
||
| 12442 | self.numColours_nsprefix_ = "pc" |
||
| 12443 | self.bgColour = _cast(None, bgColour) |
||
| 12444 | self.bgColour_nsprefix_ = "pc" |
||
| 12445 | self.embText = _cast(bool, embText) |
||
| 12446 | self.embText_nsprefix_ = "pc" |
||
| 12447 | def factory(*args_, **kwargs_): |
||
| 12448 | if CurrentSubclassModule_ is not None: |
||
| 12449 | subclass = getSubclassFromModule_( |
||
| 12450 | CurrentSubclassModule_, ChartRegionType) |
||
| 12451 | if subclass is not None: |
||
| 12452 | return subclass(*args_, **kwargs_) |
||
| 12453 | if ChartRegionType.subclass: |
||
| 12454 | return ChartRegionType.subclass(*args_, **kwargs_) |
||
| 12455 | else: |
||
| 12456 | return ChartRegionType(*args_, **kwargs_) |
||
| 12457 | factory = staticmethod(factory) |
||
| 12458 | def get_ns_prefix_(self): |
||
| 12459 | return self.ns_prefix_ |
||
| 12460 | def set_ns_prefix_(self, ns_prefix): |
||
| 12461 | self.ns_prefix_ = ns_prefix |
||
| 12462 | def get_orientation(self): |
||
| 12463 | return self.orientation |
||
| 12464 | def set_orientation(self, orientation): |
||
| 12465 | self.orientation = orientation |
||
| 12466 | def get_type(self): |
||
| 12467 | return self.type_ |
||
| 12468 | def set_type(self, type_): |
||
| 12469 | self.type_ = type_ |
||
| 12470 | def get_numColours(self): |
||
| 12471 | return self.numColours |
||
| 12472 | def set_numColours(self, numColours): |
||
| 12473 | self.numColours = numColours |
||
| 12474 | def get_bgColour(self): |
||
| 12475 | return self.bgColour |
||
| 12476 | def set_bgColour(self, bgColour): |
||
| 12477 | self.bgColour = bgColour |
||
| 12478 | def get_embText(self): |
||
| 12479 | return self.embText |
||
| 12480 | def set_embText(self, embText): |
||
| 12481 | self.embText = embText |
||
| 12482 | def validate_ChartTypeSimpleType(self, value): |
||
| 12483 | # Validate type pc:ChartTypeSimpleType, a restriction on string. |
||
| 12484 | if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None: |
||
| 12485 | if not isinstance(value, str): |
||
| 12486 | lineno = self.gds_get_node_lineno_() |
||
| 12487 | self.gds_collector_.add_message('Value "%(value)s"%(lineno)s is not of the correct base simple type (str)' % {"value": value, "lineno": lineno, }) |
||
| 12488 | return False |
||
| 12489 | value = value |
||
| 12490 | enumerations = ['bar', 'line', 'pie', 'scatter', 'surface', 'other'] |
||
| 12491 | if value not in enumerations: |
||
| 12492 | lineno = self.gds_get_node_lineno_() |
||
| 12493 | self.gds_collector_.add_message('Value "%(value)s"%(lineno)s does not match xsd enumeration restriction on ChartTypeSimpleType' % {"value" : encode_str_2_3(value), "lineno": lineno} ) |
||
| 12494 | result = False |
||
| 12495 | def validate_ColourSimpleType(self, value): |
||
| 12496 | # Validate type pc:ColourSimpleType, a restriction on string. |
||
| 12497 | if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None: |
||
| 12498 | if not isinstance(value, str): |
||
| 12499 | lineno = self.gds_get_node_lineno_() |
||
| 12500 | self.gds_collector_.add_message('Value "%(value)s"%(lineno)s is not of the correct base simple type (str)' % {"value": value, "lineno": lineno, }) |
||
| 12501 | return False |
||
| 12502 | value = value |
||
| 12503 | enumerations = ['black', 'blue', 'brown', 'cyan', 'green', 'grey', 'indigo', 'magenta', 'orange', 'pink', 'red', 'turquoise', 'violet', 'white', 'yellow', 'other'] |
||
| 12504 | if value not in enumerations: |
||
| 12505 | lineno = self.gds_get_node_lineno_() |
||
| 12506 | self.gds_collector_.add_message('Value "%(value)s"%(lineno)s does not match xsd enumeration restriction on ColourSimpleType' % {"value" : encode_str_2_3(value), "lineno": lineno} ) |
||
| 12507 | result = False |
||
| 12508 | def hasContent_(self): |
||
| 12509 | if ( |
||
| 12510 | super(ChartRegionType, self).hasContent_() |
||
| 12511 | ): |
||
| 12512 | return True |
||
| 12513 | else: |
||
| 12514 | return False |
||
| 12515 | def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='ChartRegionType', pretty_print=True): |
||
| 12516 | imported_ns_def_ = GenerateDSNamespaceDefs_.get('ChartRegionType') |
||
| 12517 | if imported_ns_def_ is not None: |
||
| 12518 | namespacedef_ = imported_ns_def_ |
||
| 12519 | if pretty_print: |
||
| 12520 | eol_ = '\n' |
||
| 12521 | else: |
||
| 12522 | eol_ = '' |
||
| 12523 | if self.original_tagname_ is not None and name_ == 'ChartRegionType': |
||
| 12524 | name_ = self.original_tagname_ |
||
| 12525 | if UseCapturedNS_ and self.ns_prefix_: |
||
| 12526 | namespaceprefix_ = self.ns_prefix_ + ':' |
||
| 12527 | showIndent(outfile, level, pretty_print) |
||
| 12528 | outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) |
||
| 12529 | already_processed = set() |
||
| 12530 | self.exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='ChartRegionType') |
||
| 12531 | if self.hasContent_(): |
||
| 12532 | outfile.write('>%s' % (eol_, )) |
||
| 12533 | self.exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='ChartRegionType', pretty_print=pretty_print) |
||
| 12534 | showIndent(outfile, level, pretty_print) |
||
| 12535 | outfile.write('</%s%s>%s' % (namespaceprefix_, name_, eol_)) |
||
| 12536 | else: |
||
| 12537 | outfile.write('/>%s' % (eol_, )) |
||
| 12538 | def exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='ChartRegionType'): |
||
| 12539 | super(ChartRegionType, self).exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='ChartRegionType') |
||
| 12540 | if self.orientation is not None and 'orientation' not in already_processed: |
||
| 12541 | already_processed.add('orientation') |
||
| 12542 | outfile.write(' orientation="%s"' % self.gds_format_float(self.orientation, input_name='orientation')) |
||
| 12543 | if self.type_ is not None and 'type_' not in already_processed: |
||
| 12544 | already_processed.add('type_') |
||
| 12545 | outfile.write(' type=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.type_), input_name='type')), )) |
||
| 12546 | if self.numColours is not None and 'numColours' not in already_processed: |
||
| 12547 | already_processed.add('numColours') |
||
| 12548 | outfile.write(' numColours="%s"' % self.gds_format_integer(self.numColours, input_name='numColours')) |
||
| 12549 | if self.bgColour is not None and 'bgColour' not in already_processed: |
||
| 12550 | already_processed.add('bgColour') |
||
| 12551 | outfile.write(' bgColour=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.bgColour), input_name='bgColour')), )) |
||
| 12552 | if self.embText is not None and 'embText' not in already_processed: |
||
| 12553 | already_processed.add('embText') |
||
| 12554 | outfile.write(' embText="%s"' % self.gds_format_boolean(self.embText, input_name='embText')) |
||
| 12555 | def exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='ChartRegionType', fromsubclass_=False, pretty_print=True): |
||
| 12556 | super(ChartRegionType, self).exportChildren(outfile, level, namespaceprefix_, namespacedef_, name_, True, pretty_print=pretty_print) |
||
| 12557 | def to_etree(self, parent_element=None, name_='ChartRegionType', mapping_=None, nsmap_=None): |
||
| 12558 | element = super(ChartRegionType, self).to_etree(parent_element, name_, mapping_) |
||
| 12559 | if self.orientation is not None: |
||
| 12560 | element.set('orientation', self.gds_format_float(self.orientation)) |
||
| 12561 | if self.type_ is not None: |
||
| 12562 | element.set('type', self.gds_format_string(self.type_)) |
||
| 12563 | if self.numColours is not None: |
||
| 12564 | element.set('numColours', self.gds_format_integer(self.numColours)) |
||
| 12565 | if self.bgColour is not None: |
||
| 12566 | element.set('bgColour', self.gds_format_string(self.bgColour)) |
||
| 12567 | if self.embText is not None: |
||
| 12568 | element.set('embText', self.gds_format_boolean(self.embText)) |
||
| 12569 | if mapping_ is not None: |
||
| 12570 | mapping_[id(self)] = element |
||
| 12571 | return element |
||
| 12572 | def build(self, node, gds_collector_=None): |
||
| 12573 | self.gds_collector_ = gds_collector_ |
||
| 12574 | if SaveElementTreeNode: |
||
| 12575 | self.gds_elementtree_node_ = node |
||
| 12576 | already_processed = set() |
||
| 12577 | self.ns_prefix_ = node.prefix |
||
| 12578 | self.buildAttributes(node, node.attrib, already_processed) |
||
| 12579 | for child in node: |
||
| 12580 | nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] |
||
| 12581 | self.buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) |
||
| 12582 | return self |
||
| 12583 | def buildAttributes(self, node, attrs, already_processed): |
||
| 12584 | value = find_attr_value_('orientation', node) |
||
| 12585 | if value is not None and 'orientation' not in already_processed: |
||
| 12586 | already_processed.add('orientation') |
||
| 12587 | value = self.gds_parse_float(value, node, 'orientation') |
||
| 12588 | self.orientation = value |
||
| 12589 | value = find_attr_value_('type', node) |
||
| 12590 | if value is not None and 'type' not in already_processed: |
||
| 12591 | already_processed.add('type') |
||
| 12592 | self.type_ = value |
||
| 12593 | self.validate_ChartTypeSimpleType(self.type_) # validate type ChartTypeSimpleType |
||
| 12594 | value = find_attr_value_('numColours', node) |
||
| 12595 | if value is not None and 'numColours' not in already_processed: |
||
| 12596 | already_processed.add('numColours') |
||
| 12597 | self.numColours = self.gds_parse_integer(value, node, 'numColours') |
||
| 12598 | value = find_attr_value_('bgColour', node) |
||
| 12599 | if value is not None and 'bgColour' not in already_processed: |
||
| 12600 | already_processed.add('bgColour') |
||
| 12601 | self.bgColour = value |
||
| 12602 | self.validate_ColourSimpleType(self.bgColour) # validate type ColourSimpleType |
||
| 12603 | value = find_attr_value_('embText', node) |
||
| 12604 | if value is not None and 'embText' not in already_processed: |
||
| 12605 | already_processed.add('embText') |
||
| 12606 | if value in ('true', '1'): |
||
| 12607 | self.embText = True |
||
| 12608 | elif value in ('false', '0'): |
||
| 12609 | self.embText = False |
||
| 12610 | else: |
||
| 12611 | raise_parse_error(node, 'Bad boolean attribute') |
||
| 12612 | super(ChartRegionType, self).buildAttributes(node, attrs, already_processed) |
||
| 12613 | def buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None): |
||
| 12614 | super(ChartRegionType, self).buildChildren(child_, node, nodeName_, True) |
||
| 12615 | pass |
||
| 12616 | def __hash__(self): |
||
| 12617 | return hash(self.id) |
||
| 12618 | def set_orientation(self, orientation): |
||
| 12619 | """ |
||
| 12620 | Set deskewing angle to given `orientation` number. |
||
| 12621 | Moreover, invalidate self's ``pc:AlternativeImage``s |
||
| 12622 | (because they will have been rotated and enlarged |
||
| 12623 | with the angle of the previous value). |
||
| 12624 | """ |
||
| 12625 | if hasattr(self, 'invalidate_AlternativeImage'): |
||
| 12626 | # PageType, RegionType: |
||
| 12627 | self.invalidate_AlternativeImage(feature_selector='deskewed') |
||
| 12628 | self.orientation = orientation |
||
| 12629 | # end class ChartRegionType |
||
| 12630 | |||
| 12631 | |||
| 12632 | class TableRegionType(RegionType): |
||
| 12633 | """Tabular data in any form is represented with a table |
||
| 12634 | region. Rows and columns may or may not have separator |
||
| 12635 | lines; these lines are not separator regions. |
||
| 12636 | The angle the rectangle encapsulating a region |
||
| 12637 | has to be rotated in clockwise direction |
||
| 12638 | in order to correct the present skew |
||
| 12639 | (negative values indicate anti-clockwise rotation). |
||
| 12640 | Range: -179.999,180 |
||
| 12641 | The number of rows present in the table |
||
| 12642 | The number of columns present in the table |
||
| 12643 | The colour of the lines used in the region |
||
| 12644 | The background colour of the region |
||
| 12645 | Specifies the presence of line separators |
||
| 12646 | Specifies whether the region also contains |
||
| 12647 | text""" |
||
| 12648 | __hash__ = GeneratedsSuper.__hash__ |
||
| 12649 | member_data_items_ = [ |
||
| 12650 | MemberSpec_('orientation', 'float', 0, 1, {'use': 'optional'}), |
||
| 12651 | MemberSpec_('rows', 'int', 0, 1, {'use': 'optional'}), |
||
| 12652 | MemberSpec_('columns', 'int', 0, 1, {'use': 'optional'}), |
||
| 12653 | MemberSpec_('lineColour', 'pc:ColourSimpleType', 0, 1, {'use': 'optional'}), |
||
| 12654 | MemberSpec_('bgColour', 'pc:ColourSimpleType', 0, 1, {'use': 'optional'}), |
||
| 12655 | MemberSpec_('lineSeparators', 'boolean', 0, 1, {'use': 'optional'}), |
||
| 12656 | MemberSpec_('embText', 'boolean', 0, 1, {'use': 'optional'}), |
||
| 12657 | MemberSpec_('Grid', 'GridType', 0, 1, {'maxOccurs': '1', 'minOccurs': '0', 'name': 'Grid', 'type': 'GridType'}, None), |
||
| 12658 | ] |
||
| 12659 | subclass = None |
||
| 12660 | superclass = RegionType |
||
| 12661 | def __init__(self, id=None, custom=None, comments=None, continuation=None, AlternativeImage=None, Coords=None, UserDefined=None, Labels=None, Roles=None, TextRegion=None, ImageRegion=None, LineDrawingRegion=None, GraphicRegion=None, TableRegion=None, ChartRegion=None, SeparatorRegion=None, MathsRegion=None, ChemRegion=None, MusicRegion=None, AdvertRegion=None, NoiseRegion=None, UnknownRegion=None, CustomRegion=None, orientation=None, rows=None, columns=None, lineColour=None, bgColour=None, lineSeparators=None, embText=None, Grid=None, gds_collector_=None, **kwargs_): |
||
| 12662 | self.gds_collector_ = gds_collector_ |
||
| 12663 | self.gds_elementtree_node_ = None |
||
| 12664 | self.original_tagname_ = None |
||
| 12665 | self.parent_object_ = kwargs_.get('parent_object_') |
||
| 12666 | self.ns_prefix_ = None |
||
| 12667 | super(TableRegionType, self).__init__(id, custom, comments, continuation, AlternativeImage, Coords, UserDefined, Labels, Roles, TextRegion, ImageRegion, LineDrawingRegion, GraphicRegion, TableRegion, ChartRegion, SeparatorRegion, MathsRegion, ChemRegion, MusicRegion, AdvertRegion, NoiseRegion, UnknownRegion, CustomRegion, **kwargs_) |
||
| 12668 | self.orientation = _cast(float, orientation) |
||
| 12669 | self.orientation_nsprefix_ = "pc" |
||
| 12670 | self.rows = _cast(int, rows) |
||
| 12671 | self.rows_nsprefix_ = "pc" |
||
| 12672 | self.columns = _cast(int, columns) |
||
| 12673 | self.columns_nsprefix_ = "pc" |
||
| 12674 | self.lineColour = _cast(None, lineColour) |
||
| 12675 | self.lineColour_nsprefix_ = "pc" |
||
| 12676 | self.bgColour = _cast(None, bgColour) |
||
| 12677 | self.bgColour_nsprefix_ = "pc" |
||
| 12678 | self.lineSeparators = _cast(bool, lineSeparators) |
||
| 12679 | self.lineSeparators_nsprefix_ = "pc" |
||
| 12680 | self.embText = _cast(bool, embText) |
||
| 12681 | self.embText_nsprefix_ = "pc" |
||
| 12682 | self.Grid = Grid |
||
| 12683 | self.Grid_nsprefix_ = "pc" |
||
| 12684 | def factory(*args_, **kwargs_): |
||
| 12685 | if CurrentSubclassModule_ is not None: |
||
| 12686 | subclass = getSubclassFromModule_( |
||
| 12687 | CurrentSubclassModule_, TableRegionType) |
||
| 12688 | if subclass is not None: |
||
| 12689 | return subclass(*args_, **kwargs_) |
||
| 12690 | if TableRegionType.subclass: |
||
| 12691 | return TableRegionType.subclass(*args_, **kwargs_) |
||
| 12692 | else: |
||
| 12693 | return TableRegionType(*args_, **kwargs_) |
||
| 12694 | factory = staticmethod(factory) |
||
| 12695 | def get_ns_prefix_(self): |
||
| 12696 | return self.ns_prefix_ |
||
| 12697 | def set_ns_prefix_(self, ns_prefix): |
||
| 12698 | self.ns_prefix_ = ns_prefix |
||
| 12699 | def get_Grid(self): |
||
| 12700 | return self.Grid |
||
| 12701 | def set_Grid(self, Grid): |
||
| 12702 | self.Grid = Grid |
||
| 12703 | def get_orientation(self): |
||
| 12704 | return self.orientation |
||
| 12705 | def set_orientation(self, orientation): |
||
| 12706 | self.orientation = orientation |
||
| 12707 | def get_rows(self): |
||
| 12708 | return self.rows |
||
| 12709 | def set_rows(self, rows): |
||
| 12710 | self.rows = rows |
||
| 12711 | def get_columns(self): |
||
| 12712 | return self.columns |
||
| 12713 | def set_columns(self, columns): |
||
| 12714 | self.columns = columns |
||
| 12715 | def get_lineColour(self): |
||
| 12716 | return self.lineColour |
||
| 12717 | def set_lineColour(self, lineColour): |
||
| 12718 | self.lineColour = lineColour |
||
| 12719 | def get_bgColour(self): |
||
| 12720 | return self.bgColour |
||
| 12721 | def set_bgColour(self, bgColour): |
||
| 12722 | self.bgColour = bgColour |
||
| 12723 | def get_lineSeparators(self): |
||
| 12724 | return self.lineSeparators |
||
| 12725 | def set_lineSeparators(self, lineSeparators): |
||
| 12726 | self.lineSeparators = lineSeparators |
||
| 12727 | def get_embText(self): |
||
| 12728 | return self.embText |
||
| 12729 | def set_embText(self, embText): |
||
| 12730 | self.embText = embText |
||
| 12731 | def validate_ColourSimpleType(self, value): |
||
| 12732 | # Validate type pc:ColourSimpleType, a restriction on string. |
||
| 12733 | if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None: |
||
| 12734 | if not isinstance(value, str): |
||
| 12735 | lineno = self.gds_get_node_lineno_() |
||
| 12736 | self.gds_collector_.add_message('Value "%(value)s"%(lineno)s is not of the correct base simple type (str)' % {"value": value, "lineno": lineno, }) |
||
| 12737 | return False |
||
| 12738 | value = value |
||
| 12739 | enumerations = ['black', 'blue', 'brown', 'cyan', 'green', 'grey', 'indigo', 'magenta', 'orange', 'pink', 'red', 'turquoise', 'violet', 'white', 'yellow', 'other'] |
||
| 12740 | if value not in enumerations: |
||
| 12741 | lineno = self.gds_get_node_lineno_() |
||
| 12742 | self.gds_collector_.add_message('Value "%(value)s"%(lineno)s does not match xsd enumeration restriction on ColourSimpleType' % {"value" : encode_str_2_3(value), "lineno": lineno} ) |
||
| 12743 | result = False |
||
| 12744 | def hasContent_(self): |
||
| 12745 | if ( |
||
| 12746 | self.Grid is not None or |
||
| 12747 | super(TableRegionType, self).hasContent_() |
||
| 12748 | ): |
||
| 12749 | return True |
||
| 12750 | else: |
||
| 12751 | return False |
||
| 12752 | def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='TableRegionType', pretty_print=True): |
||
| 12753 | imported_ns_def_ = GenerateDSNamespaceDefs_.get('TableRegionType') |
||
| 12754 | if imported_ns_def_ is not None: |
||
| 12755 | namespacedef_ = imported_ns_def_ |
||
| 12756 | if pretty_print: |
||
| 12757 | eol_ = '\n' |
||
| 12758 | else: |
||
| 12759 | eol_ = '' |
||
| 12760 | if self.original_tagname_ is not None and name_ == 'TableRegionType': |
||
| 12761 | name_ = self.original_tagname_ |
||
| 12762 | if UseCapturedNS_ and self.ns_prefix_: |
||
| 12763 | namespaceprefix_ = self.ns_prefix_ + ':' |
||
| 12764 | showIndent(outfile, level, pretty_print) |
||
| 12765 | outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) |
||
| 12766 | already_processed = set() |
||
| 12767 | self.exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='TableRegionType') |
||
| 12768 | if self.hasContent_(): |
||
| 12769 | outfile.write('>%s' % (eol_, )) |
||
| 12770 | self.exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='TableRegionType', pretty_print=pretty_print) |
||
| 12771 | showIndent(outfile, level, pretty_print) |
||
| 12772 | outfile.write('</%s%s>%s' % (namespaceprefix_, name_, eol_)) |
||
| 12773 | else: |
||
| 12774 | outfile.write('/>%s' % (eol_, )) |
||
| 12775 | def exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='TableRegionType'): |
||
| 12776 | super(TableRegionType, self).exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='TableRegionType') |
||
| 12777 | if self.orientation is not None and 'orientation' not in already_processed: |
||
| 12778 | already_processed.add('orientation') |
||
| 12779 | outfile.write(' orientation="%s"' % self.gds_format_float(self.orientation, input_name='orientation')) |
||
| 12780 | if self.rows is not None and 'rows' not in already_processed: |
||
| 12781 | already_processed.add('rows') |
||
| 12782 | outfile.write(' rows="%s"' % self.gds_format_integer(self.rows, input_name='rows')) |
||
| 12783 | if self.columns is not None and 'columns' not in already_processed: |
||
| 12784 | already_processed.add('columns') |
||
| 12785 | outfile.write(' columns="%s"' % self.gds_format_integer(self.columns, input_name='columns')) |
||
| 12786 | if self.lineColour is not None and 'lineColour' not in already_processed: |
||
| 12787 | already_processed.add('lineColour') |
||
| 12788 | outfile.write(' lineColour=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.lineColour), input_name='lineColour')), )) |
||
| 12789 | if self.bgColour is not None and 'bgColour' not in already_processed: |
||
| 12790 | already_processed.add('bgColour') |
||
| 12791 | outfile.write(' bgColour=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.bgColour), input_name='bgColour')), )) |
||
| 12792 | if self.lineSeparators is not None and 'lineSeparators' not in already_processed: |
||
| 12793 | already_processed.add('lineSeparators') |
||
| 12794 | outfile.write(' lineSeparators="%s"' % self.gds_format_boolean(self.lineSeparators, input_name='lineSeparators')) |
||
| 12795 | if self.embText is not None and 'embText' not in already_processed: |
||
| 12796 | already_processed.add('embText') |
||
| 12797 | outfile.write(' embText="%s"' % self.gds_format_boolean(self.embText, input_name='embText')) |
||
| 12798 | def exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='TableRegionType', fromsubclass_=False, pretty_print=True): |
||
| 12799 | super(TableRegionType, self).exportChildren(outfile, level, namespaceprefix_, namespacedef_, name_, True, pretty_print=pretty_print) |
||
| 12800 | if pretty_print: |
||
| 12801 | eol_ = '\n' |
||
| 12802 | else: |
||
| 12803 | eol_ = '' |
||
| 12804 | if self.Grid is not None: |
||
| 12805 | namespaceprefix_ = self.Grid_nsprefix_ + ':' if (UseCapturedNS_ and self.Grid_nsprefix_) else '' |
||
| 12806 | self.Grid.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Grid', pretty_print=pretty_print) |
||
| 12807 | def to_etree(self, parent_element=None, name_='TableRegionType', mapping_=None, nsmap_=None): |
||
| 12808 | element = super(TableRegionType, self).to_etree(parent_element, name_, mapping_) |
||
| 12809 | if self.orientation is not None: |
||
| 12810 | element.set('orientation', self.gds_format_float(self.orientation)) |
||
| 12811 | if self.rows is not None: |
||
| 12812 | element.set('rows', self.gds_format_integer(self.rows)) |
||
| 12813 | if self.columns is not None: |
||
| 12814 | element.set('columns', self.gds_format_integer(self.columns)) |
||
| 12815 | if self.lineColour is not None: |
||
| 12816 | element.set('lineColour', self.gds_format_string(self.lineColour)) |
||
| 12817 | if self.bgColour is not None: |
||
| 12818 | element.set('bgColour', self.gds_format_string(self.bgColour)) |
||
| 12819 | if self.lineSeparators is not None: |
||
| 12820 | element.set('lineSeparators', self.gds_format_boolean(self.lineSeparators)) |
||
| 12821 | if self.embText is not None: |
||
| 12822 | element.set('embText', self.gds_format_boolean(self.embText)) |
||
| 12823 | if self.Grid is not None: |
||
| 12824 | Grid_ = self.Grid |
||
| 12825 | Grid_.to_etree(element, name_='Grid', mapping_=mapping_, nsmap_=nsmap_) |
||
| 12826 | if mapping_ is not None: |
||
| 12827 | mapping_[id(self)] = element |
||
| 12828 | return element |
||
| 12829 | def build(self, node, gds_collector_=None): |
||
| 12830 | self.gds_collector_ = gds_collector_ |
||
| 12831 | if SaveElementTreeNode: |
||
| 12832 | self.gds_elementtree_node_ = node |
||
| 12833 | already_processed = set() |
||
| 12834 | self.ns_prefix_ = node.prefix |
||
| 12835 | self.buildAttributes(node, node.attrib, already_processed) |
||
| 12836 | for child in node: |
||
| 12837 | nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] |
||
| 12838 | self.buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) |
||
| 12839 | return self |
||
| 12840 | def buildAttributes(self, node, attrs, already_processed): |
||
| 12841 | value = find_attr_value_('orientation', node) |
||
| 12842 | if value is not None and 'orientation' not in already_processed: |
||
| 12843 | already_processed.add('orientation') |
||
| 12844 | value = self.gds_parse_float(value, node, 'orientation') |
||
| 12845 | self.orientation = value |
||
| 12846 | value = find_attr_value_('rows', node) |
||
| 12847 | if value is not None and 'rows' not in already_processed: |
||
| 12848 | already_processed.add('rows') |
||
| 12849 | self.rows = self.gds_parse_integer(value, node, 'rows') |
||
| 12850 | value = find_attr_value_('columns', node) |
||
| 12851 | if value is not None and 'columns' not in already_processed: |
||
| 12852 | already_processed.add('columns') |
||
| 12853 | self.columns = self.gds_parse_integer(value, node, 'columns') |
||
| 12854 | value = find_attr_value_('lineColour', node) |
||
| 12855 | if value is not None and 'lineColour' not in already_processed: |
||
| 12856 | already_processed.add('lineColour') |
||
| 12857 | self.lineColour = value |
||
| 12858 | self.validate_ColourSimpleType(self.lineColour) # validate type ColourSimpleType |
||
| 12859 | value = find_attr_value_('bgColour', node) |
||
| 12860 | if value is not None and 'bgColour' not in already_processed: |
||
| 12861 | already_processed.add('bgColour') |
||
| 12862 | self.bgColour = value |
||
| 12863 | self.validate_ColourSimpleType(self.bgColour) # validate type ColourSimpleType |
||
| 12864 | value = find_attr_value_('lineSeparators', node) |
||
| 12865 | if value is not None and 'lineSeparators' not in already_processed: |
||
| 12866 | already_processed.add('lineSeparators') |
||
| 12867 | if value in ('true', '1'): |
||
| 12868 | self.lineSeparators = True |
||
| 12869 | elif value in ('false', '0'): |
||
| 12870 | self.lineSeparators = False |
||
| 12871 | else: |
||
| 12872 | raise_parse_error(node, 'Bad boolean attribute') |
||
| 12873 | value = find_attr_value_('embText', node) |
||
| 12874 | if value is not None and 'embText' not in already_processed: |
||
| 12875 | already_processed.add('embText') |
||
| 12876 | if value in ('true', '1'): |
||
| 12877 | self.embText = True |
||
| 12878 | elif value in ('false', '0'): |
||
| 12879 | self.embText = False |
||
| 12880 | else: |
||
| 12881 | raise_parse_error(node, 'Bad boolean attribute') |
||
| 12882 | super(TableRegionType, self).buildAttributes(node, attrs, already_processed) |
||
| 12883 | def buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None): |
||
| 12884 | if nodeName_ == 'Grid': |
||
| 12885 | obj_ = GridType.factory(parent_object_=self) |
||
| 12886 | obj_.build(child_, gds_collector_=gds_collector_) |
||
| 12887 | self.Grid = obj_ |
||
| 12888 | obj_.original_tagname_ = 'Grid' |
||
| 12889 | super(TableRegionType, self).buildChildren(child_, node, nodeName_, True) |
||
| 12890 | def __hash__(self): |
||
| 12891 | return hash(self.id) |
||
| 12892 | def set_orientation(self, orientation): |
||
| 12893 | """ |
||
| 12894 | Set deskewing angle to given `orientation` number. |
||
| 12895 | Moreover, invalidate self's ``pc:AlternativeImage``s |
||
| 12896 | (because they will have been rotated and enlarged |
||
| 12897 | with the angle of the previous value). |
||
| 12898 | """ |
||
| 12899 | if hasattr(self, 'invalidate_AlternativeImage'): |
||
| 12900 | # PageType, RegionType: |
||
| 12901 | self.invalidate_AlternativeImage(feature_selector='deskewed') |
||
| 12902 | self.orientation = orientation |
||
| 12903 | # end class TableRegionType |
||
| 12904 | |||
| 12905 | |||
| 12906 | View Code Duplication | class GraphicRegionType(RegionType): |
|
| 12907 | """Regions containing simple graphics, such as a company |
||
| 12908 | logo, should be marked as graphic regions. |
||
| 12909 | The angle the rectangle encapsulating a region |
||
| 12910 | has to be rotated in clockwise direction |
||
| 12911 | in order to correct the present skew |
||
| 12912 | (negative values indicate anti-clockwise rotation). |
||
| 12913 | Range: -179.999,180 |
||
| 12914 | The type of graphic in the region |
||
| 12915 | An approximation of the number of colours |
||
| 12916 | used in the region |
||
| 12917 | Specifies whether the region also contains |
||
| 12918 | text.""" |
||
| 12919 | __hash__ = GeneratedsSuper.__hash__ |
||
| 12920 | member_data_items_ = [ |
||
| 12921 | MemberSpec_('orientation', 'float', 0, 1, {'use': 'optional'}), |
||
| 12922 | MemberSpec_('type_', 'pc:GraphicsTypeSimpleType', 0, 1, {'use': 'optional'}), |
||
| 12923 | MemberSpec_('numColours', 'int', 0, 1, {'use': 'optional'}), |
||
| 12924 | MemberSpec_('embText', 'boolean', 0, 1, {'use': 'optional'}), |
||
| 12925 | ] |
||
| 12926 | subclass = None |
||
| 12927 | superclass = RegionType |
||
| 12928 | def __init__(self, id=None, custom=None, comments=None, continuation=None, AlternativeImage=None, Coords=None, UserDefined=None, Labels=None, Roles=None, TextRegion=None, ImageRegion=None, LineDrawingRegion=None, GraphicRegion=None, TableRegion=None, ChartRegion=None, SeparatorRegion=None, MathsRegion=None, ChemRegion=None, MusicRegion=None, AdvertRegion=None, NoiseRegion=None, UnknownRegion=None, CustomRegion=None, orientation=None, type_=None, numColours=None, embText=None, gds_collector_=None, **kwargs_): |
||
| 12929 | self.gds_collector_ = gds_collector_ |
||
| 12930 | self.gds_elementtree_node_ = None |
||
| 12931 | self.original_tagname_ = None |
||
| 12932 | self.parent_object_ = kwargs_.get('parent_object_') |
||
| 12933 | self.ns_prefix_ = None |
||
| 12934 | super(GraphicRegionType, self).__init__(id, custom, comments, continuation, AlternativeImage, Coords, UserDefined, Labels, Roles, TextRegion, ImageRegion, LineDrawingRegion, GraphicRegion, TableRegion, ChartRegion, SeparatorRegion, MathsRegion, ChemRegion, MusicRegion, AdvertRegion, NoiseRegion, UnknownRegion, CustomRegion, **kwargs_) |
||
| 12935 | self.orientation = _cast(float, orientation) |
||
| 12936 | self.orientation_nsprefix_ = "pc" |
||
| 12937 | self.type_ = _cast(None, type_) |
||
| 12938 | self.type__nsprefix_ = "pc" |
||
| 12939 | self.numColours = _cast(int, numColours) |
||
| 12940 | self.numColours_nsprefix_ = "pc" |
||
| 12941 | self.embText = _cast(bool, embText) |
||
| 12942 | self.embText_nsprefix_ = "pc" |
||
| 12943 | def factory(*args_, **kwargs_): |
||
| 12944 | if CurrentSubclassModule_ is not None: |
||
| 12945 | subclass = getSubclassFromModule_( |
||
| 12946 | CurrentSubclassModule_, GraphicRegionType) |
||
| 12947 | if subclass is not None: |
||
| 12948 | return subclass(*args_, **kwargs_) |
||
| 12949 | if GraphicRegionType.subclass: |
||
| 12950 | return GraphicRegionType.subclass(*args_, **kwargs_) |
||
| 12951 | else: |
||
| 12952 | return GraphicRegionType(*args_, **kwargs_) |
||
| 12953 | factory = staticmethod(factory) |
||
| 12954 | def get_ns_prefix_(self): |
||
| 12955 | return self.ns_prefix_ |
||
| 12956 | def set_ns_prefix_(self, ns_prefix): |
||
| 12957 | self.ns_prefix_ = ns_prefix |
||
| 12958 | def get_orientation(self): |
||
| 12959 | return self.orientation |
||
| 12960 | def set_orientation(self, orientation): |
||
| 12961 | self.orientation = orientation |
||
| 12962 | def get_type(self): |
||
| 12963 | return self.type_ |
||
| 12964 | def set_type(self, type_): |
||
| 12965 | self.type_ = type_ |
||
| 12966 | def get_numColours(self): |
||
| 12967 | return self.numColours |
||
| 12968 | def set_numColours(self, numColours): |
||
| 12969 | self.numColours = numColours |
||
| 12970 | def get_embText(self): |
||
| 12971 | return self.embText |
||
| 12972 | def set_embText(self, embText): |
||
| 12973 | self.embText = embText |
||
| 12974 | def validate_GraphicsTypeSimpleType(self, value): |
||
| 12975 | # Validate type pc:GraphicsTypeSimpleType, a restriction on string. |
||
| 12976 | if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None: |
||
| 12977 | if not isinstance(value, str): |
||
| 12978 | lineno = self.gds_get_node_lineno_() |
||
| 12979 | self.gds_collector_.add_message('Value "%(value)s"%(lineno)s is not of the correct base simple type (str)' % {"value": value, "lineno": lineno, }) |
||
| 12980 | return False |
||
| 12981 | value = value |
||
| 12982 | enumerations = ['logo', 'letterhead', 'decoration', 'frame', 'handwritten-annotation', 'stamp', 'signature', 'barcode', 'paper-grow', 'punch-hole', 'other'] |
||
| 12983 | if value not in enumerations: |
||
| 12984 | lineno = self.gds_get_node_lineno_() |
||
| 12985 | self.gds_collector_.add_message('Value "%(value)s"%(lineno)s does not match xsd enumeration restriction on GraphicsTypeSimpleType' % {"value" : encode_str_2_3(value), "lineno": lineno} ) |
||
| 12986 | result = False |
||
| 12987 | def hasContent_(self): |
||
| 12988 | if ( |
||
| 12989 | super(GraphicRegionType, self).hasContent_() |
||
| 12990 | ): |
||
| 12991 | return True |
||
| 12992 | else: |
||
| 12993 | return False |
||
| 12994 | def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='GraphicRegionType', pretty_print=True): |
||
| 12995 | imported_ns_def_ = GenerateDSNamespaceDefs_.get('GraphicRegionType') |
||
| 12996 | if imported_ns_def_ is not None: |
||
| 12997 | namespacedef_ = imported_ns_def_ |
||
| 12998 | if pretty_print: |
||
| 12999 | eol_ = '\n' |
||
| 13000 | else: |
||
| 13001 | eol_ = '' |
||
| 13002 | if self.original_tagname_ is not None and name_ == 'GraphicRegionType': |
||
| 13003 | name_ = self.original_tagname_ |
||
| 13004 | if UseCapturedNS_ and self.ns_prefix_: |
||
| 13005 | namespaceprefix_ = self.ns_prefix_ + ':' |
||
| 13006 | showIndent(outfile, level, pretty_print) |
||
| 13007 | outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) |
||
| 13008 | already_processed = set() |
||
| 13009 | self.exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='GraphicRegionType') |
||
| 13010 | if self.hasContent_(): |
||
| 13011 | outfile.write('>%s' % (eol_, )) |
||
| 13012 | self.exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='GraphicRegionType', pretty_print=pretty_print) |
||
| 13013 | showIndent(outfile, level, pretty_print) |
||
| 13014 | outfile.write('</%s%s>%s' % (namespaceprefix_, name_, eol_)) |
||
| 13015 | else: |
||
| 13016 | outfile.write('/>%s' % (eol_, )) |
||
| 13017 | def exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='GraphicRegionType'): |
||
| 13018 | super(GraphicRegionType, self).exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='GraphicRegionType') |
||
| 13019 | if self.orientation is not None and 'orientation' not in already_processed: |
||
| 13020 | already_processed.add('orientation') |
||
| 13021 | outfile.write(' orientation="%s"' % self.gds_format_float(self.orientation, input_name='orientation')) |
||
| 13022 | if self.type_ is not None and 'type_' not in already_processed: |
||
| 13023 | already_processed.add('type_') |
||
| 13024 | outfile.write(' type=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.type_), input_name='type')), )) |
||
| 13025 | if self.numColours is not None and 'numColours' not in already_processed: |
||
| 13026 | already_processed.add('numColours') |
||
| 13027 | outfile.write(' numColours="%s"' % self.gds_format_integer(self.numColours, input_name='numColours')) |
||
| 13028 | if self.embText is not None and 'embText' not in already_processed: |
||
| 13029 | already_processed.add('embText') |
||
| 13030 | outfile.write(' embText="%s"' % self.gds_format_boolean(self.embText, input_name='embText')) |
||
| 13031 | def exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='GraphicRegionType', fromsubclass_=False, pretty_print=True): |
||
| 13032 | super(GraphicRegionType, self).exportChildren(outfile, level, namespaceprefix_, namespacedef_, name_, True, pretty_print=pretty_print) |
||
| 13033 | def to_etree(self, parent_element=None, name_='GraphicRegionType', mapping_=None, nsmap_=None): |
||
| 13034 | element = super(GraphicRegionType, self).to_etree(parent_element, name_, mapping_) |
||
| 13035 | if self.orientation is not None: |
||
| 13036 | element.set('orientation', self.gds_format_float(self.orientation)) |
||
| 13037 | if self.type_ is not None: |
||
| 13038 | element.set('type', self.gds_format_string(self.type_)) |
||
| 13039 | if self.numColours is not None: |
||
| 13040 | element.set('numColours', self.gds_format_integer(self.numColours)) |
||
| 13041 | if self.embText is not None: |
||
| 13042 | element.set('embText', self.gds_format_boolean(self.embText)) |
||
| 13043 | if mapping_ is not None: |
||
| 13044 | mapping_[id(self)] = element |
||
| 13045 | return element |
||
| 13046 | def build(self, node, gds_collector_=None): |
||
| 13047 | self.gds_collector_ = gds_collector_ |
||
| 13048 | if SaveElementTreeNode: |
||
| 13049 | self.gds_elementtree_node_ = node |
||
| 13050 | already_processed = set() |
||
| 13051 | self.ns_prefix_ = node.prefix |
||
| 13052 | self.buildAttributes(node, node.attrib, already_processed) |
||
| 13053 | for child in node: |
||
| 13054 | nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] |
||
| 13055 | self.buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) |
||
| 13056 | return self |
||
| 13057 | def buildAttributes(self, node, attrs, already_processed): |
||
| 13058 | value = find_attr_value_('orientation', node) |
||
| 13059 | if value is not None and 'orientation' not in already_processed: |
||
| 13060 | already_processed.add('orientation') |
||
| 13061 | value = self.gds_parse_float(value, node, 'orientation') |
||
| 13062 | self.orientation = value |
||
| 13063 | value = find_attr_value_('type', node) |
||
| 13064 | if value is not None and 'type' not in already_processed: |
||
| 13065 | already_processed.add('type') |
||
| 13066 | self.type_ = value |
||
| 13067 | self.validate_GraphicsTypeSimpleType(self.type_) # validate type GraphicsTypeSimpleType |
||
| 13068 | value = find_attr_value_('numColours', node) |
||
| 13069 | if value is not None and 'numColours' not in already_processed: |
||
| 13070 | already_processed.add('numColours') |
||
| 13071 | self.numColours = self.gds_parse_integer(value, node, 'numColours') |
||
| 13072 | value = find_attr_value_('embText', node) |
||
| 13073 | if value is not None and 'embText' not in already_processed: |
||
| 13074 | already_processed.add('embText') |
||
| 13075 | if value in ('true', '1'): |
||
| 13076 | self.embText = True |
||
| 13077 | elif value in ('false', '0'): |
||
| 13078 | self.embText = False |
||
| 13079 | else: |
||
| 13080 | raise_parse_error(node, 'Bad boolean attribute') |
||
| 13081 | super(GraphicRegionType, self).buildAttributes(node, attrs, already_processed) |
||
| 13082 | def buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None): |
||
| 13083 | super(GraphicRegionType, self).buildChildren(child_, node, nodeName_, True) |
||
| 13084 | pass |
||
| 13085 | def __hash__(self): |
||
| 13086 | return hash(self.id) |
||
| 13087 | def set_orientation(self, orientation): |
||
| 13088 | """ |
||
| 13089 | Set deskewing angle to given `orientation` number. |
||
| 13090 | Moreover, invalidate self's ``pc:AlternativeImage``s |
||
| 13091 | (because they will have been rotated and enlarged |
||
| 13092 | with the angle of the previous value). |
||
| 13093 | """ |
||
| 13094 | if hasattr(self, 'invalidate_AlternativeImage'): |
||
| 13095 | # PageType, RegionType: |
||
| 13096 | self.invalidate_AlternativeImage(feature_selector='deskewed') |
||
| 13097 | self.orientation = orientation |
||
| 13098 | # end class GraphicRegionType |
||
| 13099 | |||
| 13100 | |||
| 13101 | View Code Duplication | class LineDrawingRegionType(RegionType): |
|
| 13102 | """A line drawing is a single colour illustration without |
||
| 13103 | solid areas. |
||
| 13104 | The angle the rectangle encapsulating a region |
||
| 13105 | has to be rotated in clockwise direction |
||
| 13106 | in order to correct the present skew |
||
| 13107 | (negative values indicate anti-clockwise rotation). |
||
| 13108 | Range: -179.999,180 |
||
| 13109 | The pen (foreground) colour of the region |
||
| 13110 | The background colour of the region |
||
| 13111 | Specifies whether the region also contains |
||
| 13112 | text""" |
||
| 13113 | __hash__ = GeneratedsSuper.__hash__ |
||
| 13114 | member_data_items_ = [ |
||
| 13115 | MemberSpec_('orientation', 'float', 0, 1, {'use': 'optional'}), |
||
| 13116 | MemberSpec_('penColour', 'pc:ColourSimpleType', 0, 1, {'use': 'optional'}), |
||
| 13117 | MemberSpec_('bgColour', 'pc:ColourSimpleType', 0, 1, {'use': 'optional'}), |
||
| 13118 | MemberSpec_('embText', 'boolean', 0, 1, {'use': 'optional'}), |
||
| 13119 | ] |
||
| 13120 | subclass = None |
||
| 13121 | superclass = RegionType |
||
| 13122 | def __init__(self, id=None, custom=None, comments=None, continuation=None, AlternativeImage=None, Coords=None, UserDefined=None, Labels=None, Roles=None, TextRegion=None, ImageRegion=None, LineDrawingRegion=None, GraphicRegion=None, TableRegion=None, ChartRegion=None, SeparatorRegion=None, MathsRegion=None, ChemRegion=None, MusicRegion=None, AdvertRegion=None, NoiseRegion=None, UnknownRegion=None, CustomRegion=None, orientation=None, penColour=None, bgColour=None, embText=None, gds_collector_=None, **kwargs_): |
||
| 13123 | self.gds_collector_ = gds_collector_ |
||
| 13124 | self.gds_elementtree_node_ = None |
||
| 13125 | self.original_tagname_ = None |
||
| 13126 | self.parent_object_ = kwargs_.get('parent_object_') |
||
| 13127 | self.ns_prefix_ = None |
||
| 13128 | super(LineDrawingRegionType, self).__init__(id, custom, comments, continuation, AlternativeImage, Coords, UserDefined, Labels, Roles, TextRegion, ImageRegion, LineDrawingRegion, GraphicRegion, TableRegion, ChartRegion, SeparatorRegion, MathsRegion, ChemRegion, MusicRegion, AdvertRegion, NoiseRegion, UnknownRegion, CustomRegion, **kwargs_) |
||
| 13129 | self.orientation = _cast(float, orientation) |
||
| 13130 | self.orientation_nsprefix_ = "pc" |
||
| 13131 | self.penColour = _cast(None, penColour) |
||
| 13132 | self.penColour_nsprefix_ = "pc" |
||
| 13133 | self.bgColour = _cast(None, bgColour) |
||
| 13134 | self.bgColour_nsprefix_ = "pc" |
||
| 13135 | self.embText = _cast(bool, embText) |
||
| 13136 | self.embText_nsprefix_ = "pc" |
||
| 13137 | def factory(*args_, **kwargs_): |
||
| 13138 | if CurrentSubclassModule_ is not None: |
||
| 13139 | subclass = getSubclassFromModule_( |
||
| 13140 | CurrentSubclassModule_, LineDrawingRegionType) |
||
| 13141 | if subclass is not None: |
||
| 13142 | return subclass(*args_, **kwargs_) |
||
| 13143 | if LineDrawingRegionType.subclass: |
||
| 13144 | return LineDrawingRegionType.subclass(*args_, **kwargs_) |
||
| 13145 | else: |
||
| 13146 | return LineDrawingRegionType(*args_, **kwargs_) |
||
| 13147 | factory = staticmethod(factory) |
||
| 13148 | def get_ns_prefix_(self): |
||
| 13149 | return self.ns_prefix_ |
||
| 13150 | def set_ns_prefix_(self, ns_prefix): |
||
| 13151 | self.ns_prefix_ = ns_prefix |
||
| 13152 | def get_orientation(self): |
||
| 13153 | return self.orientation |
||
| 13154 | def set_orientation(self, orientation): |
||
| 13155 | self.orientation = orientation |
||
| 13156 | def get_penColour(self): |
||
| 13157 | return self.penColour |
||
| 13158 | def set_penColour(self, penColour): |
||
| 13159 | self.penColour = penColour |
||
| 13160 | def get_bgColour(self): |
||
| 13161 | return self.bgColour |
||
| 13162 | def set_bgColour(self, bgColour): |
||
| 13163 | self.bgColour = bgColour |
||
| 13164 | def get_embText(self): |
||
| 13165 | return self.embText |
||
| 13166 | def set_embText(self, embText): |
||
| 13167 | self.embText = embText |
||
| 13168 | def validate_ColourSimpleType(self, value): |
||
| 13169 | # Validate type pc:ColourSimpleType, a restriction on string. |
||
| 13170 | if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None: |
||
| 13171 | if not isinstance(value, str): |
||
| 13172 | lineno = self.gds_get_node_lineno_() |
||
| 13173 | self.gds_collector_.add_message('Value "%(value)s"%(lineno)s is not of the correct base simple type (str)' % {"value": value, "lineno": lineno, }) |
||
| 13174 | return False |
||
| 13175 | value = value |
||
| 13176 | enumerations = ['black', 'blue', 'brown', 'cyan', 'green', 'grey', 'indigo', 'magenta', 'orange', 'pink', 'red', 'turquoise', 'violet', 'white', 'yellow', 'other'] |
||
| 13177 | if value not in enumerations: |
||
| 13178 | lineno = self.gds_get_node_lineno_() |
||
| 13179 | self.gds_collector_.add_message('Value "%(value)s"%(lineno)s does not match xsd enumeration restriction on ColourSimpleType' % {"value" : encode_str_2_3(value), "lineno": lineno} ) |
||
| 13180 | result = False |
||
| 13181 | def hasContent_(self): |
||
| 13182 | if ( |
||
| 13183 | super(LineDrawingRegionType, self).hasContent_() |
||
| 13184 | ): |
||
| 13185 | return True |
||
| 13186 | else: |
||
| 13187 | return False |
||
| 13188 | def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='LineDrawingRegionType', pretty_print=True): |
||
| 13189 | imported_ns_def_ = GenerateDSNamespaceDefs_.get('LineDrawingRegionType') |
||
| 13190 | if imported_ns_def_ is not None: |
||
| 13191 | namespacedef_ = imported_ns_def_ |
||
| 13192 | if pretty_print: |
||
| 13193 | eol_ = '\n' |
||
| 13194 | else: |
||
| 13195 | eol_ = '' |
||
| 13196 | if self.original_tagname_ is not None and name_ == 'LineDrawingRegionType': |
||
| 13197 | name_ = self.original_tagname_ |
||
| 13198 | if UseCapturedNS_ and self.ns_prefix_: |
||
| 13199 | namespaceprefix_ = self.ns_prefix_ + ':' |
||
| 13200 | showIndent(outfile, level, pretty_print) |
||
| 13201 | outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) |
||
| 13202 | already_processed = set() |
||
| 13203 | self.exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='LineDrawingRegionType') |
||
| 13204 | if self.hasContent_(): |
||
| 13205 | outfile.write('>%s' % (eol_, )) |
||
| 13206 | self.exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='LineDrawingRegionType', pretty_print=pretty_print) |
||
| 13207 | showIndent(outfile, level, pretty_print) |
||
| 13208 | outfile.write('</%s%s>%s' % (namespaceprefix_, name_, eol_)) |
||
| 13209 | else: |
||
| 13210 | outfile.write('/>%s' % (eol_, )) |
||
| 13211 | def exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='LineDrawingRegionType'): |
||
| 13212 | super(LineDrawingRegionType, self).exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='LineDrawingRegionType') |
||
| 13213 | if self.orientation is not None and 'orientation' not in already_processed: |
||
| 13214 | already_processed.add('orientation') |
||
| 13215 | outfile.write(' orientation="%s"' % self.gds_format_float(self.orientation, input_name='orientation')) |
||
| 13216 | if self.penColour is not None and 'penColour' not in already_processed: |
||
| 13217 | already_processed.add('penColour') |
||
| 13218 | outfile.write(' penColour=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.penColour), input_name='penColour')), )) |
||
| 13219 | if self.bgColour is not None and 'bgColour' not in already_processed: |
||
| 13220 | already_processed.add('bgColour') |
||
| 13221 | outfile.write(' bgColour=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.bgColour), input_name='bgColour')), )) |
||
| 13222 | if self.embText is not None and 'embText' not in already_processed: |
||
| 13223 | already_processed.add('embText') |
||
| 13224 | outfile.write(' embText="%s"' % self.gds_format_boolean(self.embText, input_name='embText')) |
||
| 13225 | def exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='LineDrawingRegionType', fromsubclass_=False, pretty_print=True): |
||
| 13226 | super(LineDrawingRegionType, self).exportChildren(outfile, level, namespaceprefix_, namespacedef_, name_, True, pretty_print=pretty_print) |
||
| 13227 | def to_etree(self, parent_element=None, name_='LineDrawingRegionType', mapping_=None, nsmap_=None): |
||
| 13228 | element = super(LineDrawingRegionType, self).to_etree(parent_element, name_, mapping_) |
||
| 13229 | if self.orientation is not None: |
||
| 13230 | element.set('orientation', self.gds_format_float(self.orientation)) |
||
| 13231 | if self.penColour is not None: |
||
| 13232 | element.set('penColour', self.gds_format_string(self.penColour)) |
||
| 13233 | if self.bgColour is not None: |
||
| 13234 | element.set('bgColour', self.gds_format_string(self.bgColour)) |
||
| 13235 | if self.embText is not None: |
||
| 13236 | element.set('embText', self.gds_format_boolean(self.embText)) |
||
| 13237 | if mapping_ is not None: |
||
| 13238 | mapping_[id(self)] = element |
||
| 13239 | return element |
||
| 13240 | def build(self, node, gds_collector_=None): |
||
| 13241 | self.gds_collector_ = gds_collector_ |
||
| 13242 | if SaveElementTreeNode: |
||
| 13243 | self.gds_elementtree_node_ = node |
||
| 13244 | already_processed = set() |
||
| 13245 | self.ns_prefix_ = node.prefix |
||
| 13246 | self.buildAttributes(node, node.attrib, already_processed) |
||
| 13247 | for child in node: |
||
| 13248 | nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] |
||
| 13249 | self.buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) |
||
| 13250 | return self |
||
| 13251 | def buildAttributes(self, node, attrs, already_processed): |
||
| 13252 | value = find_attr_value_('orientation', node) |
||
| 13253 | if value is not None and 'orientation' not in already_processed: |
||
| 13254 | already_processed.add('orientation') |
||
| 13255 | value = self.gds_parse_float(value, node, 'orientation') |
||
| 13256 | self.orientation = value |
||
| 13257 | value = find_attr_value_('penColour', node) |
||
| 13258 | if value is not None and 'penColour' not in already_processed: |
||
| 13259 | already_processed.add('penColour') |
||
| 13260 | self.penColour = value |
||
| 13261 | self.validate_ColourSimpleType(self.penColour) # validate type ColourSimpleType |
||
| 13262 | value = find_attr_value_('bgColour', node) |
||
| 13263 | if value is not None and 'bgColour' not in already_processed: |
||
| 13264 | already_processed.add('bgColour') |
||
| 13265 | self.bgColour = value |
||
| 13266 | self.validate_ColourSimpleType(self.bgColour) # validate type ColourSimpleType |
||
| 13267 | value = find_attr_value_('embText', node) |
||
| 13268 | if value is not None and 'embText' not in already_processed: |
||
| 13269 | already_processed.add('embText') |
||
| 13270 | if value in ('true', '1'): |
||
| 13271 | self.embText = True |
||
| 13272 | elif value in ('false', '0'): |
||
| 13273 | self.embText = False |
||
| 13274 | else: |
||
| 13275 | raise_parse_error(node, 'Bad boolean attribute') |
||
| 13276 | super(LineDrawingRegionType, self).buildAttributes(node, attrs, already_processed) |
||
| 13277 | def buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None): |
||
| 13278 | super(LineDrawingRegionType, self).buildChildren(child_, node, nodeName_, True) |
||
| 13279 | pass |
||
| 13280 | def __hash__(self): |
||
| 13281 | return hash(self.id) |
||
| 13282 | def set_orientation(self, orientation): |
||
| 13283 | """ |
||
| 13284 | Set deskewing angle to given `orientation` number. |
||
| 13285 | Moreover, invalidate self's ``pc:AlternativeImage``s |
||
| 13286 | (because they will have been rotated and enlarged |
||
| 13287 | with the angle of the previous value). |
||
| 13288 | """ |
||
| 13289 | if hasattr(self, 'invalidate_AlternativeImage'): |
||
| 13290 | # PageType, RegionType: |
||
| 13291 | self.invalidate_AlternativeImage(feature_selector='deskewed') |
||
| 13292 | self.orientation = orientation |
||
| 13293 | # end class LineDrawingRegionType |
||
| 13294 | |||
| 13295 | |||
| 13296 | class ImageRegionType(RegionType): |
||
| 13297 | """An image is considered to be more intricate and complex |
||
| 13298 | than a graphic. These can be photos or drawings. |
||
| 13299 | The angle the rectangle encapsulating a region |
||
| 13300 | has to be rotated in clockwise direction |
||
| 13301 | in order to correct the present skew |
||
| 13302 | (negative values indicate anti-clockwise rotation). |
||
| 13303 | Range: -179.999,180 |
||
| 13304 | The colour bit depth required for the region |
||
| 13305 | The background colour of the region |
||
| 13306 | Specifies whether the region also contains |
||
| 13307 | text""" |
||
| 13308 | __hash__ = GeneratedsSuper.__hash__ |
||
| 13309 | member_data_items_ = [ |
||
| 13310 | MemberSpec_('orientation', 'float', 0, 1, {'use': 'optional'}), |
||
| 13311 | MemberSpec_('colourDepth', 'pc:ColourDepthSimpleType', 0, 1, {'use': 'optional'}), |
||
| 13312 | MemberSpec_('bgColour', 'pc:ColourSimpleType', 0, 1, {'use': 'optional'}), |
||
| 13313 | MemberSpec_('embText', 'boolean', 0, 1, {'use': 'optional'}), |
||
| 13314 | ] |
||
| 13315 | subclass = None |
||
| 13316 | superclass = RegionType |
||
| 13317 | def __init__(self, id=None, custom=None, comments=None, continuation=None, AlternativeImage=None, Coords=None, UserDefined=None, Labels=None, Roles=None, TextRegion=None, ImageRegion=None, LineDrawingRegion=None, GraphicRegion=None, TableRegion=None, ChartRegion=None, SeparatorRegion=None, MathsRegion=None, ChemRegion=None, MusicRegion=None, AdvertRegion=None, NoiseRegion=None, UnknownRegion=None, CustomRegion=None, orientation=None, colourDepth=None, bgColour=None, embText=None, gds_collector_=None, **kwargs_): |
||
| 13318 | self.gds_collector_ = gds_collector_ |
||
| 13319 | self.gds_elementtree_node_ = None |
||
| 13320 | self.original_tagname_ = None |
||
| 13321 | self.parent_object_ = kwargs_.get('parent_object_') |
||
| 13322 | self.ns_prefix_ = None |
||
| 13323 | super(ImageRegionType, self).__init__(id, custom, comments, continuation, AlternativeImage, Coords, UserDefined, Labels, Roles, TextRegion, ImageRegion, LineDrawingRegion, GraphicRegion, TableRegion, ChartRegion, SeparatorRegion, MathsRegion, ChemRegion, MusicRegion, AdvertRegion, NoiseRegion, UnknownRegion, CustomRegion, **kwargs_) |
||
| 13324 | self.orientation = _cast(float, orientation) |
||
| 13325 | self.orientation_nsprefix_ = "pc" |
||
| 13326 | self.colourDepth = _cast(None, colourDepth) |
||
| 13327 | self.colourDepth_nsprefix_ = "pc" |
||
| 13328 | self.bgColour = _cast(None, bgColour) |
||
| 13329 | self.bgColour_nsprefix_ = "pc" |
||
| 13330 | self.embText = _cast(bool, embText) |
||
| 13331 | self.embText_nsprefix_ = "pc" |
||
| 13332 | def factory(*args_, **kwargs_): |
||
| 13333 | if CurrentSubclassModule_ is not None: |
||
| 13334 | subclass = getSubclassFromModule_( |
||
| 13335 | CurrentSubclassModule_, ImageRegionType) |
||
| 13336 | if subclass is not None: |
||
| 13337 | return subclass(*args_, **kwargs_) |
||
| 13338 | if ImageRegionType.subclass: |
||
| 13339 | return ImageRegionType.subclass(*args_, **kwargs_) |
||
| 13340 | else: |
||
| 13341 | return ImageRegionType(*args_, **kwargs_) |
||
| 13342 | factory = staticmethod(factory) |
||
| 13343 | def get_ns_prefix_(self): |
||
| 13344 | return self.ns_prefix_ |
||
| 13345 | def set_ns_prefix_(self, ns_prefix): |
||
| 13346 | self.ns_prefix_ = ns_prefix |
||
| 13347 | def get_orientation(self): |
||
| 13348 | return self.orientation |
||
| 13349 | def set_orientation(self, orientation): |
||
| 13350 | self.orientation = orientation |
||
| 13351 | def get_colourDepth(self): |
||
| 13352 | return self.colourDepth |
||
| 13353 | def set_colourDepth(self, colourDepth): |
||
| 13354 | self.colourDepth = colourDepth |
||
| 13355 | def get_bgColour(self): |
||
| 13356 | return self.bgColour |
||
| 13357 | def set_bgColour(self, bgColour): |
||
| 13358 | self.bgColour = bgColour |
||
| 13359 | def get_embText(self): |
||
| 13360 | return self.embText |
||
| 13361 | def set_embText(self, embText): |
||
| 13362 | self.embText = embText |
||
| 13363 | def validate_ColourDepthSimpleType(self, value): |
||
| 13364 | # Validate type pc:ColourDepthSimpleType, a restriction on string. |
||
| 13365 | if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None: |
||
| 13366 | if not isinstance(value, str): |
||
| 13367 | lineno = self.gds_get_node_lineno_() |
||
| 13368 | self.gds_collector_.add_message('Value "%(value)s"%(lineno)s is not of the correct base simple type (str)' % {"value": value, "lineno": lineno, }) |
||
| 13369 | return False |
||
| 13370 | value = value |
||
| 13371 | enumerations = ['bilevel', 'greyscale', 'colour', 'other'] |
||
| 13372 | if value not in enumerations: |
||
| 13373 | lineno = self.gds_get_node_lineno_() |
||
| 13374 | self.gds_collector_.add_message('Value "%(value)s"%(lineno)s does not match xsd enumeration restriction on ColourDepthSimpleType' % {"value" : encode_str_2_3(value), "lineno": lineno} ) |
||
| 13375 | result = False |
||
| 13376 | def validate_ColourSimpleType(self, value): |
||
| 13377 | # Validate type pc:ColourSimpleType, a restriction on string. |
||
| 13378 | if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None: |
||
| 13379 | if not isinstance(value, str): |
||
| 13380 | lineno = self.gds_get_node_lineno_() |
||
| 13381 | self.gds_collector_.add_message('Value "%(value)s"%(lineno)s is not of the correct base simple type (str)' % {"value": value, "lineno": lineno, }) |
||
| 13382 | return False |
||
| 13383 | value = value |
||
| 13384 | enumerations = ['black', 'blue', 'brown', 'cyan', 'green', 'grey', 'indigo', 'magenta', 'orange', 'pink', 'red', 'turquoise', 'violet', 'white', 'yellow', 'other'] |
||
| 13385 | if value not in enumerations: |
||
| 13386 | lineno = self.gds_get_node_lineno_() |
||
| 13387 | self.gds_collector_.add_message('Value "%(value)s"%(lineno)s does not match xsd enumeration restriction on ColourSimpleType' % {"value" : encode_str_2_3(value), "lineno": lineno} ) |
||
| 13388 | result = False |
||
| 13389 | def hasContent_(self): |
||
| 13390 | if ( |
||
| 13391 | super(ImageRegionType, self).hasContent_() |
||
| 13392 | ): |
||
| 13393 | return True |
||
| 13394 | else: |
||
| 13395 | return False |
||
| 13396 | def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='ImageRegionType', pretty_print=True): |
||
| 13397 | imported_ns_def_ = GenerateDSNamespaceDefs_.get('ImageRegionType') |
||
| 13398 | if imported_ns_def_ is not None: |
||
| 13399 | namespacedef_ = imported_ns_def_ |
||
| 13400 | if pretty_print: |
||
| 13401 | eol_ = '\n' |
||
| 13402 | else: |
||
| 13403 | eol_ = '' |
||
| 13404 | if self.original_tagname_ is not None and name_ == 'ImageRegionType': |
||
| 13405 | name_ = self.original_tagname_ |
||
| 13406 | if UseCapturedNS_ and self.ns_prefix_: |
||
| 13407 | namespaceprefix_ = self.ns_prefix_ + ':' |
||
| 13408 | showIndent(outfile, level, pretty_print) |
||
| 13409 | outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) |
||
| 13410 | already_processed = set() |
||
| 13411 | self.exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='ImageRegionType') |
||
| 13412 | if self.hasContent_(): |
||
| 13413 | outfile.write('>%s' % (eol_, )) |
||
| 13414 | self.exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='ImageRegionType', pretty_print=pretty_print) |
||
| 13415 | showIndent(outfile, level, pretty_print) |
||
| 13416 | outfile.write('</%s%s>%s' % (namespaceprefix_, name_, eol_)) |
||
| 13417 | else: |
||
| 13418 | outfile.write('/>%s' % (eol_, )) |
||
| 13419 | def exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='ImageRegionType'): |
||
| 13420 | super(ImageRegionType, self).exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='ImageRegionType') |
||
| 13421 | if self.orientation is not None and 'orientation' not in already_processed: |
||
| 13422 | already_processed.add('orientation') |
||
| 13423 | outfile.write(' orientation="%s"' % self.gds_format_float(self.orientation, input_name='orientation')) |
||
| 13424 | if self.colourDepth is not None and 'colourDepth' not in already_processed: |
||
| 13425 | already_processed.add('colourDepth') |
||
| 13426 | outfile.write(' colourDepth=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.colourDepth), input_name='colourDepth')), )) |
||
| 13427 | if self.bgColour is not None and 'bgColour' not in already_processed: |
||
| 13428 | already_processed.add('bgColour') |
||
| 13429 | outfile.write(' bgColour=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.bgColour), input_name='bgColour')), )) |
||
| 13430 | if self.embText is not None and 'embText' not in already_processed: |
||
| 13431 | already_processed.add('embText') |
||
| 13432 | outfile.write(' embText="%s"' % self.gds_format_boolean(self.embText, input_name='embText')) |
||
| 13433 | def exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='ImageRegionType', fromsubclass_=False, pretty_print=True): |
||
| 13434 | super(ImageRegionType, self).exportChildren(outfile, level, namespaceprefix_, namespacedef_, name_, True, pretty_print=pretty_print) |
||
| 13435 | def to_etree(self, parent_element=None, name_='ImageRegionType', mapping_=None, nsmap_=None): |
||
| 13436 | element = super(ImageRegionType, self).to_etree(parent_element, name_, mapping_) |
||
| 13437 | if self.orientation is not None: |
||
| 13438 | element.set('orientation', self.gds_format_float(self.orientation)) |
||
| 13439 | if self.colourDepth is not None: |
||
| 13440 | element.set('colourDepth', self.gds_format_string(self.colourDepth)) |
||
| 13441 | if self.bgColour is not None: |
||
| 13442 | element.set('bgColour', self.gds_format_string(self.bgColour)) |
||
| 13443 | if self.embText is not None: |
||
| 13444 | element.set('embText', self.gds_format_boolean(self.embText)) |
||
| 13445 | if mapping_ is not None: |
||
| 13446 | mapping_[id(self)] = element |
||
| 13447 | return element |
||
| 13448 | def build(self, node, gds_collector_=None): |
||
| 13449 | self.gds_collector_ = gds_collector_ |
||
| 13450 | if SaveElementTreeNode: |
||
| 13451 | self.gds_elementtree_node_ = node |
||
| 13452 | already_processed = set() |
||
| 13453 | self.ns_prefix_ = node.prefix |
||
| 13454 | self.buildAttributes(node, node.attrib, already_processed) |
||
| 13455 | for child in node: |
||
| 13456 | nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] |
||
| 13457 | self.buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) |
||
| 13458 | return self |
||
| 13459 | def buildAttributes(self, node, attrs, already_processed): |
||
| 13460 | value = find_attr_value_('orientation', node) |
||
| 13461 | if value is not None and 'orientation' not in already_processed: |
||
| 13462 | already_processed.add('orientation') |
||
| 13463 | value = self.gds_parse_float(value, node, 'orientation') |
||
| 13464 | self.orientation = value |
||
| 13465 | value = find_attr_value_('colourDepth', node) |
||
| 13466 | if value is not None and 'colourDepth' not in already_processed: |
||
| 13467 | already_processed.add('colourDepth') |
||
| 13468 | self.colourDepth = value |
||
| 13469 | self.validate_ColourDepthSimpleType(self.colourDepth) # validate type ColourDepthSimpleType |
||
| 13470 | value = find_attr_value_('bgColour', node) |
||
| 13471 | if value is not None and 'bgColour' not in already_processed: |
||
| 13472 | already_processed.add('bgColour') |
||
| 13473 | self.bgColour = value |
||
| 13474 | self.validate_ColourSimpleType(self.bgColour) # validate type ColourSimpleType |
||
| 13475 | value = find_attr_value_('embText', node) |
||
| 13476 | if value is not None and 'embText' not in already_processed: |
||
| 13477 | already_processed.add('embText') |
||
| 13478 | if value in ('true', '1'): |
||
| 13479 | self.embText = True |
||
| 13480 | elif value in ('false', '0'): |
||
| 13481 | self.embText = False |
||
| 13482 | else: |
||
| 13483 | raise_parse_error(node, 'Bad boolean attribute') |
||
| 13484 | super(ImageRegionType, self).buildAttributes(node, attrs, already_processed) |
||
| 13485 | def buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None): |
||
| 13486 | super(ImageRegionType, self).buildChildren(child_, node, nodeName_, True) |
||
| 13487 | pass |
||
| 13488 | def __hash__(self): |
||
| 13489 | return hash(self.id) |
||
| 13490 | def set_orientation(self, orientation): |
||
| 13491 | """ |
||
| 13492 | Set deskewing angle to given `orientation` number. |
||
| 13493 | Moreover, invalidate self's ``pc:AlternativeImage``s |
||
| 13494 | (because they will have been rotated and enlarged |
||
| 13495 | with the angle of the previous value). |
||
| 13496 | """ |
||
| 13497 | if hasattr(self, 'invalidate_AlternativeImage'): |
||
| 13498 | # PageType, RegionType: |
||
| 13499 | self.invalidate_AlternativeImage(feature_selector='deskewed') |
||
| 13500 | self.orientation = orientation |
||
| 13501 | # end class ImageRegionType |
||
| 13502 | |||
| 13503 | |||
| 13504 | class TextRegionType(RegionType): |
||
| 13505 | """Pure text is represented as a text region. This includes |
||
| 13506 | drop capitals, but practically ornate text may be |
||
| 13507 | considered as a graphic. |
||
| 13508 | The angle the rectangle encapsulating the region |
||
| 13509 | has to be rotated in clockwise direction |
||
| 13510 | in order to correct the present skew |
||
| 13511 | (negative values indicate anti-clockwise rotation). |
||
| 13512 | (The rotated image can be further referenced |
||
| 13513 | via “AlternativeImage”.) |
||
| 13514 | Range: -179.999,180 |
||
| 13515 | The nature of the text in the region |
||
| 13516 | The degree of space in points between the lines of |
||
| 13517 | text (line spacing) |
||
| 13518 | The direction in which text within lines |
||
| 13519 | should be read (order of words and characters), |
||
| 13520 | in addition to “textLineOrder”. |
||
| 13521 | The order of text lines within the block, |
||
| 13522 | in addition to “readingDirection”. |
||
| 13523 | The angle the baseline of text within the region |
||
| 13524 | has to be rotated (relative to the rectangle |
||
| 13525 | encapsulating the region) in clockwise direction |
||
| 13526 | in order to correct the present skew, |
||
| 13527 | in addition to “orientation” |
||
| 13528 | (negative values indicate anti-clockwise rotation). |
||
| 13529 | Range: -179.999,180 |
||
| 13530 | Defines whether a region of text is indented or not |
||
| 13531 | Text align |
||
| 13532 | The primary language used in the region |
||
| 13533 | The secondary language used in the region |
||
| 13534 | The primary script used in the region |
||
| 13535 | The secondary script used in the region""" |
||
| 13536 | __hash__ = GeneratedsSuper.__hash__ |
||
| 13537 | member_data_items_ = [ |
||
| 13538 | MemberSpec_('orientation', 'float', 0, 1, {'use': 'optional'}), |
||
| 13539 | MemberSpec_('type_', 'pc:TextTypeSimpleType', 0, 1, {'use': 'optional'}), |
||
| 13540 | MemberSpec_('leading', 'int', 0, 1, {'use': 'optional'}), |
||
| 13541 | MemberSpec_('readingDirection', 'pc:ReadingDirectionSimpleType', 0, 1, {'use': 'optional'}), |
||
| 13542 | MemberSpec_('textLineOrder', 'pc:TextLineOrderSimpleType', 0, 1, {'use': 'optional'}), |
||
| 13543 | MemberSpec_('readingOrientation', 'float', 0, 1, {'use': 'optional'}), |
||
| 13544 | MemberSpec_('indented', 'boolean', 0, 1, {'use': 'optional'}), |
||
| 13545 | MemberSpec_('align', 'pc:AlignSimpleType', 0, 1, {'use': 'optional'}), |
||
| 13546 | MemberSpec_('primaryLanguage', 'pc:LanguageSimpleType', 0, 1, {'use': 'optional'}), |
||
| 13547 | MemberSpec_('secondaryLanguage', 'pc:LanguageSimpleType', 0, 1, {'use': 'optional'}), |
||
| 13548 | MemberSpec_('primaryScript', 'pc:ScriptSimpleType', 0, 1, {'use': 'optional'}), |
||
| 13549 | MemberSpec_('secondaryScript', 'pc:ScriptSimpleType', 0, 1, {'use': 'optional'}), |
||
| 13550 | MemberSpec_('production', 'pc:ProductionSimpleType', 0, 1, {'use': 'optional'}), |
||
| 13551 | MemberSpec_('TextLine', 'TextLineType', 1, 1, {'maxOccurs': 'unbounded', 'minOccurs': '0', 'name': 'TextLine', 'type': 'TextLineType'}, None), |
||
| 13552 | MemberSpec_('TextEquiv', 'TextEquivType', 1, 1, {'maxOccurs': 'unbounded', 'minOccurs': '0', 'name': 'TextEquiv', 'type': 'TextEquivType'}, None), |
||
| 13553 | MemberSpec_('TextStyle', 'TextStyleType', 0, 1, {'maxOccurs': '1', 'minOccurs': '0', 'name': 'TextStyle', 'type': 'TextStyleType'}, None), |
||
| 13554 | ] |
||
| 13555 | subclass = None |
||
| 13556 | superclass = RegionType |
||
| 13557 | def __init__(self, id=None, custom=None, comments=None, continuation=None, AlternativeImage=None, Coords=None, UserDefined=None, Labels=None, Roles=None, TextRegion=None, ImageRegion=None, LineDrawingRegion=None, GraphicRegion=None, TableRegion=None, ChartRegion=None, SeparatorRegion=None, MathsRegion=None, ChemRegion=None, MusicRegion=None, AdvertRegion=None, NoiseRegion=None, UnknownRegion=None, CustomRegion=None, orientation=None, type_=None, leading=None, readingDirection=None, textLineOrder=None, readingOrientation=None, indented=None, align=None, primaryLanguage=None, secondaryLanguage=None, primaryScript=None, secondaryScript=None, production=None, TextLine=None, TextEquiv=None, TextStyle=None, gds_collector_=None, **kwargs_): |
||
| 13558 | self.gds_collector_ = gds_collector_ |
||
| 13559 | self.gds_elementtree_node_ = None |
||
| 13560 | self.original_tagname_ = None |
||
| 13561 | self.parent_object_ = kwargs_.get('parent_object_') |
||
| 13562 | self.ns_prefix_ = None |
||
| 13563 | super(TextRegionType, self).__init__(id, custom, comments, continuation, AlternativeImage, Coords, UserDefined, Labels, Roles, TextRegion, ImageRegion, LineDrawingRegion, GraphicRegion, TableRegion, ChartRegion, SeparatorRegion, MathsRegion, ChemRegion, MusicRegion, AdvertRegion, NoiseRegion, UnknownRegion, CustomRegion, **kwargs_) |
||
| 13564 | self.orientation = _cast(float, orientation) |
||
| 13565 | self.orientation_nsprefix_ = "pc" |
||
| 13566 | self.type_ = _cast(None, type_) |
||
| 13567 | self.type__nsprefix_ = "pc" |
||
| 13568 | self.leading = _cast(int, leading) |
||
| 13569 | self.leading_nsprefix_ = "pc" |
||
| 13570 | self.readingDirection = _cast(None, readingDirection) |
||
| 13571 | self.readingDirection_nsprefix_ = "pc" |
||
| 13572 | self.textLineOrder = _cast(None, textLineOrder) |
||
| 13573 | self.textLineOrder_nsprefix_ = "pc" |
||
| 13574 | self.readingOrientation = _cast(float, readingOrientation) |
||
| 13575 | self.readingOrientation_nsprefix_ = "pc" |
||
| 13576 | self.indented = _cast(bool, indented) |
||
| 13577 | self.indented_nsprefix_ = "pc" |
||
| 13578 | self.align = _cast(None, align) |
||
| 13579 | self.align_nsprefix_ = "pc" |
||
| 13580 | self.primaryLanguage = _cast(None, primaryLanguage) |
||
| 13581 | self.primaryLanguage_nsprefix_ = "pc" |
||
| 13582 | self.secondaryLanguage = _cast(None, secondaryLanguage) |
||
| 13583 | self.secondaryLanguage_nsprefix_ = "pc" |
||
| 13584 | self.primaryScript = _cast(None, primaryScript) |
||
| 13585 | self.primaryScript_nsprefix_ = "pc" |
||
| 13586 | self.secondaryScript = _cast(None, secondaryScript) |
||
| 13587 | self.secondaryScript_nsprefix_ = "pc" |
||
| 13588 | self.production = _cast(None, production) |
||
| 13589 | self.production_nsprefix_ = "pc" |
||
| 13590 | if TextLine is None: |
||
| 13591 | self.TextLine = [] |
||
| 13592 | else: |
||
| 13593 | self.TextLine = TextLine |
||
| 13594 | self.TextLine_nsprefix_ = "pc" |
||
| 13595 | if TextEquiv is None: |
||
| 13596 | self.TextEquiv = [] |
||
| 13597 | else: |
||
| 13598 | self.TextEquiv = TextEquiv |
||
| 13599 | self.TextEquiv_nsprefix_ = "pc" |
||
| 13600 | self.TextStyle = TextStyle |
||
| 13601 | self.TextStyle_nsprefix_ = "pc" |
||
| 13602 | def factory(*args_, **kwargs_): |
||
| 13603 | if CurrentSubclassModule_ is not None: |
||
| 13604 | subclass = getSubclassFromModule_( |
||
| 13605 | CurrentSubclassModule_, TextRegionType) |
||
| 13606 | if subclass is not None: |
||
| 13607 | return subclass(*args_, **kwargs_) |
||
| 13608 | if TextRegionType.subclass: |
||
| 13609 | return TextRegionType.subclass(*args_, **kwargs_) |
||
| 13610 | else: |
||
| 13611 | return TextRegionType(*args_, **kwargs_) |
||
| 13612 | factory = staticmethod(factory) |
||
| 13613 | def get_ns_prefix_(self): |
||
| 13614 | return self.ns_prefix_ |
||
| 13615 | def set_ns_prefix_(self, ns_prefix): |
||
| 13616 | self.ns_prefix_ = ns_prefix |
||
| 13617 | def get_TextLine(self): |
||
| 13618 | return self.TextLine |
||
| 13619 | def set_TextLine(self, TextLine): |
||
| 13620 | self.TextLine = TextLine |
||
| 13621 | def add_TextLine(self, value): |
||
| 13622 | self.TextLine.append(value) |
||
| 13623 | def insert_TextLine_at(self, index, value): |
||
| 13624 | self.TextLine.insert(index, value) |
||
| 13625 | def replace_TextLine_at(self, index, value): |
||
| 13626 | self.TextLine[index] = value |
||
| 13627 | def get_TextEquiv(self): |
||
| 13628 | return self.TextEquiv |
||
| 13629 | def set_TextEquiv(self, TextEquiv): |
||
| 13630 | self.TextEquiv = TextEquiv |
||
| 13631 | def add_TextEquiv(self, value): |
||
| 13632 | self.TextEquiv.append(value) |
||
| 13633 | def insert_TextEquiv_at(self, index, value): |
||
| 13634 | self.TextEquiv.insert(index, value) |
||
| 13635 | def replace_TextEquiv_at(self, index, value): |
||
| 13636 | self.TextEquiv[index] = value |
||
| 13637 | def get_TextStyle(self): |
||
| 13638 | return self.TextStyle |
||
| 13639 | def set_TextStyle(self, TextStyle): |
||
| 13640 | self.TextStyle = TextStyle |
||
| 13641 | def get_orientation(self): |
||
| 13642 | return self.orientation |
||
| 13643 | def set_orientation(self, orientation): |
||
| 13644 | self.orientation = orientation |
||
| 13645 | def get_type(self): |
||
| 13646 | return self.type_ |
||
| 13647 | def set_type(self, type_): |
||
| 13648 | self.type_ = type_ |
||
| 13649 | def get_leading(self): |
||
| 13650 | return self.leading |
||
| 13651 | def set_leading(self, leading): |
||
| 13652 | self.leading = leading |
||
| 13653 | def get_readingDirection(self): |
||
| 13654 | return self.readingDirection |
||
| 13655 | def set_readingDirection(self, readingDirection): |
||
| 13656 | self.readingDirection = readingDirection |
||
| 13657 | def get_textLineOrder(self): |
||
| 13658 | return self.textLineOrder |
||
| 13659 | def set_textLineOrder(self, textLineOrder): |
||
| 13660 | self.textLineOrder = textLineOrder |
||
| 13661 | def get_readingOrientation(self): |
||
| 13662 | return self.readingOrientation |
||
| 13663 | def set_readingOrientation(self, readingOrientation): |
||
| 13664 | self.readingOrientation = readingOrientation |
||
| 13665 | def get_indented(self): |
||
| 13666 | return self.indented |
||
| 13667 | def set_indented(self, indented): |
||
| 13668 | self.indented = indented |
||
| 13669 | def get_align(self): |
||
| 13670 | return self.align |
||
| 13671 | def set_align(self, align): |
||
| 13672 | self.align = align |
||
| 13673 | def get_primaryLanguage(self): |
||
| 13674 | return self.primaryLanguage |
||
| 13675 | def set_primaryLanguage(self, primaryLanguage): |
||
| 13676 | self.primaryLanguage = primaryLanguage |
||
| 13677 | def get_secondaryLanguage(self): |
||
| 13678 | return self.secondaryLanguage |
||
| 13679 | def set_secondaryLanguage(self, secondaryLanguage): |
||
| 13680 | self.secondaryLanguage = secondaryLanguage |
||
| 13681 | def get_primaryScript(self): |
||
| 13682 | return self.primaryScript |
||
| 13683 | def set_primaryScript(self, primaryScript): |
||
| 13684 | self.primaryScript = primaryScript |
||
| 13685 | def get_secondaryScript(self): |
||
| 13686 | return self.secondaryScript |
||
| 13687 | def set_secondaryScript(self, secondaryScript): |
||
| 13688 | self.secondaryScript = secondaryScript |
||
| 13689 | def get_production(self): |
||
| 13690 | return self.production |
||
| 13691 | def set_production(self, production): |
||
| 13692 | self.production = production |
||
| 13693 | def validate_TextTypeSimpleType(self, value): |
||
| 13694 | # Validate type pc:TextTypeSimpleType, a restriction on string. |
||
| 13695 | if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None: |
||
| 13696 | if not isinstance(value, str): |
||
| 13697 | lineno = self.gds_get_node_lineno_() |
||
| 13698 | self.gds_collector_.add_message('Value "%(value)s"%(lineno)s is not of the correct base simple type (str)' % {"value": value, "lineno": lineno, }) |
||
| 13699 | return False |
||
| 13700 | value = value |
||
| 13701 | enumerations = ['paragraph', 'heading', 'caption', 'header', 'footer', 'page-number', 'drop-capital', 'credit', 'floating', 'signature-mark', 'catch-word', 'marginalia', 'footnote', 'footnote-continued', 'endnote', 'TOC-entry', 'list-label', 'other'] |
||
| 13702 | if value not in enumerations: |
||
| 13703 | lineno = self.gds_get_node_lineno_() |
||
| 13704 | self.gds_collector_.add_message('Value "%(value)s"%(lineno)s does not match xsd enumeration restriction on TextTypeSimpleType' % {"value" : encode_str_2_3(value), "lineno": lineno} ) |
||
| 13705 | result = False |
||
| 13706 | def validate_ReadingDirectionSimpleType(self, value): |
||
| 13707 | # Validate type pc:ReadingDirectionSimpleType, a restriction on string. |
||
| 13708 | if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None: |
||
| 13709 | if not isinstance(value, str): |
||
| 13710 | lineno = self.gds_get_node_lineno_() |
||
| 13711 | self.gds_collector_.add_message('Value "%(value)s"%(lineno)s is not of the correct base simple type (str)' % {"value": value, "lineno": lineno, }) |
||
| 13712 | return False |
||
| 13713 | value = value |
||
| 13714 | enumerations = ['left-to-right', 'right-to-left', 'top-to-bottom', 'bottom-to-top'] |
||
| 13715 | if value not in enumerations: |
||
| 13716 | lineno = self.gds_get_node_lineno_() |
||
| 13717 | self.gds_collector_.add_message('Value "%(value)s"%(lineno)s does not match xsd enumeration restriction on ReadingDirectionSimpleType' % {"value" : encode_str_2_3(value), "lineno": lineno} ) |
||
| 13718 | result = False |
||
| 13719 | def validate_TextLineOrderSimpleType(self, value): |
||
| 13720 | # Validate type pc:TextLineOrderSimpleType, a restriction on string. |
||
| 13721 | if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None: |
||
| 13722 | if not isinstance(value, str): |
||
| 13723 | lineno = self.gds_get_node_lineno_() |
||
| 13724 | self.gds_collector_.add_message('Value "%(value)s"%(lineno)s is not of the correct base simple type (str)' % {"value": value, "lineno": lineno, }) |
||
| 13725 | return False |
||
| 13726 | value = value |
||
| 13727 | enumerations = ['top-to-bottom', 'bottom-to-top', 'left-to-right', 'right-to-left'] |
||
| 13728 | if value not in enumerations: |
||
| 13729 | lineno = self.gds_get_node_lineno_() |
||
| 13730 | self.gds_collector_.add_message('Value "%(value)s"%(lineno)s does not match xsd enumeration restriction on TextLineOrderSimpleType' % {"value" : encode_str_2_3(value), "lineno": lineno} ) |
||
| 13731 | result = False |
||
| 13732 | def validate_AlignSimpleType(self, value): |
||
| 13733 | # Validate type pc:AlignSimpleType, a restriction on string. |
||
| 13734 | if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None: |
||
| 13735 | if not isinstance(value, str): |
||
| 13736 | lineno = self.gds_get_node_lineno_() |
||
| 13737 | self.gds_collector_.add_message('Value "%(value)s"%(lineno)s is not of the correct base simple type (str)' % {"value": value, "lineno": lineno, }) |
||
| 13738 | return False |
||
| 13739 | value = value |
||
| 13740 | enumerations = ['left', 'centre', 'right', 'justify'] |
||
| 13741 | if value not in enumerations: |
||
| 13742 | lineno = self.gds_get_node_lineno_() |
||
| 13743 | self.gds_collector_.add_message('Value "%(value)s"%(lineno)s does not match xsd enumeration restriction on AlignSimpleType' % {"value" : encode_str_2_3(value), "lineno": lineno} ) |
||
| 13744 | result = False |
||
| 13745 | def validate_LanguageSimpleType(self, value): |
||
| 13746 | # Validate type pc:LanguageSimpleType, a restriction on string. |
||
| 13747 | if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None: |
||
| 13748 | if not isinstance(value, str): |
||
| 13749 | lineno = self.gds_get_node_lineno_() |
||
| 13750 | self.gds_collector_.add_message('Value "%(value)s"%(lineno)s is not of the correct base simple type (str)' % {"value": value, "lineno": lineno, }) |
||
| 13751 | return False |
||
| 13752 | value = value |
||
| 13753 | enumerations = ['Abkhaz', 'Afar', 'Afrikaans', 'Akan', 'Albanian', 'Amharic', 'Arabic', 'Aragonese', 'Armenian', 'Assamese', 'Avaric', 'Avestan', 'Aymara', 'Azerbaijani', 'Bambara', 'Bashkir', 'Basque', 'Belarusian', 'Bengali', 'Bihari', 'Bislama', 'Bosnian', 'Breton', 'Bulgarian', 'Burmese', 'Cambodian', 'Cantonese', 'Catalan', 'Chamorro', 'Chechen', 'Chichewa', 'Chinese', 'Chuvash', 'Cornish', 'Corsican', 'Cree', 'Croatian', 'Czech', 'Danish', 'Divehi', 'Dutch', 'Dzongkha', 'English', 'Esperanto', 'Estonian', 'Ewe', 'Faroese', 'Fijian', 'Finnish', 'French', 'Fula', 'Gaelic', 'Galician', 'Ganda', 'Georgian', 'German', 'Greek', 'Guaraní', 'Gujarati', 'Haitian', 'Hausa', 'Hebrew', 'Herero', 'Hindi', 'Hiri Motu', 'Hungarian', 'Icelandic', 'Ido', 'Igbo', 'Indonesian', 'Interlingua', 'Interlingue', 'Inuktitut', 'Inupiaq', 'Irish', 'Italian', 'Japanese', 'Javanese', 'Kalaallisut', 'Kannada', 'Kanuri', 'Kashmiri', 'Kazakh', 'Khmer', 'Kikuyu', 'Kinyarwanda', 'Kirundi', 'Komi', 'Kongo', 'Korean', 'Kurdish', 'Kwanyama', 'Kyrgyz', 'Lao', 'Latin', 'Latvian', 'Limburgish', 'Lingala', 'Lithuanian', 'Luba-Katanga', 'Luxembourgish', 'Macedonian', 'Malagasy', 'Malay', 'Malayalam', 'Maltese', 'Manx', 'Māori', 'Marathi', 'Marshallese', 'Mongolian', 'Nauru', 'Navajo', 'Ndonga', 'Nepali', 'North Ndebele', 'Northern Sami', 'Norwegian', 'Norwegian Bokmål', 'Norwegian Nynorsk', 'Nuosu', 'Occitan', 'Ojibwe', 'Old Church Slavonic', 'Oriya', 'Oromo', 'Ossetian', 'Pāli', 'Panjabi', 'Pashto', 'Persian', 'Polish', 'Portuguese', 'Punjabi', 'Quechua', 'Romanian', 'Romansh', 'Russian', 'Samoan', 'Sango', 'Sanskrit', 'Sardinian', 'Serbian', 'Shona', 'Sindhi', 'Sinhala', 'Slovak', 'Slovene', 'Somali', 'South Ndebele', 'Southern Sotho', 'Spanish', 'Sundanese', 'Swahili', 'Swati', 'Swedish', 'Tagalog', 'Tahitian', 'Tajik', 'Tamil', 'Tatar', 'Telugu', 'Thai', 'Tibetan', 'Tigrinya', 'Tonga', 'Tsonga', 'Tswana', 'Turkish', 'Turkmen', 'Twi', 'Uighur', 'Ukrainian', 'Urdu', 'Uzbek', 'Venda', 'Vietnamese', 'Volapük', 'Walloon', 'Welsh', 'Western Frisian', 'Wolof', 'Xhosa', 'Yiddish', 'Yoruba', 'Zhuang', 'Zulu', 'other'] |
||
| 13754 | if value not in enumerations: |
||
| 13755 | lineno = self.gds_get_node_lineno_() |
||
| 13756 | self.gds_collector_.add_message('Value "%(value)s"%(lineno)s does not match xsd enumeration restriction on LanguageSimpleType' % {"value" : encode_str_2_3(value), "lineno": lineno} ) |
||
| 13757 | result = False |
||
| 13758 | def validate_ScriptSimpleType(self, value): |
||
| 13759 | # Validate type pc:ScriptSimpleType, a restriction on string. |
||
| 13760 | if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None: |
||
| 13761 | if not isinstance(value, str): |
||
| 13762 | lineno = self.gds_get_node_lineno_() |
||
| 13763 | self.gds_collector_.add_message('Value "%(value)s"%(lineno)s is not of the correct base simple type (str)' % {"value": value, "lineno": lineno, }) |
||
| 13764 | return False |
||
| 13765 | value = value |
||
| 13766 | enumerations = ['Adlm - Adlam', 'Afak - Afaka', 'Aghb - Caucasian Albanian', 'Ahom - Ahom, Tai Ahom', 'Arab - Arabic', 'Aran - Arabic (Nastaliq variant)', 'Armi - Imperial Aramaic', 'Armn - Armenian', 'Avst - Avestan', 'Bali - Balinese', 'Bamu - Bamum', 'Bass - Bassa Vah', 'Batk - Batak', 'Beng - Bengali', 'Bhks - Bhaiksuki', 'Blis - Blissymbols', 'Bopo - Bopomofo', 'Brah - Brahmi', 'Brai - Braille', 'Bugi - Buginese', 'Buhd - Buhid', 'Cakm - Chakma', 'Cans - Unified Canadian Aboriginal Syllabics', 'Cari - Carian', 'Cham - Cham', 'Cher - Cherokee', 'Cirt - Cirth', 'Copt - Coptic', 'Cprt - Cypriot', 'Cyrl - Cyrillic', 'Cyrs - Cyrillic (Old Church Slavonic variant)', 'Deva - Devanagari (Nagari)', 'Dsrt - Deseret (Mormon)', 'Dupl - Duployan shorthand, Duployan stenography', 'Egyd - Egyptian demotic', 'Egyh - Egyptian hieratic', 'Egyp - Egyptian hieroglyphs', 'Elba - Elbasan', 'Ethi - Ethiopic', 'Geok - Khutsuri (Asomtavruli and Nuskhuri)', 'Geor - Georgian (Mkhedruli)', 'Glag - Glagolitic', 'Goth - Gothic', 'Gran - Grantha', 'Grek - Greek', 'Gujr - Gujarati', 'Guru - Gurmukhi', 'Hanb - Han with Bopomofo', 'Hang - Hangul', 'Hani - Han (Hanzi, Kanji, Hanja)', 'Hano - Hanunoo (Hanunóo)', 'Hans - Han (Simplified variant)', 'Hant - Han (Traditional variant)', 'Hatr - Hatran', 'Hebr - Hebrew', 'Hira - Hiragana', 'Hluw - Anatolian Hieroglyphs', 'Hmng - Pahawh Hmong', 'Hrkt - Japanese syllabaries', 'Hung - Old Hungarian (Hungarian Runic)', 'Inds - Indus (Harappan)', 'Ital - Old Italic (Etruscan, Oscan etc.)', 'Jamo - Jamo', 'Java - Javanese', 'Jpan - Japanese', 'Jurc - Jurchen', 'Kali - Kayah Li', 'Kana - Katakana', 'Khar - Kharoshthi', 'Khmr - Khmer', 'Khoj - Khojki', 'Kitl - Khitan large script', 'Kits - Khitan small script', 'Knda - Kannada', 'Kore - Korean (alias for Hangul + Han)', 'Kpel - Kpelle', 'Kthi - Kaithi', 'Lana - Tai Tham (Lanna)', 'Laoo - Lao', 'Latf - Latin (Fraktur variant)', 'Latg - Latin (Gaelic variant)', 'Latn - Latin', 'Leke - Leke', 'Lepc - Lepcha (Róng)', 'Limb - Limbu', 'Lina - Linear A', 'Linb - Linear B', 'Lisu - Lisu (Fraser)', 'Loma - Loma', 'Lyci - Lycian', 'Lydi - Lydian', 'Mahj - Mahajani', 'Mand - Mandaic, Mandaean', 'Mani - Manichaean', 'Marc - Marchen', 'Maya - Mayan hieroglyphs', 'Mend - Mende Kikakui', 'Merc - Meroitic Cursive', 'Mero - Meroitic Hieroglyphs', 'Mlym - Malayalam', 'Modi - Modi, Moḍī', 'Mong - Mongolian', 'Moon - Moon (Moon code, Moon script, Moon type)', 'Mroo - Mro, Mru', 'Mtei - Meitei Mayek (Meithei, Meetei)', 'Mult - Multani', 'Mymr - Myanmar (Burmese)', 'Narb - Old North Arabian (Ancient North Arabian)', 'Nbat - Nabataean', 'Newa - Newa, Newar, Newari', 'Nkgb - Nakhi Geba', 'Nkoo - N’Ko', 'Nshu - Nüshu', 'Ogam - Ogham', 'Olck - Ol Chiki (Ol Cemet’, Ol, Santali)', 'Orkh - Old Turkic, Orkhon Runic', 'Orya - Oriya', 'Osge - Osage', 'Osma - Osmanya', 'Palm - Palmyrene', 'Pauc - Pau Cin Hau', 'Perm - Old Permic', 'Phag - Phags-pa', 'Phli - Inscriptional Pahlavi', 'Phlp - Psalter Pahlavi', 'Phlv - Book Pahlavi', 'Phnx - Phoenician', 'Piqd - Klingon (KLI pIqaD)', 'Plrd - Miao (Pollard)', 'Prti - Inscriptional Parthian', 'Rjng - Rejang (Redjang, Kaganga)', 'Roro - Rongorongo', 'Runr - Runic', 'Samr - Samaritan', 'Sara - Sarati', 'Sarb - Old South Arabian', 'Saur - Saurashtra', 'Sgnw - SignWriting', 'Shaw - Shavian (Shaw)', 'Shrd - Sharada, Śāradā', 'Sidd - Siddham', 'Sind - Khudawadi, Sindhi', 'Sinh - Sinhala', 'Sora - Sora Sompeng', 'Sund - Sundanese', 'Sylo - Syloti Nagri', 'Syrc - Syriac', 'Syre - Syriac (Estrangelo variant)', 'Syrj - Syriac (Western variant)', 'Syrn - Syriac (Eastern variant)', 'Tagb - Tagbanwa', 'Takr - Takri', 'Tale - Tai Le', 'Talu - New Tai Lue', 'Taml - Tamil', 'Tang - Tangut', 'Tavt - Tai Viet', 'Telu - Telugu', 'Teng - Tengwar', 'Tfng - Tifinagh (Berber)', 'Tglg - Tagalog (Baybayin, Alibata)', 'Thaa - Thaana', 'Thai - Thai', 'Tibt - Tibetan', 'Tirh - Tirhuta', 'Ugar - Ugaritic', 'Vaii - Vai', 'Visp - Visible Speech', 'Wara - Warang Citi (Varang Kshiti)', 'Wole - Woleai', 'Xpeo - Old Persian', 'Xsux - Cuneiform, Sumero-Akkadian', 'Yiii - Yi', 'Zinh - Code for inherited script', 'Zmth - Mathematical notation', 'Zsye - Symbols (Emoji variant)', 'Zsym - Symbols', 'Zxxx - Code for unwritten documents', 'Zyyy - Code for undetermined script', 'Zzzz - Code for uncoded script', 'other'] |
||
| 13767 | if value not in enumerations: |
||
| 13768 | lineno = self.gds_get_node_lineno_() |
||
| 13769 | self.gds_collector_.add_message('Value "%(value)s"%(lineno)s does not match xsd enumeration restriction on ScriptSimpleType' % {"value" : encode_str_2_3(value), "lineno": lineno} ) |
||
| 13770 | result = False |
||
| 13771 | def validate_ProductionSimpleType(self, value): |
||
| 13772 | # Validate type pc:ProductionSimpleType, a restriction on string. |
||
| 13773 | if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None: |
||
| 13774 | if not isinstance(value, str): |
||
| 13775 | lineno = self.gds_get_node_lineno_() |
||
| 13776 | self.gds_collector_.add_message('Value "%(value)s"%(lineno)s is not of the correct base simple type (str)' % {"value": value, "lineno": lineno, }) |
||
| 13777 | return False |
||
| 13778 | value = value |
||
| 13779 | enumerations = ['printed', 'typewritten', 'handwritten-cursive', 'handwritten-printscript', 'medieval-manuscript', 'other'] |
||
| 13780 | if value not in enumerations: |
||
| 13781 | lineno = self.gds_get_node_lineno_() |
||
| 13782 | self.gds_collector_.add_message('Value "%(value)s"%(lineno)s does not match xsd enumeration restriction on ProductionSimpleType' % {"value" : encode_str_2_3(value), "lineno": lineno} ) |
||
| 13783 | result = False |
||
| 13784 | def hasContent_(self): |
||
| 13785 | if ( |
||
| 13786 | self.TextLine or |
||
| 13787 | self.TextEquiv or |
||
| 13788 | self.TextStyle is not None or |
||
| 13789 | super(TextRegionType, self).hasContent_() |
||
| 13790 | ): |
||
| 13791 | return True |
||
| 13792 | else: |
||
| 13793 | return False |
||
| 13794 | def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='TextRegionType', pretty_print=True): |
||
| 13795 | imported_ns_def_ = GenerateDSNamespaceDefs_.get('TextRegionType') |
||
| 13796 | if imported_ns_def_ is not None: |
||
| 13797 | namespacedef_ = imported_ns_def_ |
||
| 13798 | if pretty_print: |
||
| 13799 | eol_ = '\n' |
||
| 13800 | else: |
||
| 13801 | eol_ = '' |
||
| 13802 | if self.original_tagname_ is not None and name_ == 'TextRegionType': |
||
| 13803 | name_ = self.original_tagname_ |
||
| 13804 | if UseCapturedNS_ and self.ns_prefix_: |
||
| 13805 | namespaceprefix_ = self.ns_prefix_ + ':' |
||
| 13806 | showIndent(outfile, level, pretty_print) |
||
| 13807 | outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) |
||
| 13808 | already_processed = set() |
||
| 13809 | self.exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='TextRegionType') |
||
| 13810 | if self.hasContent_(): |
||
| 13811 | outfile.write('>%s' % (eol_, )) |
||
| 13812 | self.exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='TextRegionType', pretty_print=pretty_print) |
||
| 13813 | showIndent(outfile, level, pretty_print) |
||
| 13814 | outfile.write('</%s%s>%s' % (namespaceprefix_, name_, eol_)) |
||
| 13815 | else: |
||
| 13816 | outfile.write('/>%s' % (eol_, )) |
||
| 13817 | def exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='TextRegionType'): |
||
| 13818 | super(TextRegionType, self).exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='TextRegionType') |
||
| 13819 | if self.orientation is not None and 'orientation' not in already_processed: |
||
| 13820 | already_processed.add('orientation') |
||
| 13821 | outfile.write(' orientation="%s"' % self.gds_format_float(self.orientation, input_name='orientation')) |
||
| 13822 | if self.type_ is not None and 'type_' not in already_processed: |
||
| 13823 | already_processed.add('type_') |
||
| 13824 | outfile.write(' type=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.type_), input_name='type')), )) |
||
| 13825 | if self.leading is not None and 'leading' not in already_processed: |
||
| 13826 | already_processed.add('leading') |
||
| 13827 | outfile.write(' leading="%s"' % self.gds_format_integer(self.leading, input_name='leading')) |
||
| 13828 | if self.readingDirection is not None and 'readingDirection' not in already_processed: |
||
| 13829 | already_processed.add('readingDirection') |
||
| 13830 | outfile.write(' readingDirection=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.readingDirection), input_name='readingDirection')), )) |
||
| 13831 | if self.textLineOrder is not None and 'textLineOrder' not in already_processed: |
||
| 13832 | already_processed.add('textLineOrder') |
||
| 13833 | outfile.write(' textLineOrder=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.textLineOrder), input_name='textLineOrder')), )) |
||
| 13834 | if self.readingOrientation is not None and 'readingOrientation' not in already_processed: |
||
| 13835 | already_processed.add('readingOrientation') |
||
| 13836 | outfile.write(' readingOrientation="%s"' % self.gds_format_float(self.readingOrientation, input_name='readingOrientation')) |
||
| 13837 | if self.indented is not None and 'indented' not in already_processed: |
||
| 13838 | already_processed.add('indented') |
||
| 13839 | outfile.write(' indented="%s"' % self.gds_format_boolean(self.indented, input_name='indented')) |
||
| 13840 | if self.align is not None and 'align' not in already_processed: |
||
| 13841 | already_processed.add('align') |
||
| 13842 | outfile.write(' align=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.align), input_name='align')), )) |
||
| 13843 | if self.primaryLanguage is not None and 'primaryLanguage' not in already_processed: |
||
| 13844 | already_processed.add('primaryLanguage') |
||
| 13845 | outfile.write(' primaryLanguage=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.primaryLanguage), input_name='primaryLanguage')), )) |
||
| 13846 | if self.secondaryLanguage is not None and 'secondaryLanguage' not in already_processed: |
||
| 13847 | already_processed.add('secondaryLanguage') |
||
| 13848 | outfile.write(' secondaryLanguage=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.secondaryLanguage), input_name='secondaryLanguage')), )) |
||
| 13849 | if self.primaryScript is not None and 'primaryScript' not in already_processed: |
||
| 13850 | already_processed.add('primaryScript') |
||
| 13851 | outfile.write(' primaryScript=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.primaryScript), input_name='primaryScript')), )) |
||
| 13852 | if self.secondaryScript is not None and 'secondaryScript' not in already_processed: |
||
| 13853 | already_processed.add('secondaryScript') |
||
| 13854 | outfile.write(' secondaryScript=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.secondaryScript), input_name='secondaryScript')), )) |
||
| 13855 | if self.production is not None and 'production' not in already_processed: |
||
| 13856 | already_processed.add('production') |
||
| 13857 | outfile.write(' production=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.production), input_name='production')), )) |
||
| 13858 | def exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='TextRegionType', fromsubclass_=False, pretty_print=True): |
||
| 13859 | super(TextRegionType, self).exportChildren(outfile, level, namespaceprefix_, namespacedef_, name_, True, pretty_print=pretty_print) |
||
| 13860 | if pretty_print: |
||
| 13861 | eol_ = '\n' |
||
| 13862 | else: |
||
| 13863 | eol_ = '' |
||
| 13864 | for TextLine_ in self.TextLine: |
||
| 13865 | namespaceprefix_ = self.TextLine_nsprefix_ + ':' if (UseCapturedNS_ and self.TextLine_nsprefix_) else '' |
||
| 13866 | TextLine_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='TextLine', pretty_print=pretty_print) |
||
| 13867 | for TextEquiv_ in self.TextEquiv: |
||
| 13868 | namespaceprefix_ = self.TextEquiv_nsprefix_ + ':' if (UseCapturedNS_ and self.TextEquiv_nsprefix_) else '' |
||
| 13869 | TextEquiv_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='TextEquiv', pretty_print=pretty_print) |
||
| 13870 | if self.TextStyle is not None: |
||
| 13871 | namespaceprefix_ = self.TextStyle_nsprefix_ + ':' if (UseCapturedNS_ and self.TextStyle_nsprefix_) else '' |
||
| 13872 | self.TextStyle.export(outfile, level, namespaceprefix_, namespacedef_='', name_='TextStyle', pretty_print=pretty_print) |
||
| 13873 | def to_etree(self, parent_element=None, name_='TextRegionType', mapping_=None, nsmap_=None): |
||
| 13874 | element = super(TextRegionType, self).to_etree(parent_element, name_, mapping_) |
||
| 13875 | if self.orientation is not None: |
||
| 13876 | element.set('orientation', self.gds_format_float(self.orientation)) |
||
| 13877 | if self.type_ is not None: |
||
| 13878 | element.set('type', self.gds_format_string(self.type_)) |
||
| 13879 | if self.leading is not None: |
||
| 13880 | element.set('leading', self.gds_format_integer(self.leading)) |
||
| 13881 | if self.readingDirection is not None: |
||
| 13882 | element.set('readingDirection', self.gds_format_string(self.readingDirection)) |
||
| 13883 | if self.textLineOrder is not None: |
||
| 13884 | element.set('textLineOrder', self.gds_format_string(self.textLineOrder)) |
||
| 13885 | if self.readingOrientation is not None: |
||
| 13886 | element.set('readingOrientation', self.gds_format_float(self.readingOrientation)) |
||
| 13887 | if self.indented is not None: |
||
| 13888 | element.set('indented', self.gds_format_boolean(self.indented)) |
||
| 13889 | if self.align is not None: |
||
| 13890 | element.set('align', self.gds_format_string(self.align)) |
||
| 13891 | if self.primaryLanguage is not None: |
||
| 13892 | element.set('primaryLanguage', self.gds_format_string(self.primaryLanguage)) |
||
| 13893 | if self.secondaryLanguage is not None: |
||
| 13894 | element.set('secondaryLanguage', self.gds_format_string(self.secondaryLanguage)) |
||
| 13895 | if self.primaryScript is not None: |
||
| 13896 | element.set('primaryScript', self.gds_format_string(self.primaryScript)) |
||
| 13897 | if self.secondaryScript is not None: |
||
| 13898 | element.set('secondaryScript', self.gds_format_string(self.secondaryScript)) |
||
| 13899 | if self.production is not None: |
||
| 13900 | element.set('production', self.gds_format_string(self.production)) |
||
| 13901 | for TextLine_ in self.TextLine: |
||
| 13902 | TextLine_.to_etree(element, name_='TextLine', mapping_=mapping_, nsmap_=nsmap_) |
||
| 13903 | for TextEquiv_ in self.TextEquiv: |
||
| 13904 | TextEquiv_.to_etree(element, name_='TextEquiv', mapping_=mapping_, nsmap_=nsmap_) |
||
| 13905 | if self.TextStyle is not None: |
||
| 13906 | TextStyle_ = self.TextStyle |
||
| 13907 | TextStyle_.to_etree(element, name_='TextStyle', mapping_=mapping_, nsmap_=nsmap_) |
||
| 13908 | if mapping_ is not None: |
||
| 13909 | mapping_[id(self)] = element |
||
| 13910 | return element |
||
| 13911 | def build(self, node, gds_collector_=None): |
||
| 13912 | self.gds_collector_ = gds_collector_ |
||
| 13913 | if SaveElementTreeNode: |
||
| 13914 | self.gds_elementtree_node_ = node |
||
| 13915 | already_processed = set() |
||
| 13916 | self.ns_prefix_ = node.prefix |
||
| 13917 | self.buildAttributes(node, node.attrib, already_processed) |
||
| 13918 | for child in node: |
||
| 13919 | nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] |
||
| 13920 | self.buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) |
||
| 13921 | return self |
||
| 13922 | def buildAttributes(self, node, attrs, already_processed): |
||
| 13923 | value = find_attr_value_('orientation', node) |
||
| 13924 | if value is not None and 'orientation' not in already_processed: |
||
| 13925 | already_processed.add('orientation') |
||
| 13926 | value = self.gds_parse_float(value, node, 'orientation') |
||
| 13927 | self.orientation = value |
||
| 13928 | value = find_attr_value_('type', node) |
||
| 13929 | if value is not None and 'type' not in already_processed: |
||
| 13930 | already_processed.add('type') |
||
| 13931 | self.type_ = value |
||
| 13932 | self.validate_TextTypeSimpleType(self.type_) # validate type TextTypeSimpleType |
||
| 13933 | value = find_attr_value_('leading', node) |
||
| 13934 | if value is not None and 'leading' not in already_processed: |
||
| 13935 | already_processed.add('leading') |
||
| 13936 | self.leading = self.gds_parse_integer(value, node, 'leading') |
||
| 13937 | value = find_attr_value_('readingDirection', node) |
||
| 13938 | if value is not None and 'readingDirection' not in already_processed: |
||
| 13939 | already_processed.add('readingDirection') |
||
| 13940 | self.readingDirection = value |
||
| 13941 | self.validate_ReadingDirectionSimpleType(self.readingDirection) # validate type ReadingDirectionSimpleType |
||
| 13942 | value = find_attr_value_('textLineOrder', node) |
||
| 13943 | if value is not None and 'textLineOrder' not in already_processed: |
||
| 13944 | already_processed.add('textLineOrder') |
||
| 13945 | self.textLineOrder = value |
||
| 13946 | self.validate_TextLineOrderSimpleType(self.textLineOrder) # validate type TextLineOrderSimpleType |
||
| 13947 | value = find_attr_value_('readingOrientation', node) |
||
| 13948 | if value is not None and 'readingOrientation' not in already_processed: |
||
| 13949 | already_processed.add('readingOrientation') |
||
| 13950 | value = self.gds_parse_float(value, node, 'readingOrientation') |
||
| 13951 | self.readingOrientation = value |
||
| 13952 | value = find_attr_value_('indented', node) |
||
| 13953 | if value is not None and 'indented' not in already_processed: |
||
| 13954 | already_processed.add('indented') |
||
| 13955 | if value in ('true', '1'): |
||
| 13956 | self.indented = True |
||
| 13957 | elif value in ('false', '0'): |
||
| 13958 | self.indented = False |
||
| 13959 | else: |
||
| 13960 | raise_parse_error(node, 'Bad boolean attribute') |
||
| 13961 | value = find_attr_value_('align', node) |
||
| 13962 | if value is not None and 'align' not in already_processed: |
||
| 13963 | already_processed.add('align') |
||
| 13964 | self.align = value |
||
| 13965 | self.validate_AlignSimpleType(self.align) # validate type AlignSimpleType |
||
| 13966 | value = find_attr_value_('primaryLanguage', node) |
||
| 13967 | if value is not None and 'primaryLanguage' not in already_processed: |
||
| 13968 | already_processed.add('primaryLanguage') |
||
| 13969 | self.primaryLanguage = value |
||
| 13970 | self.validate_LanguageSimpleType(self.primaryLanguage) # validate type LanguageSimpleType |
||
| 13971 | value = find_attr_value_('secondaryLanguage', node) |
||
| 13972 | if value is not None and 'secondaryLanguage' not in already_processed: |
||
| 13973 | already_processed.add('secondaryLanguage') |
||
| 13974 | self.secondaryLanguage = value |
||
| 13975 | self.validate_LanguageSimpleType(self.secondaryLanguage) # validate type LanguageSimpleType |
||
| 13976 | value = find_attr_value_('primaryScript', node) |
||
| 13977 | if value is not None and 'primaryScript' not in already_processed: |
||
| 13978 | already_processed.add('primaryScript') |
||
| 13979 | self.primaryScript = value |
||
| 13980 | self.validate_ScriptSimpleType(self.primaryScript) # validate type ScriptSimpleType |
||
| 13981 | value = find_attr_value_('secondaryScript', node) |
||
| 13982 | if value is not None and 'secondaryScript' not in already_processed: |
||
| 13983 | already_processed.add('secondaryScript') |
||
| 13984 | self.secondaryScript = value |
||
| 13985 | self.validate_ScriptSimpleType(self.secondaryScript) # validate type ScriptSimpleType |
||
| 13986 | value = find_attr_value_('production', node) |
||
| 13987 | if value is not None and 'production' not in already_processed: |
||
| 13988 | already_processed.add('production') |
||
| 13989 | self.production = value |
||
| 13990 | self.validate_ProductionSimpleType(self.production) # validate type ProductionSimpleType |
||
| 13991 | super(TextRegionType, self).buildAttributes(node, attrs, already_processed) |
||
| 13992 | def buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None): |
||
| 13993 | if nodeName_ == 'TextLine': |
||
| 13994 | obj_ = TextLineType.factory(parent_object_=self) |
||
| 13995 | obj_.build(child_, gds_collector_=gds_collector_) |
||
| 13996 | self.TextLine.append(obj_) |
||
| 13997 | obj_.original_tagname_ = 'TextLine' |
||
| 13998 | elif nodeName_ == 'TextEquiv': |
||
| 13999 | obj_ = TextEquivType.factory(parent_object_=self) |
||
| 14000 | obj_.build(child_, gds_collector_=gds_collector_) |
||
| 14001 | self.TextEquiv.append(obj_) |
||
| 14002 | obj_.original_tagname_ = 'TextEquiv' |
||
| 14003 | elif nodeName_ == 'TextStyle': |
||
| 14004 | obj_ = TextStyleType.factory(parent_object_=self) |
||
| 14005 | obj_.build(child_, gds_collector_=gds_collector_) |
||
| 14006 | self.TextStyle = obj_ |
||
| 14007 | obj_.original_tagname_ = 'TextStyle' |
||
| 14008 | super(TextRegionType, self).buildChildren(child_, node, nodeName_, True) |
||
| 14009 | def __hash__(self): |
||
| 14010 | return hash(self.id) |
||
| 14011 | def set_orientation(self, orientation): |
||
| 14012 | """ |
||
| 14013 | Set deskewing angle to given `orientation` number. |
||
| 14014 | Moreover, invalidate self's ``pc:AlternativeImage``s |
||
| 14015 | (because they will have been rotated and enlarged |
||
| 14016 | with the angle of the previous value). |
||
| 14017 | """ |
||
| 14018 | if hasattr(self, 'invalidate_AlternativeImage'): |
||
| 14019 | # PageType, RegionType: |
||
| 14020 | self.invalidate_AlternativeImage(feature_selector='deskewed') |
||
| 14021 | self.orientation = orientation |
||
| 14022 | # end class TextRegionType |
||
| 14023 | |||
| 14024 | |||
| 14025 | GDSClassesMapping = { |
||
| 14026 | 'PcGts': PcGtsType, |
||
| 14027 | } |
||
| 14028 | |||
| 14029 | |||
| 14030 | USAGE_TEXT = """ |
||
| 14031 | Usage: python <Parser>.py [ -s ] <in_xml_file> |
||
| 14032 | """ |
||
| 14033 | |||
| 14034 | |||
| 14035 | def usage(): |
||
| 14036 | print(USAGE_TEXT) |
||
| 14037 | sys.exit(1) |
||
| 14038 | |||
| 14039 | |||
| 14040 | def get_root_tag(node): |
||
| 14041 | tag = Tag_pattern_.match(node.tag).groups()[-1] |
||
| 14042 | rootClass = GDSClassesMapping.get(tag) |
||
| 14043 | if rootClass is None: |
||
| 14044 | rootClass = globals().get(tag) |
||
| 14045 | return tag, rootClass |
||
| 14046 | |||
| 14047 | |||
| 14048 | def get_required_ns_prefix_defs(rootNode): |
||
| 14049 | '''Get all name space prefix definitions required in this XML doc. |
||
| 14050 | Return a dictionary of definitions and a char string of definitions. |
||
| 14051 | ''' |
||
| 14052 | nsmap = { |
||
| 14053 | prefix: uri |
||
| 14054 | for node in rootNode.iter() |
||
| 14055 | for (prefix, uri) in node.nsmap.items() |
||
| 14056 | if prefix is not None |
||
| 14057 | } |
||
| 14058 | namespacedefs = ' '.join([ |
||
| 14059 | 'xmlns:{}="{}"'.format(prefix, uri) |
||
| 14060 | for prefix, uri in nsmap.items() |
||
| 14061 | ]) |
||
| 14062 | return nsmap, namespacedefs |
||
| 14063 | |||
| 14064 | |||
| 14065 | def parse(inFileName, silence=False, print_warnings=True): |
||
| 14066 | global CapturedNsmap_ |
||
| 14067 | gds_collector = GdsCollector_() |
||
| 14068 | parser = None |
||
| 14069 | doc = parsexml_(inFileName, parser) |
||
| 14070 | rootNode = doc.getroot() |
||
| 14071 | rootTag, rootClass = get_root_tag(rootNode) |
||
| 14072 | if rootClass is None: |
||
| 14073 | rootTag = 'PcGts' |
||
| 14074 | rootClass = PcGts |
||
| 14075 | rootObj = rootClass.factory() |
||
| 14076 | rootObj.build(rootNode, gds_collector_=gds_collector) |
||
| 14077 | CapturedNsmap_, namespacedefs = get_required_ns_prefix_defs(rootNode) |
||
| 14078 | if not SaveElementTreeNode: |
||
| 14079 | doc = None |
||
| 14080 | rootNode = None |
||
| 14081 | ## if not silence: |
||
| 14082 | ## sys.stdout.write('<?xml version="1.0" ?>\n') |
||
| 14083 | ## rootObj.export( |
||
| 14084 | ## sys.stdout, 0, name_=rootTag, |
||
| 14085 | ## namespacedef_=namespacedefs, |
||
| 14086 | ## pretty_print=True) |
||
| 14087 | if print_warnings and len(gds_collector.get_messages()) > 0: |
||
| 14088 | separator = ('-' * 50) + '\n' |
||
| 14089 | sys.stderr.write(separator) |
||
| 14090 | sys.stderr.write('----- Warnings -- count: {} -----\n'.format( |
||
| 14091 | len(gds_collector.get_messages()), )) |
||
| 14092 | gds_collector.write_messages(sys.stderr) |
||
| 14093 | sys.stderr.write(separator) |
||
| 14094 | return rootObj |
||
| 14095 | |||
| 14096 | |||
| 14097 | def parseEtree(inFileName, silence=False, print_warnings=True, |
||
| 14098 | mapping=None, nsmap=None): |
||
| 14099 | parser = None |
||
| 14100 | doc = parsexml_(inFileName, parser) |
||
| 14101 | gds_collector = GdsCollector_() |
||
| 14102 | rootNode = doc.getroot() |
||
| 14103 | rootTag, rootClass = get_root_tag(rootNode) |
||
| 14104 | if rootClass is None: |
||
| 14105 | rootTag = 'PcGts' |
||
| 14106 | rootClass = PcGts |
||
| 14107 | rootObj = rootClass.factory() |
||
| 14108 | rootObj.build(rootNode, gds_collector_=gds_collector) |
||
| 14109 | # Enable Python to collect the space used by the DOM. |
||
| 14110 | if mapping is None: |
||
| 14111 | mapping = {} |
||
| 14112 | rootElement = rootObj.to_etree( |
||
| 14113 | None, name_=rootTag, mapping_=mapping, nsmap_=nsmap) |
||
| 14114 | reverse_mapping = rootObj.gds_reverse_node_mapping(mapping) |
||
| 14115 | if not SaveElementTreeNode: |
||
| 14116 | doc = None |
||
| 14117 | rootNode = None |
||
| 14118 | ## if not silence: |
||
| 14119 | ## content = etree_.tostring( |
||
| 14120 | ## rootElement, pretty_print=True, |
||
| 14121 | ## xml_declaration=True, encoding="utf-8") |
||
| 14122 | ## sys.stdout.write(str(content)) |
||
| 14123 | ## sys.stdout.write('\n') |
||
| 14124 | if print_warnings and len(gds_collector.get_messages()) > 0: |
||
| 14125 | separator = ('-' * 50) + '\n' |
||
| 14126 | sys.stderr.write(separator) |
||
| 14127 | sys.stderr.write('----- Warnings -- count: {} -----\n'.format( |
||
| 14128 | len(gds_collector.get_messages()), )) |
||
| 14129 | gds_collector.write_messages(sys.stderr) |
||
| 14130 | sys.stderr.write(separator) |
||
| 14131 | return rootObj, rootElement, mapping, reverse_mapping |
||
| 14132 | |||
| 14133 | |||
| 14134 | View Code Duplication | def parseString(inString, silence=False, print_warnings=True): |
|
| 14135 | '''Parse a string, create the object tree, and export it. |
||
| 14136 | |||
| 14137 | Arguments: |
||
| 14138 | - inString -- A string. This XML fragment should not start |
||
| 14139 | with an XML declaration containing an encoding. |
||
| 14140 | - silence -- A boolean. If False, export the object. |
||
| 14141 | Returns -- The root object in the tree. |
||
| 14142 | ''' |
||
| 14143 | parser = None |
||
| 14144 | rootNode= parsexmlstring_(inString, parser) |
||
| 14145 | gds_collector = GdsCollector_() |
||
| 14146 | rootTag, rootClass = get_root_tag(rootNode) |
||
| 14147 | if rootClass is None: |
||
| 14148 | rootTag = 'PcGts' |
||
| 14149 | rootClass = PcGts |
||
| 14150 | rootObj = rootClass.factory() |
||
| 14151 | rootObj.build(rootNode, gds_collector_=gds_collector) |
||
| 14152 | if not SaveElementTreeNode: |
||
| 14153 | rootNode = None |
||
| 14154 | ## if not silence: |
||
| 14155 | ## sys.stdout.write('<?xml version="1.0" ?>\n') |
||
| 14156 | ## rootObj.export( |
||
| 14157 | ## sys.stdout, 0, name_=rootTag, |
||
| 14158 | ## namespacedef_='xmlns:pc="http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15"') |
||
| 14159 | if print_warnings and len(gds_collector.get_messages()) > 0: |
||
| 14160 | separator = ('-' * 50) + '\n' |
||
| 14161 | sys.stderr.write(separator) |
||
| 14162 | sys.stderr.write('----- Warnings -- count: {} -----\n'.format( |
||
| 14163 | len(gds_collector.get_messages()), )) |
||
| 14164 | gds_collector.write_messages(sys.stderr) |
||
| 14165 | sys.stderr.write(separator) |
||
| 14166 | return rootObj |
||
| 14167 | |||
| 14168 | |||
| 14169 | View Code Duplication | def parseLiteral(inFileName, silence=False, print_warnings=True): |
|
| 14170 | parser = None |
||
| 14171 | doc = parsexml_(inFileName, parser) |
||
| 14172 | gds_collector = GdsCollector_() |
||
| 14173 | rootNode = doc.getroot() |
||
| 14174 | rootTag, rootClass = get_root_tag(rootNode) |
||
| 14175 | if rootClass is None: |
||
| 14176 | rootTag = 'PcGts' |
||
| 14177 | rootClass = PcGts |
||
| 14178 | rootObj = rootClass.factory() |
||
| 14179 | rootObj.build(rootNode, gds_collector_=gds_collector) |
||
| 14180 | # Enable Python to collect the space used by the DOM. |
||
| 14181 | if not SaveElementTreeNode: |
||
| 14182 | doc = None |
||
| 14183 | rootNode = None |
||
| 14184 | ## if not silence: |
||
| 14185 | ## sys.stdout.write('#from ocrd_page_generateds import *\n\n') |
||
| 14186 | ## sys.stdout.write('import ocrd_page_generateds as model_\n\n') |
||
| 14187 | ## sys.stdout.write('rootObj = model_.rootClass(\n') |
||
| 14188 | ## rootObj.exportLiteral(sys.stdout, 0, name_=rootTag) |
||
| 14189 | ## sys.stdout.write(')\n') |
||
| 14190 | if print_warnings and len(gds_collector.get_messages()) > 0: |
||
| 14191 | separator = ('-' * 50) + '\n' |
||
| 14192 | sys.stderr.write(separator) |
||
| 14193 | sys.stderr.write('----- Warnings -- count: {} -----\n'.format( |
||
| 14194 | len(gds_collector.get_messages()), )) |
||
| 14195 | gds_collector.write_messages(sys.stderr) |
||
| 14196 | sys.stderr.write(separator) |
||
| 14197 | return rootObj |
||
| 14198 | |||
| 14199 | |||
| 14200 | def main(): |
||
| 14201 | args = sys.argv[1:] |
||
| 14202 | if len(args) == 1: |
||
| 14203 | parse(args[0]) |
||
| 14204 | else: |
||
| 14205 | usage() |
||
| 14206 | |||
| 14207 | |||
| 14208 | if __name__ == '__main__': |
||
| 14209 | #import pdb; pdb.set_trace() |
||
| 14210 | main() |
||
| 14211 | |||
| 14212 | RenameMappings_ = { |
||
| 14213 | } |
||
| 14214 | |||
| 14215 | __all__ = [ |
||
| 14216 | "AdvertRegionType", |
||
| 14217 | "AlternativeImageType", |
||
| 14218 | "BaselineType", |
||
| 14219 | "BorderType", |
||
| 14220 | "ChartRegionType", |
||
| 14221 | "ChemRegionType", |
||
| 14222 | "CoordsType", |
||
| 14223 | "CustomRegionType", |
||
| 14224 | "GlyphType", |
||
| 14225 | "GraphemeBaseType", |
||
| 14226 | "GraphemeGroupType", |
||
| 14227 | "GraphemeType", |
||
| 14228 | "GraphemesType", |
||
| 14229 | "GraphicRegionType", |
||
| 14230 | "GridPointsType", |
||
| 14231 | "GridType", |
||
| 14232 | "ImageRegionType", |
||
| 14233 | "LabelType", |
||
| 14234 | "LabelsType", |
||
| 14235 | "LayerType", |
||
| 14236 | "LayersType", |
||
| 14237 | "LineDrawingRegionType", |
||
| 14238 | "MapRegionType", |
||
| 14239 | "MathsRegionType", |
||
| 14240 | "MetadataItemType", |
||
| 14241 | "MetadataType", |
||
| 14242 | "MusicRegionType", |
||
| 14243 | "NoiseRegionType", |
||
| 14244 | "NonPrintingCharType", |
||
| 14245 | "OrderedGroupIndexedType", |
||
| 14246 | "OrderedGroupType", |
||
| 14247 | "PageType", |
||
| 14248 | "PcGtsType", |
||
| 14249 | "PrintSpaceType", |
||
| 14250 | "ReadingOrderType", |
||
| 14251 | "RegionRefIndexedType", |
||
| 14252 | "RegionRefType", |
||
| 14253 | "RegionType", |
||
| 14254 | "RelationType", |
||
| 14255 | "RelationsType", |
||
| 14256 | "RolesType", |
||
| 14257 | "SeparatorRegionType", |
||
| 14258 | "TableCellRoleType", |
||
| 14259 | "TableRegionType", |
||
| 14260 | "TextEquivType", |
||
| 14261 | "TextLineType", |
||
| 14262 | "TextRegionType", |
||
| 14263 | "TextStyleType", |
||
| 14264 | "UnknownRegionType", |
||
| 14265 | "UnorderedGroupIndexedType", |
||
| 14266 | "UnorderedGroupType", |
||
| 14267 | "UserAttributeType", |
||
| 14268 | "UserDefinedType", |
||
| 14269 | "WordType" |
||
| 14270 | ] |
||
| 14271 |
Loading history...
