model: split entity_types and their generated Collections

Collection of entity type is not "Entity Type". Schema class should return for entity_type property only parsed <EntityType> elements, not with generated possible return types for another elements. Otherwise it is misleading API to user, in a sense that there are things in schema.entity_type that are not present in the XML.

tests: Update Complex type parsing with Schema check

model: fix Flake8 errors

tests: update test_model to check better generated collections

 model: split complex_types and their generated Collections

Update Changelog.md

Remove unnecessary code.

Author: phanak-sap

CHANGELOG.md

@@ -5,6 +5,7 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/)
 and this project adheres to [Semantic Versioning](http://semver.org/).
 
 ## [Unreleased]
+- model: split properties schema.entity_types/complex_types and their generated Collections - Petr Hanak
 
 ### Fixed
 - Fix Edm.Binary literal representation - Daniel Balko

pyodata/v2/model.py

@@ -176,15 +176,14 @@ def parse(value):
 
 
 class Types:
-    """Repository of all available OData types
+    """Repository of all available OData V2 primitive types + their Collection variants
 
        Since each type has instance of appropriate type, this
        repository acts as central storage for all instances. The
        rule is: don't create any type instances if not necessary,
        always reuse existing instances if possible
     """
 
-    # dictionary of all registered types (primitive, complex and collection variants)
     Types = None
 
     @staticmethod
@@ -794,6 +793,10 @@ def __init__(self, namespace):
             self.associations = dict()
             self.association_sets = dict()
 
+            # generated collections for ease of lookup (e.g. function import return type)
+            self._collections_entity_types = dict()
+            self._collections_complex_types = dict()
+
         def list_entity_types(self):
             return list(self.entity_types.values())
 
@@ -823,9 +826,9 @@ def add_entity_type(self, etype):
             # automatically create and register collection variant if not exists
             if isinstance(etype, NullType):
                 return
-
             collection_type_name = f'Collection({etype.name})'
-            self.entity_types[collection_type_name] = Collection(etype.name, etype)
+            self._collections_entity_types[collection_type_name] = Collection(etype.name, etype)
+            # TODO performance memory: this is generating collection for every entity type encoutered, regardless of such collection is really used.
 
         def add_complex_type(self, ctype):
             """Add new complex type to the type repository as well as its collection variant"""
@@ -835,9 +838,9 @@ def add_complex_type(self, ctype):
             # automatically create and register collection variant if not exists
             if isinstance(ctype, NullType):
                 return
-
             collection_type_name = f'Collection({ctype.name})'
-            self.complex_types[collection_type_name] = Collection(ctype.name, ctype)
+            self._collections_complex_types[collection_type_name] = Collection(ctype.name, ctype)
+            # TODO performance memory: this is generating collection for every entity type encoutered, regardless of such collection is really used.
 
         def add_enum_type(self, etype):
             """Add new enum type to the type repository"""
@@ -881,7 +884,7 @@ def typ(self, type_name, namespace=None):
         """Returns either EntityType, ComplexType or EnumType that matches the name.
         """
 
-        for type_space in (self.entity_type, self.complex_type, self.enum_type):
+        for type_space in (self.entity_type, self._collections_entity_types, self.complex_type, self._collections_complex_types, self.enum_type):
             try:
                 return type_space(type_name, namespace=namespace)
             except KeyError:
@@ -905,6 +908,21 @@ def entity_type(self, type_name, namespace=None):
 
         raise KeyError(f'EntityType {type_name} does not exist in any Schema Namespace')
 
+    def _collections_entity_types(self, type_name, namespace=None):
+        if namespace is not None:
+            try:
+                return self._decls[namespace]._collections_entity_types[type_name]
+            except KeyError:
+                raise KeyError(f'EntityType collection {type_name} does not exist in Schema Namespace {namespace}')
+
+        for decl in list(self._decls.values()):
+            try:
+                return decl._collections_entity_types[type_name]
+            except KeyError:
+                pass
+
+        raise KeyError(f'EntityType collection {type_name} does not exist in any Schema Namespace')
+
     def complex_type(self, type_name, namespace=None):
         if namespace is not None:
             try:
@@ -920,6 +938,21 @@ def complex_type(self, type_name, namespace=None):
 
         raise KeyError(f'ComplexType {type_name} does not exist in any Schema Namespace')
 
+    def _collections_complex_types(self, type_name, namespace=None):
+        if namespace is not None:
+            try:
+                return self._decls[namespace]._collections_complex_types[type_name]
+            except KeyError:
+                raise KeyError(f'ComplexType collection {type_name} does not exist in Schema Namespace {namespace}')
+
+        for decl in list(self._decls.values()):
+            try:
+                return decl._collections_complex_types[type_name]
+            except KeyError:
+                pass
+
+        raise KeyError(f'ComplexType collection {type_name} does not exist in any Schema Namespace')
+
     def enum_type(self, type_name, namespace=None):
         if namespace is not None:
             try:
@@ -946,18 +979,28 @@ def get_type(self, type_info):
         except KeyError:
             pass
 
-        # then look for type in entity types
+        # then look for type in entity types and collections of entity types
         try:
             return self.entity_type(search_name, type_info.namespace)
         except KeyError:
             pass
 
-        # then look for type in complex types
+        try:
+            return self._collections_entity_types(search_name, type_info.namespace)
+        except KeyError:
+            pass
+
+        # then look for type in complex types and collections of complex types
         try:
             return self.complex_type(search_name, type_info.namespace)
         except KeyError:
             pass
 
+        try:
+            return self._collections_complex_types(search_name, type_info.namespace)
+        except KeyError:
+            pass
+
         # then look for type in enum types
         try:
             return self.enum_type(search_name, type_info.namespace)

tests/test_model_v2.py

@@ -135,11 +135,18 @@ def test_edmx(schema):
     assert schema.typ('MasterEntity') == schema.entity_type('MasterEntity')
     assert schema.typ('MasterEntity', namespace='EXAMPLE_SRV') == schema.entity_type('MasterEntity',
                                                                                      namespace='EXAMPLE_SRV')
+    # check that the collection of this EntityType was generated
+    assert schema.typ('Collection(MasterEntity)', namespace='EXAMPLE_SRV') == schema._collections_entity_types('Collection(MasterEntity)',
+                                                                                     namespace='EXAMPLE_SRV')
 
     # ComplexType from the method typ
     assert schema.typ('Building') == schema.complex_type('Building')
     assert schema.typ('Building', namespace='EXAMPLE_SRV') == schema.complex_type('Building', namespace='EXAMPLE_SRV')
 
+    # check that the collection of this ComplexType was generated
+    assert schema.typ('Collection(Building)', namespace='EXAMPLE_SRV') == schema._collections_complex_types(
+                                            'Collection(Building)',namespace='EXAMPLE_SRV')
+
     # Error handling in the method typ - without namespace
     with pytest.raises(KeyError) as typ_ex_info:
         assert schema.typ('FooBar')
@@ -349,6 +356,9 @@ def test_edmx_complex_types(schema):
     assert str(real_prop) == 'StructTypeProperty(Real)'
     assert str(real_prop.struct_type) == 'ComplexType(ComplexNumber)'
 
+    # after correct parsing, new complex type is registered in metadata schema
+    assert str(schema.typ('ComplexNumber')) == 'ComplexType(ComplexNumber)'
+    assert str(schema.typ('Collection(ComplexNumber)')) == 'Collection(ComplexNumber)'
 
 def test_edmx_complex_type_prop_vh(schema):
     """Check that value helpers work also for ComplexType properties and aliases"""