add forced inclusion for protected fields

Author: direbearform

.vscode/settings.json

@@ -0,0 +1,4 @@
+{
+  "python.formatting.provider": "autopep8",
+  "python.pythonPath": "F:\\Anaconda3\\envs\\mlexp\\python.exe"
+}

mapper/object_mapper.py

@@ -120,14 +120,15 @@ def create_map(self, type_from: type, type_to: type, mapping: Dict =None):
             self.mappings[key_from][key_to] = (type_to, mapping)
 
 
-    def map(self, from_obj, to_type: type=type(None), ignore_case=False, allow_none=False, excluded=None, allow_unmapped=False):
+    def map(self, from_obj, to_type: type=type(None), ignore_case: bool=False, allow_none: bool=False, excluded: List[str]=None, included: List[str]=None, allow_unmapped: bool=False):
         """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
@@ -172,12 +173,14 @@ def not_private(s):
         def not_excluded(s):
             return not (excluded and s in excluded)
 
+        def is_included(s):
+            return included and s in included
+
         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))}
 
         if ignore_case:
             from_props = CaseDict(from_obj_dict)
@@ -192,7 +195,7 @@ def map_obj(o, allow_unmapped):
                 key_from_child = f"{key_from_child_cls.__module__}.{key_from_child_cls.__name__}"
                 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, allow_unmapped)
+                    return self.map(o, type(None), ignore_case, allow_none, excluded, included, allow_unmapped)
                 elif (key_from_child_cls in ObjectMapper.primitive_types):
                     # allow primitive types without mapping
                     return o
@@ -209,7 +212,7 @@ def map_obj(o, allow_unmapped):
 
             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:

tests/object_mapper_test.py

@@ -14,6 +14,7 @@ class ToTestClass(object):
     def __init__(self):
         self.name = ""
         self.date = ""
+        self._actor_name = ""
         pass
 
 
@@ -59,6 +60,7 @@ def __init__(self):
         self.name = "Igor"
         self.surname = "Hnizdo"
         self.date = datetime(2015, 1, 1)
+        self._actor_name = "Jan Triska"
         pass
 
 
@@ -101,6 +103,7 @@ def test_mapping_creation_without_mappings_correct(self):
         self.assertTrue(isinstance(result, ToTestClass), "Target types must be same")
         self.assertEqual(result.name, from_class.name, "Name mapping must be equal")
         self.assertEqual(result.date, from_class.date, "Date mapping must be equal")
+        self.assertEqual(result._actor_name, "", "Private should not be copied by default")
         self.assertNotIn("surname", result.__dict__, "To class must not contain surname")
 
     def test_mapping_creation_with_mappings_correct(self):
@@ -361,6 +364,24 @@ def test_mapping_excluded_field(self):
         self.assertEqual(result.date, '', "Date mapping must be equal")
         self.assertNotIn("surname", result.__dict__, "To class must not contain surname")
 
+    def test_mapping_included_field(self):
+        """Test mapping with included fields"""
+        #Arrange
+        from_class = FromTestClass()
+        mapper = ObjectMapper()
+        mapper.create_map(FromTestClass, ToTestClass)
+
+        #Act
+        result = mapper.map(FromTestClass(), excluded=['name'], included=['name', '_actor_name'])
+
+        #Assert
+        print(result)      
+        self.assertTrue(isinstance(result, ToTestClass), "Type must be ToTestClass")
+        self.assertEqual(result.name, '', "Name must not be copied despite of inclusion, as exclusion take precedence")
+        self.assertEqual(result.date, from_class.date, "Date mapping must be equal")
+        self.assertEqual(result._actor_name, from_class._actor_name, "Private is copied if explicitly included")
+        self.assertNotIn("surname", result.__dict__, "To class must not contain surname")
+
     def test_mapping_creation_complex_without_mappings_correct(self):
         """ Test mapping creation for complex class without mappings """