Remove _(async|sync) top-level imports, use absolute instead

Author: sethmlarson

elasticsearch_dsl/_async/__init__.py

@@ -14,23 +14,3 @@
 #  KIND, either express or implied.  See the License for the
 #  specific language governing permissions and limitations
 #  under the License.
-
-try:
-    from .document import AsyncDocument, AsyncIndexMeta
-    from .faceted_search import AsyncFacetedSearch
-    from .index import AsyncIndex, AsyncIndexTemplate
-    from .search import AsyncMultiSearch, AsyncSearch
-    from .update_by_query import AsyncUpdateByQuery
-
-    __all__ = [
-        "AsyncDocument",
-        "AsyncIndexMeta",
-        "AsyncFacetedSearch",
-        "AsyncIndex",
-        "AsyncIndexTemplate",
-        "AsyncSearch",
-        "AsyncMultiSearch",
-        "AsyncUpdateByQuery",
-    ]
-except (ImportError, SyntaxError):
-    pass

elasticsearch_dsl/_async/document.py

@@ -25,8 +25,8 @@
 from elasticsearch.exceptions import NotFoundError, RequestError
 from six import add_metaclass
 
+from .._base.document import DocumentMeta
 from ..connections import get_connection
-from ..document import DocumentMeta
 from ..exceptions import IllegalOperation, ValidationException
 from ..utils import DOC_META_FIELDS, META_FIELDS, ObjectBase, merge
 from .search import AsyncSearch

elasticsearch_dsl/_async/faceted_search.py

@@ -17,7 +17,7 @@
 
 from six import iteritems, itervalues
 
-from .._base import FacetedResponse
+from .._base.faceted_search import FacetedResponse
 from ..query import MatchAll
 from .search import AsyncSearch
 

elasticsearch_dsl/_async/index.py

@@ -18,8 +18,8 @@
 from .. import analysis
 from ..connections import get_connection
 from ..exceptions import IllegalOperation
-from ..mapping import Mapping
 from ..utils import merge
+from .mapping import AsyncMapping
 from .search import AsyncSearch
 from .update_by_query import AsyncUpdateByQuery
 from .utils import ASYNC_IS_ASYNC
@@ -73,7 +73,7 @@ def __init__(self, name, using="default"):
 
     def get_or_create_mapping(self):
         if self._mapping is None:
-            self._mapping = Mapping()
+            self._mapping = AsyncMapping()
         return self._mapping
 
     def as_template(self, template_name, pattern=None, order=None):

elasticsearch_dsl/_async/mapping.py

