symposion_app Changeset - ffd428d49720

Changeset - ffd428d49720

Parent rev.

Child rev.

[Not reviewed]

Merge

0 37 0

Patrick Altman - 9 years ago 2015-09-08 19:55:49
paltman@gmail.com

Merge pull request #100 from miurahr/python3_compatibility

python3 compatibility

36 files changed with 110 insertions and 38 deletions:

symposion/boxes/models.py

symposion/cms/models.py

symposion/conference/apps.py

symposion/conference/models.py

symposion/markdown_parser.py

symposion/proposals/actions.py

symposion/proposals/apps.py

symposion/proposals/forms.py

symposion/proposals/models.py

symposion/proposals/views.py

symposion/reviews/apps.py

symposion/reviews/forms.py

symposion/reviews/models.py

symposion/reviews/utils.py

symposion/schedule/admin.py

symposion/schedule/apps.py

symposion/schedule/forms.py

symposion/schedule/helpers.py

symposion/schedule/models.py

symposion/schedule/timetable.py

symposion/schedule/urls.py

symposion/schedule/views.py

symposion/speakers/admin.py

symposion/speakers/apps.py

symposion/speakers/forms.py

symposion/speakers/models.py

symposion/speakers/urls.py

symposion/speakers/views.py

symposion/sponsorship/admin.py

symposion/sponsorship/forms.py

symposion/sponsorship/models.py

symposion/sponsorship/views.py

symposion/teams/forms.py

symposion/teams/models.py

symposion/teams/views.py

symposion/views.py

0 comments (0 inline, 0 general)

symposion/boxes/models.py

➞

Show inline comments

 from __future__ import unicode_literals
 from django.db import models
 from django.contrib.auth.models import User
 from django.utils.encoding import python_2_unicode_compatible
 import reversion
 from markitup.fields import MarkupField
 @python_2_unicode_compatible
 class Box(models.Model):
     label = models.CharField(max_length=100, db_index=True)
     content = MarkupField(blank=True)
     created_by = models.ForeignKey(User, related_name="boxes")
     last_updated_by = models.ForeignKey(User, related_name="updated_boxes")
-    def __unicode__(self):
+    def __str__(self):
         return self.label
     class Meta:
         verbose_name_plural = "boxes"
 reversion.register(Box)

symposion/cms/models.py

➞

Show inline comments

 import datetime
 import os
 import re
 from django.conf import settings
 from django.core.urlresolvers import reverse
 from django.core.exceptions import ValidationError
 from django.db import models
 from django.utils.encoding import python_2_unicode_compatible
 from django.utils.translation import ugettext_lazy as _
 from markitup.fields import MarkupField
 from taggit.managers import TaggableManager
 import reversion
 from .managers import PublishedPageManager
 @python_2_unicode_compatible
 class Page(models.Model):
     STATUS_CHOICES = (
         (1, _("Draft")),
         (2, _("Public")),
+    )
     title = models.CharField(max_length=100)
     path = models.CharField(max_length=100, unique=True)
     body = MarkupField()
     status = models.IntegerField(choices=STATUS_CHOICES, default=2)
     publish_date = models.DateTimeField(default=datetime.datetime.now)
     created = models.DateTimeField(editable=False, default=datetime.datetime.now)
     updated = models.DateTimeField(editable=False, default=datetime.datetime.now)
     tags = TaggableManager(blank=True)
     published = PublishedPageManager()
-    def __unicode__(self):
+    def __str__(self):
         return self.title
     @models.permalink
     def get_absolute_url(self):
         return ("cms_page", [self.path])
     @property
     def is_community(self):
         return self.path.lower().startswith("community/")
     def save(self, *args, **kwargs):
         self.updated = datetime.datetime.now()

symposion/conference/apps.py

➞

Show inline comments

 from __future__ import unicode_literals
 from django.apps import AppConfig
 class ConferenceConfig(AppConfig):
     name = "symposion.conference"
     label = "symposion_conference"
     verbose_name = "Symposion Conference"

symposion/conference/models.py

➞

Show inline comments

 from __future__ import unicode_literals
 from django.db import models
 from django.utils.translation import ugettext_lazy as _
 from django.utils.encoding import python_2_unicode_compatible
 from timezones.fields import TimeZoneField
 CONFERENCE_CACHE = {}
 @python_2_unicode_compatible
 class Conference(models.Model):
     """
     the full conference for a specific year, e.g. US PyCon 2012.
     """
     title = models.CharField(_("title"), max_length=100)
     # when the conference runs
     start_date = models.DateField(_("start date"), null=True, blank=True)
     end_date = models.DateField(_("end date"), null=True, blank=True)
     # timezone the conference is in
     timezone = TimeZoneField(_("timezone"), blank=True)
