text: from zeep.utils import get_base_class
  from zeep.xsd.types.simple import AnySimpleType
  
  __all__ = ['ListType', 'UnionType']
  
  
  class ListType(AnySimpleType):
      """Space separated list of simpleType values"""
  
      def __init__(self, item_type):
          self.item_type = item_type
          super(ListType, self).__init__()
  
      def __call__(self, value):
          return value
  
      def render(self, parent, value, xsd_type=None, render_path=None):
          parent.text = self.xmlvalue(value)
  
      def resolve(self):
          self.item_type = self.item_type.resolve()
          self.base_class = self.item_type.__class__
          return self
  
      def xmlvalue(self, value):
          item_type = self.item_type
          return ' '.join(item_type.xmlvalue(v) for v in value)
  
      def pythonvalue(self, value):
          if not value:
              return []
          item_type = self.item_type
          return [item_type.pythonvalue(v) for v in value.split()]
  
      def signature(self, schema=None, standalone=True):
          return self.item_type.signature(schema) + '[]'
  
  
  class UnionType(AnySimpleType):
      """Simple type existing out of multiple other types"""
  
      def __init__(self, item_types):
          self.item_types = item_types
          self.item_class = None
          assert item_types
          super(UnionType, self).__init__(None)
  
      def resolve(self):
          self.item_types = [item.resolve() for item in self.item_types]
          base_class = get_base_class(self.item_types)
          if issubclass(base_class, AnySimpleType) and base_class != AnySimpleType:
              self.item_class = base_class
          return self
  
      def signature(self, schema=None, standalone=True):
          return ''
  
      def parse_xmlelement(self, xmlelement, schema=None, allow_none=True,
                           context=None, schema_type=None):
          if self.item_class:
              return self.item_class().parse_xmlelement(
                  xmlelement, schema, allow_none, context)
          return xmlelement.text
  
      def pythonvalue(self, value):
          if self.item_class:
              return self.item_class().pythonvalue(value)
          return value
  
      def xmlvalue(self, value):
          if self.item_class:
              return self.item_class().xmlvalue(value)
          return value
  