@@ -0,0 +1,180 @@
+#  Licensed to Elasticsearch B.V. under one or more contributor
+#  license agreements. See the NOTICE file distributed with
+#  this work for additional information regarding copyright
+#  ownership. Elasticsearch B.V. licenses this file to you under
+#  the Apache License, Version 2.0 (the "License"); you may
+#  not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+# 	http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing,
+#  software distributed under the License is distributed on an
+#  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+#  KIND, either express or implied.  See the License for the
+#  specific language governing permissions and limitations
+#  under the License.
+
+try:
+    import collections.abc as collections_abc  # only works on python 3.3+
+except ImportError:
+    import collections as collections_abc
+
+from itertools import chain
+
+from six import iteritems
+
+from .._base.mapping import Properties
+from ..connections import get_connection
+from ..field import Nested, Text
+from .utils import ASYNC_IS_ASYNC
+
+
+class AsyncMapping(object):
+    def __init__(self):
+        self.properties = Properties()
+        self._meta = {}
+
+    def __repr__(self):
+        return str(type(self.__name__)) + "()"
+
+    def _clone(self):
+        m = AsyncMapping()
+        m.properties._params = self.properties._params.copy()
+        return m
+
+    @classmethod
+    async def from_es(cls, index, using="default"):
+        m = cls()
+        await m.update_from_es(index, using)
+        return m
+
+    def resolve_nested(self, field_path):
+        field = self
+        nested = []
+        parts = field_path.split(".")
+        for i, step in enumerate(parts):
+            try:
+                field = field[step]
+            except KeyError:
+                return (), None
+            if isinstance(field, Nested):
+                nested.append(".".join(parts[: i + 1]))
+        return nested, field
+
+    def resolve_field(self, field_path):
+        field = self
+        for step in field_path.split("."):
+            try:
+                field = field[step]
+            except KeyError:
+                return
+        return field
+
+    def _collect_analysis(self):
+        analysis = {}
+        fields = []
+        if "_all" in self._meta:
+            fields.append(Text(**self._meta["_all"]))
+
+        for f in chain(fields, self.properties._collect_fields()):
+            for analyzer_name in (
+                "analyzer",
+                "normalizer",
+                "search_analyzer",
+                "search_quote_analyzer",
+            ):
+                if not hasattr(f, analyzer_name):
+                    continue
+                analyzer = getattr(f, analyzer_name)
+                d = analyzer.get_analysis_definition()
+                # empty custom analyzer, probably already defined out of our control
+                if not d:
+                    continue
+
+                # merge the definition
+                # TODO: conflict detection/resolution
+                for key in d:
+                    analysis.setdefault(key, {}).update(d[key])
+
+        return analysis
+
+    async def save(self, index, using="default"):
+        from .index import AsyncIndex
+
+        index = AsyncIndex(index, using=using)
+        index.mapping(self)
+        return await index.save()
+
+    async def update_from_es(self, index, using="default"):
+        es = get_connection(using, is_async=ASYNC_IS_ASYNC)
+        raw = await es.indices.get_mapping(index=index)
+        _, raw = raw.popitem()
+        self._update_from_dict(raw["mappings"])
+
+    def _update_from_dict(self, raw):
+        for name, definition in iteritems(raw.get("properties", {})):
+            self.field(name, definition)
+
+        # metadata like _all etc
+        for name, value in iteritems(raw):
+            if name != "properties":
+                if isinstance(value, collections_abc.Mapping):
+                    self.meta(name, **value)
+                else:
+                    self.meta(name, value)
+
+    def update(self, mapping, update_only=False):
+        for name in mapping:
+            if update_only and name in self:
+                # nested and inner objects, merge recursively
+                if hasattr(self[name], "update"):
+                    # FIXME only merge subfields, not the settings
+                    self[name].update(mapping[name], update_only)
+                continue
+            self.field(name, mapping[name])
+
+        if update_only:
+            for name in mapping._meta:
+                if name not in self._meta:
+                    self._meta[name] = mapping._meta[name]
+        else:
+            self._meta.update(mapping._meta)
+
+    def __contains__(self, name):
+        return name in self.properties.properties
+
+    def __getitem__(self, name):
+        return self.properties.properties[name]
+
+    def __iter__(self):
+        return iter(self.properties.properties)
+
+    def field(self, *args, **kwargs):
+        self.properties.field(*args, **kwargs)
+        return self
+
+    def meta(self, name, params=None, **kwargs):
+        from ..mapping import META_FIELDS
+
+        if not name.startswith("_") and name not in META_FIELDS:
+            name = "_" + name
+
+        if params and kwargs:
+            raise ValueError("Meta configs cannot have both value and a dictionary.")
+
+        self._meta[name] = kwargs if params is None else params
+        return self
+
+    def to_dict(self):
+        meta = self._meta
+
+        # hard coded serialization of analyzers in _all
+        if "_all" in meta:
+            meta = meta.copy()
+            _all = meta["_all"] = meta["_all"].copy()
+            for f in ("analyzer", "search_analyzer", "search_quote_analyzer"):
+                if hasattr(_all.get(f, None), "to_dict"):
+                    _all[f] = _all[f].to_dict()
+        meta.update(self.properties.to_dict())
+        return meta

elasticsearch_dsl/_async/search.py

@@ -21,7 +21,7 @@
 from elasticsearch.helpers import async_scan
 from six import iteritems, string_types
 
-from .._base import AggsProxy, ProxyDescriptor, QueryProxy, Request
+from .._base.search import AggsProxy, ProxyDescriptor, QueryProxy, Request
 from ..aggs import A
 from ..connections import get_connection
 from ..exceptions import IllegalOperation

elasticsearch_dsl/_async/update_by_query.py