-    def __unicode__(self):
+    def __str__(self):
         return self.title
     def save(self, *args, **kwargs):
         super(Conference, self).save(*args, **kwargs)
         if self.id in CONFERENCE_CACHE:
             del CONFERENCE_CACHE[self.id]
     def delete(self):
         pk = self.pk
         super(Conference, self).delete()
         try:
             del CONFERENCE_CACHE[pk]
         except KeyError:
             pass
     class Meta(object):
         verbose_name = _("conference")
         verbose_name_plural = _("conferences")
 @python_2_unicode_compatible
 class Section(models.Model):
     """
     a section of the conference such as "Tutorials", "Workshops",
     "Talks", "Expo", "Sprints", that may have its own review and
     scheduling process.
     """
     conference = models.ForeignKey(Conference, verbose_name=_("conference"))
     name = models.CharField(_("name"), max_length=100)
     slug = models.SlugField()
     # when the section runs
     start_date = models.DateField(_("start date"), null=True, blank=True)
     end_date = models.DateField(_("end date"), null=True, blank=True)
     def __unicode__(self):
         return u"%s %s" % (self.conference, self.name)
     def __str__(self):
         return "%s %s" % (self.conference, self.name)
     class Meta(object):
         verbose_name = _("section")
         verbose_name_plural = _("sections")
         ordering = ["start_date"]
 def current_conference():
     from django.conf import settings
     try:
         conf_id = settings.CONFERENCE_ID
     except AttributeError:

symposion/markdown_parser.py

➞

Show inline comments

 from __future__ import unicode_literals
 from html5lib import html5parser, sanitizer
 import markdown
 def parse(text):
     # First run through the Markdown parser
     text = markdown.markdown(text, extensions=["extra"], safe_mode=False)
     # Sanitize using html5lib
     bits = []

symposion/proposals/actions.py

➞

Show inline comments

 from __future__ import unicode_literals
 import csv
 from django.http import HttpResponse
 def export_as_csv_action(description="Export selected objects as CSV file",
                          fields=None, exclude=None, header=True):
     """
     This function returns an export csv action
     'fields' and 'exclude' work like in Django ModelForm
     'header' is whether or not to output the column names as the first row
     """

symposion/proposals/apps.py

➞

Show inline comments

 from __future__ import unicode_literals
 from django.apps import AppConfig
 class ProposalsConfig(AppConfig):
     name = "symposion.proposals"
     label = "symposion_proposals"
     verbose_name = "Symposion Proposals"

symposion/proposals/forms.py

➞

Show inline comments

 from __future__ import unicode_literals
 from django import forms
 from django.db.models import Q
 from symposion.proposals.models import SupportingDocument
 # from markitup.widgets import MarkItUpWidget
 # @@@ generic proposal form
 class AddSpeakerForm(forms.Form):

symposion/proposals/models.py

➞

Show inline comments

 from __future__ import unicode_literals
 import os
 import uuid
 from django.core.urlresolvers import reverse
 from django.db import models
 from django.db.models import Q
 from django.utils.encoding import python_2_unicode_compatible
 from django.utils.translation import ugettext_lazy as _
 from django.utils.timezone import now
 from django.contrib.auth.models import User
 from django.core.exceptions import ObjectDoesNotExist
 from django.core.exceptions import ValidationError
 import reversion
 from markitup.fields import MarkupField
 from model_utils.managers import InheritanceManager
 from symposion.conference.models import Section
 from symposion.speakers.models import Speaker
 @python_2_unicode_compatible
 class ProposalSection(models.Model):
     """
     configuration of proposal submissions for a specific Section.
     a section is available for proposals iff:
       * it is after start (if there is one) and
       * it is before end (if there is one) and
       * closed is NULL or False
     """
     section = models.OneToOneField(Section)
@@ ... / @@ -46,45 +49,47 @@ class ProposalSection(models.Model): @@
             Q(closed=False) | Q(closed=None),
+        )
     def is_available(self):
         if self.closed:
             return False
         if self.start and self.start > now():
             return False
         if self.end and self.end < now():
             return False
         return True
-    def __unicode__(self):
+    def __str__(self):
         return self.section.name
 @python_2_unicode_compatible
 class ProposalKind(models.Model):
     """
     e.g. talk vs panel vs tutorial vs poster
     Note that if you have different deadlines, reviewers, etc. you'll want
     to distinguish the section as well as the kind.
     """
     section = models.ForeignKey(Section, related_name="proposal_kinds")
     name = models.CharField(_("Name"), max_length=100)
     slug = models.SlugField()
