Merge pull request #18 from direbearform/master

support for mapping nested objects

Author: marazt

.gitignore

@@ -58,3 +58,6 @@ target/
 # Idea
 .idea
 .python-version
+
+# VSCode
+.vscode

.travis.yml

@@ -9,7 +9,7 @@ matrix:
       os: windows           # Windows 10.0.17134 N/A Build 17134
       language: shell       # 'language: python' is an error on Travis CI Windows
       before_install:
-        - choco install python3
+        - choco install python3 --version 3.7.3
         - pip install virtualenv
         - virtualenv $HOME/venv
         - source $HOME/venv/Scripts/activate

README.md

@@ -3,7 +3,7 @@
 # Object Mapper
 
 **Version**
-1.0.7
+1.1.0
 
 **Author**
 marazt
@@ -15,7 +15,7 @@ marazt
 The MIT License (MIT)
 
 **Last updated**
-19 June 2019
+13 July 2019
 
 **Package Download**
 https://pypi.python.org/pypi/object-mapper
@@ -27,6 +27,10 @@ https://pypi.python.org/pypi/object-mapper
 
 ## Versions
 
+**1.1.0 - 2019/07/13**
+
+* Add basic support for nested object, thanks [@direbearform](https://github.com/direbearform)
+
 **1.0.7 - 2019/06/19**
 
 * Fix type name inside mapper dict to avoid collision, thanks [@renanvieira](https://github.com/renanvieira)

README.rst

@@ -1,21 +1,26 @@
 Object Mapper
 =============
 
-**Version** 1.0.7
+**Version** 1.1.0
 
 **Author** marazt
 
 **Copyright** marazt
 
 **License** The MIT License (MIT)
 
-**Last updated** 19 June 2019
+**Last updated** 13 July 2019
+
 
 **Package Download** https://pypi.python.org/pypi/object-mapper ---
 
 Versions
 --------
 
+**1.1.0 - 2019/07/13**
+
+- Add basic support for nested object, thanks [@direbearform](https://github.com/direbearform)
+
 **1.0.7 - 2019/06/19**
 
 - Fix type name inside mapper dict to avoid collision, thanks [@renanvieira](https://github.com/renanvieira)

mapper/object_mapper.py

@@ -3,6 +3,7 @@
 Copyright (C) 2015, marazt. All rights reserved.
 """
 from inspect import getmembers, isroutine
+from datetime import date, datetime
 
 from mapper.casedict import CaseDict
 from mapper.object_mapper_exception import ObjectMapperException
@@ -14,6 +15,8 @@ class ObjectMapper(object):
     Supports mapping conversions too
     """
 
+    primitive_types = { int, str, bool, date, datetime }
+
     def __init__(self):
         """Constructor
 
@@ -60,7 +63,7 @@ def __init__(self):
             mapper = ObjectMapper()
             mapper.create_map(A, B, {'last_name': None})
 
-            instance_b = mapper.map(A(), B)
+            instance_b = mapper.map(A())
 
             In this case, value of A.name will be copied into B.name automatically by the attribute name 'name'.
             Attribute A.last_name will be not mapped thanks the suppression (lambda function is None).
@@ -72,18 +75,22 @@ class 'B' with attributes 'name' and 'age' and we want to map 'A' to 'B' in a wa
             Initialization of the ObjectMapper will be:
             mapper = ObjectMapper()
             mapper.create_map(A, B)
-            instance_b = mapper.map(A(), B, ignore_case=True)
+            instance_b = mapper.map(A(), ignore_case=True)
 
             In this case, the value of A.Name will be copied into B.name and
             the value of A.Age will be copied into B.age.
 
         :return: Instance of the ObjectMapper
         """
-        # self.to_type = to_type
+
+        # mapping is a 2-layer dict keyed by source type then by dest type, and stores two things in a tuple:
+        #  - the destination type class
+        #  - custom mapping functions, if any
         self.mappings = {}
         pass
 
     def create_map(self, type_from, type_to, mapping=None):
+        # type: (type, type, Dict) -> None
         """Method for adding mapping definitions
 
         :param type_from: source type
@@ -93,32 +100,43 @@ def create_map(self, type_from, type_to, mapping=None):
 
         :return: None
         """
+
+        if (type(type_from) is not type):
+            raise ObjectMapperException("type_from must be a type")
+
+        if (type(type_to) is not type):
+            raise ObjectMapperException("type_to must be a type")
+
+        if (mapping is not None and not isinstance(mapping, dict)):
+            raise ObjectMapperException("mapping, if provided, must be a Dict type")
+
         key_from = type_from
         key_to = type_to
 
-        if mapping is None:
-            mapping = {}
-
         if key_from in self.mappings:
             inner_map = self.mappings[key_from]
             if key_to in inner_map:
                 raise ObjectMapperException(
                     "Mapping for {0}.{1} -> {2}.{3} already exists".format(key_from.__module__, key_from.__name__,
                                                                    key_to.__module__, key_to.__name__))
             else:
-                inner_map[key_to] = mapping
+                inner_map[key_to] = (type_to, mapping)
         else:
             self.mappings[key_from] = {}
-            self.mappings[key_from][key_to] = mapping
+            self.mappings[key_from][key_to] = (type_to, mapping)
+
 
-    def map(self, from_obj, to_type, ignore_case=False, allow_none=False, excluded=None):
+    def map(self, from_obj, to_type=type(None), ignore_case=False, allow_none=False, excluded=None, included=None, allow_unmapped=False):
+        # type: (object, type, bool, bool, List[str], List[str], bool) -> object
         """Method for creating target object instance
 
         :param from_obj: source object to be mapped from
         :param to_type: target type
         :param ignore_case: if set to true, ignores attribute case when performing the mapping
         :param allow_none: if set to true, returns None if the source object is None; otherwise throws an exception
         :param excluded: A list of fields to exclude when performing the mapping
+        :param included: A list of fields to force inclusion when performing the mapping
+        :param allow_unmapped: if set to true, copy over the non-primitive object that didn't have a mapping defined; otherwise exception
 
         :return: Instance of the target class with mapped attributes
         """
@@ -128,22 +146,45 @@ def map(self, from_obj, to_type, ignore_case=False, allow_none=False, excluded=N
             # one of the tests is explicitly checking for an attribute error on __dict__ if it's not set
             from_obj.__dict__
 
-        inst = to_type()
         key_from = from_obj.__class__
-        key_to = to_type
+
+        if key_from not in self.mappings:
+            raise ObjectMapperException("No mapping defined for {0}.{1}"
+                .format(key_from.__module__, key_from.__name__))
+
+        if to_type is None or to_type is type(None):
+            # automatically infer to to_type
+            # if this is a nested call and we do not currently support more than one to_types
+            assert(len(self.mappings[key_from]) > 0)
+            if len(self.mappings[key_from]) > 1:
+                raise ObjectMapperException("Ambiguous type mapping exists for {0}.{1}, must specifiy to_type explicitly"
+                    .format(key_from.__module__, key_from.__name__))
+            key_to = next(iter(self.mappings[key_from]))
+        else:
+            if to_type not in self.mappings[key_from]:
+                raise ObjectMapperException("No mapping defined for {0}.{1} -> {2}.{3}"
+                .format(key_from.__module__, key_from.__name__, to_type.__module__, to_type.__name__))
+            key_to = to_type
+        custom_mappings = self.mappings[key_from][key_to][1]
+        
+        # Currently, all target class data members need to have default value
+        # Object with __init__ that carries required non-default arguments are not supported
+        inst = key_to()
 
         def not_private(s):
             return not s.startswith('_')
 
         def not_excluded(s):
             return not (excluded and s in excluded)
 
+        def is_included(s, mapping):
+            return (included and s in included) or (mapping and s in mapping)
+
         from_obj_attributes = getmembers(from_obj, lambda a: not isroutine(a))
-        from_obj_dict = {k: v for k, v in from_obj_attributes
-                         if not_private(k) and not_excluded(k)}
+        from_obj_dict = {k: v for k, v in from_obj_attributes}
 
         to_obj_attributes = getmembers(inst, lambda a: not isroutine(a))
-        to_obj_dict = {k: v for k, v in to_obj_attributes if not_private(k)}
+        to_obj_dict = {k: v for k, v in to_obj_attributes if not_excluded(k) and (not_private(k) or is_included(k, custom_mappings))}
 
         if ignore_case:
             from_props = CaseDict(from_obj_dict)
@@ -152,29 +193,54 @@ def not_excluded(s):
             from_props = from_obj_dict
             to_props = to_obj_dict
 
-        for prop in to_props:
-            if self.mappings is not None \
-                    and key_from in self.mappings \
-                    and key_to in self.mappings[key_from]:
-                if prop in self.mappings[key_from][key_to]:
-                    # take mapping function
-                    try:
-                        fnc = self.mappings[key_from][key_to][prop]
-                        if fnc is not None:
-                            setattr(inst, prop, fnc(from_obj))
-                            # none suppress mapping
-                    except Exception:
-                        raise ObjectMapperException("Invalid mapping function while setting property {0}.{1}".
-                                                    format(inst.__class__.__name__, prop))
+        def map_obj(o, allow_unmapped):
+            if o is not None:
+                key_from_child = o.__class__
+                if (key_from_child in self.mappings):
+                    # if key_to has a mapping defined, nests the map() call
+                    return self.map(o, type(None), ignore_case, allow_none, excluded, included, allow_unmapped)
+                elif (key_from_child in ObjectMapper.primitive_types):
+                    # allow primitive types without mapping
+                    return o
+                else:
+                    # fail complex type conversion if mapping was not defined, unless explicitly allowed
+                    if allow_unmapped:
+                        return o
+                    else:
+                        raise ObjectMapperException("No mapping defined for {0}.{1}"
+                            .format(key_from_child.__module__, key_from_child.__name__))
+            else:
+                return None
 
+        for prop in to_props:
+            
+            val = None
+            suppress_mapping = False
+
+            # mapping function take precedence over complex type mapping
+            if custom_mappings is not None and prop in custom_mappings:
+                try:
+                    fnc = custom_mappings[prop]
+                    if fnc is not None:
+                        val = fnc(from_obj)
+                    else:
+                        suppress_mapping = True
+                except Exception:
+                    raise ObjectMapperException("Invalid mapping function while setting property {0}.{1}".
+                                                format(inst.__class__.__name__, prop))
+
+            elif prop in from_props:
+                # try find property with the same name in the source
+                from_obj_child = from_props[prop]
+                if isinstance(from_obj_child, list):
+                    val = [map_obj(from_obj_child_i, allow_unmapped) for from_obj_child_i in from_obj_child]
                 else:
-                    # try find property with the same name in the source
-                    if prop in from_props:
-                        setattr(inst, prop, from_props[prop])
-                        # case when target attribute is not mapped (can be extended)
+                    val = map_obj(from_obj_child, allow_unmapped)
+            
             else:
-                raise ObjectMapperException(
-                    "No mapping defined for {0}.{1} -> {2}.{3}".format(key_from.__module__, key_from.__name__,
-                                                                       key_to.__module__, key_to.__name__))
+                suppress_mapping = True
+
+            if not suppress_mapping:
+                setattr(inst, prop, val)
 
         return inst

setup.py

@@ -25,7 +25,7 @@
     # Versions should comply with PEP440.  For a discussion on single-sourcing
     # the version across setup.py and the project code, see
     # https://packaging.python.org/en/latest/single_source_version.html
-    version='1.0.7',
+    version='1.1.0',
 
     description="ObjectMapper is a class for automatic object mapping. It helps you to create objects between\
                 project layers (data layer, service layer, view) in a simple, transparent way.",