@@ -15,7 +15,7 @@
 #  specific language governing permissions and limitations
 #  under the License.
 
-from .._base import ProxyDescriptor, QueryProxy, Request
+from .._base.search import ProxyDescriptor, QueryProxy, Request
 from ..connections import get_connection
 from ..query import Bool, Q
 from ..response import UpdateByQueryResponse

elasticsearch_dsl/_base/__init__.py

@@ -14,15 +14,3 @@
 #  KIND, either express or implied.  See the License for the
 #  specific language governing permissions and limitations
 #  under the License.
-
-from .faceted_search import FacetedResponse
-from .search import AggsProxy, ProxyDescriptor, QueryProxy, Request, Response
-
-__all__ = [
-    "FacetedResponse",
-    "AggsProxy",
-    "ProxyDescriptor",
-    "QueryProxy",
-    "Request",
-    "Response",
-]

elasticsearch_dsl/_base/document.py

@@ -0,0 +1,99 @@
+#  Licensed to Elasticsearch B.V. under one or more contributor
+#  license agreements. See the NOTICE file distributed with
+#  this work for additional information regarding copyright
+#  ownership. Elasticsearch B.V. licenses this file to you under
+#  the Apache License, Version 2.0 (the "License"); you may
+#  not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+# 	http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing,
+#  software distributed under the License is distributed on an
+#  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+#  KIND, either express or implied.  See the License for the
+#  specific language governing permissions and limitations
+#  under the License.
+
+from six import add_metaclass, iteritems
+
+from ..field import Field
+from ..utils import ObjectBase, iscoroutinefunction
+
+
+class MetaField(object):
+    def __init__(self, *args, **kwargs):
+        self.args, self.kwargs = args, kwargs
+
+
+class DocumentMeta(type):
+    def __new__(cls, name, bases, attrs):
+        # DocumentMeta filters attrs in place
+        attrs["_doc_type"] = DocumentOptions(name, bases, attrs)
+        return super(DocumentMeta, cls).__new__(cls, name, bases, attrs)
+
+
+class DocumentOptions(object):
+    def __init__(self, name, bases, attrs):
+        meta = attrs.pop("Meta", None)
+
+        # Decide whether we should use an 'AsyncMapping' or sync 'Mapping'
+        # class based on whether the document.save() function is async or not.
+        if "init" in attrs and iscoroutinefunction(attrs["init"]):
+            from ..mapping import AsyncMapping
+
+            default_mapping_cls = AsyncMapping
+        else:
+            from ..mapping import Mapping
+
+            default_mapping_cls = Mapping
+
+        # create the mapping instance
+        try:
+            meta_mapping = meta.mapping
+
+            # If a synchronous 'Mapping' is defined on an
+            # 'AsyncDocument' or the reverse we can correct
+            # the definition by updating a new instance
+            # with the proper I/O flavoring.
+            if not isinstance(meta_mapping, default_mapping_cls):
+                meta_mapping = default_mapping_cls()
+                meta_mapping.update(meta_mapping)
+
+            self.mapping = meta_mapping
+        except AttributeError:
+            self.mapping = default_mapping_cls()
+
+        # register all declared fields into the mapping
+        for name, value in list(iteritems(attrs)):
+            if isinstance(value, Field):
+                self.mapping.field(name, value)
+                del attrs[name]
+
+        # add all the mappings for meta fields
+        for name in dir(meta):
+            if isinstance(getattr(meta, name, None), MetaField):
+                params = getattr(meta, name)
+                self.mapping.meta(name, *params.args, **params.kwargs)
+
+        # document inheritance - include the fields from parents' mappings
+        for b in bases:
+            if hasattr(b, "_doc_type") and hasattr(b._doc_type, "mapping"):
+                self.mapping.update(b._doc_type.mapping, update_only=True)
+
+    @property
+    def name(self):
+        return self.mapping.properties.name
+
+
+@add_metaclass(DocumentMeta)
+class InnerDoc(ObjectBase):
+    """
+    Common class for inner documents like Object or Nested
+    """
+
+    @classmethod
+    def from_es(cls, data, data_only=False):
+        if data_only:
+            data = {"_source": data}
+        return super(InnerDoc, cls).from_es(data)