-    def __unicode__(self):
+    def __str__(self):
         return self.name
 @python_2_unicode_compatible
 class ProposalBase(models.Model):
     objects = InheritanceManager()
     kind = models.ForeignKey(ProposalKind)
     title = models.CharField(max_length=100)
     description = models.TextField(
         _("Brief Description"),
         max_length=400,  # @@@ need to enforce 400 in UI
         help_text=_("If your proposal is accepted this will be made public and printed in the "
                     "program. Should be one paragraph, maximum 400 characters.")
@@ ... / @@ -146,47 +151,51 @@ class ProposalBase(models.Model): @@
             additionalspeaker__status=AdditionalSpeaker.SPEAKING_STATUS_DECLINED)
         for speaker in speakers:
             yield speaker
     def notification_email_context(self):
         return {
             "title": self.title,
             "speaker": self.speaker.name,
             "speakers": ', '.join([x.name for x in self.speakers()]),
             "kind": self.kind.name,
+        }
     def __str__(self):
         return self.title
 reversion.register(ProposalBase)
 @python_2_unicode_compatible
 class AdditionalSpeaker(models.Model):
     SPEAKING_STATUS_PENDING = 1
     SPEAKING_STATUS_ACCEPTED = 2
     SPEAKING_STATUS_DECLINED = 3
     SPEAKING_STATUS = [
         (SPEAKING_STATUS_PENDING, _("Pending")),
         (SPEAKING_STATUS_ACCEPTED, _("Accepted")),
         (SPEAKING_STATUS_DECLINED, _("Declined")),
+    ]
     speaker = models.ForeignKey(Speaker)
     proposalbase = models.ForeignKey(ProposalBase)
     status = models.IntegerField(choices=SPEAKING_STATUS, default=SPEAKING_STATUS_PENDING)
     class Meta:
         unique_together = ("speaker", "proposalbase")
-    def __unicode__(self):
+    def __str__(self):
         if self.status is self.SPEAKING_STATUS_PENDING:
             return _(u"pending speaker (%s)") % self.speaker.email
         elif self.status is self.SPEAKING_STATUS_DECLINED:
             return _(u"declined speaker (%s)") % self.speaker.email
         else:
             return self.speaker.name
 def uuid_filename(instance, filename):
     ext = filename.split(".")[-1]
     filename = "%s.%s" % (uuid.uuid4(), ext)
     return os.path.join("document", filename)

symposion/proposals/views.py

➞

Show inline comments

 from __future__ import unicode_literals
 import hashlib
 import random
 import sys
 from django.conf import settings
 from django.core.exceptions import ObjectDoesNotExist
 from django.core.urlresolvers import reverse
 from django.db.models import Q
 from django.http import Http404, HttpResponse, HttpResponseForbidden
 from django.shortcuts import render, redirect, get_object_or_404
 from django.views import static

symposion/reviews/apps.py

➞

Show inline comments

 from __future__ import unicode_literals
 from django.apps import AppConfig
 class ReviewsConfig(AppConfig):
     name = "symposion.reviews"
     label = "symposion_reviews"
     verbose_name = "Symposion Reviews"

symposion/reviews/forms.py

➞

Show inline comments

 from __future__ import unicode_literals
 from django import forms
 from markitup.widgets import MarkItUpWidget
 from symposion.reviews.models import Review, Comment, ProposalMessage, VOTES
 class ReviewForm(forms.ModelForm):
     class Meta:
         model = Review
         fields = ["vote", "comment"]
         widgets = {"comment": MarkItUpWidget()}

symposion/reviews/models.py

➞

Show inline comments

 # -*- coding: utf-8 -*-
 from __future__ import unicode_literals
 from datetime import datetime
 from decimal import Decimal
 from django.db import models
 from django.db.models import Q
 from django.db.models.signals import post_save
 from django.contrib.auth.models import User
 from markitup.fields import MarkupField
 from symposion.proposals.models import ProposalBase
@@ ... / @@ -18,26 +19,26 @@ class ProposalScoreExpression(object): @@
     def as_sql(self, qn, connection=None):
         sql = "((3 * plus_one + plus_zero) - (minus_zero + 3 * minus_one))"
         return sql, []
     def prepare_database_save(self, unused):
         return self
 class Votes(object):
     PLUS_ONE = "+1"
     PLUS_ZERO = "+0"
     MINUS_ZERO = u"−0"
     MINUS_ONE = u"−1"
     MINUS_ZERO = "−0"
     MINUS_ONE = "−1"
     CHOICES = [
         (PLUS_ONE, u"+1 — Good proposal and I will argue for it to be accepted."),
         (PLUS_ZERO, u"+0 — OK proposal, but I will not argue for it to be accepted."),
         (MINUS_ZERO, u"−0 — Weak proposal, but I will not argue strongly against acceptance."),
         (MINUS_ONE, u"−1 — Serious issues and I will argue to reject this proposal."),
+    ]
 VOTES = Votes()
 class ReviewAssignment(models.Model):
     AUTO_ASSIGNED_INITIAL = 0

