Fix import error in python 3.6

In Python 3.7 importlib which resolves imports was updated. It allowed
to use "import x.y as c" in __x__.py, but as we support python 3.6 as
well we needed to optimize to work properly even with previous versions
of importlib. Thus, the reason for this commit.

All imports of files defined in the same folder as __module__.py are
now in the form of "from .x import a,b,c". Also, since now all relevant
classes for using pyodata e. g. elements, types are now directly
imported in the appropriate module. User should always use API exposed
directly from importing "pyodata.v2" or "pyodata.v4"

Moreover, to remove cyclic imports:
1) Adapter function for build_entity_set(Credit to Jakub Filak)
was added as well as class.

2) ODATAVersion was moved to separate file.

3) Redundant function schema_from_xml which required importing
pyodata.v2 was removed. Used MetadataBuilder(xml, Config(ODataV2))
instead.

Author: mamiksik

CHANGELOG.md

@@ -26,6 +26,7 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 - make sure configured error policies are applied for Annotations referencing
   unknown type/member - Martin Miksik
 - Race condition in `test_types_repository_separation` - Martin Miksik
+- Import error while using python version prior to 3.7 - Martin Miksik
 
 ## [1.3.0]
 

pyodata/config.py

@@ -1,41 +1,8 @@
-""" Contains definition of configuration class for PyOData and for ODATA versions. """
-
-from abc import ABC, abstractmethod
-from typing import Type, List, Dict, Callable, TYPE_CHECKING
+""" Contains definition of configuration class for PyOData"""
 
+from typing import Type, Dict
 from pyodata.policies import PolicyFatal, ParserError, ErrorPolicy
-
-# pylint: disable=cyclic-import
-if TYPE_CHECKING:
-    from pyodata.model.elements import Typ, Annotation  # noqa
-
-
-class ODATAVersion(ABC):
-    """ This is base class for different OData releases. In it we define what are supported types, elements and so on.
-        Furthermore, we specify how individual elements are parsed or represented by python objects.
-    """
-
-    def __init__(self):
-        raise RuntimeError('ODATAVersion and its children are intentionally stateless, '
-                           'therefore you can not create instance of them')
-
-    # Separate dictionary of all registered types (primitive, complex and collection variants) for each child
-    Types: Dict[str, 'Typ'] = dict()
-
-    @staticmethod
-    @abstractmethod
-    def primitive_types() -> List['Typ']:
-        """ Here we define which primitive types are supported and what is their python representation"""
-
-    @staticmethod
-    @abstractmethod
-    def build_functions() -> Dict[type, Callable]:
-        """ Here we define which elements are supported and what is their python representation"""
-
-    @staticmethod
-    @abstractmethod
-    def annotations() -> Dict['Annotation', Callable]:
-        """ Here we define which annotations are supported and what is their python representation"""
+import pyodata.version
 
 
 class Config:
