Splits python representation of metadata and its parser

The current implementation of python representation of metadata and metadata parser was tightly interconnected. Support for other versions of OData was not possible as in each version elements are added, removed or modified. Therefore, we decided to split metadata representation and its parser. With this approach, we can easily define supported elements and its parsing functions in a single class. This "configuration" class is stateless and has to be a child of ODATAVersion.

Additional changes including updating directory structure and refactoring old code to accommodate for incoming ODATA V4 support.

New module model:
- builder -> MetadataBuilder was moved here to make code easier to read
elements -> All EDM elements were moved here, to make python representation of elements version independent. All parsable elements have to inherit from "from_etree_mixin".

- from_etree_callbacks -> All  from_etree static methods were moved into separated function. This is a naive approach as its premise is that all from_etree implementations will be reusable in version V4.

- types_traits -> "types traits" were moved here to make code cleaner and easier to read.

Module V2:
- __init__ -> includes OData2 definition.

- service -> function-wise nothing has been changed.

"Main" module:
- config -> class Config was moved here to make it version and model-independent. In case we will ever need a config class also for service. Also ODataVersion class lives here.

- policies -> All policies were moved here as well as ParserError enum. Again to make policies version and model-independent.

Tests were only updated to incorporate new API.

Author: mamiksik

CHANGELOG.md

@@ -9,6 +9,7 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 ### Added
 - Client can be created from local metadata - Jakub Filak
 - support all standard EDM schema versions - Jakub Filak
+- Splits python representation of metadata and metadata parsing - Martin Miksik
 
 ### Fixed
 - make sure configured error policies are applied for Annotations referencing

docs/usage/README.md

@@ -1,4 +1,4 @@
-The User Guide
+versionThe User Guide
 --------------
 
 * [Initialization](initialization.rst)

docs/usage/initialization.rst

@@ -121,7 +121,9 @@ For parser to use your custom configuration, it needs to be passed as an argumen
 .. code-block:: python
 
     import pyodata
-    from pyodata.v2.model import PolicyFatal, PolicyWarning, PolicyIgnore, ParserError, Config
+    from pyodata.v2 import ODataV2
+    from pyodata.policies import PolicyFatal, PolicyWarning, PolicyIgnore, ParserError
+    from pyodata.config import Config
     import requests
 
     SERVICE_URL = 'http://services.odata.org/V2/Northwind/Northwind.svc/'