symposion/reviews/utils.py

➞

Show inline comments

 from __future__ import unicode_literals
 def has_permission(user, proposal, speaker=False, reviewer=False):
     """
     Returns whether or not ther user has permission to review this proposal,
     with the specified requirements.
     If ``speaker`` is ``True`` then the user can be one of the speakers for the
     proposal.  If ``reviewer`` is ``True`` the speaker can be a part of the
     reviewer group.
     """
     if user.is_superuser:
         return True
     if speaker:

symposion/schedule/admin.py

➞

Show inline comments

 from __future__ import unicode_literals
 from django.contrib import admin
 from symposion.schedule.models import Schedule, Day, Room, SlotKind, Slot, SlotRoom, Presentation, Session, SessionRole
 class DayInline(admin.StackedInline):
     model = Day
     extra = 2
 class SlotKindInline(admin.StackedInline):
     model = SlotKind

symposion/schedule/apps.py

➞

Show inline comments

 from __future__ import unicode_literals
 from django.apps import AppConfig
 class ScheduleConfig(AppConfig):
     name = "symposion.schedule"
     label = "symposion_schedule"
     verbose_name = "Symposion Schedule"

symposion/schedule/forms.py

➞

Show inline comments

 from __future__ import unicode_literals
 import csv
 import time
 from datetime import datetime
 from django import forms
 from django.contrib import messages
 from django.db import IntegrityError, transaction
 from django.db.models import Q
 from markitup.widgets import MarkItUpWidget

symposion/schedule/helpers.py

➞

Show inline comments

 """
 This file contains functions that are useful to humans at the shell for
 manipulating the database in more natural ways.
 """
 from __future__ import unicode_literals
 from django.db import transaction
 from .models import Schedule, Day, Room, Slot, SlotKind, SlotRoom
 @transaction.commit_on_success
 def create_slot(section_slug, date, kind, start, end, rooms):
     schedule = Schedule.objects.get(section__slug=section_slug)
     slot = Slot()
     slot.day = Day.objects.get(schedule=schedule, date=date)
     slot.kind = SlotKind.objects.get(schedule=schedule, label=kind)
     slot.start = start

symposion/schedule/models.py

➞

Show inline comments

 from __future__ import unicode_literals
 import datetime
 from django.core.exceptions import ObjectDoesNotExist
 from django.contrib.auth.models import User
 from django.db import models
 from django.utils.encoding import python_2_unicode_compatible
 from markitup.fields import MarkupField
 from symposion.proposals.models import ProposalBase
 from symposion.conference.models import Section
 from symposion.speakers.models import Speaker
 @python_2_unicode_compatible
 class Schedule(models.Model):
     section = models.OneToOneField(Section)
     published = models.BooleanField(default=True)
     hidden = models.BooleanField("Hide schedule from overall conference view", default=False)
     def __unicode__(self):
         return u"%s Schedule" % self.section
     def __str__(self):
         return "%s Schedule" % self.section
     class Meta:
         ordering = ["section"]
 @python_2_unicode_compatible
 class Day(models.Model):
     schedule = models.ForeignKey(Schedule)
     date = models.DateField()
     def __unicode__(self):
         return u"%s" % self.date
     def __str__(self):
         return "%s" % self.date
     class Meta:
         unique_together = [("schedule", "date")]
         ordering = ["date"]
 @python_2_unicode_compatible
 class Room(models.Model):
     schedule = models.ForeignKey(Schedule)
     name = models.CharField(max_length=65)
     order = models.PositiveIntegerField()
-    def __unicode__(self):
+    def __str__(self):
         return self.name
 @python_2_unicode_compatible
 class SlotKind(models.Model):
     """
     A slot kind represents what kind a slot is. For example, a slot can be a
     break, lunch, or X-minute talk.
     """
     schedule = models.ForeignKey(Schedule)
     label = models.CharField(max_length=50)
