Fixed merge conflicts- new version as per #8 should be ready.

parse_rest/installation.py

+#    This program is free software: you can redistribute it and/or modify
+#    it under the terms of the GNU General Public License as published by
+#    the Free Software Foundation, either version 3 of the License, or
+#    (at your option) any later version.
+#
+#    This program is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#    GNU General Public License for more details.
+#
+#    You should have received a copy of the GNU General Public License
+#    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+import __init__ as parse_rest
+from __init__ import API_ROOT, ParseResource
+from query import QueryManager, Query
+
+
+class InstallationManager(QueryManager):
+    def __init__(self):
+        self._model_class = Installation
+
+
+class InstallationQuery(Query):
+    def _fetch(self):
+        opts = dict(self._options)  # make a local copy
+        if self._where:
+            # JSON encode WHERE values
+            where = json.dumps(self._where)
+            opts.update({'where': where})
+
+        extra_headers = {'X-Parse-Master-Key': parse_rest.MASTER_KEY}
+        klass = self._manager.model_class
+        uri = self._manager.model_class.ENDPOINT_ROOT
+        return [klass(**it) for it in klass.GET(uri, **options).get('results')]
+
+
+class Installation(ParseResource):
+    ENDPOINT_ROOT = '/'.join([API_ROOT, 'installations'])
+
+
+class Push(ParseResource):
+    ENDPOINT_ROOT = '/'.join([API_ROOT, 'push'])
+
+    @classmethod
+    def send(cls, message, channels=None, **kw):
+        alert_message = {'alert': message}
+        targets = {}
+        if channels:
+            targets['channels'] = channels
+        if kw:
+            targets['where'] = kw
+        return cls.POST('', data=alert_message, **targets)
+
+Installation.Query = InstallationManager()

parse_rest/query.py

+#    This program is free software: you can redistribute it and/or modify
+#    it under the terms of the GNU General Public License as published by
+#    the Free Software Foundation, either version 3 of the License, or
+#    (at your option) any later version.
+#
+#    This program is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#    GNU General Public License for more details.
+#
+#    You should have received a copy of the GNU General Public License
+#    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+import json
+import collections
+
+
+class QueryResourceDoesNotExist(Exception):
+    '''Query returned no results'''
+    pass
+
+
+class QueryResourceMultipleResultsReturned(Exception):
+    '''Query was supposed to return unique result, returned more than one'''
+    pass
+
+
+class QueryManager(object):
+    def __init__(self, model_class):
+        self.model_class = model_class
+
+    def all(self):
+        return Queryset(self)
+
+    def where(self, **kw):
+        return Queryset(self).where(**kw)
+
+    def get(self, **kw):
+        return Queryset(self).where(**kw).get()
+
+
+class Queryset(object):
+
+    def __init__(self, manager):
+        self._manager = manager
+        self._where = collections.defaultdict(dict)
+        self._options = {}
+
+    def __iter__(self):
+        return iter(self._fetch())
+
+    def where(self, **kw):
+        for key, value in kw.items():
+            self.eq(key, value)
+        return self
+
+    def eq(self, name, value):
+        self._where[name] = value
+        return self
+
+    # It's tempting to generate the comparison functions programatically,
+    # but probably not worth the decrease in readability of the code.
+    def lt(self, name, value):
+        self._where[name]['$lt'] = value
+        return self
+
+    def lte(self, name, value):
+        self._where[name]['$lte'] = value
+        return self
+
+    def gt(self, name, value):
+        self._where[name]['$gt'] = value
+        return self
+
+    def gte(self, name, value):
+        self._where[name]['$gte'] = value
+        return self
+
+    def ne(self, name, value):
+        self._where[name]['$ne'] = value
+        return self
+
+    def order(self, order, decending=False):
+        # add a minus sign before the order value if decending == True
+        self._options['order'] = decending and ('-' + order) or order
+        return self
+
+    def limit(self, limit):
+        self._options['limit'] = limit
+        return self
+
+    def skip(self, skip):
+        self._options['skip'] = skip
+        return self
+
+    def exists(self):
+        results = self._fetch()
+        return len(results) > 0
+
+    def get(self):
+        results = self._fetch()
+        if len(results) == 0:
+            raise QueryResourceDoesNotExist
+        if len(results) >= 2:
+            raise QueryResourceMultipleResultsReturned
+        return results[0]
+
+    def _fetch(self):
+        options = dict(self._options)  # make a local copy
+        if self._where:
+            # JSON encode WHERE values
+            where = json.dumps(self._where)
+            options.update({'where': where})
+
+        klass = self._manager.model_class
+        uri = self._manager.model_class.ENDPOINT_ROOT
+        return [klass(**it) for it in klass.GET(uri, **options).get('results')]

parse_rest/user.py

+#    This program is free software: you can redistribute it and/or modify
+#    it under the terms of the GNU General Public License as published by
+#    the Free Software Foundation, either version 3 of the License, or
+#    (at your option) any later version.
+#
+#    This program is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#    GNU General Public License for more details.
+#
+#    You should have received a copy of the GNU General Public License
+#    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+import logging
+
+from __init__ import ParseResource, API_ROOT
+from __init__ import ResourceRequestLoginRequired, ResourceRequestBadRequest
+
+from query import QueryManager
+
+
+def login_required(func):
+    '''decorator describing User methods that need to be logged in'''
+    def ret(obj, *args, **kw):
+        if not hasattr(obj, 'sessionToken'):
+            message = '%s requires a logged-in session' % func.__name__
+            raise ResourceRequestLoginRequired(message)
+        func(obj, *args, **kw)
+    return ret
+
+
+class User(ParseResource):
+    '''
+    A User is like a regular Parse object (can be modified and saved) but
+    it requires additional methods and functionality
+    '''
+    ENDPOINT_ROOT = '/'.join([API_ROOT, 'users'])
+    PROTECTED_ATTRIBUTES = ParseResource.PROTECTED_ATTRIBUTES + [
+        'username', 'sessionToken']
+
+    def is_authenticated(self):
+        return getattr(self, 'sessionToken', None) or False
+
+    @login_required
+    def save(self):
+        session_header = {'X-Parse-Session-Token': self.sessionToken}
+        return self.__class__.PUT(
+            self._absolute_url,
+            extra_headers=session_header,
+            **self._to_native())
+
+    @login_required
+    def delete(self):
+        session_header = {'X-Parse-Session-Token': self.sessionToken}
+        return self.DELETE(self._absolute_url, extra_headers=session_header)
+
+    @staticmethod
+    def signup(username, password, **kw):
+        return User(**User.POST('', username=username, password=password,
+                                **kw))
+
+    @staticmethod
+    def login(username, password):
+        login_url = '/'.join([API_ROOT, 'login'])
+        return User(**User.GET(login_url, username=username,
+                                password=password))
+
+    @staticmethod
+    def request_password_reset(email):
+        '''Trigger Parse's Password Process. Return True/False
+        indicate success/failure on the request'''
+
+        url = '/'.join([API_ROOT, 'requestPasswordReset'])
+        try:
+            User.POST(url, email=email)
+            return True
+        except Exception, why:
+            return False
+
+
+User.Query = QueryManager(User)