Change implementation of struct type build functions

They(EnumType, EntityType, ComplexType) now handle parsing of invalid
metadata independently. Thus, you do not have to wrap build_element in
try-except block. Build function either return valid type, null type or
fails. (Last two options depend on which policy is set.)

Author: mamiksik

CHANGELOG.md

@@ -18,6 +18,7 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 
 ### Changed
 - Implementation and naming schema of `from_etree` - Martin Miksik
+- Build functions of struct types now handle invalid metadata independently. - Martin Miksik 
 
 ### Fixed
 - make sure configured error policies are applied for Annotations referencing

pyodata/model/build_functions.py

@@ -6,10 +6,10 @@
 
 from pyodata.policies import ParserError
 from pyodata.config import Config
-from pyodata.exceptions import PyODataParserError, PyODataModelError
+from pyodata.exceptions import PyODataParserError, PyODataModelError, PyODataException
 from pyodata.model.elements import sap_attribute_get_bool, sap_attribute_get_string, StructType, StructTypeProperty, \
     Types, EnumType, EnumMember, EntitySet, ValueHelper, ValueHelperParameter, FunctionImportParameter, \
-    FunctionImport, metadata_attribute_get, EntityType, ComplexType, build_element
+    FunctionImport, metadata_attribute_get, EntityType, ComplexType, build_element, NullType
 
 # pylint: disable=cyclic-import
 # When using `import xxx as yyy` it is not a problem and we need this dependency
@@ -83,75 +83,87 @@ def build_struct_type(config: Config, type_node, typ, schema=None):
 
 
 def build_complex_type(config: Config, type_node, schema=None):
-    return build_element(StructType, config, type_node=type_node, typ=ComplexType, schema=schema)
+    try:
+        return build_element(StructType, config, type_node=type_node, typ=ComplexType, schema=schema)
+    except (PyODataException, KeyError, AttributeError) as ex:
+        config.err_policy(ParserError.COMPLEX_TYPE).resolve(ex)
+        return NullType(type_node.get('Name'))
 
 
 # pylint: disable=protected-access
 def build_entity_type(config: Config, type_node, schema=None):
-    etype = build_element(StructType, config, type_node=type_node, typ=EntityType, schema=schema)
+    try:
+        etype = build_element(StructType, config, type_node=type_node, typ=EntityType, schema=schema)
 
-    for proprty in type_node.xpath('edm:Key/edm:PropertyRef', namespaces=config.namespaces):
-        etype._key.append(etype.proprty(proprty.get('Name')))
+        for proprty in type_node.xpath('edm:Key/edm:PropertyRef', namespaces=config.namespaces):
+            etype._key.append(etype.proprty(proprty.get('Name')))
 
-    for proprty in type_node.xpath('edm:NavigationProperty', namespaces=config.namespaces):
-        navp = build_element('NavigationTypeProperty', config, node=proprty)
+        for proprty in type_node.xpath('edm:NavigationProperty', namespaces=config.namespaces):
+            navp = build_element('NavigationTypeProperty', config, node=proprty)
 
-        if navp.name in etype._nav_properties:
-            raise KeyError('{0} already has navigation property {1}'.format(etype, navp.name))
+            if navp.name in etype._nav_properties:
+                raise KeyError('{0} already has navigation property {1}'.format(etype, navp.name))
 
-        etype._nav_properties[navp.name] = navp
+            etype._nav_properties[navp.name] = navp
 
-    return etype
+        return etype
+    except (KeyError, AttributeError) as ex:
+        config.err_policy(ParserError.ENTITY_TYPE).resolve(ex)
+        return NullType(type_node.get('Name'))
 
 
 # pylint: disable=protected-access, too-many-locals
 def build_enum_type(config: Config, type_node, namespace):
-    ename = type_node.get('Name')
-    is_flags = type_node.get('IsFlags')
+    try:
+        ename = type_node.get('Name')
+        is_flags = type_node.get('IsFlags')
 
-    # namespace = kwargs['namespace']
+        # namespace = kwargs['namespace']
 
-    underlying_type = type_node.get('UnderlyingType')
+        underlying_type = type_node.get('UnderlyingType')
 
-    # https://docs.oasis-open.org/odata/odata-csdl-json/v4.01/csprd04/odata-csdl-json-v4.01-csprd04.html#sec_EnumerationType
-    if underlying_type is None:
-        underlying_type = 'Edm.Int32'
+        # https://docs.oasis-open.org/odata/odata-csdl-json/v4.01/csprd04/odata-csdl-json-v4.01-csprd04.html#sec_EnumerationType
+        if underlying_type is None:
+            underlying_type = 'Edm.Int32'
 
-    valid_types = {
-        'Edm.Byte': [0, 2 ** 8 - 1],
-        'Edm.Int16': [-2 ** 15, 2 ** 15 - 1],
-        'Edm.Int32': [-2 ** 31, 2 ** 31 - 1],
-        'Edm.Int64': [-2 ** 63, 2 ** 63 - 1],
-        'Edm.SByte': [-2 ** 7, 2 ** 7 - 1]
-    }
+        valid_types = {
+            'Edm.Byte': [0, 2 ** 8 - 1],
+            'Edm.Int16': [-2 ** 15, 2 ** 15 - 1],
+            'Edm.Int32': [-2 ** 31, 2 ** 31 - 1],
+            'Edm.Int64': [-2 ** 63, 2 ** 63 - 1],
+            'Edm.SByte': [-2 ** 7, 2 ** 7 - 1]
+        }
 