-    def __unicode__(self):
+    def __str__(self):
         return self.label
 @python_2_unicode_compatible
 class Slot(models.Model):
     day = models.ForeignKey(Day)
     kind = models.ForeignKey(SlotKind)
     start = models.TimeField()
     end = models.TimeField()
     content_override = MarkupField(blank=True)
     def assign(self, content):
         """
         Assign the given content to this slot and if a previous slot content
         was given we need to unlink it to avoid integrity errors.
@@ ... / @@ -115,48 +122,50 @@ class Slot(models.Model): @@
             self.end.hour,
             self.end.minute)
     @property
     def length_in_minutes(self):
         return int(
             (self.end_datetime - self.start_datetime).total_seconds() / 60)
     @property
     def rooms(self):
         return Room.objects.filter(pk__in=self.slotroom_set.values("room"))
-    def __unicode__(self):
+    def __str__(self):
         roomlist = ' '.join(map(lambda r: r.__unicode__(), self.rooms))
-        return u"%s %s (%s - %s) %s" % (self.day, self.kind, self.start, self.end, roomlist)
         return "%s %s (%s - %s) %s" % (self.day, self.kind, self.start, self.end, roomlist)
     class Meta:
         ordering = ["day", "start", "end"]
 @python_2_unicode_compatible
 class SlotRoom(models.Model):
     """
     Links a slot with a room.
     """
     slot = models.ForeignKey(Slot)
     room = models.ForeignKey(Room)
     def __unicode__(self):
         return u"%s %s" % (self.room, self.slot)
     def __str__(self):
         return "%s %s" % (self.room, self.slot)
     class Meta:
         unique_together = [("slot", "room")]
         ordering = ["slot", "room__order"]
 @python_2_unicode_compatible
 class Presentation(models.Model):
     slot = models.OneToOneField(Slot, null=True, blank=True, related_name="content_ptr")
     title = models.CharField(max_length=100)
     description = MarkupField()
     abstract = MarkupField()
     speaker = models.ForeignKey(Speaker, related_name="presentations")
     additional_speakers = models.ManyToManyField(Speaker, related_name="copresentations",
                                                  blank=True)
     cancelled = models.BooleanField(default=False)
     proposal_base = models.OneToOneField(ProposalBase, related_name="presentation")
     section = models.ForeignKey(Section, related_name="presentations")
@@ ... / @@ -168,76 +177,78 @@ class Presentation(models.Model): @@
     @property
     def proposal(self):
         if self.proposal_base_id is None:
             return None
         return ProposalBase.objects.get_subclass(pk=self.proposal_base_id)
     def speakers(self):
         yield self.speaker
         for speaker in self.additional_speakers.all():
             if speaker.user:
                 yield speaker
     def __unicode__(self):
         return u"#%s %s (%s)" % (self.number, self.title, self.speaker)
     def __str__(self):
         return "#%s %s (%s)" % (self.number, self.title, self.speaker)
     class Meta:
         ordering = ["slot"]
 @python_2_unicode_compatible
 class Session(models.Model):
     day = models.ForeignKey(Day, related_name="sessions")
     slots = models.ManyToManyField(Slot, related_name="sessions")
     def sorted_slots(self):
         return self.slots.order_by("start")
     def start(self):
         slots = self.sorted_slots()
         if slots:
             return list(slots)[0].start
         else:
             return None
     def end(self):
         slots = self.sorted_slots()
         if slots:
             return list(slots)[-1].end
         else:
             return None
-    def __unicode__(self):
+    def __str__(self):
         start = self.start()
         end = self.end()
         if start and end:
-            return u"%s: %s - %s" % (
             return "%s: %s - %s" % (
                 self.day.date.strftime("%a"),
                 start.strftime("%X"),
                 end.strftime("%X")
+            )
-        return u""
         return ""
 @python_2_unicode_compatible
 class SessionRole(models.Model):
     SESSION_ROLE_CHAIR = 1
     SESSION_ROLE_RUNNER = 2
     SESSION_ROLE_TYPES = [
         (SESSION_ROLE_CHAIR, "Session Chair"),
         (SESSION_ROLE_RUNNER, "Session Runner"),
+    ]
     session = models.ForeignKey(Session)
     user = models.ForeignKey(User)
     role = models.IntegerField(choices=SESSION_ROLE_TYPES)
     status = models.NullBooleanField()
     submitted = models.DateTimeField(default=datetime.datetime.now)
     class Meta:
         unique_together = [("session", "user", "role")]
     def __unicode__(self):
         return u"%s %s: %s" % (self.user, self.session,
                                self.SESSION_ROLE_TYPES[self.role - 1][1])
     def __str__(self):
         return "%s %s: %s" % (self.user, self.session,
                               self.SESSION_ROLE_TYPES[self.role - 1][1])

symposion/schedule/timetable.py

➞

Show inline comments

 from __future__ import unicode_literals
 import itertools
 from django.db.models import Count, Min
 from symposion.schedule.models import Room, Slot, SlotRoom
 class TimeTable(object):
     def __init__(self, day):
         self.day = day

symposion/schedule/urls.py

➞

Show inline comments

 from __future__ import unicode_literals
 from django.conf.urls import url, patterns
 urlpatterns = patterns(
     "symposion.schedule.views",
     url(r"^$", "schedule_conference", name="schedule_conference"),
     url(r"^edit/$", "schedule_edit", name="schedule_edit"),
     url(r"^list/$", "schedule_list", name="schedule_list"),
     url(r"^presentations.csv$", "schedule_list_csv", name="schedule_list_csv"),
     url(r"^presentation/(\d+)/$", "schedule_presentation_detail",
         name="schedule_presentation_detail"),
     url(r"^([\w\-]+)/$", "schedule_detail", name="schedule_detail"),

symposion/schedule/views.py

➞

Show inline comments

 from __future__ import unicode_literals
 import json
 from django.core.urlresolvers import reverse
 from django.http import Http404, HttpResponse
 from django.shortcuts import render, get_object_or_404, redirect
 from django.template import loader, Context
 from django.contrib.auth.decorators import login_required
 from django.contrib.auth.models import User
 from django.contrib import messages
 from django.contrib.sites.models import Site

symposion/speakers/admin.py

➞

Show inline comments

 from __future__ import unicode_literals
 from django.contrib import admin
 from symposion.speakers.models import Speaker
 admin.site.register(Speaker,
                     list_display=["name", "email", "created"],
                     search_fields=["name"])

symposion/speakers/apps.py

➞

Show inline comments

 from __future__ import unicode_literals
 from django.apps import AppConfig
 class SpeakersConfig(AppConfig):
     name = "symposion.speakers"
     label = "symposion_speakers"
     verbose_name = "Symposion Speakers"

symposion/speakers/forms.py

➞

Show inline comments

 from __future__ import unicode_literals
 from django import forms
 from markitup.widgets import MarkItUpWidget
 from symposion.speakers.models import Speaker
 class SpeakerForm(forms.ModelForm):
     class Meta:
         model = Speaker
         fields = [

symposion/speakers/models.py

➞

Show inline comments

 from __future__ import unicode_literals
 import datetime
 from django.utils.encoding import python_2_unicode_compatible
 from django.db import models
 from django.core.urlresolvers import reverse
 from django.contrib.auth.models import User
 from markitup.fields import MarkupField
 @python_2_unicode_compatible
 class Speaker(models.Model):
     SESSION_COUNT_CHOICES = [
         (1, "One"),
         (2, "Two")
+    ]
     user = models.OneToOneField(User, null=True, related_name="speaker_profile")
     name = models.CharField(max_length=100, help_text=("As you would like it to appear in the "
                                                        "conference program."))
     biography = MarkupField(blank=True, help_text=("A little bit about you.  Edit using "
                                                    "<a href='http://warpedvisions.org/projects/"
@@ ... / @@ -25,29 +28,29 @@ class Speaker(models.Model): @@
     photo = models.ImageField(upload_to="speaker_photos", blank=True)
     annotation = models.TextField()  # staff only
     invite_email = models.CharField(max_length=200, unique=True, null=True, db_index=True)
     invite_token = models.CharField(max_length=40, db_index=True)
     created = models.DateTimeField(
         default=datetime.datetime.now,
         editable=False
+    )
     class Meta:
         ordering = ['name']
-    def __unicode__(self):
+    def __str__(self):
         if self.user:
             return self.name
         else:
-            return u"?"
             return "?"
     def get_absolute_url(self):
         return reverse("speaker_edit")
     @property
     def email(self):
         if self.user is not None:
             return self.user.email
         else:
             return self.invite_email
     @property

symposion/speakers/urls.py

➞

Show inline comments

 from __future__ import unicode_literals
 from django.conf.urls import patterns, url
 urlpatterns = patterns(
     "symposion.speakers.views",
     url(r"^create/$", "speaker_create", name="speaker_create"),
     url(r"^create/(\w+)/$", "speaker_create_token",
         name="speaker_create_token"),
     url(r"^edit/(?:(?P<pk>\d+)/)?$", "speaker_edit", name="speaker_edit"),
     url(r"^profile/(?P<pk>\d+)/$", "speaker_profile", name="speaker_profile"),
     url(r"^staff/create/(\d+)/$", "speaker_create_staff",
         name="speaker_create_staff"),

symposion/speakers/views.py

➞

Show inline comments

 from __future__ import unicode_literals
 from django.core.exceptions import ObjectDoesNotExist
 from django.http import Http404
 from django.shortcuts import render, redirect, get_object_or_404
 from django.contrib import messages
 from django.contrib.auth.decorators import login_required
 from django.contrib.auth.models import User
 from symposion.proposals.models import ProposalBase
 from symposion.speakers.forms import SpeakerForm
 from symposion.speakers.models import Speaker

symposion/sponsorship/admin.py

➞

Show inline comments

 from __future__ import unicode_literals
 from django.contrib import admin
 from django.utils.html import escape
 from django.utils.safestring import mark_safe
 from django.utils.translation import ugettext_lazy as _
 from symposion.sponsorship.models import SponsorLevel, Sponsor, Benefit, BenefitLevel, \
     SponsorBenefit
 class BenefitLevelInline(admin.TabularInline):
     model = BenefitLevel
     extra = 0

symposion/sponsorship/forms.py

➞

Show inline comments

 from __future__ import unicode_literals
 from django import forms
 from django.forms.models import inlineformset_factory, BaseInlineFormSet
 from django.contrib.admin.widgets import AdminFileWidget
 from symposion.sponsorship.models import Sponsor, SponsorBenefit
 class SponsorApplicationForm(forms.ModelForm):
     def __init__(self, *args, **kwargs):
         self.user = kwargs.pop("user")
         kwargs.update({

symposion/sponsorship/models.py

➞

Show inline comments

 from __future__ import unicode_literals
 import datetime
 from django.conf import settings
 from django.core.exceptions import ValidationError
 from django.core.urlresolvers import reverse
 from django.db import models
 from django.db.models.signals import post_init, post_save
 from django.utils.encoding import python_2_unicode_compatible
 from django.utils.translation import ugettext_lazy as _
 from django.contrib.auth.models import User
 from symposion.conference.models import Conference
 from symposion.sponsorship.managers import SponsorManager
 @python_2_unicode_compatible
 class SponsorLevel(models.Model):
     conference = models.ForeignKey(Conference, verbose_name=_("conference"))
     name = models.CharField(_("name"), max_length=100)
     order = models.IntegerField(_("order"), default=0)
     cost = models.PositiveIntegerField(_("cost"))
     description = models.TextField(_("description"), blank=True, help_text=_("This is private."))
     class Meta:
         ordering = ["conference", "order"]
         verbose_name = _("sponsor level")
         verbose_name_plural = _("sponsor levels")
-    def __unicode__(self):
+    def __str__(self):
         return self.name
     def sponsors(self):
         return self.sponsor_set.filter(active=True).order_by("added")
 @python_2_unicode_compatible
 class Sponsor(models.Model):
     applicant = models.ForeignKey(User, related_name="sponsorships", verbose_name=_("applicant"),
                                   null=True)
     name = models.CharField(_("Sponsor Name"), max_length=100)
     display_url = models.URLField(_("display URL"), blank=True)
     external_url = models.URLField(_("external URL"))
     annotation = models.TextField(_("annotation"), blank=True)
     contact_name = models.CharField(_("Contact Name"), max_length=100)
     contact_email = models.EmailField(_(u"Contact Email"))
     level = models.ForeignKey(SponsorLevel, verbose_name=_("level"))
     added = models.DateTimeField(_("added"), default=datetime.datetime.now)
     active = models.BooleanField(_("active"), default=False)
     # Denormalization (this assumes only one logo)
     sponsor_logo = models.ForeignKey("SponsorBenefit", related_name="+", null=True, blank=True,
                                      editable=False)
     objects = SponsorManager()
-    def __unicode__(self):
+    def __str__(self):
         return self.name
     class Meta:
         verbose_name = _("sponsor")
         verbose_name_plural = _("sponsors")
     def get_absolute_url(self):
         if self.active:
             return reverse("sponsor_detail", kwargs={"pk": self.pk})
         return reverse("sponsor_list")
     def get_display_url(self):
@@ ... / @@ -157,73 +161,76 @@ BENEFIT_TYPE_CHOICES = [ @@
     ("weblogo", "Web Logo"),
     ("simple", "Simple"),
     ("option", "Option")
+]
 CONTENT_TYPE_CHOICES = [
     ("simple", "Simple"),
 ] + [
     ("listing_text_%s" % lang, "Listing Text (%s)" % label) for lang, label in settings.LANGUAGES
+]
 @python_2_unicode_compatible
 class Benefit(models.Model):
     name = models.CharField(_("name"), max_length=100)
     description = models.TextField(_("description"), blank=True)
     type = models.CharField(_("type"), choices=BENEFIT_TYPE_CHOICES,
                             max_length=10, default="simple")
     content_type = models.CharField(_("content type"), choices=CONTENT_TYPE_CHOICES,
                                     max_length=20, default="simple")
-    def __unicode__(self):
+    def __str__(self):
         return self.name
 @python_2_unicode_compatible
 class BenefitLevel(models.Model):
     benefit = models.ForeignKey(Benefit, related_name="benefit_levels", verbose_name=_("benefit"))
     level = models.ForeignKey(SponsorLevel, related_name="benefit_levels", verbose_name=_("level"))
     # default limits for this benefit at given level
     max_words = models.PositiveIntegerField(_("max words"), blank=True, null=True)
     other_limits = models.CharField(_("other limits"), max_length=200, blank=True)
     class Meta:
         ordering = ["level"]
     def __unicode__(self):
         return u"%s - %s" % (self.level, self.benefit)
     def __str__(self):
         return "%s - %s" % (self.level, self.benefit)
 @python_2_unicode_compatible
 class SponsorBenefit(models.Model):
     sponsor = models.ForeignKey(Sponsor, related_name="sponsor_benefits", verbose_name=_("sponsor"))
     benefit = models.ForeignKey(Benefit, related_name="sponsor_benefits", verbose_name=_("benefit"))
     active = models.BooleanField(default=True)
     # Limits: will initially be set to defaults from corresponding BenefitLevel
     max_words = models.PositiveIntegerField(_("max words"), blank=True, null=True)
     other_limits = models.CharField(_("other limits"), max_length=200, blank=True)
     # Data: zero or one of these fields will be used, depending on the
     # type of the Benefit (text, file, or simple)
     text = models.TextField(_("text"), blank=True)
     upload = models.FileField(_("file"), blank=True, upload_to="sponsor_files")
     class Meta:
         ordering = ["-active"]
     def __unicode__(self):
         return u"%s - %s" % (self.sponsor, self.benefit)
     def __str__(self):
         return "%s - %s" % (self.sponsor, self.benefit)
     def clean(self):
         num_words = len(self.text.split())
         if self.max_words and num_words > self.max_words:
             raise ValidationError(
                 "Sponsorship level only allows for %s words, you provided %d." % (
                     self.max_words, num_words))
     def data_fields(self):
         """
         Return list of data field names which should be editable for
         this ``SponsorBenefit``, depending on its ``Benefit`` type.