@@ -46,7 +13,7 @@ class Config:
     """ This is configuration class for PyOData. All session dependent settings should be stored here. """
 
     def __init__(self,
-                 odata_version: Type[ODATAVersion],
+                 odata_version: Type[pyodata.version.ODATAVersion],
                  custom_error_policies=None,
                  default_error_policy=None,
                  xml_namespaces=None
@@ -108,7 +75,7 @@ def namespaces(self, value: Dict[str, str]):
         self._namespaces = value
 
     @property
-    def odata_version(self) -> Type[ODATAVersion]:
+    def odata_version(self) -> Type[pyodata.version.ODATAVersion]:
         return self._odata_version
 
     @property

pyodata/model/build_functions.py

@@ -11,10 +11,6 @@
     Types, EnumType, EnumMember, EntitySet, ValueHelper, ValueHelperParameter, FunctionImportParameter, \
     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
-import pyodata.v4 as v4
-
 
 def modlog():
     return logging.getLogger("callbacks")
@@ -166,14 +162,10 @@ def build_enum_type(config: Config, type_node, namespace):
         return NullType(type_node.get('Name'))
 
 
-def build_entity_set(config, entity_set_node):
+def build_entity_set(config, entity_set_node, builder=None):
     name = entity_set_node.get('Name')
     et_info = Types.parse_type_name(entity_set_node.get('EntityType'))
 
-    nav_prop_bins = []
-    for nav_prop_bin in entity_set_node.xpath('edm:NavigationPropertyBinding', namespaces=config.namespaces):
-        nav_prop_bins.append(build_element('NavigationPropertyBinding', config, node=nav_prop_bin, et_info=et_info))
-
     # TODO: create a class SAP attributes
     addressable = sap_attribute_get_bool(entity_set_node, 'addressable', True)
     creatable = sap_attribute_get_bool(entity_set_node, 'creatable', True)
@@ -186,12 +178,12 @@ def build_entity_set(config, entity_set_node):
     req_filter = sap_attribute_get_bool(entity_set_node, 'requires-filter', False)
     label = sap_attribute_get_string(entity_set_node, 'label')
 
-    if config.odata_version == v4.ODataV4:
-        return v4.EntitySet(name, et_info, addressable, creatable, updatable, deletable, searchable, countable,
-                            pageable, topable, req_filter, label, nav_prop_bins)
+    if builder:
+        return builder(config, entity_set_node, name, et_info, addressable, creatable, updatable, deletable, searchable,
+                       countable, pageable, topable, req_filter, label)
 
-    return EntitySet(name, et_info, addressable, creatable, updatable, deletable, searchable, countable, pageable,
-                     topable, req_filter, label)
+    return EntitySet(name, et_info, addressable, creatable, updatable, deletable, searchable, countable,
+                     pageable, topable, req_filter, label)
 
 
 def build_value_helper(config, target, annotation_node, schema):

pyodata/model/builder.py

@@ -6,7 +6,6 @@
 from pyodata.config import Config
 from pyodata.exceptions import PyODataParserError
 from pyodata.model.elements import ValueHelperParameter, Schema, build_element
-import pyodata.v2 as v2
 
 
 ANNOTATION_NAMESPACES = {
@@ -40,11 +39,8 @@ class MetadataBuilder:
         'http://docs.oasis-open.org/odata/ns/edm'
     ]
 
-    def __init__(self, xml, config=None):
+    def __init__(self, xml, config):
         self._xml = xml
-
-        if config is None:
-            config = Config(v2.ODataV2)
         self._config = config
 
     # pylint: disable=missing-docstring
@@ -132,16 +128,3 @@ def update_alias(aliases, config: Config):
                 if alias_namespace == namespace:
                     config._sap_value_helper_directions[alias + '.' + suffix] = \
                         config.sap_value_helper_directions[direction_key]
-
-
-def schema_from_xml(metadata_xml, namespaces=None):
-    """Parses XML data and returns Schema representing OData Metadata"""
-
-    meta = MetadataBuilder(
-        metadata_xml,
-        config=Config(
-            v2.ODataV2,
-            xml_namespaces=namespaces,
-        ))
-
-    return meta.build()

pyodata/v2/__init__.py

@@ -3,20 +3,20 @@
 import logging
 from typing import List
 
-from pyodata.v2.type_traits import EdmDateTimeTypTraits
 
+from pyodata.version import ODATAVersion
+from pyodata.model.elements import StructTypeProperty, StructType, ComplexType, EntityType, EntitySet, ValueHelper, \
+    ValueHelperParameter, FunctionImport, Typ
+from pyodata.model.build_functions import build_value_helper, build_entity_type, build_complex_type, \
+    build_value_helper_parameter, build_entity_set, build_struct_type_property, build_struct_type, build_function_import
 from pyodata.model.type_traits import EdmBooleanTypTraits, EdmPrefixedTypTraits, EdmIntTypTraits, \
     EdmLongIntTypTraits, EdmStringTypTraits
-from pyodata.config import ODATAVersion
 
-from pyodata.v2.elements import NavigationTypeProperty, EndRole, Association, AssociationSetEndRole, AssociationSet, \
+from .elements import NavigationTypeProperty, EndRole, Association, AssociationSetEndRole, AssociationSet, \
     ReferentialConstraint, Schema
-from pyodata.model.elements import StructTypeProperty, StructType, ComplexType, EntityType, EntitySet, ValueHelper, \
-    ValueHelperParameter, FunctionImport, Typ
-
-
-import pyodata.v2.build_functions as build_functions_v2
-import pyodata.model.build_functions as build_functions
+from .build_functions import build_association_set, build_end_role, build_association, build_schema, \
+    build_navigation_type_property, build_referential_constraint, build_association_set_end_role
+from .type_traits import EdmDateTimeTypTraits
 
 
 def modlog():
@@ -30,20 +30,20 @@ class ODataV2(ODATAVersion):
     @staticmethod
     def build_functions():
         return {
-            StructTypeProperty: build_functions.build_struct_type_property,
-            StructType: build_functions.build_struct_type,
-            NavigationTypeProperty: build_functions_v2.build_navigation_type_property,
-            ComplexType: build_functions.build_complex_type,
-            EntityType: build_functions.build_entity_type,
-            EntitySet: build_functions.build_entity_set,
-            EndRole: build_functions_v2.build_end_role,
-            ReferentialConstraint: build_functions_v2.build_referential_constraint,
-            Association: build_functions_v2.build_association,
-            AssociationSetEndRole: build_functions_v2.build_association_set_end_role,
-            AssociationSet: build_functions_v2.build_association_set,
-            ValueHelperParameter: build_functions.build_value_helper_parameter,
-            FunctionImport: build_functions.build_function_import,
-            Schema: build_functions_v2.build_schema
+            StructTypeProperty: build_struct_type_property,
+            StructType: build_struct_type,
+            NavigationTypeProperty: build_navigation_type_property,
+            ComplexType: build_complex_type,
+            EntityType: build_entity_type,
+            EntitySet: build_entity_set,
+            EndRole: build_end_role,
+            ReferentialConstraint: build_referential_constraint,
+            Association: build_association,
+            AssociationSetEndRole: build_association_set_end_role,
+            AssociationSet: build_association_set,
+            ValueHelperParameter: build_value_helper_parameter,
+            FunctionImport: build_function_import,
+            Schema: build_schema
         }
 
     @staticmethod
@@ -70,5 +70,5 @@ def primitive_types() -> List[Typ]:
     @staticmethod
     def annotations():
         return {
-            ValueHelper: build_functions.build_value_helper
+            ValueHelper: build_value_helper
         }

pyodata/v4/__init__.py

@@ -2,34 +2,35 @@
 
 from typing import List
 
-from pyodata.config import ODATAVersion
-from pyodata.model.type_traits import EdmBooleanTypTraits, EdmIntTypTraits
+from pyodata.version import ODATAVersion
 from pyodata.model.elements import Typ, Schema, EnumType, ComplexType, StructType, StructTypeProperty, EntityType
+from pyodata.model.build_functions import build_entity_type, build_complex_type, build_struct_type_property, \
+    build_enum_type, build_struct_type
+from pyodata.model.type_traits import EdmBooleanTypTraits, EdmIntTypTraits
 
-from pyodata.v4.elements import NavigationTypeProperty, NavigationPropertyBinding, EntitySet, Unit
-from pyodata.v4.type_traits import EdmDateTypTraits, GeoTypeTraits, EdmDoubleQuotesEncapsulatedTypTraits, \
+from .elements import NavigationTypeProperty, NavigationPropertyBinding, EntitySet, Unit
+from .build_functions import build_unit_annotation, build_type_definition, build_schema, \
+    build_navigation_type_property, build_navigation_property_binding, build_entity_set_with_v4_builder
+from .type_traits import EdmDateTypTraits, GeoTypeTraits, EdmDoubleQuotesEncapsulatedTypTraits, \
     EdmTimeOfDay, EdmDateTimeOffsetTypTraits, EdmDuration
 
-import pyodata.v4.build_functions as build_functions_v4
-import pyodata.model.build_functions as build_functions
-
 
 class ODataV4(ODATAVersion):
     """ Definition of OData V4 """
 
     @staticmethod
     def build_functions():
         return {
-            StructTypeProperty: build_functions.build_struct_type_property,
-            StructType: build_functions.build_struct_type,
-            NavigationTypeProperty: build_functions_v4.build_navigation_type_property,
-            NavigationPropertyBinding: build_functions_v4.build_navigation_property_binding,
-            EnumType: build_functions.build_enum_type,
-            ComplexType: build_functions.build_complex_type,
-            EntityType: build_functions.build_entity_type,
-            EntitySet: build_functions.build_entity_set,
-            Typ: build_functions_v4.build_type_definition,
-            Schema: build_functions_v4.build_schema,
+            StructTypeProperty: build_struct_type_property,
+            StructType: build_struct_type,
+            NavigationTypeProperty: build_navigation_type_property,
+            NavigationPropertyBinding: build_navigation_property_binding,
+            EnumType: build_enum_type,
+            ComplexType: build_complex_type,
+            EntityType: build_entity_type,
+            EntitySet: build_entity_set_with_v4_builder,
+            Typ: build_type_definition,
+            Schema: build_schema,
         }
 
     @staticmethod
@@ -75,5 +76,5 @@ def primitive_types() -> List[Typ]:
     @staticmethod
     def annotations():
         return {
-            Unit: build_functions_v4.build_unit_annotation
+            Unit: build_unit_annotation
         }

pyodata/v4/build_functions.py

@@ -8,6 +8,7 @@
 
 from pyodata.config import Config
 from pyodata.exceptions import PyODataParserError, PyODataModelError
+from pyodata.model.build_functions import build_entity_set
 from pyodata.model.elements import ComplexType, Schema, EnumType, NullType, build_element, EntityType, Types, \
     StructTypeProperty, build_annotation, Typ
 from pyodata.policies import ParserError
@@ -157,3 +158,20 @@ def build_type_definition(config: Config, node):
         build_annotation(annotation_node.get('Term'), config, target=typ, annotation_node=annotation_node)
 
     return typ
+
+
+# pylint: disable=too-many-arguments
+def build_entity_set_v4(config, entity_set_node, name, et_info, addressable, creatable, updatable, deletable,
+                        searchable, countable, pageable, topable, req_filter, label):
+    nav_prop_bins = []
+    for nav_prop_bin in entity_set_node.xpath('edm:NavigationPropertyBinding', namespaces=config.namespaces):
+        nav_prop_bins.append(build_element(NavigationPropertyBinding, config, node=nav_prop_bin, et_info=et_info))
+
+    return EntitySet(name, et_info, addressable, creatable, updatable, deletable, searchable, countable, pageable,
+                     topable, req_filter, label, nav_prop_bins)
+
+
+def build_entity_set_with_v4_builder(config, entity_set_node):
+    """Adapter inserting the V4 specific builder"""
+
+    return build_entity_set(config, entity_set_node, builder=build_entity_set_v4)

pyodata/version.py

@@ -0,0 +1,36 @@
+""" Base class for defining ODATA versions. """
+
+from abc import ABC, abstractmethod
+from typing import List, Dict, Callable, TYPE_CHECKING
+
+# pylint: disable=cyclic-import
+if TYPE_CHECKING:
+    from pyodata.model.elements import Typ, Annotation  # noqa
+
+
+class ODATAVersion(ABC):
+    """ This is base class for different OData releases. In it we define what are supported types, elements and so on.
+        Furthermore, we specify how individual elements are parsed or represented by python objects.
+    """
+
+    def __init__(self):
+        raise RuntimeError('ODATAVersion and its children are intentionally stateless, '
+                           'therefore you can not create instance of them')
+
+    # Separate dictionary of all registered types (primitive, complex and collection variants) for each child
+    Types: Dict[str, 'Typ'] = dict()
+
+    @staticmethod
+    @abstractmethod
+    def primitive_types() -> List['Typ']:
+        """ Here we define which primitive types are supported and what is their python representation"""
+
+    @staticmethod
+    @abstractmethod
+    def build_functions() -> Dict[type, Callable]:
+        """ Here we define which elements are supported and what is their python representation"""
+
+    @staticmethod
+    @abstractmethod
+    def annotations() -> Dict['Annotation', Callable]:
+        """ Here we define which annotations are supported and what is their python representation"""

tests/conftest.py

@@ -4,7 +4,8 @@
 import pytest
 
 from pyodata.config import Config
-from pyodata.model.builder import schema_from_xml, MetadataBuilder
+from pyodata.model.builder import MetadataBuilder
+from pyodata.v2 import ODataV2
 from pyodata.v4 import ODataV4
 
 
@@ -124,7 +125,12 @@ def schema(metadata_v2):
 
     # pylint: disable=redefined-outer-name
 
-    return schema_from_xml(metadata_v2)
+    meta = MetadataBuilder(
+        metadata_v2,
+        config=Config(ODataV2)
+    )
+
+    return meta.build()
 
 
 @pytest.fixture

tests/test_model.py

@@ -1,7 +1,8 @@
 from typing import List
 import pytest
 
-from pyodata.config import Config, ODATAVersion
+from pyodata.config import Config
+from pyodata.version import ODATAVersion
 from pyodata.exceptions import PyODataParserError
 from pyodata.model.builder import MetadataBuilder
 from pyodata.model.elements import Schema, Types, Typ