from django.db import models

from django.contrib.auth.models import User

import reversion

from markitup.fields import MarkupField

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")

        return self.label

    class Meta:

        verbose_name_plural = "boxes"

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.translation import ugettext_lazy as _

from markitup.fields import MarkupField

from .managers import PublishedPageManager

class Page(models.Model):

    STATUS_CHOICES = (

        (1, _("Draft")),

    tags = TaggableManager(blank=True)

    published = PublishedPageManager()

        return self.title

    @models.permalink

    def get_absolute_url(self):

from django.apps import AppConfig

class ConferenceConfig(AppConfig):

from django.db import models

from django.utils.translation import ugettext_lazy as _

from timezones.fields import TimeZoneField

CONFERENCE_CACHE = {}

class Conference(models.Model):

    """

    the full conference for a specific year, e.g. US PyCon 2012.

    """

    # timezone the conference is in

    timezone = TimeZoneField(_("timezone"), blank=True)

        return self.title

    def save(self, *args, **kwargs):

        super(Conference, self).save(*args, **kwargs)

        verbose_name = _("conference")

        verbose_name_plural = _("conferences")

class Section(models.Model):

    """

    a section of the conference such as "Tutorials", "Workshops",

    "Talks", "Expo", "Sprints", that may have its own review and

    # when the section runs

    start_date = models.DateField(_("start date"), null=True, blank=True)

    end_date = models.DateField(_("end date"), null=True, blank=True)

    class Meta(object):

        verbose_name = _("section")

        verbose_name_plural = _("sections")

from html5lib import html5parser, sanitizer

import markdown

import csv

from django.http import HttpResponse

from django.apps import AppConfig

class ProposalsConfig(AppConfig):

from django import forms

from django.db.models import Q

from symposion.proposals.models import SupportingDocument

import os

import uuid

from django.core.urlresolvers import reverse

from django.db import models

from django.db.models import Q

from django.utils.translation import ugettext_lazy as _

from django.utils.timezone import now

from django.contrib.auth.models import User

from symposion.conference.models import Section

from symposion.speakers.models import Speaker

class ProposalSection(models.Model):

    """

    configuration of proposal submissions for a specific Section.

        if self.end and self.end < now():

            return False

        return True

        return self.section.name

class ProposalKind(models.Model):

    """

    e.g. talk vs panel vs tutorial vs poster

    name = models.CharField(_("Name"), max_length=100)

    slug = models.SlugField()

        return self.name

class ProposalBase(models.Model):

    objects = InheritanceManager()

            "speakers": ', '.join([x.name for x in self.speakers()]),

            "kind": self.kind.name,

        }

reversion.register(ProposalBase)

class AdditionalSpeaker(models.Model):

    SPEAKING_STATUS_PENDING = 1

    SPEAKING_STATUS_ACCEPTED = 2

    class Meta:

        unique_together = ("speaker", "proposalbase")

        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

import hashlib

import random

import sys

from django.apps import AppConfig

class ReviewsConfig(AppConfig):

from django import forms

from markitup.widgets import MarkItUpWidget

# -*- coding: utf-8 -*-

from datetime import datetime

from decimal import Decimal

from django.db import models

class Votes(object):

    PLUS_ONE = "+1"

    PLUS_ZERO = "+0"

    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."),

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.

from django.contrib import admin

from symposion.schedule.models import Schedule, Day, Room, SlotKind, Slot, SlotRoom, Presentation, Session, SessionRole

from django.apps import AppConfig

class ScheduleConfig(AppConfig):

import csv

import time

from datetime import datetime

"""

This file contains functions that are useful to humans at the shell for

manipulating the database in more natural ways.

"""

from django.db import transaction

from .models import Schedule, Day, Room, Slot, SlotKind, SlotRoom

import datetime

from django.core.exceptions import ObjectDoesNotExist

from django.contrib.auth.models import User

from django.db import models

from markitup.fields import MarkupField

from symposion.proposals.models import ProposalBase

from symposion.conference.models import Section

from symposion.speakers.models import Speaker

class Schedule(models.Model):

    section = models.OneToOneField(Section)

    published = models.BooleanField(default=True)

    hidden = models.BooleanField("Hide schedule from overall conference view", default=False)

    class Meta:

        ordering = ["section"]

class Day(models.Model):

    schedule = models.ForeignKey(Schedule)

    date = models.DateField()

    class Meta:

        unique_together = [("schedule", "date")]

        ordering = ["date"]

class Room(models.Model):

    schedule = models.ForeignKey(Schedule)

    name = models.CharField(max_length=65)

    order = models.PositiveIntegerField()

        return self.name

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)

        return self.label

class Slot(models.Model):

    day = models.ForeignKey(Day)

    kind = models.ForeignKey(SlotKind)

    @property

    def rooms(self):

        return Room.objects.filter(pk__in=self.slotroom_set.values("room"))

        roomlist = ' '.join(map(lambda r: r.__unicode__(), self.rooms))

    class Meta:

        ordering = ["day", "start", "end"]

class SlotRoom(models.Model):

    """

    Links a slot with a room.

    """

    slot = models.ForeignKey(Slot)

    room = models.ForeignKey(Room)

    class Meta:

        unique_together = [("slot", "room")]

        ordering = ["slot", "room__order"]

class Presentation(models.Model):

    slot = models.OneToOneField(Slot, null=True, blank=True, related_name="content_ptr")

    title = models.CharField(max_length=100)

        for speaker in self.additional_speakers.all():

            if speaker.user:

                yield speaker

    class Meta:

        ordering = ["slot"]

class Session(models.Model):

    day = models.ForeignKey(Day, related_name="sessions")

    slots = models.ManyToManyField(Slot, related_name="sessions")

            return list(slots)[-1].end

        else:

            return None

        start = self.start()

        end = self.end()

        if start and end:

                self.day.date.strftime("%a"),

                start.strftime("%X"),

                end.strftime("%X")

            )

class SessionRole(models.Model):

    SESSION_ROLE_CHAIR = 1

    SESSION_ROLE_RUNNER = 2

    class Meta:

        unique_together = [("session", "user", "role")]

import itertools

from django.db.models import Count, Min

from django.conf.urls import url, patterns

urlpatterns = patterns(

import json

from django.core.urlresolvers import reverse

from django.http import Http404, HttpResponse

from django.contrib import admin

from symposion.speakers.models import Speaker

from django.apps import AppConfig

class SpeakersConfig(AppConfig):

from django import forms

from markitup.widgets import MarkItUpWidget

import datetime

from django.db import models

from django.core.urlresolvers import reverse

from markitup.fields import MarkupField

class Speaker(models.Model):

    SESSION_COUNT_CHOICES = [

        (1, "One"),

    class Meta:

        ordering = ['name']

        if self.user:

            return self.name

        else:

    def get_absolute_url(self):

        return reverse("speaker_edit")

from django.conf.urls import patterns, url

urlpatterns = patterns(

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 admin

from django.utils.html import escape

from django.utils.safestring import mark_safe

from django.utils.translation import ugettext_lazy as _

from django import forms

from django.forms.models import inlineformset_factory, BaseInlineFormSet

from django.contrib.admin.widgets import AdminFileWidget

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.translation import ugettext_lazy as _

from django.contrib.auth.models import User

from symposion.sponsorship.managers import SponsorManager

class SponsorLevel(models.Model):

    conference = models.ForeignKey(Conference, verbose_name=_("conference"))

    name = models.CharField(_("name"), max_length=100)

        ordering = ["conference", "order"]

        verbose_name = _("sponsor level")

        verbose_name_plural = _("sponsor levels")

        return self.name

    def sponsors(self):

        return self.sponsor_set.filter(active=True).order_by("added")

class Sponsor(models.Model):

    applicant = models.ForeignKey(User, related_name="sponsorships", verbose_name=_("applicant"),

                                  null=True)

                                     editable=False)

    objects = SponsorManager()

        return self.name

    class Meta:

        verbose_name = _("sponsor")

    ("listing_text_%s" % lang, "Listing Text (%s)" % label) for lang, label in settings.LANGUAGES

]

class Benefit(models.Model):

    name = models.CharField(_("name"), max_length=100)

    description = models.TextField(_("description"), blank=True)

                            max_length=10, default="simple")

    content_type = models.CharField(_("content type"), choices=CONTENT_TYPE_CHOICES,

                                    max_length=20, default="simple")

        return self.name

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"))

    class Meta:

        ordering = ["level"]

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"))

    class Meta:

        ordering = ["-active"]

    def clean(self):

        num_words = len(self.text.split())

        if self.max_words and num_words > self.max_words:

from cStringIO import StringIO

import itertools

import logging

import os

from django import forms

from django.utils.html import escape

from django.utils.safestring import mark_safe

import datetime

from django.db import models

import reversion

from django.contrib.auth.models import Permission, User

TEAM_ACCESS_CHOICES = [

    ("open", "open"),

    ("invitation", "by invitation")

]

class Team(models.Model):

    slug = models.SlugField(unique=True)

    name = models.CharField(max_length=100)

    @models.permalink

    def get_absolute_url(self):

        return ("team_detail", [self.slug])

        return self.name

    def get_state_for_user(self, user):

        try:

from django.http import Http404, HttpResponseNotAllowed

from django.shortcuts import render, redirect, get_object_or_404

from django.contrib.auth.decorators import login_required

import hashlib

import random

from django.shortcuts import render, redirect