-    if underlying_type not in valid_types:
-        raise PyODataParserError(
-            f'Type {underlying_type} is not valid as underlying type for EnumType - must be one of {valid_types}')
+        if underlying_type not in valid_types:
+            raise PyODataParserError(
+                f'Type {underlying_type} is not valid as underlying type for EnumType - must be one of {valid_types}')
 
-    mtype = Types.from_name(underlying_type, config)
-    etype = EnumType(ename, is_flags, mtype, namespace)
+        mtype = Types.from_name(underlying_type, config)
+        etype = EnumType(ename, is_flags, mtype, namespace)
 
-    members = type_node.xpath('edm:Member', namespaces=config.namespaces)
+        members = type_node.xpath('edm:Member', namespaces=config.namespaces)
 
-    next_value = 0
-    for member in members:
-        name = member.get('Name')
-        value = member.get('Value')
+        next_value = 0
+        for member in members:
+            name = member.get('Name')
+            value = member.get('Value')
 
-        if value is not None:
-            next_value = int(value)
+            if value is not None:
+                next_value = int(value)
 
-        vtype = valid_types[underlying_type]
-        if not vtype[0] < next_value < vtype[1]:
-            raise PyODataParserError(f'Value {next_value} is out of range for type {underlying_type}')
+            vtype = valid_types[underlying_type]
+            if not vtype[0] < next_value < vtype[1]:
+                raise PyODataParserError(f'Value {next_value} is out of range for type {underlying_type}')
 
-        emember = EnumMember(etype, name, next_value)
-        etype._member.append(emember)
+            emember = EnumMember(etype, name, next_value)
+            etype._member.append(emember)
 
-        next_value += 1
+            next_value += 1
 
-    return etype
+        return etype
+    except (PyODataParserError, AttributeError) as ex:
+        config.err_policy(ParserError.ENUM_TYPE).resolve(ex)
+        return NullType(type_node.get('Name'))
 
 
 def build_entity_set(config, entity_set_node):

pyodata/v2/build_functions.py

@@ -38,22 +38,10 @@ def build_schema(config: Config, schema_nodes):
         schema._decls[namespace] = decl
 
         for complex_type in schema_node.xpath('edm:ComplexType', namespaces=config.namespaces):
-            try:
-                ctype = build_element(ComplexType, config, type_node=complex_type)
-            except (KeyError, AttributeError) as ex:
-                config.err_policy(ParserError.COMPLEX_TYPE).resolve(ex)
-                ctype = NullType(complex_type.get('Name'))
-
-            decl.add_complex_type(ctype)
+            decl.add_complex_type(build_element(ComplexType, config, type_node=complex_type, schema=schema))
 
         for entity_type in schema_node.xpath('edm:EntityType', namespaces=config.namespaces):
-            try:
-                etype = build_element(EntityType, config, type_node=entity_type)
-            except (KeyError, AttributeError) as ex:
-                config.err_policy(ParserError.ENTITY_TYPE).resolve(ex)
-                etype = NullType(entity_type.get('Name'))
-
-            decl.add_entity_type(etype)
+            decl.add_entity_type(build_element(EntityType, config, type_node=entity_type, schema=schema))
 
     # resolve types of properties
     for stype in itertools.chain(schema.entity_types, schema.complex_types):

pyodata/v4/build_functions.py

@@ -36,31 +36,13 @@ def build_schema(config: Config, schema_nodes):
             decl.add_type_definition(build_element(Typ, config, node=type_def))
 
         for enum_type in schema_node.xpath('edm:EnumType', namespaces=config.namespaces):
-            try:
-                etype = build_element(EnumType, config, type_node=enum_type, namespace=namespace)
-            except (PyODataParserError, AttributeError) as ex:
-                config.err_policy(ParserError.ENUM_TYPE).resolve(ex)
-                etype = NullType(enum_type.get('Name'))
-
-            decl.add_enum_type(etype)
+            decl.add_enum_type(build_element(EnumType, config, type_node=enum_type, namespace=namespace))
 
         for complex_type in schema_node.xpath('edm:ComplexType', namespaces=config.namespaces):
-            try:
-                ctype = build_element(ComplexType, config, type_node=complex_type, schema=schema)
-            except (KeyError, AttributeError) as ex:
-                config.err_policy(ParserError.COMPLEX_TYPE).resolve(ex)
-                ctype = NullType(complex_type.get('Name'))
-
-            decl.add_complex_type(ctype)
+            decl.add_complex_type(build_element(ComplexType, config, type_node=complex_type, schema=schema))
 
         for entity_type in schema_node.xpath('edm:EntityType', namespaces=config.namespaces):
-            try:
-                etype = build_element(EntityType, config, type_node=entity_type, schema=schema)
-            except (KeyError, AttributeError) as ex:
-                config.err_policy(ParserError.ENTITY_TYPE).resolve(ex)
-                etype = NullType(entity_type.get('Name'))
-
-            decl.add_entity_type(etype)
+            decl.add_entity_type(build_element(EntityType, config, type_node=entity_type, schema=schema))
 
     # resolve types of properties
     for stype in itertools.chain(schema.entity_types, schema.complex_types):