include private specified in mapping

Author: direbearform

mapper/object_mapper.py

@@ -101,8 +101,10 @@ def create_map(self, type_from: type, type_to: type, mapping: Dict =None):
 
         if (type(type_from) is not type):
             raise ObjectMapperException(f"type_from must be a type")
+
         if (type(type_to) is not type):
             raise ObjectMapperException(f"type_to must be a type")
+
         if (mapping is not None and not isinstance(mapping, Dict)):
             raise ObjectMapperException(f"mapping, if provided, must be a Dict type")
 
@@ -162,7 +164,7 @@ def map(self, from_obj, to_type: type=type(None), ignore_case: bool=False, allow
                 raise ObjectMapperException(f"No mapping defined for {key_from} to {key_to}")
             key_to_cls = self.mappings[key_from][key_to][0]
             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_cls()
@@ -173,14 +175,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
+        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}
 
         to_obj_attributes = getmembers(inst, lambda a: not isroutine(a))
-        to_obj_dict = {k: v for k, v in to_obj_attributes if not_excluded(k) and (not_private(k) or is_included(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)

tests/object_mapper_test.py

@@ -382,6 +382,24 @@ def test_mapping_included_field(self):
         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_included_field_by_mapping(self):
+        """Test mapping with included fields by mapping"""
+        #Arrange
+        from_class = FromTestClass()
+        mapper = ObjectMapper()
+        mapper.create_map(FromTestClass, ToTestClass, mapping={'_actor_name': lambda o: f"{o.name} acted by {o._actor_name}"})
+
+        #Act
+        result = mapper.map(FromTestClass())
+
+        #Assert
+        print(result)      
+        self.assertTrue(isinstance(result, ToTestClass), "Type must be ToTestClass")
+        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, f"{from_class.name} acted by {from_class._actor_name}", "Private is copied if explicitly mapped")
+        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 """