#!/usr/bin/env python # -*- coding: utf-8 -*- # # Generated Thu Feb 29 18:07:09 2024 by generateDS.py version 2.43.3. # Python 3.11.3 (main, Apr 19 2023, 18:49:55) [Clang 14.0.6 ] # # Command line options: # ('-f', '') # ('-o', 'schema/partner_relation_lib.py') # ('-s', 'schema/partner_relation.py') # # Command line arguments: # definitions/PARTNER_VERTRETER_.xsd # # Command line: # /Users/daniilossinkin/anaconda3/bin/generateDS -f -o "schema/partner_relation_lib.py" -s "schema/partner_relation.py" definitions/PARTNER_VERTRETER_.xsd # # Current working directory (os.getcwd()): # imports # import sys try: ModulenotfoundExp_ = ModuleNotFoundError except NameError: ModulenotfoundExp_ = ImportError from six.moves import zip_longest import os import re as re_ import base64 import datetime as datetime_ import decimal as decimal_ from lxml import etree as etree_ Validate_simpletypes_ = True SaveElementTreeNode = True TagNamePrefix = "" if sys.version_info.major == 2: BaseStrType_ = basestring else: BaseStrType_ = str def parsexml_(infile, parser=None, **kwargs): if parser is None: # Use the lxml ElementTree compatible parser so that, e.g., # we ignore comments. try: parser = etree_.ETCompatXMLParser() except AttributeError: # fallback to xml.etree parser = etree_.XMLParser() try: if isinstance(infile, os.PathLike): infile = os.path.join(infile) except AttributeError: pass doc = etree_.parse(infile, parser=parser, **kwargs) return doc def parsexmlstring_(instring, parser=None, **kwargs): if parser is None: # Use the lxml ElementTree compatible parser so that, e.g., # we ignore comments. try: parser = etree_.ETCompatXMLParser() except AttributeError: # fallback to xml.etree parser = etree_.XMLParser() element = etree_.fromstring(instring, parser=parser, **kwargs) return element # # Namespace prefix definition table (and other attributes, too) # # The module generatedsnamespaces, if it is importable, must contain # a dictionary named GeneratedsNamespaceDefs. This Python dictionary # should map element type names (strings) to XML schema namespace prefix # definitions. The export method for any class for which there is # a namespace prefix definition, will export that definition in the # XML representation of that element. See the export method of # any generated element type class for an example of the use of this # table. # A sample table is: # # # File: generatedsnamespaces.py # # GenerateDSNamespaceDefs = { # "ElementtypeA": "http://www.xxx.com/namespaceA", # "ElementtypeB": "http://www.xxx.com/namespaceB", # } # # Additionally, the generatedsnamespaces module can contain a python # dictionary named GenerateDSNamespaceTypePrefixes that associates element # types with the namespace prefixes that are to be added to the # "xsi:type" attribute value. See the _exportAttributes method of # any generated element type and the generation of "xsi:type" for an # example of the use of this table. # An example table: # # # File: generatedsnamespaces.py # # GenerateDSNamespaceTypePrefixes = { # "ElementtypeC": "aaa:", # "ElementtypeD": "bbb:", # } # try: from generatedsnamespaces import GenerateDSNamespaceDefs as GenerateDSNamespaceDefs_ except ModulenotfoundExp_ : GenerateDSNamespaceDefs_ = {} try: from generatedsnamespaces import GenerateDSNamespaceTypePrefixes as GenerateDSNamespaceTypePrefixes_ except ModulenotfoundExp_ : GenerateDSNamespaceTypePrefixes_ = {} # # You can replace the following class definition by defining an # importable module named "generatedscollector" containing a class # named "GdsCollector". See the default class definition below for # clues about the possible content of that class. # try: from generatedscollector import GdsCollector as GdsCollector_ except ModulenotfoundExp_ : class GdsCollector_(object): def __init__(self, messages=None): if messages is None: self.messages = [] else: self.messages = messages def add_message(self, msg): self.messages.append(msg) def get_messages(self): return self.messages def clear_messages(self): self.messages = [] def print_messages(self): for msg in self.messages: print("Warning: {}".format(msg)) def write_messages(self, outstream): for msg in self.messages: outstream.write("Warning: {}\n".format(msg)) # # The super-class for enum types # try: from enum import Enum except ModulenotfoundExp_ : Enum = object # # The root super-class for element type classes # # Calls to the methods in these classes are generated by generateDS.py. # You can replace these methods by re-implementing the following class # in a module named generatedssuper.py. try: from generatedssuper import GeneratedsSuper except ModulenotfoundExp_ as exp: try: from generatedssupersuper import GeneratedsSuperSuper except ModulenotfoundExp_ as exp: class GeneratedsSuperSuper(object): pass class GeneratedsSuper(GeneratedsSuperSuper): __hash__ = object.__hash__ tzoff_pattern = re_.compile(r'(\+|-)((0\d|1[0-3]):[0-5]\d|14:00)$') class _FixedOffsetTZ(datetime_.tzinfo): def __init__(self, offset, name): self.__offset = datetime_.timedelta(minutes=offset) self.__name = name def utcoffset(self, dt): return self.__offset def tzname(self, dt): return self.__name def dst(self, dt): return None def __str__(self): settings = { 'str_pretty_print': True, 'str_indent_level': 0, 'str_namespaceprefix': '', 'str_name': self.__class__.__name__, 'str_namespacedefs': '', } for n in settings: if hasattr(self, n): settings[n] = getattr(self, n) if sys.version_info.major == 2: from StringIO import StringIO else: from io import StringIO output = StringIO() self.export( output, settings['str_indent_level'], pretty_print=settings['str_pretty_print'], namespaceprefix_=settings['str_namespaceprefix'], name_=settings['str_name'], namespacedef_=settings['str_namespacedefs'] ) strval = output.getvalue() output.close() return strval def gds_format_string(self, input_data, input_name=''): return input_data def gds_parse_string(self, input_data, node=None, input_name=''): return input_data def gds_validate_string(self, input_data, node=None, input_name=''): if not input_data: return '' else: return input_data def gds_format_base64(self, input_data, input_name=''): return base64.b64encode(input_data).decode('ascii') def gds_validate_base64(self, input_data, node=None, input_name=''): return input_data def gds_format_integer(self, input_data, input_name=''): return '%d' % int(input_data) def gds_parse_integer(self, input_data, node=None, input_name=''): try: ival = int(input_data) except (TypeError, ValueError) as exp: raise_parse_error(node, 'Requires integer value: %s' % exp) return ival def gds_validate_integer(self, input_data, node=None, input_name=''): try: value = int(input_data) except (TypeError, ValueError): raise_parse_error(node, 'Requires integer value') return value def gds_format_integer_list(self, input_data, input_name=''): if len(input_data) > 0 and not isinstance(input_data[0], BaseStrType_): input_data = [str(s) for s in input_data] return '%s' % ' '.join(input_data) def gds_validate_integer_list( self, input_data, node=None, input_name=''): values = input_data.split() for value in values: try: int(value) except (TypeError, ValueError): raise_parse_error(node, 'Requires sequence of integer values') return values def gds_format_float(self, input_data, input_name=''): value = ('%.15f' % float(input_data)).rstrip('0') if value.endswith('.'): value += '0' return value def gds_parse_float(self, input_data, node=None, input_name=''): try: fval_ = float(input_data) except (TypeError, ValueError) as exp: raise_parse_error(node, 'Requires float or double value: %s' % exp) return fval_ def gds_validate_float(self, input_data, node=None, input_name=''): try: value = float(input_data) except (TypeError, ValueError): raise_parse_error(node, 'Requires float value') return value def gds_format_float_list(self, input_data, input_name=''): if len(input_data) > 0 and not isinstance(input_data[0], BaseStrType_): input_data = [str(s) for s in input_data] return '%s' % ' '.join(input_data) def gds_validate_float_list( self, input_data, node=None, input_name=''): values = input_data.split() for value in values: try: float(value) except (TypeError, ValueError): raise_parse_error(node, 'Requires sequence of float values') return values def gds_format_decimal(self, input_data, input_name=''): return_value = '%s' % input_data if '.' in return_value: return_value = return_value.rstrip('0') if return_value.endswith('.'): return_value = return_value.rstrip('.') return return_value def gds_parse_decimal(self, input_data, node=None, input_name=''): try: decimal_value = decimal_.Decimal(input_data) except (TypeError, ValueError): raise_parse_error(node, 'Requires decimal value') return decimal_value def gds_validate_decimal(self, input_data, node=None, input_name=''): try: value = decimal_.Decimal(input_data) except (TypeError, ValueError): raise_parse_error(node, 'Requires decimal value') return value def gds_format_decimal_list(self, input_data, input_name=''): if len(input_data) > 0 and not isinstance(input_data[0], BaseStrType_): input_data = [str(s) for s in input_data] return ' '.join([self.gds_format_decimal(item) for item in input_data]) def gds_validate_decimal_list( self, input_data, node=None, input_name=''): values = input_data.split() for value in values: try: decimal_.Decimal(value) except (TypeError, ValueError): raise_parse_error(node, 'Requires sequence of decimal values') return values def gds_format_double(self, input_data, input_name=''): return '%s' % input_data def gds_parse_double(self, input_data, node=None, input_name=''): try: fval_ = float(input_data) except (TypeError, ValueError) as exp: raise_parse_error(node, 'Requires double or float value: %s' % exp) return fval_ def gds_validate_double(self, input_data, node=None, input_name=''): try: value = float(input_data) except (TypeError, ValueError): raise_parse_error(node, 'Requires double or float value') return value def gds_format_double_list(self, input_data, input_name=''): if len(input_data) > 0 and not isinstance(input_data[0], BaseStrType_): input_data = [str(s) for s in input_data] return '%s' % ' '.join(input_data) def gds_validate_double_list( self, input_data, node=None, input_name=''): values = input_data.split() for value in values: try: float(value) except (TypeError, ValueError): raise_parse_error( node, 'Requires sequence of double or float values') return values def gds_format_boolean(self, input_data, input_name=''): return ('%s' % input_data).lower() def gds_parse_boolean(self, input_data, node=None, input_name=''): input_data = input_data.strip() if input_data in ('true', '1'): bval = True elif input_data in ('false', '0'): bval = False else: raise_parse_error(node, 'Requires boolean value') return bval def gds_validate_boolean(self, input_data, node=None, input_name=''): if input_data not in (True, 1, False, 0, ): raise_parse_error( node, 'Requires boolean value ' '(one of True, 1, False, 0)') return input_data def gds_format_boolean_list(self, input_data, input_name=''): if len(input_data) > 0 and not isinstance(input_data[0], BaseStrType_): input_data = [str(s) for s in input_data] return '%s' % ' '.join(input_data) def gds_validate_boolean_list( self, input_data, node=None, input_name=''): values = input_data.split() for value in values: value = self.gds_parse_boolean(value, node, input_name) if value not in (True, 1, False, 0, ): raise_parse_error( node, 'Requires sequence of boolean values ' '(one of True, 1, False, 0)') return values def gds_validate_datetime(self, input_data, node=None, input_name=''): return input_data def gds_format_datetime(self, input_data, input_name=''): if input_data.microsecond == 0: _svalue = '%04d-%02d-%02dT%02d:%02d:%02d' % ( input_data.year, input_data.month, input_data.day, input_data.hour, input_data.minute, input_data.second, ) else: _svalue = '%04d-%02d-%02dT%02d:%02d:%02d.%s' % ( input_data.year, input_data.month, input_data.day, input_data.hour, input_data.minute, input_data.second, ('%f' % (float(input_data.microsecond) / 1000000))[2:], ) if input_data.tzinfo is not None: tzoff = input_data.tzinfo.utcoffset(input_data) if tzoff is not None: total_seconds = tzoff.seconds + (86400 * tzoff.days) if total_seconds == 0: _svalue += 'Z' else: if total_seconds < 0: _svalue += '-' total_seconds *= -1 else: _svalue += '+' hours = total_seconds // 3600 minutes = (total_seconds - (hours * 3600)) // 60 _svalue += '{0:02d}:{1:02d}'.format(hours, minutes) return _svalue @classmethod def gds_parse_datetime(cls, input_data): tz = None if input_data[-1] == 'Z': tz = GeneratedsSuper._FixedOffsetTZ(0, 'UTC') input_data = input_data[:-1] else: results = GeneratedsSuper.tzoff_pattern.search(input_data) if results is not None: tzoff_parts = results.group(2).split(':') tzoff = int(tzoff_parts[0]) * 60 + int(tzoff_parts[1]) if results.group(1) == '-': tzoff *= -1 tz = GeneratedsSuper._FixedOffsetTZ( tzoff, results.group(0)) input_data = input_data[:-6] time_parts = input_data.split('.') if len(time_parts) > 1: micro_seconds = int(float('0.' + time_parts[1]) * 1000000) input_data = '%s.%s' % ( time_parts[0], "{}".format(micro_seconds).rjust(6, "0"), ) dt = datetime_.datetime.strptime( input_data, '%Y-%m-%dT%H:%M:%S.%f') else: dt = datetime_.datetime.strptime( input_data, '%Y-%m-%dT%H:%M:%S') dt = dt.replace(tzinfo=tz) return dt def gds_validate_date(self, input_data, node=None, input_name=''): return input_data def gds_format_date(self, input_data, input_name=''): _svalue = '%04d-%02d-%02d' % ( input_data.year, input_data.month, input_data.day, ) try: if input_data.tzinfo is not None: tzoff = input_data.tzinfo.utcoffset(input_data) if tzoff is not None: total_seconds = tzoff.seconds + (86400 * tzoff.days) if total_seconds == 0: _svalue += 'Z' else: if total_seconds < 0: _svalue += '-' total_seconds *= -1 else: _svalue += '+' hours = total_seconds // 3600 minutes = (total_seconds - (hours * 3600)) // 60 _svalue += '{0:02d}:{1:02d}'.format( hours, minutes) except AttributeError: pass return _svalue @classmethod def gds_parse_date(cls, input_data): tz = None if input_data[-1] == 'Z': tz = GeneratedsSuper._FixedOffsetTZ(0, 'UTC') input_data = input_data[:-1] else: results = GeneratedsSuper.tzoff_pattern.search(input_data) if results is not None: tzoff_parts = results.group(2).split(':') tzoff = int(tzoff_parts[0]) * 60 + int(tzoff_parts[1]) if results.group(1) == '-': tzoff *= -1 tz = GeneratedsSuper._FixedOffsetTZ( tzoff, results.group(0)) input_data = input_data[:-6] dt = datetime_.datetime.strptime(input_data, '%Y-%m-%d') dt = dt.replace(tzinfo=tz) return dt.date() def gds_validate_time(self, input_data, node=None, input_name=''): return input_data def gds_format_time(self, input_data, input_name=''): if input_data.microsecond == 0: _svalue = '%02d:%02d:%02d' % ( input_data.hour, input_data.minute, input_data.second, ) else: _svalue = '%02d:%02d:%02d.%s' % ( input_data.hour, input_data.minute, input_data.second, ('%f' % (float(input_data.microsecond) / 1000000))[2:], ) if input_data.tzinfo is not None: tzoff = input_data.tzinfo.utcoffset(input_data) if tzoff is not None: total_seconds = tzoff.seconds + (86400 * tzoff.days) if total_seconds == 0: _svalue += 'Z' else: if total_seconds < 0: _svalue += '-' total_seconds *= -1 else: _svalue += '+' hours = total_seconds // 3600 minutes = (total_seconds - (hours * 3600)) // 60 _svalue += '{0:02d}:{1:02d}'.format(hours, minutes) return _svalue def gds_validate_simple_patterns(self, patterns, target): # pat is a list of lists of strings/patterns. # The target value must match at least one of the patterns # in order for the test to succeed. found1 = True target = str(target) for patterns1 in patterns: found2 = False for patterns2 in patterns1: mo = re_.search(patterns2, target) if mo is not None and len(mo.group(0)) == len(target): found2 = True break if not found2: found1 = False break return found1 @classmethod def gds_parse_time(cls, input_data): tz = None if input_data[-1] == 'Z': tz = GeneratedsSuper._FixedOffsetTZ(0, 'UTC') input_data = input_data[:-1] else: results = GeneratedsSuper.tzoff_pattern.search(input_data) if results is not None: tzoff_parts = results.group(2).split(':') tzoff = int(tzoff_parts[0]) * 60 + int(tzoff_parts[1]) if results.group(1) == '-': tzoff *= -1 tz = GeneratedsSuper._FixedOffsetTZ( tzoff, results.group(0)) input_data = input_data[:-6] if len(input_data.split('.')) > 1: dt = datetime_.datetime.strptime(input_data, '%H:%M:%S.%f') else: dt = datetime_.datetime.strptime(input_data, '%H:%M:%S') dt = dt.replace(tzinfo=tz) return dt.time() def gds_check_cardinality_( self, value, input_name, min_occurs=0, max_occurs=1, required=None): if value is None: length = 0 elif isinstance(value, list): length = len(value) else: length = 1 if required is not None : if required and length < 1: self.gds_collector_.add_message( "Required value {}{} is missing".format( input_name, self.gds_get_node_lineno_())) if length < min_occurs: self.gds_collector_.add_message( "Number of values for {}{} is below " "the minimum allowed, " "expected at least {}, found {}".format( input_name, self.gds_get_node_lineno_(), min_occurs, length)) elif length > max_occurs: self.gds_collector_.add_message( "Number of values for {}{} is above " "the maximum allowed, " "expected at most {}, found {}".format( input_name, self.gds_get_node_lineno_(), max_occurs, length)) def gds_validate_builtin_ST_( self, validator, value, input_name, min_occurs=None, max_occurs=None, required=None): if value is not None: try: validator(value, input_name=input_name) except GDSParseError as parse_error: self.gds_collector_.add_message(str(parse_error)) def gds_validate_defined_ST_( self, validator, value, input_name, min_occurs=None, max_occurs=None, required=None): if value is not None: try: validator(value) except GDSParseError as parse_error: self.gds_collector_.add_message(str(parse_error)) def gds_str_lower(self, instring): return instring.lower() def get_path_(self, node): path_list = [] self.get_path_list_(node, path_list) path_list.reverse() path = '/'.join(path_list) return path Tag_strip_pattern_ = re_.compile(r'\{.*\}') def get_path_list_(self, node, path_list): if node is None: return tag = GeneratedsSuper.Tag_strip_pattern_.sub('', node.tag) if tag: path_list.append(tag) self.get_path_list_(node.getparent(), path_list) def get_class_obj_(self, node, default_class=None): class_obj1 = default_class if 'xsi' in node.nsmap: classname = node.get('{%s}type' % node.nsmap['xsi']) if classname is not None: names = classname.split(':') if len(names) == 2: classname = names[1] class_obj2 = globals().get(classname) if class_obj2 is not None: class_obj1 = class_obj2 return class_obj1 def gds_build_any(self, node, type_name=None): # provide default value in case option --disable-xml is used. content = "" content = etree_.tostring(node, encoding="unicode") return content @classmethod def gds_reverse_node_mapping(cls, mapping): return dict(((v, k) for k, v in mapping.items())) @staticmethod def gds_encode(instring): if sys.version_info.major == 2: if ExternalEncoding: encoding = ExternalEncoding else: encoding = 'utf-8' return instring.encode(encoding) else: return instring @staticmethod def convert_unicode(instring): if isinstance(instring, str): result = quote_xml(instring) elif sys.version_info.major == 2 and isinstance(instring, unicode): result = quote_xml(instring).encode('utf8') else: result = GeneratedsSuper.gds_encode(str(instring)) return result def __eq__(self, other): def excl_select_objs_(obj): return (obj[0] != 'parent_object_' and obj[0] != 'gds_collector_') if type(self) != type(other): return False return all(x == y for x, y in zip_longest( filter(excl_select_objs_, self.__dict__.items()), filter(excl_select_objs_, other.__dict__.items()))) def __ne__(self, other): return not self.__eq__(other) # Django ETL transform hooks. def gds_djo_etl_transform(self): pass def gds_djo_etl_transform_db_obj(self, dbobj): pass # SQLAlchemy ETL transform hooks. def gds_sqa_etl_transform(self): return 0, None def gds_sqa_etl_transform_db_obj(self, dbobj): pass def gds_get_node_lineno_(self): if (hasattr(self, "gds_elementtree_node_") and self.gds_elementtree_node_ is not None): return ' near line {}'.format( self.gds_elementtree_node_.sourceline) else: return "" def getSubclassFromModule_(module, class_): '''Get the subclass of a class from a specific module.''' name = class_.__name__ + 'Sub' if hasattr(module, name): return getattr(module, name) else: return None # # If you have installed IPython you can uncomment and use the following. # IPython is available from http://ipython.scipy.org/. # ## from IPython.Shell import IPShellEmbed ## args = '' ## ipshell = IPShellEmbed(args, ## banner = 'Dropping into IPython', ## exit_msg = 'Leaving Interpreter, back to program.') # Then use the following line where and when you want to drop into the # IPython shell: # ipshell(' -- Entering ipshell.\nHit Ctrl-D to exit') # # Globals # ExternalEncoding = '' # Set this to false in order to deactivate during export, the use of # name space prefixes captured from the input document. UseCapturedNS_ = True CapturedNsmap_ = {} Tag_pattern_ = re_.compile(r'({.*})?(.*)') String_cleanup_pat_ = re_.compile(r"[\n\r\s]+") Namespace_extract_pat_ = re_.compile(r'{(.*)}(.*)') CDATA_pattern_ = re_.compile(r"", re_.DOTALL) # Change this to redirect the generated superclass module to use a # specific subclass module. CurrentSubclassModule_ = None # # Support/utility functions. # def showIndent(outfile, level, pretty_print=True): if pretty_print: for idx in range(level): outfile.write(' ') def quote_xml(inStr): "Escape markup chars, but do not modify CDATA sections." if not inStr: return '' s1 = (isinstance(inStr, BaseStrType_) and inStr or '%s' % inStr) s2 = '' pos = 0 matchobjects = CDATA_pattern_.finditer(s1) for mo in matchobjects: s3 = s1[pos:mo.start()] s2 += quote_xml_aux(s3) s2 += s1[mo.start():mo.end()] pos = mo.end() s3 = s1[pos:] s2 += quote_xml_aux(s3) return s2 def quote_xml_aux(inStr): s1 = inStr.replace('&', '&') s1 = s1.replace('<', '<') s1 = s1.replace('>', '>') return s1 def quote_attrib(inStr): s1 = (isinstance(inStr, BaseStrType_) and inStr or '%s' % inStr) s1 = s1.replace('&', '&') s1 = s1.replace('<', '<') s1 = s1.replace('>', '>') s1 = s1.replace('\n', ' ') if '"' in s1: if "'" in s1: s1 = '"%s"' % s1.replace('"', """) else: s1 = "'%s'" % s1 else: s1 = '"%s"' % s1 return s1 def quote_python(inStr): s1 = inStr if s1.find("'") == -1: if s1.find('\n') == -1: return "'%s'" % s1 else: return "'''%s'''" % s1 else: if s1.find('"') != -1: s1 = s1.replace('"', '\\"') if s1.find('\n') == -1: return '"%s"' % s1 else: return '"""%s"""' % s1 def get_all_text_(node): if node.text is not None: text = node.text else: text = '' for child in node: if child.tail is not None: text += child.tail return text def find_attr_value_(attr_name, node): attrs = node.attrib attr_parts = attr_name.split(':') value = None if len(attr_parts) == 1: value = attrs.get(attr_name) elif len(attr_parts) == 2: prefix, name = attr_parts if prefix == 'xml': namespace = 'http://www.w3.org/XML/1998/namespace' else: namespace = node.nsmap.get(prefix) if namespace is not None: value = attrs.get('{%s}%s' % (namespace, name, )) return value def encode_str_2_3(instr): return instr class GDSParseError(Exception): pass def raise_parse_error(node, msg): if node is not None: msg = '%s (element %s/line %d)' % (msg, node.tag, node.sourceline, ) raise GDSParseError(msg) class MixedContainer: # Constants for category: CategoryNone = 0 CategoryText = 1 CategorySimple = 2 CategoryComplex = 3 # Constants for content_type: TypeNone = 0 TypeText = 1 TypeString = 2 TypeInteger = 3 TypeFloat = 4 TypeDecimal = 5 TypeDouble = 6 TypeBoolean = 7 TypeBase64 = 8 def __init__(self, category, content_type, name, value): self.category = category self.content_type = content_type self.name = name self.value = value def getCategory(self): return self.category def getContenttype(self, content_type): return self.content_type def getValue(self): return self.value def getName(self): return self.name def export(self, outfile, level, name, namespace, pretty_print=True): if self.category == MixedContainer.CategoryText: # Prevent exporting empty content as empty lines. if self.value.strip(): outfile.write(self.value) elif self.category == MixedContainer.CategorySimple: self.exportSimple(outfile, level, name) else: # category == MixedContainer.CategoryComplex self.value.export( outfile, level, namespace, name_=name, pretty_print=pretty_print) def exportSimple(self, outfile, level, name): if self.content_type == MixedContainer.TypeString: outfile.write('<%s>%s' % ( self.name, self.value, self.name)) elif self.content_type == MixedContainer.TypeInteger or \ self.content_type == MixedContainer.TypeBoolean: outfile.write('<%s>%d' % ( self.name, self.value, self.name)) elif self.content_type == MixedContainer.TypeFloat or \ self.content_type == MixedContainer.TypeDecimal: outfile.write('<%s>%f' % ( self.name, self.value, self.name)) elif self.content_type == MixedContainer.TypeDouble: outfile.write('<%s>%g' % ( self.name, self.value, self.name)) elif self.content_type == MixedContainer.TypeBase64: outfile.write('<%s>%s' % ( self.name, base64.b64encode(self.value), self.name)) def to_etree(self, element, mapping_=None, reverse_mapping_=None, nsmap_=None): if self.category == MixedContainer.CategoryText: # Prevent exporting empty content as empty lines. if self.value.strip(): if len(element) > 0: if element[-1].tail is None: element[-1].tail = self.value else: element[-1].tail += self.value else: if element.text is None: element.text = self.value else: element.text += self.value elif self.category == MixedContainer.CategorySimple: subelement = etree_.SubElement( element, '%s' % self.name) subelement.text = self.to_etree_simple() else: # category == MixedContainer.CategoryComplex self.value.to_etree(element) def to_etree_simple(self, mapping_=None, reverse_mapping_=None, nsmap_=None): if self.content_type == MixedContainer.TypeString: text = self.value elif (self.content_type == MixedContainer.TypeInteger or self.content_type == MixedContainer.TypeBoolean): text = '%d' % self.value elif (self.content_type == MixedContainer.TypeFloat or self.content_type == MixedContainer.TypeDecimal): text = '%f' % self.value elif self.content_type == MixedContainer.TypeDouble: text = '%g' % self.value elif self.content_type == MixedContainer.TypeBase64: text = '%s' % base64.b64encode(self.value) return text def exportLiteral(self, outfile, level, name): if self.category == MixedContainer.CategoryText: showIndent(outfile, level) outfile.write( 'model_.MixedContainer(%d, %d, "%s", "%s"),\n' % ( self.category, self.content_type, self.name, self.value)) elif self.category == MixedContainer.CategorySimple: showIndent(outfile, level) outfile.write( 'model_.MixedContainer(%d, %d, "%s", "%s"),\n' % ( self.category, self.content_type, self.name, self.value)) else: # category == MixedContainer.CategoryComplex showIndent(outfile, level) outfile.write( 'model_.MixedContainer(%d, %d, "%s",\n' % ( self.category, self.content_type, self.name,)) self.value.exportLiteral(outfile, level + 1) showIndent(outfile, level) outfile.write(')\n') class MemberSpec_(object): def __init__(self, name='', data_type='', container=0, optional=0, child_attrs=None, choice=None): self.name = name self.data_type = data_type self.container = container self.child_attrs = child_attrs self.choice = choice self.optional = optional def set_name(self, name): self.name = name def get_name(self): return self.name def set_data_type(self, data_type): self.data_type = data_type def get_data_type_chain(self): return self.data_type def get_data_type(self): if isinstance(self.data_type, list): if len(self.data_type) > 0: return self.data_type[-1] else: return 'xs:string' else: return self.data_type def set_container(self, container): self.container = container def get_container(self): return self.container def set_child_attrs(self, child_attrs): self.child_attrs = child_attrs def get_child_attrs(self): return self.child_attrs def set_choice(self, choice): self.choice = choice def get_choice(self): return self.choice def set_optional(self, optional): self.optional = optional def get_optional(self): return self.optional def _cast(typ, value): if typ is None or value is None: return value return typ(value) # # Start enum classes # class com_cisag_app_general_PartnerType(str, Enum): EXTERNAL='EXTERNAL' INTERNAL='INTERNAL' _='' # # Start data representation classes # class semiramis(GeneratedsSuper): __hash__ = GeneratedsSuper.__hash__ subclass = None superclass = None def __init__(self, created=None, locale=None, nlsMode='SINGLE_LANGUAGE', dateTimeMode='NORMALIZED', Partner=None, gds_collector_=None, **kwargs_): self.gds_collector_ = gds_collector_ self.gds_elementtree_node_ = None self.original_tagname_ = None self.parent_object_ = kwargs_.get('parent_object_') self.ns_prefix_ = None if isinstance(created, BaseStrType_): initvalue_ = datetime_.datetime.strptime(created, '%Y-%m-%dT%H:%M:%S') else: initvalue_ = created self.created = initvalue_ self.locale = _cast(None, locale) self.locale_nsprefix_ = None self.nlsMode = _cast(None, nlsMode) self.nlsMode_nsprefix_ = None self.dateTimeMode = _cast(None, dateTimeMode) self.dateTimeMode_nsprefix_ = None if Partner is None: self.Partner = [] else: self.Partner = Partner self.Partner_nsprefix_ = None def factory(*args_, **kwargs_): if CurrentSubclassModule_ is not None: subclass = getSubclassFromModule_( CurrentSubclassModule_, semiramis) if subclass is not None: return subclass(*args_, **kwargs_) if semiramis.subclass: return semiramis.subclass(*args_, **kwargs_) else: return semiramis(*args_, **kwargs_) factory = staticmethod(factory) def get_ns_prefix_(self): return self.ns_prefix_ def set_ns_prefix_(self, ns_prefix): self.ns_prefix_ = ns_prefix def get_Partner(self): return self.Partner def set_Partner(self, Partner): self.Partner = Partner def add_Partner(self, value): self.Partner.append(value) def insert_Partner_at(self, index, value): self.Partner.insert(index, value) def replace_Partner_at(self, index, value): self.Partner[index] = value def get_created(self): return self.created def set_created(self, created): self.created = created def get_locale(self): return self.locale def set_locale(self, locale): self.locale = locale def get_nlsMode(self): return self.nlsMode def set_nlsMode(self, nlsMode): self.nlsMode = nlsMode def get_dateTimeMode(self): return self.dateTimeMode def set_dateTimeMode(self, dateTimeMode): self.dateTimeMode = dateTimeMode def has__content(self): if ( self.Partner ): return True else: return False def export(self, outfile, level, namespaceprefix_='', namespacedef_=' xmlns:None="com.cisag.app.general.obj.Partner" ', name_='semiramis', pretty_print=True): imported_ns_def_ = GenerateDSNamespaceDefs_.get('semiramis') if imported_ns_def_ is not None: namespacedef_ = imported_ns_def_ if pretty_print: eol_ = '\n' else: eol_ = '' if self.original_tagname_ is not None and name_ == 'semiramis': name_ = self.original_tagname_ if UseCapturedNS_ and self.ns_prefix_: namespaceprefix_ = self.ns_prefix_ + ':' showIndent(outfile, level, pretty_print) outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) already_processed = set() self._exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='semiramis') if self.has__content(): outfile.write('>%s' % (eol_, )) self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='semiramis', pretty_print=pretty_print) showIndent(outfile, level, pretty_print) outfile.write('%s' % (namespaceprefix_, name_, eol_)) else: outfile.write('/>%s' % (eol_, )) def _exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='semiramis'): if self.created is not None and 'created' not in already_processed: already_processed.add('created') outfile.write(' created="%s"' % self.gds_format_datetime(self.created, input_name='created')) if self.locale is not None and 'locale' not in already_processed: already_processed.add('locale') outfile.write(' locale=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.locale), input_name='locale')), )) if self.nlsMode != "SINGLE_LANGUAGE" and 'nlsMode' not in already_processed: already_processed.add('nlsMode') outfile.write(' nlsMode=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.nlsMode), input_name='nlsMode')), )) if self.dateTimeMode is not None and 'dateTimeMode' not in already_processed: already_processed.add('dateTimeMode') outfile.write(' dateTimeMode=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.dateTimeMode), input_name='dateTimeMode')), )) def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_=' xmlns:None="com.cisag.app.general.obj.Partner" ', name_='semiramis', fromsubclass_=False, pretty_print=True): if pretty_print: eol_ = '\n' else: eol_ = '' for Partner_ in self.Partner: namespaceprefix_ = self.Partner_nsprefix_ + ':' if (UseCapturedNS_ and self.Partner_nsprefix_) else '' Partner_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Partner', pretty_print=pretty_print) def build(self, node, gds_collector_=None): self.gds_collector_ = gds_collector_ if SaveElementTreeNode: self.gds_elementtree_node_ = node already_processed = set() self.ns_prefix_ = node.prefix self._buildAttributes(node, node.attrib, already_processed) for child in node: nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] self._buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) return self def _buildAttributes(self, node, attrs, already_processed): value = find_attr_value_('created', node) if value is not None and 'created' not in already_processed: already_processed.add('created') try: self.created = self.gds_parse_datetime(value) except ValueError as exp: raise ValueError('Bad date-time attribute (created): %s' % exp) value = find_attr_value_('locale', node) if value is not None and 'locale' not in already_processed: already_processed.add('locale') self.locale = value value = find_attr_value_('nlsMode', node) if value is not None and 'nlsMode' not in already_processed: already_processed.add('nlsMode') self.nlsMode = value value = find_attr_value_('dateTimeMode', node) if value is not None and 'dateTimeMode' not in already_processed: already_processed.add('dateTimeMode') self.dateTimeMode = value def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None): if nodeName_ == 'Partner': obj_ = PartnerType.factory(parent_object_=self) obj_.build(child_, gds_collector_=gds_collector_) self.Partner.append(obj_) obj_.original_tagname_ = 'Partner' # end class semiramis class PartnerType(GeneratedsSuper): __hash__ = GeneratedsSuper.__hash__ subclass = None superclass = None def __init__(self, mark=None, mode=None, invalid=None, number=None, type_=None, Customer=None, gds_collector_=None, **kwargs_): self.gds_collector_ = gds_collector_ self.gds_elementtree_node_ = None self.original_tagname_ = None self.parent_object_ = kwargs_.get('parent_object_') self.ns_prefix_ = None self.mark = _cast(None, mark) self.mark_nsprefix_ = None self.mode = _cast(None, mode) self.mode_nsprefix_ = None self.invalid = _cast(bool, invalid) self.invalid_nsprefix_ = None self.number = number self.number_nsprefix_ = None self.type_ = type_ self.validate_com_cisag_app_general_PartnerType(self.type_) self.type__nsprefix_ = None if Customer is None: self.Customer = [] else: self.Customer = Customer self.Customer_nsprefix_ = None def factory(*args_, **kwargs_): if CurrentSubclassModule_ is not None: subclass = getSubclassFromModule_( CurrentSubclassModule_, PartnerType) if subclass is not None: return subclass(*args_, **kwargs_) if PartnerType.subclass: return PartnerType.subclass(*args_, **kwargs_) else: return PartnerType(*args_, **kwargs_) factory = staticmethod(factory) def get_ns_prefix_(self): return self.ns_prefix_ def set_ns_prefix_(self, ns_prefix): self.ns_prefix_ = ns_prefix def get_number(self): return self.number def set_number(self, number): self.number = number def get_type(self): return self.type_ def set_type(self, type_): self.type_ = type_ def get_Customer(self): return self.Customer def set_Customer(self, Customer): self.Customer = Customer def add_Customer(self, value): self.Customer.append(value) def insert_Customer_at(self, index, value): self.Customer.insert(index, value) def replace_Customer_at(self, index, value): self.Customer[index] = value def get_mark(self): return self.mark def set_mark(self, mark): self.mark = mark def get_mode(self): return self.mode def set_mode(self, mode): self.mode = mode def get_invalid(self): return self.invalid def set_invalid(self, invalid): self.invalid = invalid def validate_com_cisag_app_general_PartnerType(self, value): result = True # Validate type com.cisag.app.general.PartnerType, a restriction on xsd:string. if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None: if not isinstance(value, str): lineno = self.gds_get_node_lineno_() self.gds_collector_.add_message('Value "%(value)s"%(lineno)s is not of the correct base simple type (str)' % {"value": value, "lineno": lineno, }) return False value = value enumerations = ['EXTERNAL', 'INTERNAL', ''] if value not in enumerations: lineno = self.gds_get_node_lineno_() self.gds_collector_.add_message('Value "%(value)s"%(lineno)s does not match xsd enumeration restriction on com.cisag.app.general.PartnerType' % {"value" : encode_str_2_3(value), "lineno": lineno} ) result = False return result def has__content(self): if ( self.number is not None or self.type_ is not None or self.Customer ): return True else: return False def export(self, outfile, level, namespaceprefix_='', namespacedef_=' xmlns:None="com.cisag.app.general.obj.Partner" ', name_='PartnerType', pretty_print=True): imported_ns_def_ = GenerateDSNamespaceDefs_.get('PartnerType') if imported_ns_def_ is not None: namespacedef_ = imported_ns_def_ if pretty_print: eol_ = '\n' else: eol_ = '' if self.original_tagname_ is not None and name_ == 'PartnerType': name_ = self.original_tagname_ if UseCapturedNS_ and self.ns_prefix_: namespaceprefix_ = self.ns_prefix_ + ':' showIndent(outfile, level, pretty_print) outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) already_processed = set() self._exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='PartnerType') if self.has__content(): outfile.write('>%s' % (eol_, )) self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='PartnerType', pretty_print=pretty_print) showIndent(outfile, level, pretty_print) outfile.write('%s' % (namespaceprefix_, name_, eol_)) else: outfile.write('/>%s' % (eol_, )) def _exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='PartnerType'): if self.mark is not None and 'mark' not in already_processed: already_processed.add('mark') outfile.write(' mark=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.mark), input_name='mark')), )) if self.mode is not None and 'mode' not in already_processed: already_processed.add('mode') outfile.write(' mode=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.mode), input_name='mode')), )) if self.invalid is not None and 'invalid' not in already_processed: already_processed.add('invalid') outfile.write(' invalid="%s"' % self.gds_format_boolean(self.invalid, input_name='invalid')) def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_=' xmlns:None="com.cisag.app.general.obj.Partner" ', name_='PartnerType', fromsubclass_=False, pretty_print=True): if pretty_print: eol_ = '\n' else: eol_ = '' if self.number is not None: namespaceprefix_ = self.number_nsprefix_ + ':' if (UseCapturedNS_ and self.number_nsprefix_) else '' showIndent(outfile, level, pretty_print) outfile.write('<%snumber>%s%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.number), input_name='number')), namespaceprefix_ , eol_)) if self.type_ is not None: namespaceprefix_ = self.type__nsprefix_ + ':' if (UseCapturedNS_ and self.type__nsprefix_) else '' showIndent(outfile, level, pretty_print) outfile.write('<%stype>%s%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.type_), input_name='type')), namespaceprefix_ , eol_)) for Customer_ in self.Customer: namespaceprefix_ = self.Customer_nsprefix_ + ':' if (UseCapturedNS_ and self.Customer_nsprefix_) else '' Customer_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Customer', pretty_print=pretty_print) def build(self, node, gds_collector_=None): self.gds_collector_ = gds_collector_ if SaveElementTreeNode: self.gds_elementtree_node_ = node already_processed = set() self.ns_prefix_ = node.prefix self._buildAttributes(node, node.attrib, already_processed) for child in node: nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] self._buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) return self def _buildAttributes(self, node, attrs, already_processed): value = find_attr_value_('mark', node) if value is not None and 'mark' not in already_processed: already_processed.add('mark') self.mark = value value = find_attr_value_('mode', node) if value is not None and 'mode' not in already_processed: already_processed.add('mode') self.mode = value value = find_attr_value_('invalid', node) if value is not None and 'invalid' not in already_processed: already_processed.add('invalid') if value in ('true', '1'): self.invalid = True elif value in ('false', '0'): self.invalid = False else: raise_parse_error(node, 'Bad boolean attribute') def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None): if nodeName_ == 'number': value_ = child_.text value_ = self.gds_parse_string(value_, node, 'number') value_ = self.gds_validate_string(value_, node, 'number') self.number = value_ self.number_nsprefix_ = child_.prefix elif nodeName_ == 'type': value_ = child_.text value_ = self.gds_parse_string(value_, node, 'type') value_ = self.gds_validate_string(value_, node, 'type') self.type_ = value_ self.type_nsprefix_ = child_.prefix # validate type com.cisag.app.general.PartnerType self.validate_com_cisag_app_general_PartnerType(self.type_) elif nodeName_ == 'Customer': obj_ = CustomerType.factory(parent_object_=self) obj_.build(child_, gds_collector_=gds_collector_) self.Customer.append(obj_) obj_.original_tagname_ = 'Customer' # end class PartnerType class CustomerType(GeneratedsSuper): __hash__ = GeneratedsSuper.__hash__ subclass = None superclass = None def __init__(self, mark=None, mode=None, invalid=None, allowOrders=None, deliveryDataInfo=None, PartnerRelations=None, gds_collector_=None, **kwargs_): self.gds_collector_ = gds_collector_ self.gds_elementtree_node_ = None self.original_tagname_ = None self.parent_object_ = kwargs_.get('parent_object_') self.ns_prefix_ = None self.mark = _cast(None, mark) self.mark_nsprefix_ = None self.mode = _cast(None, mode) self.mode_nsprefix_ = None self.invalid = _cast(bool, invalid) self.invalid_nsprefix_ = None self.allowOrders = allowOrders self.allowOrders_nsprefix_ = None self.deliveryDataInfo = deliveryDataInfo self.deliveryDataInfo_nsprefix_ = None if PartnerRelations is None: self.PartnerRelations = [] else: self.PartnerRelations = PartnerRelations self.PartnerRelations_nsprefix_ = None def factory(*args_, **kwargs_): if CurrentSubclassModule_ is not None: subclass = getSubclassFromModule_( CurrentSubclassModule_, CustomerType) if subclass is not None: return subclass(*args_, **kwargs_) if CustomerType.subclass: return CustomerType.subclass(*args_, **kwargs_) else: return CustomerType(*args_, **kwargs_) factory = staticmethod(factory) def get_ns_prefix_(self): return self.ns_prefix_ def set_ns_prefix_(self, ns_prefix): self.ns_prefix_ = ns_prefix def get_allowOrders(self): return self.allowOrders def set_allowOrders(self, allowOrders): self.allowOrders = allowOrders def get_deliveryDataInfo(self): return self.deliveryDataInfo def set_deliveryDataInfo(self, deliveryDataInfo): self.deliveryDataInfo = deliveryDataInfo def get_PartnerRelations(self): return self.PartnerRelations def set_PartnerRelations(self, PartnerRelations): self.PartnerRelations = PartnerRelations def add_PartnerRelations(self, value): self.PartnerRelations.append(value) def insert_PartnerRelations_at(self, index, value): self.PartnerRelations.insert(index, value) def replace_PartnerRelations_at(self, index, value): self.PartnerRelations[index] = value def get_mark(self): return self.mark def set_mark(self, mark): self.mark = mark def get_mode(self): return self.mode def set_mode(self, mode): self.mode = mode def get_invalid(self): return self.invalid def set_invalid(self, invalid): self.invalid = invalid def has__content(self): if ( self.allowOrders is not None or self.deliveryDataInfo is not None or self.PartnerRelations ): return True else: return False def export(self, outfile, level, namespaceprefix_='', namespacedef_=' xmlns:None="com.cisag.app.general.obj.Partner" ', name_='CustomerType', pretty_print=True): imported_ns_def_ = GenerateDSNamespaceDefs_.get('CustomerType') if imported_ns_def_ is not None: namespacedef_ = imported_ns_def_ if pretty_print: eol_ = '\n' else: eol_ = '' if self.original_tagname_ is not None and name_ == 'CustomerType': name_ = self.original_tagname_ if UseCapturedNS_ and self.ns_prefix_: namespaceprefix_ = self.ns_prefix_ + ':' showIndent(outfile, level, pretty_print) outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) already_processed = set() self._exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='CustomerType') if self.has__content(): outfile.write('>%s' % (eol_, )) self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='CustomerType', pretty_print=pretty_print) showIndent(outfile, level, pretty_print) outfile.write('%s' % (namespaceprefix_, name_, eol_)) else: outfile.write('/>%s' % (eol_, )) def _exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='CustomerType'): if self.mark is not None and 'mark' not in already_processed: already_processed.add('mark') outfile.write(' mark=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.mark), input_name='mark')), )) if self.mode is not None and 'mode' not in already_processed: already_processed.add('mode') outfile.write(' mode=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.mode), input_name='mode')), )) if self.invalid is not None and 'invalid' not in already_processed: already_processed.add('invalid') outfile.write(' invalid="%s"' % self.gds_format_boolean(self.invalid, input_name='invalid')) def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_=' xmlns:None="com.cisag.app.general.obj.Partner" ', name_='CustomerType', fromsubclass_=False, pretty_print=True): if pretty_print: eol_ = '\n' else: eol_ = '' if self.allowOrders is not None: namespaceprefix_ = self.allowOrders_nsprefix_ + ':' if (UseCapturedNS_ and self.allowOrders_nsprefix_) else '' showIndent(outfile, level, pretty_print) outfile.write('<%sallowOrders>%s%s' % (namespaceprefix_ , self.gds_format_boolean(self.allowOrders, input_name='allowOrders'), namespaceprefix_ , eol_)) if self.deliveryDataInfo is not None: namespaceprefix_ = self.deliveryDataInfo_nsprefix_ + ':' if (UseCapturedNS_ and self.deliveryDataInfo_nsprefix_) else '' self.deliveryDataInfo.export(outfile, level, namespaceprefix_, namespacedef_='', name_='deliveryDataInfo', pretty_print=pretty_print) for PartnerRelations_ in self.PartnerRelations: namespaceprefix_ = self.PartnerRelations_nsprefix_ + ':' if (UseCapturedNS_ and self.PartnerRelations_nsprefix_) else '' PartnerRelations_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='PartnerRelations', pretty_print=pretty_print) def build(self, node, gds_collector_=None): self.gds_collector_ = gds_collector_ if SaveElementTreeNode: self.gds_elementtree_node_ = node already_processed = set() self.ns_prefix_ = node.prefix self._buildAttributes(node, node.attrib, already_processed) for child in node: nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] self._buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) return self def _buildAttributes(self, node, attrs, already_processed): value = find_attr_value_('mark', node) if value is not None and 'mark' not in already_processed: already_processed.add('mark') self.mark = value value = find_attr_value_('mode', node) if value is not None and 'mode' not in already_processed: already_processed.add('mode') self.mode = value value = find_attr_value_('invalid', node) if value is not None and 'invalid' not in already_processed: already_processed.add('invalid') if value in ('true', '1'): self.invalid = True elif value in ('false', '0'): self.invalid = False else: raise_parse_error(node, 'Bad boolean attribute') def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None): if nodeName_ == 'allowOrders': sval_ = child_.text ival_ = self.gds_parse_boolean(sval_, node, 'allowOrders') ival_ = self.gds_validate_boolean(ival_, node, 'allowOrders') self.allowOrders = ival_ self.allowOrders_nsprefix_ = child_.prefix elif nodeName_ == 'deliveryDataInfo': obj_ = deliveryDataInfoType.factory(parent_object_=self) obj_.build(child_, gds_collector_=gds_collector_) self.deliveryDataInfo = obj_ obj_.original_tagname_ = 'deliveryDataInfo' elif nodeName_ == 'PartnerRelations': obj_ = PartnerRelationsType.factory(parent_object_=self) obj_.build(child_, gds_collector_=gds_collector_) self.PartnerRelations.append(obj_) obj_.original_tagname_ = 'PartnerRelations' # end class CustomerType class deliveryDataInfoType(GeneratedsSuper): __hash__ = GeneratedsSuper.__hash__ subclass = None superclass = None def __init__(self, mark=None, mode=None, invalid=None, DeliveryTerms=None, gds_collector_=None, **kwargs_): self.gds_collector_ = gds_collector_ self.gds_elementtree_node_ = None self.original_tagname_ = None self.parent_object_ = kwargs_.get('parent_object_') self.ns_prefix_ = None self.mark = _cast(None, mark) self.mark_nsprefix_ = None self.mode = _cast(None, mode) self.mode_nsprefix_ = None self.invalid = _cast(bool, invalid) self.invalid_nsprefix_ = None self.DeliveryTerms = DeliveryTerms self.DeliveryTerms_nsprefix_ = None def factory(*args_, **kwargs_): if CurrentSubclassModule_ is not None: subclass = getSubclassFromModule_( CurrentSubclassModule_, deliveryDataInfoType) if subclass is not None: return subclass(*args_, **kwargs_) if deliveryDataInfoType.subclass: return deliveryDataInfoType.subclass(*args_, **kwargs_) else: return deliveryDataInfoType(*args_, **kwargs_) factory = staticmethod(factory) def get_ns_prefix_(self): return self.ns_prefix_ def set_ns_prefix_(self, ns_prefix): self.ns_prefix_ = ns_prefix def get_DeliveryTerms(self): return self.DeliveryTerms def set_DeliveryTerms(self, DeliveryTerms): self.DeliveryTerms = DeliveryTerms def get_mark(self): return self.mark def set_mark(self, mark): self.mark = mark def get_mode(self): return self.mode def set_mode(self, mode): self.mode = mode def get_invalid(self): return self.invalid def set_invalid(self, invalid): self.invalid = invalid def has__content(self): if ( self.DeliveryTerms is not None ): return True else: return False def export(self, outfile, level, namespaceprefix_='', namespacedef_=' xmlns:None="com.cisag.app.general.obj.Partner" ', name_='deliveryDataInfoType', pretty_print=True): imported_ns_def_ = GenerateDSNamespaceDefs_.get('deliveryDataInfoType') if imported_ns_def_ is not None: namespacedef_ = imported_ns_def_ if pretty_print: eol_ = '\n' else: eol_ = '' if self.original_tagname_ is not None and name_ == 'deliveryDataInfoType': name_ = self.original_tagname_ if UseCapturedNS_ and self.ns_prefix_: namespaceprefix_ = self.ns_prefix_ + ':' showIndent(outfile, level, pretty_print) outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) already_processed = set() self._exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='deliveryDataInfoType') if self.has__content(): outfile.write('>%s' % (eol_, )) self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='deliveryDataInfoType', pretty_print=pretty_print) showIndent(outfile, level, pretty_print) outfile.write('%s' % (namespaceprefix_, name_, eol_)) else: outfile.write('/>%s' % (eol_, )) def _exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='deliveryDataInfoType'): if self.mark is not None and 'mark' not in already_processed: already_processed.add('mark') outfile.write(' mark=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.mark), input_name='mark')), )) if self.mode is not None and 'mode' not in already_processed: already_processed.add('mode') outfile.write(' mode=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.mode), input_name='mode')), )) if self.invalid is not None and 'invalid' not in already_processed: already_processed.add('invalid') outfile.write(' invalid="%s"' % self.gds_format_boolean(self.invalid, input_name='invalid')) def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_=' xmlns:None="com.cisag.app.general.obj.Partner" ', name_='deliveryDataInfoType', fromsubclass_=False, pretty_print=True): if pretty_print: eol_ = '\n' else: eol_ = '' if self.DeliveryTerms is not None: namespaceprefix_ = self.DeliveryTerms_nsprefix_ + ':' if (UseCapturedNS_ and self.DeliveryTerms_nsprefix_) else '' self.DeliveryTerms.export(outfile, level, namespaceprefix_, namespacedef_='', name_='DeliveryTerms', pretty_print=pretty_print) def build(self, node, gds_collector_=None): self.gds_collector_ = gds_collector_ if SaveElementTreeNode: self.gds_elementtree_node_ = node already_processed = set() self.ns_prefix_ = node.prefix self._buildAttributes(node, node.attrib, already_processed) for child in node: nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] self._buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) return self def _buildAttributes(self, node, attrs, already_processed): value = find_attr_value_('mark', node) if value is not None and 'mark' not in already_processed: already_processed.add('mark') self.mark = value value = find_attr_value_('mode', node) if value is not None and 'mode' not in already_processed: already_processed.add('mode') self.mode = value value = find_attr_value_('invalid', node) if value is not None and 'invalid' not in already_processed: already_processed.add('invalid') if value in ('true', '1'): self.invalid = True elif value in ('false', '0'): self.invalid = False else: raise_parse_error(node, 'Bad boolean attribute') def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None): if nodeName_ == 'DeliveryTerms': obj_ = DeliveryTermsType.factory(parent_object_=self) obj_.build(child_, gds_collector_=gds_collector_) self.DeliveryTerms = obj_ obj_.original_tagname_ = 'DeliveryTerms' # end class deliveryDataInfoType class DeliveryTermsType(GeneratedsSuper): __hash__ = GeneratedsSuper.__hash__ subclass = None superclass = None def __init__(self, mark=None, mode=None, invalid=None, code=None, gds_collector_=None, **kwargs_): self.gds_collector_ = gds_collector_ self.gds_elementtree_node_ = None self.original_tagname_ = None self.parent_object_ = kwargs_.get('parent_object_') self.ns_prefix_ = None self.mark = _cast(None, mark) self.mark_nsprefix_ = None self.mode = _cast(None, mode) self.mode_nsprefix_ = None self.invalid = _cast(bool, invalid) self.invalid_nsprefix_ = None self.code = code self.code_nsprefix_ = None def factory(*args_, **kwargs_): if CurrentSubclassModule_ is not None: subclass = getSubclassFromModule_( CurrentSubclassModule_, DeliveryTermsType) if subclass is not None: return subclass(*args_, **kwargs_) if DeliveryTermsType.subclass: return DeliveryTermsType.subclass(*args_, **kwargs_) else: return DeliveryTermsType(*args_, **kwargs_) factory = staticmethod(factory) def get_ns_prefix_(self): return self.ns_prefix_ def set_ns_prefix_(self, ns_prefix): self.ns_prefix_ = ns_prefix def get_code(self): return self.code def set_code(self, code): self.code = code def get_mark(self): return self.mark def set_mark(self, mark): self.mark = mark def get_mode(self): return self.mode def set_mode(self, mode): self.mode = mode def get_invalid(self): return self.invalid def set_invalid(self, invalid): self.invalid = invalid def has__content(self): if ( self.code is not None ): return True else: return False def export(self, outfile, level, namespaceprefix_='', namespacedef_=' xmlns:None="com.cisag.app.general.obj.Partner" ', name_='DeliveryTermsType', pretty_print=True): imported_ns_def_ = GenerateDSNamespaceDefs_.get('DeliveryTermsType') if imported_ns_def_ is not None: namespacedef_ = imported_ns_def_ if pretty_print: eol_ = '\n' else: eol_ = '' if self.original_tagname_ is not None and name_ == 'DeliveryTermsType': name_ = self.original_tagname_ if UseCapturedNS_ and self.ns_prefix_: namespaceprefix_ = self.ns_prefix_ + ':' showIndent(outfile, level, pretty_print) outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) already_processed = set() self._exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='DeliveryTermsType') if self.has__content(): outfile.write('>%s' % (eol_, )) self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='DeliveryTermsType', pretty_print=pretty_print) showIndent(outfile, level, pretty_print) outfile.write('%s' % (namespaceprefix_, name_, eol_)) else: outfile.write('/>%s' % (eol_, )) def _exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='DeliveryTermsType'): if self.mark is not None and 'mark' not in already_processed: already_processed.add('mark') outfile.write(' mark=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.mark), input_name='mark')), )) if self.mode is not None and 'mode' not in already_processed: already_processed.add('mode') outfile.write(' mode=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.mode), input_name='mode')), )) if self.invalid is not None and 'invalid' not in already_processed: already_processed.add('invalid') outfile.write(' invalid="%s"' % self.gds_format_boolean(self.invalid, input_name='invalid')) def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_=' xmlns:None="com.cisag.app.general.obj.Partner" ', name_='DeliveryTermsType', fromsubclass_=False, pretty_print=True): if pretty_print: eol_ = '\n' else: eol_ = '' if self.code is not None: namespaceprefix_ = self.code_nsprefix_ + ':' if (UseCapturedNS_ and self.code_nsprefix_) else '' showIndent(outfile, level, pretty_print) outfile.write('<%scode>%s%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.code), input_name='code')), namespaceprefix_ , eol_)) def build(self, node, gds_collector_=None): self.gds_collector_ = gds_collector_ if SaveElementTreeNode: self.gds_elementtree_node_ = node already_processed = set() self.ns_prefix_ = node.prefix self._buildAttributes(node, node.attrib, already_processed) for child in node: nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] self._buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) return self def _buildAttributes(self, node, attrs, already_processed): value = find_attr_value_('mark', node) if value is not None and 'mark' not in already_processed: already_processed.add('mark') self.mark = value value = find_attr_value_('mode', node) if value is not None and 'mode' not in already_processed: already_processed.add('mode') self.mode = value value = find_attr_value_('invalid', node) if value is not None and 'invalid' not in already_processed: already_processed.add('invalid') if value in ('true', '1'): self.invalid = True elif value in ('false', '0'): self.invalid = False else: raise_parse_error(node, 'Bad boolean attribute') def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None): if nodeName_ == 'code': value_ = child_.text value_ = self.gds_parse_string(value_, node, 'code') value_ = self.gds_validate_string(value_, node, 'code') self.code = value_ self.code_nsprefix_ = child_.prefix # end class DeliveryTermsType class PartnerRelationsType(GeneratedsSuper): __hash__ = GeneratedsSuper.__hash__ subclass = None superclass = None def __init__(self, mark=None, mode=None, invalid=None, Target=None, Type=None, gds_collector_=None, **kwargs_): self.gds_collector_ = gds_collector_ self.gds_elementtree_node_ = None self.original_tagname_ = None self.parent_object_ = kwargs_.get('parent_object_') self.ns_prefix_ = None self.mark = _cast(None, mark) self.mark_nsprefix_ = None self.mode = _cast(None, mode) self.mode_nsprefix_ = None self.invalid = _cast(bool, invalid) self.invalid_nsprefix_ = None self.Target = Target self.Target_nsprefix_ = None self.Type = Type self.Type_nsprefix_ = None def factory(*args_, **kwargs_): if CurrentSubclassModule_ is not None: subclass = getSubclassFromModule_( CurrentSubclassModule_, PartnerRelationsType) if subclass is not None: return subclass(*args_, **kwargs_) if PartnerRelationsType.subclass: return PartnerRelationsType.subclass(*args_, **kwargs_) else: return PartnerRelationsType(*args_, **kwargs_) factory = staticmethod(factory) def get_ns_prefix_(self): return self.ns_prefix_ def set_ns_prefix_(self, ns_prefix): self.ns_prefix_ = ns_prefix def get_Target(self): return self.Target def set_Target(self, Target): self.Target = Target def get_Type(self): return self.Type def set_Type(self, Type): self.Type = Type def get_mark(self): return self.mark def set_mark(self, mark): self.mark = mark def get_mode(self): return self.mode def set_mode(self, mode): self.mode = mode def get_invalid(self): return self.invalid def set_invalid(self, invalid): self.invalid = invalid def has__content(self): if ( self.Target is not None or self.Type is not None ): return True else: return False def export(self, outfile, level, namespaceprefix_='', namespacedef_=' xmlns:None="com.cisag.app.general.obj.Partner" ', name_='PartnerRelationsType', pretty_print=True): imported_ns_def_ = GenerateDSNamespaceDefs_.get('PartnerRelationsType') if imported_ns_def_ is not None: namespacedef_ = imported_ns_def_ if pretty_print: eol_ = '\n' else: eol_ = '' if self.original_tagname_ is not None and name_ == 'PartnerRelationsType': name_ = self.original_tagname_ if UseCapturedNS_ and self.ns_prefix_: namespaceprefix_ = self.ns_prefix_ + ':' showIndent(outfile, level, pretty_print) outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) already_processed = set() self._exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='PartnerRelationsType') if self.has__content(): outfile.write('>%s' % (eol_, )) self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='PartnerRelationsType', pretty_print=pretty_print) showIndent(outfile, level, pretty_print) outfile.write('%s' % (namespaceprefix_, name_, eol_)) else: outfile.write('/>%s' % (eol_, )) def _exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='PartnerRelationsType'): if self.mark is not None and 'mark' not in already_processed: already_processed.add('mark') outfile.write(' mark=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.mark), input_name='mark')), )) if self.mode is not None and 'mode' not in already_processed: already_processed.add('mode') outfile.write(' mode=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.mode), input_name='mode')), )) if self.invalid is not None and 'invalid' not in already_processed: already_processed.add('invalid') outfile.write(' invalid="%s"' % self.gds_format_boolean(self.invalid, input_name='invalid')) def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_=' xmlns:None="com.cisag.app.general.obj.Partner" ', name_='PartnerRelationsType', fromsubclass_=False, pretty_print=True): if pretty_print: eol_ = '\n' else: eol_ = '' if self.Target is not None: namespaceprefix_ = self.Target_nsprefix_ + ':' if (UseCapturedNS_ and self.Target_nsprefix_) else '' self.Target.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Target', pretty_print=pretty_print) if self.Type is not None: namespaceprefix_ = self.Type_nsprefix_ + ':' if (UseCapturedNS_ and self.Type_nsprefix_) else '' self.Type.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Type', pretty_print=pretty_print) def build(self, node, gds_collector_=None): self.gds_collector_ = gds_collector_ if SaveElementTreeNode: self.gds_elementtree_node_ = node already_processed = set() self.ns_prefix_ = node.prefix self._buildAttributes(node, node.attrib, already_processed) for child in node: nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] self._buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) return self def _buildAttributes(self, node, attrs, already_processed): value = find_attr_value_('mark', node) if value is not None and 'mark' not in already_processed: already_processed.add('mark') self.mark = value value = find_attr_value_('mode', node) if value is not None and 'mode' not in already_processed: already_processed.add('mode') self.mode = value value = find_attr_value_('invalid', node) if value is not None and 'invalid' not in already_processed: already_processed.add('invalid') if value in ('true', '1'): self.invalid = True elif value in ('false', '0'): self.invalid = False else: raise_parse_error(node, 'Bad boolean attribute') def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None): if nodeName_ == 'Target': obj_ = TargetType.factory(parent_object_=self) obj_.build(child_, gds_collector_=gds_collector_) self.Target = obj_ obj_.original_tagname_ = 'Target' elif nodeName_ == 'Type': obj_ = TypeType.factory(parent_object_=self) obj_.build(child_, gds_collector_=gds_collector_) self.Type = obj_ obj_.original_tagname_ = 'Type' # end class PartnerRelationsType class TargetType(GeneratedsSuper): __hash__ = GeneratedsSuper.__hash__ subclass = None superclass = None def __init__(self, mark=None, mode=None, invalid=None, number=None, gds_collector_=None, **kwargs_): self.gds_collector_ = gds_collector_ self.gds_elementtree_node_ = None self.original_tagname_ = None self.parent_object_ = kwargs_.get('parent_object_') self.ns_prefix_ = None self.mark = _cast(None, mark) self.mark_nsprefix_ = None self.mode = _cast(None, mode) self.mode_nsprefix_ = None self.invalid = _cast(bool, invalid) self.invalid_nsprefix_ = None self.number = number self.number_nsprefix_ = None def factory(*args_, **kwargs_): if CurrentSubclassModule_ is not None: subclass = getSubclassFromModule_( CurrentSubclassModule_, TargetType) if subclass is not None: return subclass(*args_, **kwargs_) if TargetType.subclass: return TargetType.subclass(*args_, **kwargs_) else: return TargetType(*args_, **kwargs_) factory = staticmethod(factory) def get_ns_prefix_(self): return self.ns_prefix_ def set_ns_prefix_(self, ns_prefix): self.ns_prefix_ = ns_prefix def get_number(self): return self.number def set_number(self, number): self.number = number def get_mark(self): return self.mark def set_mark(self, mark): self.mark = mark def get_mode(self): return self.mode def set_mode(self, mode): self.mode = mode def get_invalid(self): return self.invalid def set_invalid(self, invalid): self.invalid = invalid def has__content(self): if ( self.number is not None ): return True else: return False def export(self, outfile, level, namespaceprefix_='', namespacedef_=' xmlns:None="com.cisag.app.general.obj.Partner" ', name_='TargetType', pretty_print=True): imported_ns_def_ = GenerateDSNamespaceDefs_.get('TargetType') if imported_ns_def_ is not None: namespacedef_ = imported_ns_def_ if pretty_print: eol_ = '\n' else: eol_ = '' if self.original_tagname_ is not None and name_ == 'TargetType': name_ = self.original_tagname_ if UseCapturedNS_ and self.ns_prefix_: namespaceprefix_ = self.ns_prefix_ + ':' showIndent(outfile, level, pretty_print) outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) already_processed = set() self._exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='TargetType') if self.has__content(): outfile.write('>%s' % (eol_, )) self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='TargetType', pretty_print=pretty_print) showIndent(outfile, level, pretty_print) outfile.write('%s' % (namespaceprefix_, name_, eol_)) else: outfile.write('/>%s' % (eol_, )) def _exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='TargetType'): if self.mark is not None and 'mark' not in already_processed: already_processed.add('mark') outfile.write(' mark=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.mark), input_name='mark')), )) if self.mode is not None and 'mode' not in already_processed: already_processed.add('mode') outfile.write(' mode=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.mode), input_name='mode')), )) if self.invalid is not None and 'invalid' not in already_processed: already_processed.add('invalid') outfile.write(' invalid="%s"' % self.gds_format_boolean(self.invalid, input_name='invalid')) def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_=' xmlns:None="com.cisag.app.general.obj.Partner" ', name_='TargetType', fromsubclass_=False, pretty_print=True): if pretty_print: eol_ = '\n' else: eol_ = '' if self.number is not None: namespaceprefix_ = self.number_nsprefix_ + ':' if (UseCapturedNS_ and self.number_nsprefix_) else '' showIndent(outfile, level, pretty_print) outfile.write('<%snumber>%s%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.number), input_name='number')), namespaceprefix_ , eol_)) def build(self, node, gds_collector_=None): self.gds_collector_ = gds_collector_ if SaveElementTreeNode: self.gds_elementtree_node_ = node already_processed = set() self.ns_prefix_ = node.prefix self._buildAttributes(node, node.attrib, already_processed) for child in node: nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] self._buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) return self def _buildAttributes(self, node, attrs, already_processed): value = find_attr_value_('mark', node) if value is not None and 'mark' not in already_processed: already_processed.add('mark') self.mark = value value = find_attr_value_('mode', node) if value is not None and 'mode' not in already_processed: already_processed.add('mode') self.mode = value value = find_attr_value_('invalid', node) if value is not None and 'invalid' not in already_processed: already_processed.add('invalid') if value in ('true', '1'): self.invalid = True elif value in ('false', '0'): self.invalid = False else: raise_parse_error(node, 'Bad boolean attribute') def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None): if nodeName_ == 'number': value_ = child_.text value_ = self.gds_parse_string(value_, node, 'number') value_ = self.gds_validate_string(value_, node, 'number') self.number = value_ self.number_nsprefix_ = child_.prefix # end class TargetType class TypeType(GeneratedsSuper): __hash__ = GeneratedsSuper.__hash__ subclass = None superclass = None def __init__(self, mark=None, mode=None, invalid=None, name=None, gds_collector_=None, **kwargs_): self.gds_collector_ = gds_collector_ self.gds_elementtree_node_ = None self.original_tagname_ = None self.parent_object_ = kwargs_.get('parent_object_') self.ns_prefix_ = None self.mark = _cast(None, mark) self.mark_nsprefix_ = None self.mode = _cast(None, mode) self.mode_nsprefix_ = None self.invalid = _cast(bool, invalid) self.invalid_nsprefix_ = None self.name = name self.name_nsprefix_ = None def factory(*args_, **kwargs_): if CurrentSubclassModule_ is not None: subclass = getSubclassFromModule_( CurrentSubclassModule_, TypeType) if subclass is not None: return subclass(*args_, **kwargs_) if TypeType.subclass: return TypeType.subclass(*args_, **kwargs_) else: return TypeType(*args_, **kwargs_) factory = staticmethod(factory) def get_ns_prefix_(self): return self.ns_prefix_ def set_ns_prefix_(self, ns_prefix): self.ns_prefix_ = ns_prefix def get_name(self): return self.name def set_name(self, name): self.name = name def get_mark(self): return self.mark def set_mark(self, mark): self.mark = mark def get_mode(self): return self.mode def set_mode(self, mode): self.mode = mode def get_invalid(self): return self.invalid def set_invalid(self, invalid): self.invalid = invalid def has__content(self): if ( self.name is not None ): return True else: return False def export(self, outfile, level, namespaceprefix_='', namespacedef_=' xmlns:None="com.cisag.app.general.obj.Partner" ', name_='TypeType', pretty_print=True): imported_ns_def_ = GenerateDSNamespaceDefs_.get('TypeType') if imported_ns_def_ is not None: namespacedef_ = imported_ns_def_ if pretty_print: eol_ = '\n' else: eol_ = '' if self.original_tagname_ is not None and name_ == 'TypeType': name_ = self.original_tagname_ if UseCapturedNS_ and self.ns_prefix_: namespaceprefix_ = self.ns_prefix_ + ':' showIndent(outfile, level, pretty_print) outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) already_processed = set() self._exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='TypeType') if self.has__content(): outfile.write('>%s' % (eol_, )) self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='TypeType', pretty_print=pretty_print) showIndent(outfile, level, pretty_print) outfile.write('%s' % (namespaceprefix_, name_, eol_)) else: outfile.write('/>%s' % (eol_, )) def _exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='TypeType'): if self.mark is not None and 'mark' not in already_processed: already_processed.add('mark') outfile.write(' mark=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.mark), input_name='mark')), )) if self.mode is not None and 'mode' not in already_processed: already_processed.add('mode') outfile.write(' mode=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.mode), input_name='mode')), )) if self.invalid is not None and 'invalid' not in already_processed: already_processed.add('invalid') outfile.write(' invalid="%s"' % self.gds_format_boolean(self.invalid, input_name='invalid')) def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_=' xmlns:None="com.cisag.app.general.obj.Partner" ', name_='TypeType', fromsubclass_=False, pretty_print=True): if pretty_print: eol_ = '\n' else: eol_ = '' if self.name is not None: namespaceprefix_ = self.name_nsprefix_ + ':' if (UseCapturedNS_ and self.name_nsprefix_) else '' showIndent(outfile, level, pretty_print) outfile.write('<%sname>%s%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.name), input_name='name')), namespaceprefix_ , eol_)) def build(self, node, gds_collector_=None): self.gds_collector_ = gds_collector_ if SaveElementTreeNode: self.gds_elementtree_node_ = node already_processed = set() self.ns_prefix_ = node.prefix self._buildAttributes(node, node.attrib, already_processed) for child in node: nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] self._buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) return self def _buildAttributes(self, node, attrs, already_processed): value = find_attr_value_('mark', node) if value is not None and 'mark' not in already_processed: already_processed.add('mark') self.mark = value value = find_attr_value_('mode', node) if value is not None and 'mode' not in already_processed: already_processed.add('mode') self.mode = value value = find_attr_value_('invalid', node) if value is not None and 'invalid' not in already_processed: already_processed.add('invalid') if value in ('true', '1'): self.invalid = True elif value in ('false', '0'): self.invalid = False else: raise_parse_error(node, 'Bad boolean attribute') def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None): if nodeName_ == 'name': value_ = child_.text value_ = self.gds_parse_string(value_, node, 'name') value_ = self.gds_validate_string(value_, node, 'name') self.name = value_ self.name_nsprefix_ = child_.prefix # end class TypeType # # End data representation classes. # GDSClassesMapping = { } USAGE_TEXT = """ Usage: python .py [ -s ] """ def usage(): print(USAGE_TEXT) sys.exit(1) def get_root_tag(node): tag = Tag_pattern_.match(node.tag).groups()[-1] prefix_tag = TagNamePrefix + tag rootClass = GDSClassesMapping.get(prefix_tag) if rootClass is None: rootClass = globals().get(prefix_tag) return tag, rootClass def get_required_ns_prefix_defs(rootNode): '''Get all name space prefix definitions required in this XML doc. Return a dictionary of definitions and a char string of definitions. ''' nsmap = { prefix: uri for node in rootNode.iter() for (prefix, uri) in node.nsmap.items() if prefix is not None } namespacedefs = ' '.join([ 'xmlns:{}="{}"'.format(prefix, uri) for prefix, uri in nsmap.items() ]) return nsmap, namespacedefs def parse(inFileName, silence=False, print_warnings=True): global CapturedNsmap_ gds_collector = GdsCollector_() parser = None doc = parsexml_(inFileName, parser) rootNode = doc.getroot() rootTag, rootClass = get_root_tag(rootNode) if rootClass is None: rootTag = 'semiramis' rootClass = semiramis rootObj = rootClass.factory() rootObj.build(rootNode, gds_collector_=gds_collector) CapturedNsmap_, namespacedefs = get_required_ns_prefix_defs(rootNode) if not SaveElementTreeNode: doc = None rootNode = None if not silence: sys.stdout.write('\n') rootObj.export( sys.stdout, 0, name_=rootTag, namespacedef_=namespacedefs, pretty_print=True) if print_warnings and len(gds_collector.get_messages()) > 0: separator = ('-' * 50) + '\n' sys.stderr.write(separator) sys.stderr.write('----- Warnings -- count: {} -----\n'.format( len(gds_collector.get_messages()), )) gds_collector.write_messages(sys.stderr) sys.stderr.write(separator) return rootObj def parseEtree(inFileName, silence=False, print_warnings=True, mapping=None, reverse_mapping=None, nsmap=None): parser = None doc = parsexml_(inFileName, parser) gds_collector = GdsCollector_() rootNode = doc.getroot() rootTag, rootClass = get_root_tag(rootNode) if rootClass is None: rootTag = 'semiramis' rootClass = semiramis rootObj = rootClass.factory() rootObj.build(rootNode, gds_collector_=gds_collector) if mapping is None: mapping = {} if reverse_mapping is None: reverse_mapping = {} rootElement = rootObj.to_etree( None, name_=rootTag, mapping_=mapping, reverse_mapping_=reverse_mapping, nsmap_=nsmap) reverse_node_mapping = rootObj.gds_reverse_node_mapping(mapping) # Enable Python to collect the space used by the DOM. if not SaveElementTreeNode: doc = None rootNode = None if not silence: content = etree_.tostring( rootElement, pretty_print=True, xml_declaration=True, encoding="utf-8") sys.stdout.write(str(content)) sys.stdout.write('\n') if print_warnings and len(gds_collector.get_messages()) > 0: separator = ('-' * 50) + '\n' sys.stderr.write(separator) sys.stderr.write('----- Warnings -- count: {} -----\n'.format( len(gds_collector.get_messages()), )) gds_collector.write_messages(sys.stderr) sys.stderr.write(separator) return rootObj, rootElement, mapping, reverse_node_mapping def parseString(inString, silence=False, print_warnings=True): '''Parse a string, create the object tree, and export it. Arguments: - inString -- A string. This XML fragment should not start with an XML declaration containing an encoding. - silence -- A boolean. If False, export the object. Returns -- The root object in the tree. ''' parser = None rootNode= parsexmlstring_(inString, parser) gds_collector = GdsCollector_() rootTag, rootClass = get_root_tag(rootNode) if rootClass is None: rootTag = 'semiramis' rootClass = semiramis rootObj = rootClass.factory() rootObj.build(rootNode, gds_collector_=gds_collector) if not SaveElementTreeNode: rootNode = None if not silence: sys.stdout.write('\n') rootObj.export( sys.stdout, 0, name_=rootTag, namespacedef_='') if print_warnings and len(gds_collector.get_messages()) > 0: separator = ('-' * 50) + '\n' sys.stderr.write(separator) sys.stderr.write('----- Warnings -- count: {} -----\n'.format( len(gds_collector.get_messages()), )) gds_collector.write_messages(sys.stderr) sys.stderr.write(separator) return rootObj def parseLiteral(inFileName, silence=False, print_warnings=True): parser = None doc = parsexml_(inFileName, parser) gds_collector = GdsCollector_() rootNode = doc.getroot() rootTag, rootClass = get_root_tag(rootNode) if rootClass is None: rootTag = 'semiramis' rootClass = semiramis rootObj = rootClass.factory() rootObj.build(rootNode, gds_collector_=gds_collector) # Enable Python to collect the space used by the DOM. if not SaveElementTreeNode: doc = None rootNode = None if not silence: sys.stdout.write('#from partner_relation_lib import *\n\n') sys.stdout.write('import partner_relation_lib as model_\n\n') sys.stdout.write('rootObj = model_.rootClass(\n') rootObj.exportLiteral(sys.stdout, 0, name_=rootTag) sys.stdout.write(')\n') if print_warnings and len(gds_collector.get_messages()) > 0: separator = ('-' * 50) + '\n' sys.stderr.write(separator) sys.stderr.write('----- Warnings -- count: {} -----\n'.format( len(gds_collector.get_messages()), )) gds_collector.write_messages(sys.stderr) sys.stderr.write(separator) return rootObj def main(): args = sys.argv[1:] if len(args) == 1: parse(args[0]) else: usage() if __name__ == '__main__': #import pdb; pdb.set_trace() main() RenameMappings_ = { } # # Mapping of namespaces to types defined in them # and the file in which each is defined. # simpleTypes are marked "ST" and complexTypes "CT". NamespaceToDefMappings_ = {'com.cisag.app.general.obj.Partner': [('com.cisag.app.general.PartnerType', 'definitions/PARTNER_VERTRETER_.xsd', 'ST'), ('java.lang.Byte', 'definitions/PARTNER_VERTRETER_.xsd', 'ST'), ('java.lang.Short', 'definitions/PARTNER_VERTRETER_.xsd', 'ST'), ('java.lang.Integer', 'definitions/PARTNER_VERTRETER_.xsd', 'ST'), ('java.lang.Long', 'definitions/PARTNER_VERTRETER_.xsd', 'ST'), ('java.lang.Character', 'definitions/PARTNER_VERTRETER_.xsd', 'ST')]} __all__ = [ "CustomerType", "DeliveryTermsType", "PartnerRelationsType", "PartnerType", "TargetType", "TypeType", "deliveryDataInfoType", "semiramis" ]