django-rangevoting

range-based voting w/ ranking support

django-rangevoting

django-rangevoting allows flexible voting on django objects and includes a pluggable ranking backend to make writing custom ranking algorithms easy.

This project is 100% "under development", so watch your fingers around the rough edges.

Before you ask "why not just fork django-voting", let me say:

  • I wanted to use an aggregate table
  • django-voting probably could've been extended fairly easily, but I'd prefer to start from scratch.

Setup

Add rangevoting to INSTALLED_APPS:

INSTALLED_APPS = ( # other apps ... 'rangevoting', )

Sync up:

python manage.py syncdb

Included w/ the svn checkout is a test app called testapp. If you checked out the entire project and have testapp, you can run tests with:

python manage.py test rangevoting

Usage

Add the post-save signal to each model you'd like users to vote on -- this signal will create an entry in the VoteSummary table, an aggregate table used to store vote tallies and other information about each object's voting history.

``` from django.db.models.signals import post_save from rangevoting.signals import create_voting_summary

class MyModel(models.Model): ...

post_save.connect(create_voting_summary, sender=MyModel) ```

Cast a Vote on an object:

``` from django.contrib.auth.models import from rangevoting.models import Vote from myapp.models import MyModel

get a user

user1 = User.objects.get(...) user2 = User.objects.get(...)

get an object to vote on

obj = MyModel.objects.get(...)

cast the votes

Vote.objects.cast_vote(user=user1, obj=obj, score=10.0) Vote.objects.cast_vote(user=user2, obj=obj, score=6.5)

get the score for an object

VoteSummary.objects.get_obj_score(obj=obj)

{"total": 2, "score": Decimal("8.250")}

```

Ranking

django-rangevoting comes w/ a ranking engine that lets you hack together ranking algorithms by providing, at this time, templated-out raw SQL. This area of the application will probably come under considerable re-writing, but works at the moment. I'd consider its implementation somewhere between "proof of concept" and "working draft", but it works. And its kinda cool :)

Out-of-the-box, I've provided the following Rankers:

  • Average - ranks objects by their avg score (vote sum / vote count) in descending fashion.

  • Bayesian - ranks with weighted consideration of actual worth: ``` If there is only few votes, then these votes should count less than when there are many votes and we can trust that this is how the public feels about it. In other texts this value is also refered to as “certainty” or “believability”.

  • Hacker News (modified) - a slightly modified (see docstring) version of the Hacker News algorithm.

To rank with a Ranker:

``` from rangevoting.rankers import AvgRanker

rank with the AvgRanker

ranked = VoteSummary.objects.rank(model=MyModel, ranker=AvgRanker) ```

ranked receives a list of ranked MyModel objects:

[<MyModel: ...>, <MyModel: ...>, ...]

As mentioned before, the ranking backend is still under construction. I'd love some input on it.

Note: The Hacker News algorithm relies on a MySQL function called 'unix_timestamp'. I know introduces incompatibilities -- in the future there'll be a work-around, but not right this second. In the meantime, subclass Ranker and have at your own version.

Status/Notes

This application was most definitely "released early". I provided a JSON view to store a Vote, but its definitely more perfunctory than anything else. Until otherwise noted in giant bold letters, consider the views something to write yourself.

Project Information

Labels:
django voting bayes ranking range rating