Create MapPath for mapping nested objects

Author: Saurus119

README.md

@@ -134,7 +134,12 @@ print(vars(public_user_info))
 # {'full_name': 'John Cusack', 'profession': 'engineer'}
 ```
 
-It is possible to easily specify nested field mappings.
+It is possible to easily specify nested field mappings. It can be done through "MapPath" object for your fields.
+Please be aware that you can´t mix in one mapping string mapping with MapPath mapping. You don´t need to specify source class
+from which mappings comes from as code will automatically use ```__name__``` of your source class.
+
+This is supported only if you register mapping through ```add``` method.
+
 ```python
 class BasicUser:
     def __init__(self, name: str, city: str):
@@ -148,9 +153,11 @@ class AdvancedUser:
         self.salary = salary
 
 mapper.add(
-    AdvancedUser, BasicUser, fields_mapping={
-        "name": "AdvancedUser.user.name",
-        "city": "AdvancedUser.user.city",
+    AdvancedUser,
+    BasicUser,
+    fields_mapping={
+        "name": MapPath("user.name"),
+        "city": MapPath("user.city"),
     }
 )
 

automapper/__init__.py

@@ -6,6 +6,7 @@
 )
 from .mapper import Mapper
 from .mapper_initializer import create_mapper
+from .path_mapper import MapPath
 
 # Global mapper
 mapper = create_mapper()

automapper/custom_types.py

@@ -0,0 +1,10 @@
+from typing import Any, Callable, Dict, Iterable, Optional, Type, TypeVar
+
+from automapper.path_mapper import MapPath
+
+# Custom Types
+S = TypeVar("S")
+T = TypeVar("T")
+ClassifierFunction = Callable[[Type[T]], bool]
+SpecFunction = Callable[[Type[T]], Iterable[str]]
+FieldsMap = Optional[Dict[str | MapPath, Any]]

automapper/exceptions.py

@@ -6,6 +6,10 @@ class MappingError(Exception):
     pass
 
 
