Always foallback to fields from Index

Author: honzakral

Changelog.rst

@@ -8,6 +8,8 @@ Changelog
 
 * Fixed logic around defining a different ``doc_type`` name.
 * Added ``retry_on_conflict`` parameter to ``Document.update``.
+* fields defined on an index are now used to (de)serialize the data even when not
+  defined on a ``Document``
 
 6.2.1 (2018-07-03)
 ------------------

elasticsearch_dsl/utils.py

@@ -355,6 +355,39 @@ def __init__(self, meta=None, **kwargs):
 
         super(ObjectBase, self).__init__(kwargs)
 
+    @classmethod
+    def __list_fields(cls):
+        """
+        Get all the fields defined for our class, if we have an Index, try
+        looking at the index mappings as well, mark the fields from Index as
+        optional.
+        """
+        for name in cls._doc_type.mapping:
+            field = cls._doc_type.mapping[name]
+            yield name, field, False
+
+        if hasattr(cls.__class__, '_index'):
+            if not cls._index._mapping:
+                return
+            for name in cls._index._mapping:
+                # don't return fields that are in _doc_type
+                if name in cls._doc_type.mapping:
+                    continue
+                field = cls._index._mapping[name]
+                yield name, field, True
+
+    @classmethod
+    def __get_field(cls, name):
+        try:
+            return cls._doc_type.mapping[name]
+        except KeyError:
+            # fallback to fields on the Index
+            if hasattr(cls, '_index') and cls._index._mapping:
+                try:
+                    return cls._index._mapping[name]
+                except KeyError:
+                    pass
+
     @classmethod
     def from_es(cls, hit):
         meta = hit.copy()
@@ -367,10 +400,10 @@ def from_es(cls, hit):
                     data[k] = v
 
         doc = cls(meta=meta)
-        m = cls._doc_type.mapping
         for k, v in iteritems(data):
-            if k in m and m[k]._coerce:
-                v = m[k].deserialize(v)
+            f = cls.__get_field(k)
+            if f and f._coerce:
+                v = f.deserialize(v)
             setattr(doc, k, v)
         return doc
 
@@ -386,27 +419,15 @@ def __getattr__(self, name):
         try:
             return super(ObjectBase, self).__getattr__(name)
         except AttributeError:
-            if name in self._doc_type.mapping:
-                f = self._doc_type.mapping[name]
-                if hasattr(f, 'empty'):
-                    value = f.empty()
-                    if value not in SKIP_VALUES:
-                        setattr(self, name, value)
-                        value = getattr(self, name)
-                    return value
+            f = self.__get_field(name)
+            if hasattr(f, 'empty'):
+                value = f.empty()
+                if value not in SKIP_VALUES:
+                    setattr(self, name, value)
+                    value = getattr(self, name)
+                return value
             raise
 
-    def __get_field(self, name):
-        try:
-            return self._doc_type.mapping[name]
-        except KeyError:
-            # fallback to fields on the Index
-            if hasattr(self, '_index') and self._index._mapping:
-                try:
-                    return self._index._mapping[name]
-                except KeyError:
-                    pass
-
     def to_dict(self, skip_empty=True):
         out = {}
         for k, v in iteritems(self._d_):
@@ -428,26 +449,6 @@ def to_dict(self, skip_empty=True):
             out[k] = v
         return out
 
-    def __list_fields(self):
-        """
-        Get all the fields defined for our class, if we have an Index, try
-        looking at the index mappings as well, mark the fields from Index as
-        optional.
-        """
-        for name in self._doc_type.mapping:
-            field = self._doc_type.mapping[name]
-            yield name, field, False
-
-        if hasattr(self, '_index'):
-            if not self._index._mapping:
-                return
-            for name in self._index._mapping:
-                # don't return fields that are in _doc_type
-                if name in self._doc_type.mapping:
-                    continue
-                field = self._index._mapping[name]
-                yield name, field, True
-
     def clean_fields(self):
         errors = {}
         for name, field, optional in self.__list_fields():