7.x compatibility

TODO:
  concurrency control

Author: honzakral

elasticsearch_dsl/document.py

@@ -6,7 +6,7 @@
 from fnmatch import fnmatch
 
 from elasticsearch.exceptions import NotFoundError, RequestError
-from six import iteritems, add_metaclass, string_types
+from six import iteritems, add_metaclass
 
 from .field import Field
 from .mapping import Mapping
@@ -68,11 +68,8 @@ class DocumentOptions(object):
     def __init__(self, name, bases, attrs):
         meta = attrs.pop('Meta', None)
 
-        # get doc_type name, if not defined use 'doc'
-        doc_type = getattr(meta, 'doc_type', 'doc')
-
         # create the mapping instance
-        self.mapping = getattr(meta, 'mapping', Mapping(doc_type))
+        self.mapping = getattr(meta, 'mapping', Mapping())
 
         # register all declared fields into the mapping
         for name, value in list(iteritems(attrs)):
@@ -114,8 +111,7 @@ class Document(ObjectBase):
     """
     @classmethod
     def _matches(cls, hit):
-        return fnmatch(hit.get('_index', ''), cls._index._name) \
-            and cls._doc_type.name == hit.get('_type')
+        return fnmatch(hit.get('_index', ''), cls._index._name)
 
     @classmethod
     def _get_using(cls, using=None):
@@ -154,7 +150,7 @@ def __repr__(self):
         return '{}({})'.format(
             self.__class__.__name__,
             ', '.join('{}={!r}'.format(key, getattr(self.meta, key)) for key in
-                      ('index', 'doc_type', 'id') if key in self.meta)
+                      ('index', 'id') if key in self.meta)
         )
 
     @classmethod
@@ -185,7 +181,6 @@ def get(cls, id, using=None, index=None, **kwargs):
         es = cls._get_connection(using)
         doc = es.get(
             index=cls._default_index(index),
-            doc_type=cls._doc_type.name,
             id=id,
             **kwargs
         )
@@ -225,7 +220,6 @@ def mget(cls, docs, using=None, index=None, raise_on_error=True,
         results = es.mget(
             body,
             index=cls._default_index(index),
-            doc_type=cls._doc_type.name,
             **kwargs
         )
 
@@ -283,7 +277,6 @@ def delete(self, using=None, index=None, **kwargs):
         doc_meta.update(kwargs)
         es.delete(
             index=self._get_index(index),
-            doc_type=self._doc_type.name,
             **doc_meta
         )
 
@@ -292,7 +285,7 @@ def to_dict(self, include_meta=False, skip_empty=True):
         Serialize the instance into a dictionary so that it can be saved in elasticsearch.
 
         :arg include_meta: if set to ``True`` will include all the metadata
-            (``_index``, ``_type``, ``_id`` etc). Otherwise just the document's
+            (``_index``, ``_id`` etc). Otherwise just the document's
             data is serialized. This is useful when passing multiple instances into
             ``elasticsearch.helpers.bulk``.
         :arg skip_empty: if set to ``False`` will cause empty values (``None``,
@@ -314,7 +307,6 @@ def to_dict(self, include_meta=False, skip_empty=True):
         if index is not None:
             meta['_index'] = index
 
-        meta['_type'] = self._doc_type.name
         meta['_source'] = d
         return meta
 
@@ -398,7 +390,6 @@ def update(self, using=None, index=None,  detect_noop=True,
 
         meta = self._get_connection(using).update(
             index=self._get_index(index),
-            doc_type=self._doc_type.name,
             body=body,
             refresh=refresh,
             **doc_meta
@@ -442,7 +433,6 @@ def save(self, using=None, index=None, validate=True, skip_empty=True, **kwargs)
         doc_meta.update(kwargs)
         meta = es.index(
             index=self._get_index(index),
-            doc_type=self._doc_type.name,
             body=self.to_dict(skip_empty=skip_empty),
             **doc_meta
         )

elasticsearch_dsl/field.py

@@ -173,7 +173,6 @@ def empty(self):
 
     def to_dict(self):
         d = self._mapping.to_dict()
-        _, d = d.popitem()
         d.update(super(Object, self).to_dict())
         return d
 

elasticsearch_dsl/index.py

@@ -33,7 +33,7 @@ def save(self, using=None):
         es.indices.put_template(name=self._template_name, body=self.to_dict())
 
 class Index(object):
-    def __init__(self, name, doc_type=DEFAULT_DOC_TYPE, using='default'):
+    def __init__(self, name, using='default'):
         """
         :arg name: name of the index
         :arg using: connection alias to use, defaults to ``'default'``
