Installation instructions

Added ParseBatcher class to execute batch create, update or delete operations with a single API call, including test cases and documentation. Also added ability to log in a user using Facebook or Twitter authorization.

breaking down of Push send into two distinct methods, Push.alert (for json data) and Push.message (for text). Uses 'where' as an optional variable to make specific queries, and pass any other optional parameters through **kw)

Thanks for the work. I will break down the "send text" and "send json" into two distinct methods (Push.message and Push.alert?)

Found out that User.signup was not actually returning a valid User instance (missing username). Fixed and improved test to catch the problem.

Added new push optional parameters and the possibility to send a json payload instead of a simple string message

Finally getting rid of all the senseless code on __init__, and creating the code (for exceptions) and connection (for access keys management and the ParseBase class) modules.

getting _editable_attrs to return a dict. That will make things easier to get only 'public' attributes from objects'

Adding authentication methods, and figured out that Parse does return sessionToken info if requests are made with master key set, so I'm adding a new way to setup the connection. Before any interaction with Parse, simply call ParseBase.register(app_id, rest_key, **optional_keys) and it will save them. So the library now becomes usable for applications both with or without the master key.

A phenomenal hack to allow us to have a connection parameter set. Implemented a register method on ParseBase to replace the setting of parse_rest variables (that could not be seen on other modules). Application code can do from parse_rest.__init__ import ParseBase, and from there call register.

Fooled by parse. I thought that I could query by sessionToken in order to authenticate users on the client end, but it looks like they (rightly) omit the sessionToken from the allowed queryable parameters, and return a list of all users. Removing tests that gave the idea that such thing was possible.

Returning to QueryManager eliminated the need to copy_method. Updated README. Added a more friendlt repr method for Object and Users

Reverting handling of queries through QueryManagers, instead of simply using Querysets. Added a the _fetch method on QueryManager to eliminate the dependency of querysets on model_class. Added a  method to Queryset. Installation objects now are able to be imported. (Still need test cases, though.)

Small typo correction in parameter name

Fixed #9 by allowing ParseResources to be converted into Pointers and
back, such as when one object is set as an attribute of another. This
required:

- ParseResource now inherits Pointer
- All values are now converted to ParseType in the initialization of a
ParseResource
- The `_to_native` method of ParseResource was changed to `_to_dict`,
which allows `_to_native()` to construct a Pointer when one object is
an attribute of another.

Also:

- Added test coverage and example to README

- Fixed bug where many `from_native` methods used `self` instead of
`cls`

- `class_name` is converted to a string before being assigned to
`DerivedClass.__name__` (necessary because it is unicode when returned
from Parse)

- Changed TestUser to rely on parse_user.User instead of
parse_user.user.User

Many changes:

- Removed the QueryManager class- all querying is now handled by the
Queryset class. This was necessary to manage chained query lines like

GameScore.Query.gte("score", 1000).lt("score",
2000).order("playerName")

- Queryset methods for comparison and options are now added
programatically (makes it easier to change their operation all at
once).

- Added test coverage of querying methods, including comparison
operators and limit/skip options.

- Removed user.py, moving its classes into `__init__.py`. The reason is
that lines like

import parse_rest
from parse_rest.user import User

parse_rest.APPLICATION_ID = "something"

meant the module attribute APPLICATION_ID was actually not accessible
from the User class. Perhaps there's a way to make this work- I just
couldn't find it yet.

- Set up createdAt and updatedAt to return date time objects rather
than strings

Brought README.mkd up to date with new version (pull request #8). Also removed >>> in each of the example Python code snippets- they end up being confusing since they make it harder to cut-and-paste code. Incremented version.

Set up the QueryManager in a metaclass instead of in the __new__ method, which means one doesn't have to instantiate an instance of the class before querying it. Fixed the __iter__ method of Queryset, which yielded only the first object from the query. Put back test cases for CloudCode functions.

Lots of changes. Too many to put in a single commit message. In short, transformed Query objects into a method that belongs to ResourceClass. Also, added classes to represent ParseTypes. It should be possible to use these transparently. Added tests\!