wip - imports? another try

I wish for python 4 with better way of handling imports. :(

Author: mamiksik

pyodata/model/build_functions.py

@@ -3,9 +3,9 @@
 import io
 from lxml import etree
 
-from pyodata.config import Config
-from pyodata.exceptions import PyODataParserError
-from pyodata.model.elements import ValueHelperParameter, Schema, build_element
+import pyodata.config as pyodata
+import pyodata.exceptions as exceptions
+import pyodata.model.elements as elements
 import pyodata.v2 as v2
 
 
@@ -15,11 +15,11 @@
 }
 
 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
+    'com.sap.vocabularies.Common.v1.ValueListParameterIn': elements.ValueHelperParameter.Direction.In,
+    'com.sap.vocabularies.Common.v1.ValueListParameterInOut': elements.ValueHelperParameter.Direction.InOut,
+    'com.sap.vocabularies.Common.v1.ValueListParameterOut': elements.ValueHelperParameter.Direction.Out,
+    'com.sap.vocabularies.Common.v1.ValueListParameterDisplayOnly': elements.ValueHelperParameter.Direction.DisplayOnly,
+    'com.sap.vocabularies.Common.v1.ValueListParameterFilterOnly': elements.ValueHelperParameter.Direction.FilterOnly
 }
 
 
@@ -44,12 +44,12 @@ def __init__(self, xml, config=None):
         self._xml = xml
 
         if config is None:
-            config = Config(v2.ODataV2)
+            config = pyodata.Config(v2.ODataV2)
         self._config = config
 
     # pylint: disable=missing-docstring
     @property
-    def config(self) -> Config:
+    def config(self) -> pyodata.Config:
         return self._config
 
     def build(self):
@@ -69,26 +69,26 @@ def build(self):
         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')
+            raise exceptions.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')
+            raise exceptions.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}')
+                raise exceptions.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}')
+                raise exceptions.PyODataParserError(f'Unsupported Schema namespace - {namespace}')
 
             namespaces['edm'] = namespace
 
@@ -100,10 +100,10 @@ def build(self):
         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 build_element(Schema, self._config, schema_nodes=edm_schemas)
+        return elements.build_element(elements.Schema, self._config, schema_nodes=edm_schemas)
 
     @staticmethod
-    def get_aliases(edmx, config: Config):
+    def get_aliases(edmx, config: pyodata.Config):
         """Get all aliases"""
 
         # aliases = collections.defaultdict(set)
@@ -121,7 +121,7 @@ def get_aliases(edmx, config: Config):
         return aliases
 
     @staticmethod
-    def update_alias(aliases, config: Config):
+    def update_alias(aliases, config: pyodata.Config):
         """Update config with aliases"""
         config.aliases = aliases
         helper_direction_keys = list(config.sap_value_helper_directions.keys())