@@ -45,19 +45,10 @@ def __init__(self, name, doc_type=DEFAULT_DOC_TYPE, using='default'):
         self._aliases = {}
         self._analysis = {}
         self._mapping = None
-        if doc_type is not DEFAULT_DOC_TYPE:
-            self._mapping = Mapping(doc_type)
 
-    def _get_doc_type(self):
-        if self._mapping is not None:
-            return self._mapping.doc_type
-        for d in self._doc_types:
-            return d._doc_type.name
-        return None
-
-    def get_or_create_mapping(self, doc_type=DEFAULT_DOC_TYPE):
+    def get_or_create_mapping(self):
         if self._mapping is None:
-            self._mapping = Mapping(doc_type)
+            self._mapping = Mapping()
         return self._mapping
 
     def as_template(self, template_name, pattern=None):
@@ -87,7 +78,7 @@ def resolve_field(self, field_path):
     def load_mappings(self, using=None):
         self.get_or_create_mapping().update_from_es(self._name, using=using or self._using)
 
-    def clone(self, name=None, doc_type=None, using=None):
+    def clone(self, name=None, using=None):
         """
         Create a copy of the instance with another name or connection alias.
         Useful for creating multiple indices with shared configuration::
@@ -102,10 +93,7 @@ def clone(self, name=None, doc_type=None, using=None):
         :arg name: name of the index
         :arg using: connection alias to use, defaults to ``'default'``
         """
-        doc_type = doc_type or self._get_doc_type() or DEFAULT_DOC_TYPE
-        i = Index(name or self._name,
-                  doc_type=doc_type,
-                  using=using or self._using)
+        i = Index(name or self._name, using=using or self._using)
         i._settings = self._settings.copy()
         i._aliases = self._aliases.copy()
         i._analysis = self._analysis.copy()
@@ -128,11 +116,7 @@ def mapping(self, mapping):
         This means that, when this index is created, it will contain the
         mappings for the document type defined by those mappings.
         """
-        if self._mapping is not None and mapping.doc_type != self._mapping.doc_type:
-            raise IllegalOperation(
-                'Index object cannot have multiple types, %s already set, '
-                'trying to assign %s.' % (self._mapping.doc_type, mapping.doc_type))
-        self.get_or_create_mapping(mapping.doc_type).update(mapping)
+        self.get_or_create_mapping().update(mapping)
 
     def document(self, document):
         """
@@ -155,12 +139,6 @@ class Post(Document):
             # properly deserialized Post instances
             s = i.search()
         """
-        name = document._doc_type.name
-        doc_type = self._get_doc_type()
-        if doc_type and name != doc_type:
-            raise IllegalOperation(
-                'Index object cannot have multiple types, %s already set, '
-                'trying to assign %s.' % (doc_type, name))
         self._doc_types.append(document)
 
         # If the document index does not have any name, that means the user
@@ -170,7 +148,6 @@ class Post(Document):
             document._index = self
 
         return document
-    doc_type = document
 
     def settings(self, **kwargs):
         """
@@ -234,7 +211,7 @@ def to_dict(self):
             mapping = d._doc_type.mapping
             merge(mappings, mapping.to_dict(), True)
             merge(analysis, mapping._collect_analysis(), True)
-        if mappings and mappings[self._get_doc_type()]:
+        if mappings:
             out['mappings'] = mappings
         if analysis or self._analysis:
             merge(analysis, self._analysis)
@@ -265,7 +242,6 @@ def updateByQuery(self, using=None):
         return UpdateByQuery(
             using=using or self._using,
             index=self._name,
-            doc_type=self._doc_types
         )
 
     def create(self, using=None, **kwargs):
@@ -328,8 +304,7 @@ def save(self, using=None):
         # exception
         mappings = body.pop('mappings', {})
         if mappings:
