Content system

Proposals

Proposals deal exclusively with content which is submitted via the Call for Participation for inclusion in the official schedule.

Some proposals are handled through an anonymous review system, where they are anonymised and sent to a review panel to vote on.

class models.content.cfp.Proposal(**kwargs)

A proposal for content submitted to us through the Call for Participation.

Proposals can be reviewed manually or through the anonymous review system. If a proposal is accepted, a ScheduleItem is created.

type: Mapped[Literal['talk', 'performance', 'workshop', 'familyworkshop', 'installation']]

The type of the proposal. This controls how the proposal is handled.

state: Mapped[Literal['new', 'edit', 'checked', 'rejected', 'anonymised', 'anon-blocked', 'manual-review', 'accepted', 'finalised', 'withdrawn', 'conduct-blocked']]

The state of the proposal: where it is in the review process

user: Mapped[User]

The associated user, usually the person who submitted the proposal

accept()

Accept the proposal, create a ScheduleItem, and issue the user a CfP voucher if needed.

Return type:

None

reject()

Mark the proposal as rejected, and remove from the schedule if present.

Return type:

None

withdraw()

Mark the proposal as withdrawn, and remove from the schedule if present.

Return type:

None

property is_editable: bool

Whether this proposal can be edited by the submitter.

to_dict()

JSON-compatible dict representation for CSV export.

Return type:

dict[str, Any]

models.content.cfp.ProposalState

alias of Literal[‘new’, ‘edit’, ‘checked’, ‘rejected’, ‘anonymised’, ‘anon-blocked’, ‘manual-review’, ‘accepted’, ‘finalised’, ‘withdrawn’, ‘conduct-blocked’]

models.content.cfp.ProposalType

alias of Literal[‘talk’, ‘performance’, ‘workshop’, ‘familyworkshop’, ‘installation’]

Schedule

The schedule deals with the entire schedule for the event, including accepted CfP content, manually-added/booked official content, and attendee content.

class models.content.schedule.ScheduleItem(**kwargs)

An item of content in the schedule.

This contains the details displayed in the schedule on the website. ScheduleItems are created for a Proposal if it’s submitted through the CfP and accepted, but they can also be created directly by villages.

type: Mapped[Literal['talk', 'performance', 'workshop', 'film', 'familyworkshop', 'installation', 'lightning', 'music', 'djset', 'meetup']]

The type of the ScheduleItem, which controls how it’s displayed in the schedule

state: Mapped[Literal['published', 'unpublished', 'cancelled']]

The state of the ScheduleItem

user_id: Mapped[int]

The user who owns the ScheduleItem. An attendee ScheduleItem has an associated owner who can edit it (in addition to anyone who’s an admin for the scheduled village)

proposal_id: Mapped[int | None]

The proposal for this ScheduleItem. May be None in the case of attendee content.

official_content: Mapped[bool]

Whether this is official content or attendee content.

video_privacy: Mapped[Literal['public', 'review', 'none']]

Whether this should be recorded

availability: Mapped[list[ScheduleItemAvailability]]

The speaker’s availability to present this item - applies to all occurrences.

cancel()

Mark this ScheduleItem as cancelled, as well as any occurrences.

Return type:

None

property presenters: set[User]

The list of Users who are presenting this ScheduleItem, which may be different to the

user who owns it.

Currently only returns a single user, or an empty list for manually-added ScheduleItems. This is used by the automatic scheduler to prevent speaker clashes.

class models.content.schedule.Occurrence(**kwargs)

An occurrence of a ScheduleItem. This indicates when and where a ScheduleItem will occur.

In future there may be multiple occurrences of a ScheduleItem, for example if the same workshop is presented twice, however this is not currently guaranteed to work.

manually_scheduled: Mapped[bool]

Prevents the automatic scheduler from trying to move this occurrence

scheduled_time: Mapped[datetime | None]

The time this occurrence is scheduled to happen at. This may be changed by the automatic scheduler, unless manually_scheduled is set.

potential_scheduled_slots: Mapped[list[PotentialScheduleOccurrence]]

Potential timeslots for this occurrence in a proposed schedule.

allowed_venues: Mapped[list[Venue]]

Venues this occurrence is allowed to be scheduled in. If the manually_scheduled flag is set, and scheduled_venue is set, this is ignored. get_allowed_venues() should be used to access this, which will default if this isn’t set.

scheduled_venue: Mapped[Venue | None]

The venue this occurrence is scheduled in. This may be changed by the automatic scheduler, unless manually_scheduled is set.

validate_scheduled_duration(key, value)

SQLAlchemy validator to ensure duration is a multiple of the slot duration.

Return type:

int | None

is_valid_slot(start_time, venue, user=None)

Check whether this occurrence can be scheduled in a given start_time and venue.

For village content, a user object should be passed in.

Return type:

bool

set_slot(start_time, venue, user=None)

Set the start_time and venue, validating that this is allowed.

For village content, a user object should be passed in.

Return type:

None

cancel()

Cancel this occurrence.

Return type:

None

uncancel()

Uncancel this occurrence.

Return type:

None

property availability: list[ScheduleItemAvailability]

The speaker’s availability to present this occurrence.

Inherited from the ScheduleItem.

get_allowed_venues()

Get the allowed venues for this Occurrence, defaulting to venues with automatic TimeBlocks if none are set.

Return type:

set[Venue]

property valid_allowed_venues: set[Venue]

A list of venues this Occurrence could be scheduled in. This is used to offer the correct selection of venues to admin users when setting allowed_venues.

time_blocks()

TimeBlocks which this Occurrence can be scheduled in.

This takes into account whether the Occurrence has been manually scheduled, but it doesn’t take into account speaker availability.

Return type:

Iterable[TimeBlock]

allowed_times(automatic)

Return type:

dict[Venue, list[tuple[datetime, datetime]]]

Return a mapping of Venue -> time range for when this occurrence is allowed to be scheduled,

which is the input into the automatic scheduler.

This is the intersection of speaker availability and the allowed TimeBlocks for this content type.

property scheduled: bool

Whether this occurrence has been scheduled

Venues

Venues are places on site (official or village-run) where content can be scheduled.

class models.content.venue.Venue(**kwargs)

A location where content can be scheduled.

This can be an official talk stage, a village location, or any other place on site.

allows_attendee_content: Mapped[bool | None]

Whether this venue allows any attendee to schedule content in it. This is only true for official venues which allow attendee content (e.g. bar, lounge) and is currently null for village stages (which allow content to be scheduled by their admins)

class models.content.venue.TimeBlock(**kwargs)

A block of time allocated in a venue for scheduling official content.

Villages can schedule content in their venues outside a TimeBlock, but all official content must be inside a TimeBlock.

Constraints:

• There can only be one TimeBlock active for a venue at any time.

• Each TimeBlock can only allow one content type in it.

• TimeBlocks cannot span 5am, when the scheduling day ends.

type: Mapped[Literal['talk', 'performance', 'workshop', 'film', 'familyworkshop', 'installation', 'lightning', 'music', 'djset', 'meetup']]

The type of item which can be scheduled in this TimeBlock

automatic: Mapped[bool]

Whether this block should be considered by the automatic scheduler