@@ -139,7 +139,7 @@ def schema_from_xml(metadata_xml, namespaces=None):
 
     meta = MetadataBuilder(
         metadata_xml,
-        config=Config(
+        config=pyodata.Config(
             v2.ODataV2,
             xml_namespaces=namespaces,
         ))

pyodata/model/builder.py

@@ -3,15 +3,16 @@
 import collections
 import itertools
 import logging
+
 from abc import abstractmethod
 from enum import Enum
 from typing import Union
 
-from pyodata.policies import ParserError
-from pyodata.config import Config
-from pyodata.exceptions import PyODataModelError, PyODataException, PyODataParserError
 
-from pyodata.model.type_traits import TypTraits, EdmStructTypTraits, EnumTypTrait
+import pyodata.config as pyodata
+import pyodata.policies as policies
+import pyodata.exceptions as exceptions
+import pyodata.model.type_traits as base_traits
 
 
 IdentifierInfo = collections.namedtuple('IdentifierInfo', 'namespace name')
@@ -22,7 +23,7 @@ def modlog():
     return logging.getLogger("Elements")
 
 
-def build_element(element_name: Union[str, type], config: Config, **kwargs):
+def build_element(element_name: Union[str, type], config: pyodata.Config, **kwargs):
     """
     This function is responsible for resolving which implementation is to be called for parsing EDM element. It's a
     primitive implementation of dynamic dispatch, thus there exist table where all supported elements are assigned
@@ -48,10 +49,10 @@ def build_element(element_name: Union[str, type], config: Config, **kwargs):
         if element_name == clb.__name__:
             return callbacks[clb](config, **kwargs)
 
-    raise PyODataParserError(f'{element_name} is unsupported in {config.odata_version.__name__}')
+    raise exceptions.PyODataParserError(f'{element_name} is unsupported in {config.odata_version.__name__}')
 
 
-def build_annotation(term: str, config: Config, **kwargs):
+def build_annotation(term: str, config: pyodata.Config, **kwargs):
     """
     Similarly to build_element this function purpoas is to resolve build function for annotations. There are two
     main differences:
@@ -80,27 +81,30 @@ def build_annotation(term: str, config: Config, **kwargs):
                 annotations[annotation](config, **kwargs)
                 return
 
-        raise PyODataParserError(f'Annotation with term {term} is unsupported in {config.odata_version.__name__}')
-    except PyODataException as ex:
-        config.err_policy(ParserError.ANNOTATION).resolve(ex)
+        raise exceptions.PyODataParserError(
+            f'Annotation with term {term} is unsupported in {config.odata_version.__name__}')
+    except exceptions.PyODataException as ex:
+        config.err_policy(policies.ParserError.ANNOTATION).resolve(ex)
 
 
 class NullType:
     def __init__(self, name):
         self.name = name
 
     def __getattr__(self, item):
-        raise PyODataModelError(f'Cannot access this type. An error occurred during parsing type stated in '
-                                f'xml({self.name}) was not found, therefore it has been replaced with NullType.')
+        raise exceptions.PyODataModelError(
+            f'Cannot access this type. An error occurred during parsing type stated in xml({self.name}) was not found, '
+            f'therefore it has been replaced with NullType.')
 
 
 class NullAnnotation:
     def __init__(self, term):
         self.term = term
 
     def __getattr__(self, item):
-        raise PyODataModelError(f'Cannot access this annotation. An error occurred during parsing '
-                                f'annotation(term = {self.term}), therefore it has been replaced with NullAnnotation.')
+        raise exceptions.PyODataModelError(
+            f'Cannot access this annotation. An error occurred during parsing annotation(term = {self.term}), '
+            f'therefore it has been replaced with NullAnnotation.')
 
 
 class Identifier:
@@ -139,7 +143,7 @@ class Types:
     """
 
     @staticmethod
-    def register_type(typ: 'Typ', config: Config):
+    def register_type(typ: 'Typ', config: pyodata.Config):
         """Add new type to the ODATA version type repository as well as its collection variant"""
 
         o_version = config.odata_version
@@ -155,7 +159,7 @@ def register_type(typ: 'Typ', config: Config):
             o_version.Types[collection_name] = collection_typ
 
     @staticmethod
-    def from_name(name, config: Config) -> 'Typ':
+    def from_name(name, config: pyodata.Config) -> 'Typ':
         o_version = config.odata_version
 
         # build types hierarchy on first use (lazy creation)
@@ -199,7 +203,7 @@ class Typ(Identifier):
     Kinds = Enum('Kinds', 'Primitive Complex')
 
     # pylint: disable=line-too-long
-    def __init__(self, name, null_value, traits=TypTraits(), kind=None):
+    def __init__(self, name, null_value, traits=base_traits.TypTraits(), kind=None):
         super(Typ, self).__init__(name)
 
         self._null_value = null_value
@@ -262,14 +266,14 @@ def traits(self):
     # pylint: disable=no-self-use
     def to_literal(self, value):
         if not isinstance(value, list):
-            raise PyODataException('Bad format: invalid list value {}'.format(value))
+            raise exceptions.PyODataException('Bad format: invalid list value {}'.format(value))
 
         return [self._item_type.traits.to_literal(v) for v in value]
 
     # pylint: disable=no-self-use
     def from_json(self, value):
         if not isinstance(value, list):
-            raise PyODataException('Bad format: invalid list value {}'.format(value))
+            raise exceptions.PyODataException('Bad format: invalid list value {}'.format(value))
 
         return [self._item_type.traits.from_json(v) for v in value]
 
@@ -338,8 +342,8 @@ def scale(self):
 
     def _check_scale_value(self):
         if self._scale > self._precision:
-            raise PyODataModelError('Scale value ({}) must be less than or equal to precision value ({})'
-                                    .format(self._scale, self._precision))
+            raise exceptions.PyODataModelError('Scale value ({}) must be less than or equal to precision value ({})'
+                                               .format(self._scale, self._precision))
 
 
 class Schema:
@@ -422,7 +426,7 @@ def __getitem__(self, key):
             except KeyError:
                 raise KeyError('There is no Schema Namespace {}'.format(key))
 
-    def __init__(self, config: Config):
+    def __init__(self, config: pyodata.Config):
         super(Schema, self).__init__()
 
         self._decls = Schema.Declarations()
@@ -547,7 +551,7 @@ def get_type(self, type_info):
         except KeyError:
             pass
 
-        raise PyODataModelError(
+        raise exceptions.PyODataModelError(
             'Neither primitive types nor types parsed from service metadata contain requested type {}'
             .format(type_info.name))
 
@@ -607,17 +611,17 @@ def check_role_property_names(self, role, entity_type_name, namespace):
             try:
                 entity_type = self.entity_type(entity_type_name, namespace)
             except KeyError:
-                raise PyODataModelError('EntityType {} does not exist in Schema Namespace {}'
-                                        .format(entity_type_name, namespace))
+                raise exceptions.PyODataModelError('EntityType {} does not exist in Schema Namespace {}'
+                                                   .format(entity_type_name, namespace))
             try:
                 entity_type.proprty(proprty)
             except KeyError:
-                raise PyODataModelError('Property {} does not exist in {}'.format(proprty, entity_type.name))
+                raise exceptions.PyODataModelError('Property {} does not exist in {}'.format(proprty, entity_type.name))
 
 
 class StructType(Typ):
     def __init__(self, name, label, is_value_list):
-        super(StructType, self).__init__(name, None, EdmStructTypTraits(self), Typ.Kinds.Complex)
+        super(StructType, self).__init__(name, None, base_traits.EdmStructTypTraits(self), Typ.Kinds.Complex)
 
         self._label = label
         self._is_value_list = is_value_list
@@ -654,7 +658,7 @@ def null_value(self):
     @property
     def traits(self):
         # return self._traits
-        return EdmStructTypTraits(self)
+        return base_traits.EdmStructTypTraits(self)
 
 
 class ComplexType(StructType):
@@ -688,7 +692,7 @@ def __init__(self, name, is_flags, underlying_type, namespace):
         super(EnumType, self).__init__(name)
         self._member = list()
         self._underlying_type = underlying_type
-        self._traits = TypTraits()
+        self._traits = base_traits.TypTraits()
         self._namespace = namespace
 
         if is_flags == 'True':
@@ -702,7 +706,7 @@ def __str__(self):
     def __getattr__(self, item):
         member = next(filter(lambda x: x.name == item, self._member), None)
         if member is None:
-            raise PyODataException(f'EnumType {self} has no member {item}')
+            raise exceptions.PyODataException(f'EnumType {self} has no member {item}')
 
         return member
 
@@ -713,7 +717,7 @@ def __getitem__(self, item):
 
         member = next(filter(lambda x: x.value == int(item), self._member), None)
         if member is None:
-            raise PyODataException(f'EnumType {self} has no member with value {item}')
+            raise exceptions.PyODataException(f'EnumType {self} has no member with value {item}')
 
         return member
 
@@ -723,7 +727,7 @@ def is_flags(self):
 
     @property
     def traits(self):
-        return EnumTypTrait(self)
+        return base_traits.EnumTypTrait(self)
 
     @property
     def namespace(self):
@@ -750,7 +754,7 @@ def nav_proprty(self, property_name):
         try:
             return self._nav_properties[property_name]
         except KeyError as ex:
-            raise PyODataModelError(f'{self} does not contain navigation property {property_name}') from ex
+            raise exceptions.PyODataModelError(f'{self} does not contain navigation property {property_name}') from ex
 
 
 class EntitySet(Identifier):

pyodata/model/elements.py

@@ -2,7 +2,7 @@
 
 import re
 
-from pyodata.exceptions import PyODataException, PyODataModelError
+import pyodata.exceptions as exceptions
 
 
 class EdmStructTypeSerializer:
@@ -21,7 +21,7 @@ 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))
+            raise exceptions.PyODataException('Cannot encode value {} without complex type information'.format(value))
 
         result = {}
         for type_prop in edm_type.proprties():
@@ -35,7 +35,7 @@ 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))
+            raise exceptions.PyODataException('Cannot decode value {} without complex type information'.format(value))
 
         result = {}
         for type_prop in edm_type.proprties():
@@ -49,7 +49,7 @@ 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))
+            raise exceptions.PyODataException('Cannot decode value {} without complex type information'.format(value))
 
         result = {}
         for type_prop in edm_type.proprties():
@@ -93,7 +93,7 @@ def to_literal(self, value):
     def from_literal(self, value):
         matches = re.match("^{}'(.*)'$".format(self._prefix), value)
         if not matches:
-            raise PyODataModelError(
+            raise exceptions.PyODataModelError(
                 "Malformed value {0} for primitive Edm type. Expected format is {1}'value'".format(value, self._prefix))
         return matches.group(1)