What is the equivalent of mongoengine.GeoPointField in motorengine to perform near queries?

Question

I have the following model: class DbObjectWithCoordinates(Document): coordinates = GeoPointField() # this used to work with mongengine

I used the mongoengine.GeoPointField to perform queries like find all objects near to given coordinates:

user_coordinates = user.coordinates
objects_of_interest = DbObjectWithCoordinates.objects(coordinates__near=user_coordinates, coordinaes_max_distance=3)

Howewer the GeoPointField field is not available in motorengine. Is it possible to define objects and use queries like this with motorengine? And if not is there a workaround for this kind of use case?

Answer 1

I think it would be fairly easy to implement geopoint field. Below is very simple implementation offcourse it is not a full one.

from motorengine.fields import *
from pymongo import GEOSPHERE, GEO2D
from motorengine.query.base import QueryOperator
from motorengine.utils import serialize, deserialize

class GeoPointField(BaseField):

    def __init__(self, *args, **kwargs):
        super(GeoPointField, self).__init__(*args, **kwargs)

    def validate(self, lst):
        if not isinstance(lst, (list, )):
            return False
        return True

    def to_son(self, lst):
        longitude = lst[1]
        latitude = lst[0]
        value = {"type": "Point", "coordinates": [latitude, longitude]}
        return value

    def from_son(self, jsn):
        valued = jsn
        longitude = valued.get("coordinates")[1]
        latitude = valued.get("coordinates")[0]
        return [latitude, longitude]

class GeoNearOperator(QueryOperator):

    def to_query(self, field_name, value):
        return {
                field_name: {
                      "$near": {
                         "$geometry": {
                           "type": "Point",
                           "coordinates": list(value[0])
                         },
                         "$minDistance": value[1]
                      }
                   }
                }

    def get_value(self, field_name, raw_value):
        return raw_value


class GeoSphearNearOperator(QueryOperator):

    EARTH_RADIOUS = 3963.2

    def to_query(self, field_name, value):
        return {
                 field_name: {
                  "$geoWithin": {
                       "$centerSphere": [list(value[0]),
                                         value[1]/self.EARTH_RADIOUS]
                     }
                 }
               }

    def get_value(self, field_name, raw_value):
        return raw_value

class Events(MotorEngineDocument):

    __indexes__ = [('location', GEOSPHERE)]

    name = StringField(required=True)
    tid = StringField(required=True)
    event_on = DateTimeField(required=True)
    location = GeoPointField(required=True)


    @classmethod
    async def nearby(cls, lat, lon, radious, limit=10, skip=0):
        results = await cls.objects.limit(limit).skip(skip)\
            .filter(location__around=[(lat, lon), radious])\
            .find_all()
        return results

But you need to be sure that the motorengine operators are updated properly before geo query.

from motorengine.query_builder.transform import OPERATORS
OPERATORS.update({
   "near": GeoNearOperator,
   "around": GeoSphearNearOperator,
   "search": TextSearch
})