-            for doc_type in mappings:
-                self.put_mapping(using=using, doc_type=doc_type, body=mappings[doc_type])
+            self.put_mapping(using=using, body=mappings)
 
     def analyze(self, using=None, **kwargs):
         """

elasticsearch_dsl/mapping.py

@@ -16,23 +16,23 @@
 ))
 
 class Properties(DslBase):
+    # FIXME: to_dict pop
+    name = 'properties'
     _param_defs = {'properties': {'type': 'field', 'hash': True}}
-    def __init__(self, name):
-        self._name = name
+    def __init__(self):
         super(Properties, self).__init__()
 
     def __repr__(self):
-        return 'Properties(%r)' % self._name
+        return 'Properties()'
 
     def __getitem__(self, name):
         return self.properties[name]
 
     def __contains__(self, name):
         return name in self.properties
 
-    @property
-    def name(self):
-        return self._name
+    def to_dict(self):
+        return super().to_dict()['properties']
 
     def field(self, name, *args, **kwargs):
         self.properties[name] = construct_field(*args, **kwargs)
@@ -66,21 +66,21 @@ def update(self, other_object):
 
 
 class Mapping(object):
-    def __init__(self, name):
-        self.properties = Properties(name)
+    def __init__(self):
+        self.properties = Properties()
         self._meta = {}
 
     def __repr__(self):
-        return 'Mapping(%r)' % self.doc_type
+        return 'Mapping()'
 
     def _clone(self):
-        m = Mapping(self.properties.name)
+        m = Mapping()
         m.properties._params = self.properties._params.copy()
         return m
 
     @classmethod
-    def from_es(cls, index, doc_type, using='default'):
-        m = cls(doc_type)
+    def from_es(cls, index, using='default'):
+        m = cls()
         m.update_from_es(index, using)
         return m
 
@@ -131,18 +131,17 @@ def _collect_analysis(self):
 
     def save(self, index, using='default'):
         from .index import Index
-        index = Index(index, doc_type=self.doc_type, using=using)
+        index = Index(index, using=using)
         index.mapping(self)
         return index.save()
 
     def update_from_es(self, index, using='default'):
         es = connections.get_connection(using)
-        raw = es.indices.get_mapping(index=index, doc_type=self.doc_type)
+        raw = es.indices.get_mapping(index=index)
         _, raw = raw.popitem()
         self._update_from_dict(raw['mappings'])
 
     def _update_from_dict(self, raw):
-        raw = raw[self.doc_type]
         for name, definition in iteritems(raw.get('properties', {})):
             self.field(name, definition)
 
@@ -180,10 +179,6 @@ def __getitem__(self, name):
     def __iter__(self):
         return iter(self.properties.properties)
 
-    @property
-    def doc_type(self):
-        return self.properties.name
-
     def field(self, *args, **kwargs):
         self.properties.field(*args, **kwargs)
         return self
@@ -199,7 +194,6 @@ def meta(self, name, params=None, **kwargs):
         return self
 
     def to_dict(self):
-        d = self.properties.to_dict()
         meta = self._meta
 
         # hard coded serialization of analyzers in _all
@@ -209,5 +203,5 @@ def to_dict(self):
             for f in ('analyzer', 'search_analyzer', 'search_quote_analyzer'):
                 if hasattr(_all.get(f, None), 'to_dict'):
                     _all[f] = _all[f].to_dict()
-        d[self.doc_type].update(meta)
-        return d
+        meta.update(self.properties.to_dict())
+        return meta

elasticsearch_dsl/response/__init__.py

@@ -1,4 +1,4 @@
-from ..utils import AttrDict, AttrList
+from ..utils import AttrDict, AttrList, _wrap
 
 from .hit import Hit, HitMeta
 
@@ -52,7 +52,7 @@ def hits(self):
             # avoid assigning _hits into self._d_
             super(AttrDict, self).__setattr__('_hits', hits)
             for k in h:
-                setattr(self._hits, k, h[k])
+                setattr(self._hits, k, _wrap(h[k]))
         return self._hits
 
     @property

elasticsearch_dsl/response/hit.py

@@ -28,7 +28,7 @@ def __repr__(self):
         return '<Hit({}): {}>'.format(
             '/'.join(
                 getattr(self.meta, key)
-                for key in ('index', 'doc_type', 'id')
+                for key in ('index', 'id')
                 if key in self.meta),
             super(Hit, self).__repr__()
         )