@@ -132,6 +134,7 @@ For parser to use your custom configuration, it needs to be passed as an argumen
     }
 
     custom_config = Config(
+        ODataV2,
         xml_namespaces=namespaces,
         default_error_policy=PolicyFatal(),
         custom_error_policies={

pyodata/client.py

@@ -3,9 +3,11 @@
 import logging
 import warnings
 
-import pyodata.v2.model
-import pyodata.v2.service
+from pyodata.config import Config
+from pyodata.model.builder import MetadataBuilder
 from pyodata.exceptions import PyODataException, HttpError
+from pyodata.v2.service import Service
+from pyodata.v2 import ODataV2
 
 
 def _fetch_metadata(connection, url, logger):
@@ -34,43 +36,37 @@ class Client:
     """OData service client"""
 
     # pylint: disable=too-few-public-methods
-
-    ODATA_VERSION_2 = 2
-
-    def __new__(cls, url, connection, odata_version=ODATA_VERSION_2, namespaces=None,
-                config: pyodata.v2.model.Config = None, metadata: str = None):
+    def __new__(cls, url, connection, namespaces=None,
+                config: Config = None, metadata: str = None):
         """Create instance of the OData Client for given URL"""
 
         logger = logging.getLogger('pyodata.client')
 
-        if odata_version == Client.ODATA_VERSION_2:
-
-            # sanitize url
-            url = url.rstrip('/') + '/'
-
-            if metadata is None:
-                metadata = _fetch_metadata(connection, url, logger)
-            else:
-                logger.info('Using static metadata')
+        # sanitize url
+        url = url.rstrip('/') + '/'
 
-            if config is not None and namespaces is not None:
-                raise PyODataException('You cannot pass namespaces and config at the same time')
+        if metadata is None:
+            metadata = _fetch_metadata(connection, url, logger)
+        else:
+            logger.info('Using static metadata')
 
-            if config is None:
-                config = pyodata.v2.model.Config()
+        if config is not None and namespaces is not None:
+            raise PyODataException('You cannot pass namespaces and config at the same time')
 
-            if namespaces is not None:
-                warnings.warn("Passing namespaces directly is deprecated. Use class Config instead", DeprecationWarning)
-                config.namespaces = namespaces
+        if config is None:
+            logger.info('No OData version has been provided. Client defaulted to OData v2')
+            config = Config(ODataV2)
 
-            # create model instance from received metadata
-            logger.info('Creating OData Schema (version: %d)', odata_version)
-            schema = pyodata.v2.model.MetadataBuilder(metadata, config=config).build()
+        if namespaces is not None:
+            warnings.warn("Passing namespaces directly is deprecated. Use class Config instead", DeprecationWarning)
+            config.namespaces = namespaces
 
-            # create service instance based on model we have
-            logger.info('Creating OData Service (version: %d)', odata_version)
-            service = pyodata.v2.service.Service(url, schema, connection)
+        # create model instance from received metadata
+        logger.info('Creating OData Schema (version: %d)', config.odata_version)
+        schema = MetadataBuilder(metadata, config=config).build()
 
-            return service
+        # create service instance based on model we have
+        logger.info('Creating OData Service (version: %d)', config.odata_version)
+        service = Service(url, schema, connection)
 
-        raise PyODataException('No implementation for selected odata version {}'.format(odata_version))
+        return service

pyodata/config.py

@@ -0,0 +1,117 @@
+""" Contains definition of configuration class for PyOData and for ODATA versions. """
+
+from abc import ABC, abstractmethod
+from typing import Type, List, Dict, Callable
+
+from pyodata.policies import PolicyFatal, ParserError, ErrorPolicy
+
+
+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')
+
+    @staticmethod
+    @abstractmethod
+    def supported_primitive_types() -> List[str]:
+        """ Here we define which primitive types are supported and what is their python representation"""
+
+    @staticmethod
+    @abstractmethod
+    def from_etree_callbacks() -> Dict[object, Callable]:
+        """ Here we define which elements are supported and what is their python representation"""
+
+    @classmethod
+    def is_primitive_type_supported(cls, type_name):
+        """ Convenience method which decides whatever given type is supported."""
+        return type_name in cls.supported_primitive_types()
+
+
+class Config:
+    # pylint: disable=too-many-instance-attributes,missing-docstring
+    # All attributes have purpose and are used for configuration
+    # Having docstring for properties is not necessary as we do have type hints
+
+    """ This is configuration class for PyOData. All session dependent settings should be stored here. """
+
+    def __init__(self,
+                 odata_version: Type[ODATAVersion],
+                 custom_error_policies=None,
+                 default_error_policy=None,
+                 xml_namespaces=None
+                 ):
+
+        """
+        :param custom_error_policies: {ParserError: ErrorPolicy} (default None)
+                                      Used to specified individual policies for XML tags. See documentation for more
+                                      details.
+
+        :param default_error_policy: ErrorPolicy (default PolicyFatal)
+                                     If custom policy is not specified for the tag, the default policy will be used.
+
+        :param xml_namespaces: {str: str} (default None)
+        """
+
+        self._custom_error_policy = custom_error_policies
+
+        if default_error_policy is None:
+            default_error_policy = PolicyFatal()
+
+        self._default_error_policy = default_error_policy
+
+        if xml_namespaces is None:
+            xml_namespaces = {}
+
+        self._namespaces = xml_namespaces
+
+        self._odata_version = odata_version
+
+        self._sap_value_helper_directions = None
+        self._sap_annotation_value_list = None
+        self._annotation_namespaces = None
+
+    def err_policy(self, error: ParserError) -> ErrorPolicy:
+        """ Returns error policy for given error. If custom error policy fo error is set, then returns that."""
+        if self._custom_error_policy is None:
+            return self._default_error_policy
+
+        return self._custom_error_policy.get(error, self._default_error_policy)
+
+    def set_default_error_policy(self, policy: ErrorPolicy):
+        """ Sets default error policy as well as resets custom error policies"""
+        self._custom_error_policy = None
+        self._default_error_policy = policy
+
+    def set_custom_error_policy(self, policies: Dict[ParserError, Type[ErrorPolicy]]):
+        """ Sets custom error policy. It should be called only after setting default error policy, otherwise
+            it has no effect. See implementation of "set_default_error_policy" for more details.
+        """
+        self._custom_error_policy = policies
+
+    @property
+    def namespaces(self) -> str:
+        return self._namespaces
+
+    @namespaces.setter
+    def namespaces(self, value: Dict[str, str]):
+        self._namespaces = value
+
+    @property
+    def odata_version(self) -> Type[ODATAVersion]:
+        return self._odata_version
+
+    @property
+    def sap_value_helper_directions(self):
+        return self._sap_value_helper_directions
+
+    @property
+    def sap_annotation_value_list(self):
+        return self._sap_annotation_value_list
+
+    @property
+    def annotation_namespace(self):
+        return self._annotation_namespaces

pyodata/model/__init__.py

@@ -0,0 +1,151 @@
+"""Metadata Builder Implementation"""
+
+import collections
+import io
+from lxml import etree
+
+from pyodata.config import Config
+from pyodata.exceptions import PyODataParserError
+from pyodata.model.elements import ValueHelperParameter, Schema
+import pyodata.v2 as v2
+
+
+ANNOTATION_NAMESPACES = {
+    'edm': 'http://docs.oasis-open.org/odata/ns/edm',
+    'edmx': 'http://docs.oasis-open.org/odata/ns/edmx'
+}
+
+SAP_VALUE_HELPER_DIRECTIONS = {
+    'com.sap.vocabularies.Common.v1.ValueListParameterIn': ValueHelperParameter.Direction.In,
+    'com.sap.vocabularies.Common.v1.ValueListParameterInOut': ValueHelperParameter.Direction.InOut,
+    'com.sap.vocabularies.Common.v1.ValueListParameterOut': ValueHelperParameter.Direction.Out,
+    'com.sap.vocabularies.Common.v1.ValueListParameterDisplayOnly': ValueHelperParameter.Direction.DisplayOnly,
+    'com.sap.vocabularies.Common.v1.ValueListParameterFilterOnly': ValueHelperParameter.Direction.FilterOnly
+}
+
+
+SAP_ANNOTATION_VALUE_LIST = ['com.sap.vocabularies.Common.v1.ValueList']
+
+
+# pylint: disable=protected-access
+class MetadataBuilder:
+    """Metadata builder"""
+
+    EDMX_WHITELIST = [
+        'http://schemas.microsoft.com/ado/2007/06/edmx',
+        'http://docs.oasis-open.org/odata/ns/edmx',
+    ]
+
+    EDM_WHITELIST = [
+        'http://schemas.microsoft.com/ado/2006/04/edm',
+        'http://schemas.microsoft.com/ado/2007/05/edm',
+        'http://schemas.microsoft.com/ado/2008/09/edm',
+        'http://schemas.microsoft.com/ado/2009/11/edm',
+        'http://docs.oasis-open.org/odata/ns/edm'
+    ]
+
+    def __init__(self, xml, config=None):
+        self._xml = xml
+
+        if config is None:
+            config = Config(v2.ODataV2)
+        self._config = config
+
+    # pylint: disable=missing-docstring
+    @property
+    def config(self) -> Config:
+        return self._config
+
+    def build(self):
+        """ Build model from the XML metadata"""
+
+        if isinstance(self._xml, str):
+            mdf = io.StringIO(self._xml)
+        elif isinstance(self._xml, bytes):
+            mdf = io.BytesIO(self._xml)
+        else:
+            raise TypeError('Expected bytes or str type on metadata_xml, got : {0}'.format(type(self._xml)))
+
+        namespaces = self._config.namespaces
+        xml = etree.parse(mdf)
+        edmx = xml.getroot()
+
+        try:
+            dataservices = next((child for child in edmx if etree.QName(child.tag).localname == 'DataServices'))
+        except StopIteration:
+            raise PyODataParserError('Metadata document is missing the element DataServices')
+
+        try:
+            schema = next((child for child in dataservices if etree.QName(child.tag).localname == 'Schema'))
+        except StopIteration:
+            raise PyODataParserError('Metadata document is missing the element Schema')
+
+        if 'edmx' not in self._config.namespaces:
+            namespace = etree.QName(edmx.tag).namespace
+
+            if namespace not in self.EDMX_WHITELIST:
+                raise PyODataParserError(f'Unsupported Edmx namespace - {namespace}')
+
+            namespaces['edmx'] = namespace
+
+        if 'edm' not in self._config.namespaces:
+            namespace = etree.QName(schema.tag).namespace
+
+            if namespace not in self.EDM_WHITELIST:
+                raise PyODataParserError(f'Unsupported Schema namespace - {namespace}')
+
+            namespaces['edm'] = namespace
+
+        self._config.namespaces = namespaces
+
+        self._config._sap_value_helper_directions = SAP_VALUE_HELPER_DIRECTIONS
+        self._config._sap_annotation_value_list = SAP_ANNOTATION_VALUE_LIST
+        self._config._annotation_namespaces = ANNOTATION_NAMESPACES
+
+        self.update_alias(self.get_aliases(xml, self._config), self._config)
+
+        edm_schemas = xml.xpath('/edmx:Edmx/edmx:DataServices/edm:Schema', namespaces=self._config.namespaces)
+        return Schema.from_etree(edm_schemas, self._config)
+
+    @staticmethod
+    def get_aliases(edmx, config: Config):
+        """Get all aliases"""
+
+        aliases = collections.defaultdict(set)
+        edm_root = edmx.xpath('/edmx:Edmx', namespaces=config.namespaces)
+        if edm_root:
+            edm_ref_includes = edm_root[0].xpath('edmx:Reference/edmx:Include', namespaces=config.annotation_namespace)
+            for ref_incl in edm_ref_includes:
+                namespace = ref_incl.get('Namespace')
+                alias = ref_incl.get('Alias')
+                if namespace is not None and alias is not None:
+                    aliases[namespace].add(alias)
+
+        return aliases
+
+    @staticmethod
+    def update_alias(aliases, config: Config):
+        """Update config with aliases"""
+
+        namespace, suffix = config.sap_annotation_value_list[0].rsplit('.', 1)
+        config._sap_annotation_value_list.extend([alias + '.' + suffix for alias in aliases[namespace]])
+
+        helper_direction_keys = list(config.sap_value_helper_directions.keys())
+        for direction_key in helper_direction_keys:
+            namespace, suffix = direction_key.rsplit('.', 1)
+            for alias in aliases[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/model/builder.py

@@ -0,0 +1,344 @@
+""" Reusable implementation of from_etree methods for the most of edm elements """
+
+# pylint: disable=unused-argument, missing-docstring, invalid-name
+import logging
+
+from pyodata.config import Config
+from pyodata.exceptions import PyODataParserError, PyODataModelError
+from pyodata.model.elements import sap_attribute_get_bool, sap_attribute_get_string, StructType, StructTypeProperty, \
+    NavigationTypeProperty, Identifier, Types, EnumType, EnumMember, EntitySet, EndRole, ReferentialConstraint, \
+    PrincipalRole, DependentRole, Association, AssociationSetEndRole, AssociationSet, \
+    ValueHelper, ValueHelperParameter, FunctionImportParameter, \
+    FunctionImport, metadata_attribute_get, EntityType, ComplexType, Annotation
+
+
+def modlog():
+    return logging.getLogger("callbacks")
+
+
+def struct_type_property_from_etree(entity_type_property_node, config: Config):
+    return StructTypeProperty(
+        entity_type_property_node.get('Name'),
+        Types.parse_type_name(entity_type_property_node.get('Type')),
+        entity_type_property_node.get('Nullable'),
+        entity_type_property_node.get('MaxLength'),
+        entity_type_property_node.get('Precision'),
+        entity_type_property_node.get('Scale'),
+        # TODO: create a class SAP attributes
+        sap_attribute_get_bool(entity_type_property_node, 'unicode', True),
+        sap_attribute_get_string(entity_type_property_node, 'label'),
+        sap_attribute_get_bool(entity_type_property_node, 'creatable', True),
+        sap_attribute_get_bool(entity_type_property_node, 'updatable', True),
+        sap_attribute_get_bool(entity_type_property_node, 'sortable', True),
+        sap_attribute_get_bool(entity_type_property_node, 'filterable', True),
+        sap_attribute_get_string(entity_type_property_node, 'filter-restriction'),
+        sap_attribute_get_bool(entity_type_property_node, 'required-in-filter', False),
+        sap_attribute_get_string(entity_type_property_node, 'text'),
+        sap_attribute_get_bool(entity_type_property_node, 'visible', True),
+        sap_attribute_get_string(entity_type_property_node, 'display-format'),
+        sap_attribute_get_string(entity_type_property_node, 'value-list'), )
+
+
+# pylint: disable=protected-access
+def struct_type_from_etree(type_node, config: Config, kwargs):
+    name = type_node.get('Name')
+    label = sap_attribute_get_string(type_node, 'label')
+    is_value_list = sap_attribute_get_bool(type_node, 'value-list', False)
+
+    stype = kwargs['type'](name, label, is_value_list)
+
+    for proprty in type_node.xpath('edm:Property', namespaces=config.namespaces):
+        stp = StructTypeProperty.from_etree(proprty, config)
+
+        if stp.name in stype._properties:
+            raise KeyError('{0} already has property {1}'.format(stype, stp.name))
+
+        stype._properties[stp.name] = stp
+
+    # We have to update the property when
+    # all properites are loaded because
+    # there might be links between them.
+    for ctp in list(stype._properties.values()):
+        ctp.struct_type = stype
+
+    return stype
+
+
+def navigation_type_property_from_etree(node, config: Config):
+    return NavigationTypeProperty(
+        node.get('Name'), node.get('FromRole'), node.get('ToRole'), Identifier.parse(node.get('Relationship')))
+
+
+def complex_type_from_etree(etree, config: Config):
+    return StructType.from_etree(etree, config, type=ComplexType)
+
+
+# pylint: disable=protected-access
+def entity_type_from_etree(etree, config: Config):
+    etype = StructType.from_etree(etree, config, type=EntityType)
+
+    for proprty in etree.xpath('edm:Key/edm:PropertyRef', namespaces=config.namespaces):
+        etype._key.append(etype.proprty(proprty.get('Name')))
+
+    for proprty in etree.xpath('edm:NavigationProperty', namespaces=config.namespaces):
+        navp = NavigationTypeProperty.from_etree(proprty, config)
+
+        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
+
+    return etype
+
+
+# pylint: disable=protected-access, too-many-locals
+def enum_type_from_etree(type_node, config: Config, kwargs):
+    ename = type_node.get('Name')
+    is_flags = type_node.get('IsFlags')
+
+    namespace = kwargs['namespace']
+
+    underlying_type = type_node.get('UnderlyingType')
+
+    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}')
+
+    mtype = Types.from_name(underlying_type, config)
+    etype = EnumType(ename, is_flags, mtype, namespace)
+
+    members = type_node.xpath('edm:Member', namespaces=config.namespaces)
+
+    next_value = 0
+    for member in members:
+        name = member.get('Name')
+        value = member.get('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}')
+
+        emember = EnumMember(etype, name, next_value)
+        etype._member.append(emember)
+
+        next_value += 1
+
+    return etype
+
+
+def entity_set_from_etree(entity_set_node, config):
+    name = entity_set_node.get('Name')
+    et_info = Types.parse_type_name(entity_set_node.get('EntityType'))
+
+    # 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)
+    updatable = sap_attribute_get_bool(entity_set_node, 'updatable', True)
+    deletable = sap_attribute_get_bool(entity_set_node, 'deletable', True)
+    searchable = sap_attribute_get_bool(entity_set_node, 'searchable', False)
+    countable = sap_attribute_get_bool(entity_set_node, 'countable', True)
+    pageable = sap_attribute_get_bool(entity_set_node, 'pageable', True)
+    topable = sap_attribute_get_bool(entity_set_node, 'topable', pageable)
+    req_filter = sap_attribute_get_bool(entity_set_node, 'requires-filter', False)
+    label = sap_attribute_get_string(entity_set_node, 'label')
+
+    return EntitySet(name, et_info, addressable, creatable, updatable, deletable, searchable, countable, pageable,
+                     topable, req_filter, label)
+
+
+def end_role_from_etree(end_role_node, config):
+    entity_type_info = Types.parse_type_name(end_role_node.get('Type'))
+    multiplicity = end_role_node.get('Multiplicity')
+    role = end_role_node.get('Role')
+
+    return EndRole(entity_type_info, multiplicity, role)
+
+
+def referential_constraint_from_etree(referential_constraint_node, config: Config):
+    principal = referential_constraint_node.xpath('edm:Principal', namespaces=config.namespaces)
+    if len(principal) != 1:
+        raise RuntimeError('Referential constraint must contain exactly one principal element')
+
+    principal_name = principal[0].get('Role')
+    if principal_name is None:
+        raise RuntimeError('Principal role name was not specified')
+
+    principal_refs = []
+    for property_ref in principal[0].xpath('edm:PropertyRef', namespaces=config.namespaces):
+        principal_refs.append(property_ref.get('Name'))
+    if not principal_refs:
+        raise RuntimeError('In role {} should be at least one principal property defined'.format(principal_name))
+
+    dependent = referential_constraint_node.xpath('edm:Dependent', namespaces=config.namespaces)
+    if len(dependent) != 1:
+        raise RuntimeError('Referential constraint must contain exactly one dependent element')
+
+    dependent_name = dependent[0].get('Role')
+    if dependent_name is None:
+        raise RuntimeError('Dependent role name was not specified')
+
+    dependent_refs = []
+    for property_ref in dependent[0].xpath('edm:PropertyRef', namespaces=config.namespaces):
+        dependent_refs.append(property_ref.get('Name'))
+    if len(principal_refs) != len(dependent_refs):
+        raise RuntimeError('Number of properties should be equal for the principal {} and the dependent {}'
+                           .format(principal_name, dependent_name))
+
+    return ReferentialConstraint(
+        PrincipalRole(principal_name, principal_refs), DependentRole(dependent_name, dependent_refs))
+
+
+# pylint: disable=protected-access
+def association_from_etree(association_node, config: Config):
+    name = association_node.get('Name')
+    association = Association(name)
+
+    for end in association_node.xpath('edm:End', namespaces=config.namespaces):
+        end_role = EndRole.from_etree(end, config)
+        if end_role.entity_type_info is None:
+            raise RuntimeError('End type is not specified in the association {}'.format(name))
+        association._end_roles.append(end_role)
+
+    if len(association._end_roles) != 2:
+        raise RuntimeError('Association {} does not have two end roles'.format(name))
+
+    refer = association_node.xpath('edm:ReferentialConstraint', namespaces=config.namespaces)
+    if len(refer) > 1:
+        raise RuntimeError('In association {} is defined more than one referential constraint'.format(name))
+
+    if not refer:
+        referential_constraint = None
+    else:
+        referential_constraint = ReferentialConstraint.from_etree(refer[0], config)
+
+    association._referential_constraint = referential_constraint
+
+    return association
+
+
+def association_set_end_role_from_etree(end_node, config):
+    role = end_node.get('Role')
+    entity_set = end_node.get('EntitySet')
+
+    return AssociationSetEndRole(role, entity_set)
+
+
+def association_set_from_etree(association_set_node, config: Config):
+    end_roles = []
+    name = association_set_node.get('Name')
+    association = Identifier.parse(association_set_node.get('Association'))
+
+    end_roles_list = association_set_node.xpath('edm:End', namespaces=config.namespaces)
+    if len(end_roles) > 2:
+        raise PyODataModelError('Association {} cannot have more than 2 end roles'.format(name))
+
+    for end_role in end_roles_list:
+        end_roles.append(AssociationSetEndRole.from_etree(end_role, config))
+
+    return AssociationSet(name, association.name, association.namespace, end_roles)
+
+
+def external_annotation_from_etree(annotations_node, config):
+    target = annotations_node.get('Target')
+
+    if annotations_node.get('Qualifier'):
+        modlog().warning('Ignoring qualified Annotations of %s', target)
+        return
+
+    for annotation in annotations_node.xpath('edm:Annotation', namespaces=config.annotation_namespace):
+        annot = Annotation.from_etree(target, config, annotation_node=annotation)
+        if annot is None:
+            continue
+        yield annot
+
+
+def annotation_from_etree(target, config, kwargs):
+    annotation_node = kwargs['annotation_node']
+    term = annotation_node.get('Term')
+
+    if term in config.sap_annotation_value_list:
+        return ValueHelper.from_etree(target, config, annotation_node=annotation_node)
+
+    modlog().warning('Unsupported Annotation( %s )', term)
+    return None
+
+
+def value_helper_from_etree(target, config, kwargs):
+    label = None
+    collection_path = None
+    search_supported = False
+    params_node = None
+
+    annotation_node = kwargs['annotation_node']
+    for prop_value in annotation_node.xpath('edm:Record/edm:PropertyValue', namespaces=config.annotation_namespace):
+        rprop = prop_value.get('Property')
+        if rprop == 'Label':
+            label = prop_value.get('String')
+        elif rprop == 'CollectionPath':
+            collection_path = prop_value.get('String')
+        elif rprop == 'SearchSupported':
+            search_supported = prop_value.get('Bool')
+        elif rprop == 'Parameters':
+            params_node = prop_value
+
+    value_helper = ValueHelper(target, collection_path, label, search_supported)
+
+    if params_node is not None:
+        for prm in params_node.xpath('edm:Collection/edm:Record', namespaces=config.annotation_namespace):
+            param = ValueHelperParameter.from_etree(prm, config)
+            param.value_helper = value_helper
+            value_helper._parameters.append(param)
+
+    return value_helper
+
+
+def value_helper_parameter_from_etree(value_help_parameter_node, config):
+    typ = value_help_parameter_node.get('Type')
+    direction = config.sap_value_helper_directions[typ]
+    local_prop_name = None
+    list_prop_name = None
+    for pval in value_help_parameter_node.xpath('edm:PropertyValue', namespaces=config.annotation_namespace):
+        pv_name = pval.get('Property')
+        if pv_name == 'LocalDataProperty':
+            local_prop_name = pval.get('PropertyPath')
+        elif pv_name == 'ValueListProperty':
+            list_prop_name = pval.get('String')
+
+    return ValueHelperParameter(direction, local_prop_name, list_prop_name)
+
+
+# pylint: disable=too-many-locals
+def function_import_from_etree(function_import_node, config: Config):
+    name = function_import_node.get('Name')
+    entity_set = function_import_node.get('EntitySet')
+    http_method = metadata_attribute_get(function_import_node, 'HttpMethod')
+
+    rt_type = function_import_node.get('ReturnType')
+    rt_info = None if rt_type is None else Types.parse_type_name(rt_type)
+    print(name, rt_type, rt_info)
+
+    parameters = dict()
+    for param in function_import_node.xpath('edm:Parameter', namespaces=config.namespaces):
+        param_name = param.get('Name')
+        param_type_info = Types.parse_type_name(param.get('Type'))
+        param_nullable = param.get('Nullable')
+        param_max_length = param.get('MaxLength')
+        param_precision = param.get('Precision')
+        param_scale = param.get('Scale')
+        param_mode = param.get('Mode')
+
+        parameters[param_name] = FunctionImportParameter(param_name, param_type_info, param_nullable,
+                                                         param_max_length, param_precision, param_scale, param_mode)
+
+    return FunctionImport(name, rt_info, entity_set, parameters, http_method)

pyodata/v2/model.py pyodata/model/elements.py

@@ -0,0 +1,280 @@
+# pylint: disable=missing-docstring
+
+import datetime
+import re
+
+from pyodata.exceptions import PyODataException, PyODataModelError
+
+
+class EdmStructTypeSerializer:
+    """Basic implementation of (de)serialization for Edm complex types
+
+       All properties existing in related Edm type are taken
+       into account, others are ignored
+
+       TODO: it can happen that inifinite recurision occurs for cases
+       when property types are referencich each other. We need some research
+       here to avoid such cases.
+    """
+
+    @staticmethod
+    def to_literal(edm_type, value):
+
+        # pylint: disable=no-self-use
+        if not edm_type:
+            raise PyODataException('Cannot encode value {} without complex type information'.format(value))
+
+        result = {}
+        for type_prop in edm_type.proprties():
+            if type_prop.name in value:
+                result[type_prop.name] = type_prop.typ.traits.to_literal(value[type_prop.name])
+
+        return result
+
+    @staticmethod
+    def from_json(edm_type, value):
+
+        # pylint: disable=no-self-use
+        if not edm_type:
+            raise PyODataException('Cannot decode value {} without complex type information'.format(value))
+
+        result = {}
+        for type_prop in edm_type.proprties():
+            if type_prop.name in value:
+                result[type_prop.name] = type_prop.typ.traits.from_json(value[type_prop.name])
+
+        return result
+
+    @staticmethod
+    def from_literal(edm_type, value):
+
+        # pylint: disable=no-self-use
+        if not edm_type:
+            raise PyODataException('Cannot decode value {} without complex type information'.format(value))
+
+        result = {}
+        for type_prop in edm_type.proprties():
+            if type_prop.name in value:
+                result[type_prop.name] = type_prop.typ.traits.from_literal(value[type_prop.name])
+
+        return result
+
+
+class TypTraits:
+    """Encapsulated differences between types"""
+
+    def __repr__(self):
+        return self.__class__.__name__
+
+    # pylint: disable=no-self-use
+    def to_literal(self, value):
+        return value
+
+    # pylint: disable=no-self-use
+    def from_json(self, value):
+        return value
+
+    def to_json(self, value):
+        return value
+
+    def from_literal(self, value):
+        return value
+
+
+class EdmPrefixedTypTraits(TypTraits):
+    """Is good for all types where values have form: prefix'value'"""
+
+    def __init__(self, prefix):
+        super(EdmPrefixedTypTraits, self).__init__()
+        self._prefix = prefix
+
+    def to_literal(self, value):
+        return '{}\'{}\''.format(self._prefix, value)
+
+    def from_literal(self, value):
+        matches = re.match("^{}'(.*)'$".format(self._prefix), value)
+        if not matches:
+            raise PyODataModelError(
+                "Malformed value {0} for primitive Edm type. Expected format is {1}'value'".format(value, self._prefix))
+        return matches.group(1)
+
+
+class EdmDateTimeTypTraits(EdmPrefixedTypTraits):
+    """Emd.DateTime traits
+
+       Represents date and time with values ranging from 12:00:00 midnight,
+       January 1, 1753 A.D. through 11:59:59 P.M, December 9999 A.D.
+
+       Literal form:
+       datetime'yyyy-mm-ddThh:mm[:ss[.fffffff]]'
+       NOTE: Spaces are not allowed between datetime and quoted portion.
+       datetime is case-insensitive
+
+       Example 1: datetime'2000-12-12T12:00'
+       JSON has following format: /Date(1516614510000)/
+       https://blogs.sap.com/2017/01/05/date-and-time-in-sap-gateway-foundation/
+    """
+
+    def __init__(self):
+        super(EdmDateTimeTypTraits, self).__init__('datetime')
+
+    def to_literal(self, value):
+        """Convert python datetime representation to literal format
+
+           None: this could be done also via formatting string:
+           value.strftime('%Y-%m-%dT%H:%M:%S.%f')
+        """
+
+        if not isinstance(value, datetime.datetime):
+            raise PyODataModelError(
+                'Cannot convert value of type {} to literal. Datetime format is required.'.format(type(value)))
+
+        return super(EdmDateTimeTypTraits, self).to_literal(value.replace(tzinfo=None).isoformat())
+
+    def to_json(self, value):
+        if isinstance(value, str):
+            return value
+
+        # Converts datetime into timestamp in milliseconds in UTC timezone as defined in ODATA specification
+        # https://www.odata.org/documentation/odata-version-2-0/json-format/
+        return f'/Date({int(value.replace(tzinfo=datetime.timezone.utc).timestamp()) * 1000})/'
+
+    def from_json(self, value):
+
+        if value is None:
+            return None
+
+        matches = re.match(r"^/Date\((.*)\)/$", value)
+        if not matches:
+            raise PyODataModelError(
+                "Malformed value {0} for primitive Edm type. Expected format is /Date(value)/".format(value))
+        value = matches.group(1)
+
+        try:
+            # https://stackoverflow.com/questions/36179914/timestamp-out-of-range-for-platform-localtime-gmtime-function
+            value = datetime.datetime(1970, 1, 1, tzinfo=datetime.timezone.utc) + datetime.timedelta(
+                milliseconds=int(value))
+        except ValueError:
+            raise PyODataModelError('Cannot decode datetime from value {}.'.format(value))
+
+        return value
+
+    def from_literal(self, value):
+
+        if value is None:
+            return None
+
+        value = super(EdmDateTimeTypTraits, self).from_literal(value)
+
+        try:
+            value = datetime.datetime.strptime(value, '%Y-%m-%dT%H:%M:%S.%f')
+        except ValueError:
+            try:
+                value = datetime.datetime.strptime(value, '%Y-%m-%dT%H:%M:%S')
+            except ValueError:
+                try:
+                    value = datetime.datetime.strptime(value, '%Y-%m-%dT%H:%M')
+                except ValueError:
+                    raise PyODataModelError('Cannot decode datetime from value {}.'.format(value))
+
+        return value
+
+
+class EdmStringTypTraits(TypTraits):
+    """Edm.String traits"""
+
+    # pylint: disable=no-self-use
+    def to_literal(self, value):
+        return '\'%s\'' % (value)
+
+    # pylint: disable=no-self-use
+    def from_json(self, value):
+        return value.strip('\'')
+
+    def from_literal(self, value):
+        return value.strip('\'')
+
+
+class EdmBooleanTypTraits(TypTraits):
+    """Edm.Boolean traits"""
+
+    # pylint: disable=no-self-use
+    def to_literal(self, value):
+        return 'true' if value else 'false'
+
+    # pylint: disable=no-self-use
+    def from_json(self, value):
+        return value
+
+    def from_literal(self, value):
+        return value == 'true'
+
+
+class EdmIntTypTraits(TypTraits):
+    """All Edm Integer traits"""
+
+    # pylint: disable=no-self-use
+    def to_literal(self, value):
+        return '%d' % (value)
+
+    # pylint: disable=no-self-use
+    def from_json(self, value):
+        return int(value)
+
+    def from_literal(self, value):
+        return int(value)
+
+
+class EdmLongIntTypTraits(TypTraits):
+    """All Edm Integer for big numbers traits"""
+
+    # pylint: disable=no-self-use
+    def to_literal(self, value):
+        return '%dL' % (value)
+
+    # pylint: disable=no-self-use
+    def from_json(self, value):
+        if value[-1] == 'L':
+            return int(value[:-1])
+
+        return int(value)
+
+    def from_literal(self, value):
+        return self.from_json(value)
+
+
+class EdmStructTypTraits(TypTraits):
+    """Edm structural types (EntityType, ComplexType) traits"""
+
+    def __init__(self, edm_type=None):
+        super(EdmStructTypTraits, self).__init__()
+        self._edm_type = edm_type
+
+    # pylint: disable=no-self-use
+    def to_literal(self, value):
+        return EdmStructTypeSerializer.to_literal(self._edm_type, value)
+
+    # pylint: disable=no-self-use
+    def from_json(self, value):
+        return EdmStructTypeSerializer.from_json(self._edm_type, value)
+
+    def from_literal(self, value):
+        return EdmStructTypeSerializer.from_json(self._edm_type, value)
+
+
+class EnumTypTrait(TypTraits):
+    def __init__(self, enum_type):
+        self._enum_type = enum_type
+
+    def to_literal(self, value):
+        return f'{value.parent.namespace}.{value}'
+
+    def from_json(self, value):
+        return getattr(self._enum_type, value)
+
+    def from_literal(self, value):
+        # remove namespaces
+        enum_value = value.split('.')[-1]
+        # remove enum type
+        name = enum_value.split("'")[1]
+        return getattr(self._enum_type, name)

pyodata/model/from_etree_callbacks.py

@@ -0,0 +1,48 @@
+"""
+    This module servers as repository of different kind of errors which can be encounter during parsing and
+    policies which defines how the parser should response to given error.
+"""
+
+import logging
+from abc import ABC, abstractmethod
+from enum import Enum, auto
+
+
+class ParserError(Enum):
+    """ Represents all the different errors the parser is able to deal with."""
+    PROPERTY = auto()
+    ANNOTATION = auto()
+    ASSOCIATION = auto()
+
+    ENUM_TYPE = auto()
+    ENTITY_TYPE = auto()
+    COMPLEX_TYPE = auto()
+
+
+class ErrorPolicy(ABC):
+    """ All policies has to inhere this class"""
+    @abstractmethod
+    def resolve(self, ekseption):
+        """ This method is invoked when an error arise."""
+
+
+class PolicyFatal(ErrorPolicy):
+    """ Encounter error should result in parser failing. """
+    def resolve(self, ekseption):
+        raise ekseption
+
+
+class PolicyWarning(ErrorPolicy):
+    """ Encounter error is logged, but parser continues as nothing has happened """
+    def __init__(self):
+        logging.basicConfig(format='%(levelname)s: %(message)s')
+        self._logger = logging.getLogger()
+
+    def resolve(self, ekseption):
+        self._logger.warning('[%s] %s', ekseption.__class__.__name__, str(ekseption))
+
+
+class PolicyIgnore(ErrorPolicy):
+    """ Encounter error is ignored and parser continues as nothing has happened """
+    def resolve(self, ekseption):
+        pass

pyodata/model/type_traits.py

@@ -0,0 +1,296 @@
+""" This module represents implementation of ODATA V2 """
+
+import itertools
+import logging
+from typing import List
+
+from pyodata.policies import ParserError
+from pyodata.config import ODATAVersion, Config
+from pyodata.exceptions import PyODataParserError, PyODataModelError
+
+from pyodata.model.elements import StructTypeProperty, StructType, NavigationTypeProperty, ComplexType, EntityType, \
+    EnumType, EntitySet, EndRole, ReferentialConstraint, Association, AssociationSetEndRole, AssociationSet, \
+    ExternalAnnotation, Annotation, ValueHelper, ValueHelperParameter, FunctionImport, Schema, NullType, Typ, \
+    NullAssociation
+
+from pyodata.model.from_etree_callbacks import struct_type_property_from_etree, struct_type_from_etree, \
+    navigation_type_property_from_etree, complex_type_from_etree, entity_type_from_etree, enum_type_from_etree, \
+    entity_set_from_etree, end_role_from_etree, referential_constraint_from_etree, association_from_etree, \
+    association_set_end_role_from_etree, association_set_from_etree, external_annotation_from_etree, \
+    annotation_from_etree, value_helper_from_etree, value_helper_parameter_from_etree, function_import_from_etree
+
+
+def modlog():
+    """ Logging function for debugging."""
+    return logging.getLogger("v2")
+
+
+class ODataV2(ODATAVersion):
+    """ Definition of OData V2 """
+
+    @staticmethod
+    def from_etree_callbacks():
+        return {
+            StructTypeProperty: struct_type_property_from_etree,
+            StructType: struct_type_from_etree,
+            NavigationTypeProperty: navigation_type_property_from_etree,
+            ComplexType: complex_type_from_etree,
+            EntityType: entity_type_from_etree,
+            EnumType: enum_type_from_etree,
+            EntitySet: entity_set_from_etree,
+            EndRole: end_role_from_etree,
+            ReferentialConstraint: referential_constraint_from_etree,
+            Association: association_from_etree,
+            AssociationSetEndRole: association_set_end_role_from_etree,
+            AssociationSet: association_set_from_etree,
+            ExternalAnnotation: external_annotation_from_etree,
+            Annotation: annotation_from_etree,
+            ValueHelper: value_helper_from_etree,
+            ValueHelperParameter: value_helper_parameter_from_etree,
+            FunctionImport: function_import_from_etree,
+            Schema: ODataV2.schema_from_etree
+        }
+
+    @staticmethod
+    def supported_primitive_types() -> List[str]:
+        return [
+            'Null',
+            'Edm.Binary',
+            'Edm.Boolean',
+            'Edm.Byte',
+            'Edm.DateTime',
+            'Edm.Decimal',
+            'Edm.Double',
+            'Edm.Single',
+            'Edm.Guid',
+            'Edm.Int16',
+            'Edm.Int32',
+            'Edm.Int64',
+            'Edm.SByte',
+            'Edm.String',
+            'Edm.Time',
+            'Edm.DateTimeOffset',
+        ]
+
+    # pylint: disable=too-many-locals,too-many-branches,too-many-statements, protected-access,missing-docstring
+    @staticmethod
+    def schema_from_etree(schema_nodes, config: Config):
+        schema = Schema(config)
+
+        # Parse Schema nodes by parts to get over the problem of not-yet known
+        # entity types referenced by entity sets, function imports and
+        # annotations.
+
+        # First, process EnumType, EntityType and ComplexType nodes. They have almost no dependencies on other elements.
+        for schema_node in schema_nodes:
+            namespace = schema_node.get('Namespace')
+            decl = Schema.Declaration(namespace)
+            schema._decls[namespace] = decl
+
+            for enum_type in schema_node.xpath('edm:EnumType', namespaces=config.namespaces):
+                try:
+                    etype = EnumType.from_etree(enum_type, config, 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)
+
+            for complex_type in schema_node.xpath('edm:ComplexType', namespaces=config.namespaces):
+                try:
+                    ctype = ComplexType.from_etree(complex_type, config)
+                except (KeyError, AttributeError) as ex:
+                    config.err_policy(ParserError.COMPLEX_TYPE).resolve(ex)
+                    ctype = NullType(complex_type.get('Name'))
+
+                decl.add_complex_type(ctype)
+
+            for entity_type in schema_node.xpath('edm:EntityType', namespaces=config.namespaces):
+                try:
+                    etype = EntityType.from_etree(entity_type, config)
+                except (KeyError, AttributeError) as ex:
+                    config.err_policy(ParserError.ENTITY_TYPE).resolve(ex)
+                    etype = NullType(entity_type.get('Name'))
+
+                decl.add_entity_type(etype)
+
+        # resolve types of properties
+        for stype in itertools.chain(schema.entity_types, schema.complex_types):
+            if isinstance(stype, NullType):
+                continue
+
+            if stype.kind == Typ.Kinds.Complex:
+                # skip collections (no need to assign any types since type of collection
+                # items is resolved separately
+                if stype.is_collection:
+                    continue
+
+                for prop in stype.proprties():
+                    try:
+                        prop.typ = schema.get_type(prop.type_info)
+                    except PyODataModelError as ex:
+                        config.err_policy(ParserError.PROPERTY).resolve(ex)
+                        prop.typ = NullType(prop.type_info.name)
+
+        # pylint: disable=too-many-nested-blocks
+        # Then, process Associations nodes because they refer EntityTypes and
+        # they are referenced by AssociationSets.
+        for schema_node in schema_nodes:
+            namespace = schema_node.get('Namespace')
+            decl = schema._decls[namespace]
+
+            for association in schema_node.xpath('edm:Association', namespaces=config.namespaces):
+                assoc = Association.from_etree(association, config)
+                try:
+                    for end_role in assoc.end_roles:
+                        try:
+                            # search and assign entity type (it must exist)
+                            if end_role.entity_type_info.namespace is None:
+                                end_role.entity_type_info.namespace = namespace
+
+                            etype = schema.entity_type(end_role.entity_type_info.name,
+                                                       end_role.entity_type_info.namespace)
+
+                            end_role.entity_type = etype
+                        except KeyError:
+                            raise PyODataModelError(
+                                f'EntityType {end_role.entity_type_info.name} does not exist in Schema '
+                                f'Namespace {end_role.entity_type_info.namespace}')
+
+                    if assoc.referential_constraint is not None:
+                        role_names = [end_role.role for end_role in assoc.end_roles]
+                        principal_role = assoc.referential_constraint.principal
+
+                        # Check if the role was defined in the current association
+                        if principal_role.name not in role_names:
+                            raise RuntimeError(
+                                'Role {} was not defined in association {}'.format(principal_role.name, assoc.name))
+
+                        # Check if principal role properties exist
+                        role_name = principal_role.name
+                        entity_type_name = assoc.end_by_role(role_name).entity_type_name
+                        schema.check_role_property_names(principal_role, entity_type_name, namespace)
+
+                        dependent_role = assoc.referential_constraint.dependent
+
+                        # Check if the role was defined in the current association
+                        if dependent_role.name not in role_names:
+                            raise RuntimeError(
+                                'Role {} was not defined in association {}'.format(dependent_role.name, assoc.name))
+
+                        # Check if dependent role properties exist
+                        role_name = dependent_role.name
+                        entity_type_name = assoc.end_by_role(role_name).entity_type_name
+                        schema.check_role_property_names(dependent_role, entity_type_name, namespace)
+                except (PyODataModelError, RuntimeError) as ex:
+                    config.err_policy(ParserError.ASSOCIATION).resolve(ex)
+                    decl.associations[assoc.name] = NullAssociation(assoc.name)
+                else:
+                    decl.associations[assoc.name] = assoc
+
+        # resolve navigation properties
+        for stype in schema.entity_types:
+            # skip null type
+            if isinstance(stype, NullType):
+                continue
+
+            # skip collections
+            if stype.is_collection:
+                continue
+
+            for nav_prop in stype.nav_proprties:
+                try:
+                    assoc = schema.association(nav_prop.association_info.name, nav_prop.association_info.namespace)
+                    nav_prop.association = assoc
+                except KeyError as ex:
+                    config.err_policy(ParserError.ASSOCIATION).resolve(ex)
+                    nav_prop.association = NullAssociation(nav_prop.association_info.name)
+
+        # Then, process EntitySet, FunctionImport and AssociationSet nodes.
+        for schema_node in schema_nodes:
+            namespace = schema_node.get('Namespace')
+            decl = schema._decls[namespace]
+
+            for entity_set in schema_node.xpath('edm:EntityContainer/edm:EntitySet', namespaces=config.namespaces):
+                eset = EntitySet.from_etree(entity_set, config)
+                eset.entity_type = schema.entity_type(eset.entity_type_info[1], namespace=eset.entity_type_info[0])
+                decl.entity_sets[eset.name] = eset
+
+            for function_import in schema_node.xpath('edm:EntityContainer/edm:FunctionImport',
+                                                     namespaces=config.namespaces):
+                efn = FunctionImport.from_etree(function_import, config)
+
+                # complete type information for return type and parameters
+                if efn.return_type_info is not None:
+                    efn.return_type = schema.get_type(efn.return_type_info)
+                for param in efn.parameters:
+                    param.typ = schema.get_type(param.type_info)
+                decl.function_imports[efn.name] = efn
+
+            for association_set in schema_node.xpath('edm:EntityContainer/edm:AssociationSet',
+                                                     namespaces=config.namespaces):
+                assoc_set = AssociationSet.from_etree(association_set, config)
+                try:
+                    try:
+                        assoc_set.association_type = schema.association(assoc_set.association_type_name,
+                                                                        assoc_set.association_type_namespace)
+                    except KeyError:
+                        raise PyODataModelError(
+                            'Association {} does not exist in namespace {}'
+                            .format(assoc_set.association_type_name, assoc_set.association_type_namespace))
+
+                    for end in assoc_set.end_roles:
+                        # Check if an entity set exists in the current scheme
+                        # and add a reference to the corresponding entity set
+                        try:
+                            entity_set = schema.entity_set(end.entity_set_name, namespace)
+                            end.entity_set = entity_set
+                        except KeyError:
+                            raise PyODataModelError('EntitySet {} does not exist in Schema Namespace {}'
+                                                    .format(end.entity_set_name, namespace))
+                        # Check if role is defined in Association
+                        if assoc_set.association_type.end_by_role(end.role) is None:
+                            raise PyODataModelError('Role {} is not defined in association {}'
+                                                    .format(end.role, assoc_set.association_type_name))
+                except (PyODataModelError, KeyError) as ex:
+                    config.err_policy(ParserError.ASSOCIATION).resolve(ex)
+                    decl.association_sets[assoc_set.name] = NullAssociation(assoc_set.name)
+                else:
+                    decl.association_sets[assoc_set.name] = assoc_set
+
+        # pylint: disable=too-many-nested-blocks
+        # Finally, process Annotation nodes when all Scheme nodes are completely processed.
+        for schema_node in schema_nodes:
+            for annotation_group in schema_node.xpath('edm:Annotations', namespaces=config.annotation_namespace):
+                etree = ExternalAnnotation.from_etree(annotation_group, config)
+                for annotation in etree:
+                    if not annotation.element_namespace != schema.namespaces:
+                        modlog().warning('%s not in the namespaces %s', annotation, ','.join(schema.namespaces))
+                        continue
+
+                    try:
+                        if annotation.kind == Annotation.Kinds.ValueHelper:
+                            try:
+                                annotation.entity_set = schema.entity_set(
+                                    annotation.collection_path, namespace=annotation.element_namespace)
+                            except KeyError:
+                                raise RuntimeError(f'Entity Set {annotation.collection_path} '
+                                                   f'for {annotation} does not exist')
+
+                            try:
+                                vh_type = schema.typ(annotation.proprty_entity_type_name,
+                                                     namespace=annotation.element_namespace)
+                            except KeyError:
+                                raise RuntimeError(f'Target Type {annotation.proprty_entity_type_name} '
+                                                   f'of {annotation} does not exist')
+
+                            try:
+                                target_proprty = vh_type.proprty(annotation.proprty_name)
+                            except KeyError:
+                                raise RuntimeError(f'Target Property {annotation.proprty_name} '
+                                                   f'of {vh_type} as defined in {annotation} does not exist')
+                        annotation.proprty = target_proprty
+                        target_proprty.value_helper = annotation
+                    except (RuntimeError, PyODataModelError) as ex:
+                        config.err_policy(ParserError.ANNOTATION).resolve(ex)
+        return schema

pyodata/policies.py

@@ -16,8 +16,8 @@
 
 import requests
 
+from pyodata.model import elements
 from pyodata.exceptions import HttpError, PyODataException, ExpressionError
-from . import model
 
 LOGGER_NAME = 'pyodata.service'
 
@@ -736,16 +736,16 @@ def __init__(self, service, entity_set, entity_type, proprties=None, entity_key=
 
                     # cache value according to multiplicity
                     if prop.to_role.multiplicity in \
-                            [model.EndRole.MULTIPLICITY_ONE,
-                             model.EndRole.MULTIPLICITY_ZERO_OR_ONE]:
+                            [elements.EndRole.MULTIPLICITY_ONE,
+                             elements.EndRole.MULTIPLICITY_ZERO_OR_ONE]:
 
                         # cache None in case we receive nothing (null) instead of entity data
                         if proprties[prop.name] is None:
                             self._cache[prop.name] = None
                         else:
                             self._cache[prop.name] = EntityProxy(service, None, prop_etype, proprties[prop.name])
 
-                    elif prop.to_role.multiplicity == model.EndRole.MULTIPLICITY_ZERO_OR_MORE:
+                    elif prop.to_role.multiplicity == elements.EndRole.MULTIPLICITY_ZERO_OR_MORE:
                         # default value is empty array
                         self._cache[prop.name] = []
 
@@ -815,7 +815,7 @@ def nav(self, nav_property):
             raise PyODataException('No association set for role {}'.format(navigation_property.to_role))
 
         roles = navigation_property.association.end_roles
-        if all((role.multiplicity != model.EndRole.MULTIPLICITY_ZERO_OR_MORE for role in roles)):
+        if all((role.multiplicity != elements.EndRole.MULTIPLICITY_ZERO_OR_MORE for role in roles)):
             return NavEntityProxy(self, nav_property, navigation_entity_set.entity_type, {})
 
         return EntitySetProxy(
@@ -1024,7 +1024,7 @@ def nav(self, nav_property, key):
                 'No association set for role {} {}'.format(navigation_property.to_role, association_set.end_roles))
 
         roles = navigation_property.association.end_roles
-        if all((role.multiplicity != model.EndRole.MULTIPLICITY_ZERO_OR_MORE for role in roles)):
+        if all((role.multiplicity != elements.EndRole.MULTIPLICITY_ZERO_OR_MORE for role in roles)):
             return self._get_nav_entity(key, nav_property, navigation_entity_set)
 
         return EntitySetProxy(
@@ -1260,7 +1260,7 @@ def function_import_handler(fimport, response):
             response_data = response.json()['d']
 
             # 1. if return types is "entity type", return instance of appropriate entity proxy
-            if isinstance(fimport.return_type, model.EntityType):
+            if isinstance(fimport.return_type, elements.EntityType):
                 entity_set = self._service.schema.entity_set(fimport.entity_set_name)
                 return EntityProxy(self._service, entity_set, fimport.return_type, response_data)
 

pyodata/v2/__init__.py

@@ -2,7 +2,7 @@
 import logging
 import os
 import pytest
-from pyodata.v2.model import schema_from_xml
+from pyodata.model.builder import schema_from_xml
 
 
 @pytest.fixture

pyodata/v2/service.py

@@ -1,25 +1,20 @@
 """PyOData Client tests"""
 
+from unittest.mock import patch
 import responses
 import requests
 import pytest
-import pyodata
-import pyodata.v2.service
-from unittest.mock import patch
-from pyodata.exceptions import PyODataException, HttpError
-from pyodata.v2.model import ParserError, PolicyWarning, PolicyFatal, PolicyIgnore, Config
 
-SERVICE_URL = 'http://example.com'
+import pyodata
 
+from pyodata.exceptions import PyODataException, HttpError
+from pyodata.policies import ParserError, PolicyWarning, PolicyFatal, PolicyIgnore
+from pyodata.config import Config
 
-@responses.activate
-def test_invalid_odata_version():
-    """Check handling of request for invalid OData version implementation"""
+from pyodata.v2.service import Service
+from pyodata.v2 import ODataV2
 
-    with pytest.raises(PyODataException) as e_info:
-        pyodata.Client(SERVICE_URL, requests, 'INVALID VERSION')
-
-    assert str(e_info.value).startswith('No implementation for selected odata version')
+SERVICE_URL = 'http://example.com'
 
 
 @responses.activate
@@ -46,13 +41,13 @@ def test_create_service_application_xml(metadata):
 
     client = pyodata.Client(SERVICE_URL, requests)
 
-    assert isinstance(client, pyodata.v2.service.Service)
+    assert isinstance(client, Service)
 
     # onw more test for '/' terminated url
 
     client = pyodata.Client(SERVICE_URL + '/', requests)
 
-    assert isinstance(client, pyodata.v2.service.Service)
+    assert isinstance(client, Service)
 
 
 @responses.activate
@@ -68,13 +63,13 @@ def test_create_service_text_xml(metadata):
 
     client = pyodata.Client(SERVICE_URL, requests)
 
-    assert isinstance(client, pyodata.v2.service.Service)
+    assert isinstance(client, Service)
 
     # onw more test for '/' terminated url
 
     client = pyodata.Client(SERVICE_URL + '/', requests)
 
-    assert isinstance(client, pyodata.v2.service.Service)
+    assert isinstance(client, Service)
 
 
 @responses.activate
@@ -127,6 +122,7 @@ def test_client_custom_configuration(mock_warning, metadata):
     }
 
     custom_config = Config(
+        ODataV2,
         xml_namespaces=namespaces,
         default_error_policy=PolicyFatal(),
         custom_error_policies={
@@ -145,10 +141,10 @@ def test_client_custom_configuration(mock_warning, metadata):
         'Passing namespaces directly is deprecated. Use class Config instead',
         DeprecationWarning
     )
-    assert isinstance(client, pyodata.v2.service.Service)
+    assert isinstance(client, Service)
     assert client.schema.config.namespaces == namespaces
 
     client = pyodata.Client(SERVICE_URL, requests, config=custom_config)
 
-    assert isinstance(client, pyodata.v2.service.Service)
+    assert isinstance(client, Service)
     assert client.schema.config == custom_config

tests/conftest.py

@@ -0,0 +1,61 @@
+from typing import List
+import pytest
+
+from pyodata.config import Config, ODATAVersion
+from pyodata.exceptions import PyODataParserError
+from pyodata.model.builder import MetadataBuilder
+from pyodata.model.elements import Schema, Types
+
+
+def test_from_etree_mixin(metadata):
+    """Test FromEtreeMixin class"""
+
+    class EmptyODATA(ODATAVersion):
+        @staticmethod
+        def from_etree_callbacks():
+            return {}
+
+    config = Config(EmptyODATA)
+    builder = MetadataBuilder(metadata, config=config)
+
+    with pytest.raises(PyODataParserError) as typ_ex_info:
+        builder.build()
+
+    assert typ_ex_info.value.args[0] == f'{Schema.__name__} is unsupported in {config.odata_version.__name__}'
+
+
+def test_supported_primitive_types():
+    """Test handling of unsupported primitive types class"""
+
+    class EmptyODATA(ODATAVersion):
+        @staticmethod
+        def supported_primitive_types() -> List[str]:
+            return [
+                'Edm.Binary'
+            ]
+
+    config = Config(EmptyODATA)
+    with pytest.raises(KeyError) as typ_ex_info:
+        Types.from_name('UnsupportedType', config)
+
+    assert typ_ex_info.value.args[0] == f'Requested primitive type is not supported in this version of ODATA'
+
+    assert Types.from_name('Edm.Binary', config).name == 'Edm.Binary'
+
+
+def test_odata_version_statelessness():
+
+    class EmptyODATA(ODATAVersion):
+        @staticmethod
+        def from_etree_callbacks():
+            return {}
+
+        @staticmethod
+        def supported_primitive_types() -> List[str]:
+            return []
+
+    with pytest.raises(RuntimeError) as typ_ex_info:
+        EmptyODATA()
+
+    assert typ_ex_info.value.args[0] == 'ODATAVersion and its children are intentionally stateless, ' \
+                                        'therefore you can not create instance of them'

tests/test_client.py

@@ -4,11 +4,17 @@
 from datetime import datetime, timezone
 from unittest.mock import patch
 import pytest
-from pyodata.v2.model import Schema, Typ, StructTypeProperty, Types, EntityType, EdmStructTypeSerializer, \
-    Association, AssociationSet, EndRole, AssociationSetEndRole, TypeInfo, MetadataBuilder, ParserError, PolicyWarning, \
-    PolicyIgnore, Config, PolicyFatal, NullType, NullAssociation
-from pyodata.exceptions import PyODataException, PyODataModelError, PyODataParserError
+
 from tests.conftest import assert_logging_policy
+from pyodata.config import Config
+from pyodata.model.builder import MetadataBuilder
+from pyodata.model.elements import Typ, Types, EntityType, TypeInfo, NullType, NullAssociation, EndRole, \
+    AssociationSetEndRole, Schema, StructTypeProperty, AssociationSet, Association
+from pyodata.model.type_traits import EdmStructTypeSerializer
+from pyodata.policies import ParserError, PolicyWarning, PolicyIgnore, PolicyFatal
+from pyodata.exceptions import PyODataException, PyODataModelError, PyODataParserError
+from pyodata.v2 import ODataV2
+
 
 
 def test_edmx(schema):
@@ -350,20 +356,22 @@ def test_edmx_complex_type_prop_vh(schema):
 def test_traits():
     """Test individual traits"""
 
+    config = Config(ODataV2)
+
     # generic
-    typ = Types.from_name('Edm.Binary')
+    typ = Types.from_name('Edm.Binary', config)
     assert repr(typ.traits) == 'TypTraits'
     assert typ.traits.to_literal('bincontent') == 'bincontent'
     assert typ.traits.from_literal('some bin content') == 'some bin content'
 
     # string
-    typ = Types.from_name('Edm.String')
+    typ = Types.from_name('Edm.String', config)
     assert repr(typ.traits) == 'EdmStringTypTraits'
     assert typ.traits.to_literal('Foo Foo') == "'Foo Foo'"
     assert typ.traits.from_literal("'Alice Bob'") == 'Alice Bob'
 
     # bool
-    typ = Types.from_name('Edm.Boolean')
+    typ = Types.from_name('Edm.Boolean', config)
     assert repr(typ.traits) == 'EdmBooleanTypTraits'
     assert typ.traits.to_literal(True) == 'true'
     assert typ.traits.from_literal('true') is True
@@ -376,17 +384,17 @@ def test_traits():
     assert typ.traits.from_json(False) is False
 
     # integers
-    typ = Types.from_name('Edm.Int16')
+    typ = Types.from_name('Edm.Int16', config)
     assert repr(typ.traits) == 'EdmIntTypTraits'
     assert typ.traits.to_literal(23) == '23'
     assert typ.traits.from_literal('345') == 345
 
-    typ = Types.from_name('Edm.Int32')
+    typ = Types.from_name('Edm.Int32', config)
     assert repr(typ.traits) == 'EdmIntTypTraits'
     assert typ.traits.to_literal(23) == '23'
     assert typ.traits.from_literal('345') == 345
 
-    typ = Types.from_name('Edm.Int64')
+    typ = Types.from_name('Edm.Int64', config)
     assert repr(typ.traits) == 'EdmLongIntTypTraits'
     assert typ.traits.to_literal(23) == '23L'
     assert typ.traits.from_literal('345L') == 345
@@ -399,7 +407,7 @@ def test_traits():
     assert typ.traits.from_json('0L') == 0
 
     # GUIDs
-    typ = Types.from_name('Edm.Guid')
+    typ = Types.from_name('Edm.Guid', config)
     assert repr(typ.traits) == 'EdmPrefixedTypTraits'
     assert typ.traits.to_literal('000-0000') == "guid'000-0000'"
     assert typ.traits.from_literal("guid'1234-56'") == '1234-56'
@@ -411,7 +419,9 @@ def test_traits():
 def test_traits_datetime():
     """Test Edm.DateTime traits"""
 
-    typ = Types.from_name('Edm.DateTime')
+    config = Config(ODataV2)
+
+    typ = Types.from_name('Edm.DateTime', config)
     assert repr(typ.traits) == 'EdmDateTimeTypTraits'
 
     # 1. direction Python -> OData
@@ -500,10 +510,12 @@ def test_traits_datetime():
 def test_traits_collections():
     """Test collection traits"""
 
-    typ = Types.from_name('Collection(Edm.Int32)')
+    config = Config(ODataV2)
+
+    typ = Types.from_name('Collection(Edm.Int32)', config)
     assert typ.traits.from_json(['23', '34']) == [23, 34]
 
-    typ = Types.from_name('Collection(Edm.String)')
+    typ = Types.from_name('Collection(Edm.String)', config)
     assert typ.traits.from_json(['Bob', 'Alice']) == ['Bob', 'Alice']
 
 
@@ -545,14 +557,16 @@ def test_type_parsing():
 def test_types():
     """Test Types repository"""
 
+    config = Config(ODataV2)
+
     # generic
     for type_name in ['Edm.Binary', 'Edm.String', 'Edm.Int16', 'Edm.Guid']:
-        typ = Types.from_name(type_name)
+        typ = Types.from_name(type_name, config)
         assert typ.kind == Typ.Kinds.Primitive
         assert not typ.is_collection
 
     # Collection of primitive types
-    typ = Types.from_name('Collection(Edm.String)')
+    typ = Types.from_name('Collection(Edm.String)', config)
     assert repr(typ) == 'Collection(Typ(Edm.String))'
     assert typ.kind is Typ.Kinds.Primitive
     assert typ.is_collection
@@ -690,7 +704,7 @@ def test_annot_v_l_missing_e_t(mock_warning, xml_builder_factory):
                           )
 
 
-@patch('pyodata.v2.model.PolicyIgnore.resolve')
+@patch.object(PolicyIgnore, 'resolve')
 @patch('logging.Logger.warning')
 def test_annot_v_l_trgt_inv_prop(mock_warning, mock_resolve, xml_builder_factory):
     """Test correct handling of annotations whose target property does not exist"""
@@ -843,6 +857,7 @@ def test_edmx_entity_sets(schema):
 def test_config_set_default_error_policy():
     """ Test configurability of policies """
     config = Config(
+        ODataV2,
         custom_error_policies={
             ParserError.ANNOTATION: PolicyWarning()
         }
@@ -880,6 +895,7 @@ def test_null_type(xml_builder_factory):
     metadata = MetadataBuilder(
         xml_builder.serialize(),
         config=Config(
+            ODataV2,
             default_error_policy=PolicyIgnore()
         ))
 
@@ -927,6 +943,7 @@ def test_faulty_association(xml_builder_factory):
     metadata = MetadataBuilder(
         xml_builder.serialize(),
         config=Config(
+            ODataV2,
             default_error_policy=PolicyIgnore()
         ))
 
@@ -953,6 +970,7 @@ def test_faulty_association_set(xml_builder_factory):
     metadata = MetadataBuilder(
         xml_builder.serialize(),
         config=Config(
+            ODataV2,
             default_error_policy=PolicyWarning()
         ))
 
@@ -1079,6 +1097,7 @@ def test_unsupported_edmx_n(mock_from_etree, xml_builder_factory):
     MetadataBuilder(
         xml,
         config=Config(
+            ODataV2,
             xml_namespaces={'edmx': edmx}
         )
     ).build()
@@ -1107,6 +1126,7 @@ def test_unsupported_schema_n(mock_from_etree, xml_builder_factory):
     MetadataBuilder(
         xml,
         config=Config(
+            ODataV2,
             xml_namespaces={'edm': edm}
         )
     ).build()
@@ -1232,7 +1252,7 @@ def test_enum_value_out_of_range(xml_builder_factory):
 
     try:
         MetadataBuilder(xml).build()
-    except PyODataParserError as ex:
+    except BaseException as ex:
         assert str(ex) == f'Value -130 is out of range for type Edm.Byte'
 
 
@@ -1286,6 +1306,7 @@ def test_missing_property_referenced_in_annotation(mock_warning, xml_builder_fac
                                         'an non existing LocalDataProperty --- of EntityType(MasterEntity)'
 
     MetadataBuilder(xml, Config(
+        ODataV2,
         default_error_policy=PolicyWarning()
     )).build()
 
@@ -1307,6 +1328,7 @@ def test_missing_property_referenced_in_annotation(mock_warning, xml_builder_fac
                                         'existing ValueListProperty --- of EntityType(DataEntity)'
 
     MetadataBuilder(xml, Config(
+        ODataV2,
         default_error_policy=PolicyWarning()
     )).build()
 
@@ -1324,6 +1346,7 @@ def test_missing_property_referenced_in_annotation(mock_warning, xml_builder_fac
     mock_warning.reset_mock()
 
     MetadataBuilder(xml, Config(
+        ODataV2,
         default_error_policy=PolicyWarning()
     )).build()
 

tests/test_model.py

@@ -6,7 +6,6 @@
 import pytest
 from unittest.mock import patch
 
-import pyodata.v2.model
 import pyodata.v2.service
 from pyodata.exceptions import PyODataException, HttpError, ExpressionError
 from pyodata.v2.service import EntityKey, EntityProxy, GetEntitySetFilter