+class MapPathMissMatchError(Exception):
+    pass
+
+
 class CircularReferenceError(Exception):
     def __init__(self, *args: object) -> None:
         super().__init__(

automapper/mapper.py

@@ -1,37 +1,18 @@
 import inspect
 from copy import deepcopy
 from functools import reduce
-from typing import (
-    Any,
-    Callable,
-    Dict,
-    Generic,
-    Iterable,
-    Optional,
-    Set,
-    Tuple,
-    Type,
-    TypeVar,
-    Union,
-    cast,
-    overload,
-)
+from typing import Any, Dict, Generic, Iterable, Set, Tuple, Type, Union, cast, overload
 
+from .custom_types import ClassifierFunction, FieldsMap, S, SpecFunction, T
 from .exceptions import (
     CircularReferenceError,
     DuplicatedRegistrationError,
+    MapPathMissMatchError,
     MappingError,
 )
 from .path_mapper import MapPath
 from .utils import is_dictionary, is_enum, is_primitive, is_sequence, object_contains
 
-# Custom Types
-S = TypeVar("S")
-T = TypeVar("T")
-ClassifierFunction = Callable[[Type[T]], bool]
-SpecFunction = Callable[[Type[T]], Iterable[str]]
-FieldsMap = Optional[Dict[str | MapPath, Any]]
-
 
 def _try_get_field_value(
     field_name: str, original_obj: Any, custom_mapping: FieldsMap
@@ -162,14 +143,28 @@ def add(
 
         Raises:
             DuplicatedRegistrationError: Same mapping for `source class` was added.
-            Only one mapping per source class can exist at a time for now.
-            You can specify target class manually using `mapper.to(target_cls)` method
-            or use `override` argument to replace existing mapping.
+                Only one mapping per source class can exist at a time for now.
+                You can specify target class manually using `mapper.to(target_cls)` method
+                or use `override` argument to replace existing mapping.
+            MapPathMissMatchError: When mixing `MapPath` with string mappings for a single mapping.
         """
         if source_cls in self._mappings and not override:
             raise DuplicatedRegistrationError(
                 f"source_cls {source_cls} was already added for mapping"
             )
+
+        if fields_mapping and any(
+            isinstance(map_path, MapPath) for map_path in fields_mapping.values()
+        ):
+            map_paths = fields_mapping.values()
+            if not all(isinstance(map_path, MapPath) for map_path in map_paths):
+                raise MapPathMissMatchError(
+                    "It is not allowed to mix MapPath mappings with string mappings."
+                )
+
+            for map_path in map_paths:
+                map_path.obj_prefix = source_cls.__name__
+
         self._mappings[source_cls] = (target_cls, fields_mapping)
 
     def map(

automapper/path_mapper.py

@@ -4,16 +4,23 @@ class MapPath:
     def __init__(self, path: str):
         if "." not in path:
             raise ValueError(f"Invalid path: '{path}' does not contain '.'")
-
         self.path = path
         self.attributes = path.split(".")
-        if not len(self.attributes) >= 2:
+        if not len(self.attributes) >= 1:
             raise ValueError(
                 f"Invalid path: '{path}'. Can´t reference to object attribute."
             )
 
-        self.obj_prefix = self.attributes[0]
-        self.attributes = self.attributes[1:]
+        self._obj_prefix: str | None = None
+
+    @property
+    def obj_prefix(self):
+        return self._obj_prefix
+
+    @obj_prefix.setter
+    def obj_prefix(self, src_cls_name: str) -> None:
+        """Setter for obj_prefix."""
+        self._obj_prefix = src_cls_name
 
     def __call__(self):
         return self.attributes

tests/test_path_mapper.py

@@ -1,8 +1,6 @@
 import pytest
-from automapper import mapper
-from automapper.path_mapper import (  # Replace 'your_module' with the actual module name
-    MapPath,
-)
+from automapper import MapPath, mapper
+from automapper.exceptions import MapPathMissMatchError
 
 
 class BasicUser:
@@ -28,8 +26,10 @@ def test_valid_map_path(self):
         """Test that MapPath correctly splits a valid path."""
         path = MapPath("some.example.path")
         assert path.path == "some.example.path"
-        assert path.attributes == ["example", "path"]  # obj_prefix is excluded
-        assert path.obj_prefix == "some"  # obj_prefix is correctly assigned
+        assert path.attributes == ["some", "example", "path"]
+        assert (
+            path.obj_prefix is None
+        )  # this is set by automatic in the process of mapping.
 
     def test_invalid_map_path_missing_dot(self):
         """Test that MapPath raises ValueError for paths without a dot."""
@@ -41,25 +41,23 @@ def test_invalid_map_path_missing_dot(self):
     def test_callable_behavior(self):
         """Test that calling an instance returns the correct split attributes."""
         path = MapPath("one.two.three")
-        assert path() == ["two", "three"]
+        assert path() == ["one", "two", "three"]
 
     def test_repr(self):
         """Test that __repr__ returns the expected string representation."""
         path = MapPath("foo.bar")
-        assert (
-            repr(path) == "MapPath(['bar'])"
-        )  # Only attributes are shown, excluding obj_prefix
+        assert repr(path) == "MapPath(['foo', 'bar'])"
 
 
-class TestMappingObjectAttributes:
+class TestAddMappingWithNestedObjectReference:
     def test_use_registered_mapping_with_map_path(self):
         try:
             mapper.add(
                 AdvancedUser,
                 BasicUser,
                 fields_mapping={
-                    "name": MapPath("AdvancedUser.user.name"),
-                    "city": MapPath("AdvancedUser.user.city"),
+                    "name": MapPath("user.name"),
+                    "city": MapPath("user.city"),
                 },
             )
 
@@ -83,3 +81,15 @@ def test_map_object_directly_without_adding_map_path_cant_be_resolved(self):
                 mapper.to(BasicUser).map(advanced_user)
         finally:
             mapper._mappings.clear()
+
+    def test_cant_add_mapping_with_mixed_map_path_and_string_mapping(self):
+        """Cant mix MapPath for one field and another field be classic string mapping."""
+        with pytest.raises(MapPathMissMatchError):
+            mapper.add(
+                AdvancedUser,
+                BasicUser,
+                fields_mapping={
+                    "name": "AdvancedUser.user.name",
+                    "city": MapPath("AdvancedUser.user.city"),
+                },
+            )