symposion/sponsorship/views.py

➞

Show inline comments

 from __future__ import unicode_literals
 from cStringIO import StringIO
 import itertools
 import logging
 import os
 import time
 from zipfile import ZipFile, ZipInfo
 from django.conf import settings
 from django.http import Http404, HttpResponse
 from django.shortcuts import render_to_response, redirect, get_object_or_404
 from django.template import RequestContext

symposion/teams/forms.py

➞

Show inline comments

 from __future__ import unicode_literals
 from django import forms
 from django.utils.html import escape
 from django.utils.safestring import mark_safe
 from django.contrib.auth.models import User
 from symposion.teams.models import Membership
 class TeamInvitationForm(forms.Form):

symposion/teams/models.py

➞

Show inline comments

 from __future__ import unicode_literals
 import datetime
 from django.db import models
 import reversion
 from django.contrib.auth.models import Permission, User
 from django.utils.encoding import python_2_unicode_compatible
 TEAM_ACCESS_CHOICES = [
     ("open", "open"),
     ("application", "by application"),
     ("invitation", "by invitation")
+]
 @python_2_unicode_compatible
 class Team(models.Model):
     slug = models.SlugField(unique=True)
     name = models.CharField(max_length=100)
     description = models.TextField(blank=True)
     access = models.CharField(max_length=20, choices=TEAM_ACCESS_CHOICES)
     # member permissions
     permissions = models.ManyToManyField(Permission, blank=True, related_name="member_teams")
     # manager permissions
     manager_permissions = models.ManyToManyField(Permission, blank=True,
                                                  related_name="manager_teams")
     created = models.DateTimeField(default=datetime.datetime.now, editable=False)
     @models.permalink
     def get_absolute_url(self):
         return ("team_detail", [self.slug])
-    def __unicode__(self):
+    def __str__(self):
         return self.name
     def get_state_for_user(self, user):
         try:
             return self.memberships.get(user=user).state
         except Membership.DoesNotExist:
             return None
     def applicants(self):
         return self.memberships.filter(state="applied")
     def invitees(self):

symposion/teams/views.py

➞

Show inline comments

 from __future__ import unicode_literals
 from django.http import Http404, HttpResponseNotAllowed
 from django.shortcuts import render, redirect, get_object_or_404
 from django.contrib.auth.decorators import login_required
 from django.contrib import messages
 from symposion.utils.mail import send_email
 from symposion.teams.forms import TeamInvitationForm
 from symposion.teams.models import Team, Membership

symposion/views.py

➞

Show inline comments

 from __future__ import unicode_literals
 import hashlib
 import random
 from django.shortcuts import render, redirect
 from django.contrib.auth.models import User
 from django.contrib.auth.decorators import login_required
 import account.views
 import symposion.forms

0 comments (0 inline, 0 general)