File emoji.py has 1720 lines of code (exceeds 600 allowed). Consider refactoring.

Open

# -*- coding: utf-8 -*-
import random
import logging
from typing import Tuple, Optional

File serializers.py has 1235 lines of code (exceeds 600 allowed). Consider refactoring.

Open

from collections import OrderedDict
from collections.abc import Mapping
from datetime import date, datetime, time
from functools import partial, partialmethod

File views.py has 1171 lines of code (exceeds 600 allowed). Consider refactoring.

Open

from copy import deepcopy
from itertools import groupby

from asgiref.sync import async_to_sync
from channels.layers import get_channel_layer

Function _import has a Cognitive Complexity of 90 (exceeds 8 allowed). Consider refactoring.

Open

    def _import(self, csvfile, model, interpreter=make_interpreter(), expect_unique=None):
        """Parses the object given in f, using the callable interpreter to parse
        each line, and passing the arguments to the given model's constructor.
        `csvfile` can be any object that is supported by csv.DictReader(), which
        includes file objects and lists of strings.

• Read up
  Read up

Function import_results has a Cognitive Complexity of 74 (exceeds 8 allowed). Consider refactoring.

Open

    def import_results(self):
        for round in self.root.findall('round'):
            consensus = self.preliminary_consensus if round.get('elimination') == 'false' else self.elimination_consensus

            for debate in round.findall('debate'):

• Read up
  Read up

Function populate_results has a Cognitive Complexity of 67 (exceeds 8 allowed). Consider refactoring.

Open

def populate_results(ballotsubs, tournament=None):
    """Populates the `_result` attribute of each BallotSubmission in
    `ballotsubs` with a populated DebateResult instance.

    For best performance, the ballot submissions should already have their

• Read up
  Read up

File result.py has 862 lines of code (exceeds 600 allowed). Consider refactoring.

Open

"""Debate result classes.

Debate result classes aggregate scoresheets to produce results for an entire
debate, and interact with the database with respect to models recording scores
given in the debate. They do not deal with metadata (like motions), only scores

File tables.py has 856 lines of code (exceeds 600 allowed). Consider refactoring.

Open

import logging
import warnings

from django.contrib.auth.models import AnonymousUser
from django.contrib.humanize.templatetags.humanize import ordinal

Function setSorting has a Cognitive Complexity of 47 (exceeds 8 allowed). Consider refactoring.

Open

    setSorting (state, sortType) {
      let debatesArray = Object.values(state.debatesOrPanels)

      if (debatesArray.length === 0) {
        return // e.g. Preformed Panels page prior to use

• Read up
  Read up

File forms.py has 792 lines of code (exceeds 600 allowed). Consider refactoring.

Open

import logging
from decimal import Decimal
from itertools import product
from typing import TYPE_CHECKING

Function add_debate_adjudicators_column has a Cognitive Complexity of 46 (exceeds 8 allowed). Consider refactoring.

Open

    def add_debate_adjudicators_column(self, debates, title="Adjudicators",
            show_splits=False, highlight_adj=None, for_admin=False):
        da_data = []

        def construct_text(adjs_data):

• Read up
  Read up

Function add_feedback has a Cognitive Complexity of 44 (exceeds 8 allowed). Consider refactoring.

Open

def add_feedback(debate, submitter_type, user, probability=1.0, discarded=False, confirmed=False):
    """Adds feedback to a debate.
    Specifically, adds feedback from both teams on the chair, and from every
    adjudicator on every other adjudicator.

• Read up
  Read up

File views.py has 757 lines of code (exceeds 600 allowed). Consider refactoring.

Open

import logging

from asgiref.sync import async_to_sync
from channels.layers import get_channel_layer
from django.conf import settings

Function add_result has a Cognitive Complexity of 41 (exceeds 8 allowed). Consider refactoring.

Open

def add_result(debate, submitter_type, user, discarded=False, confirmed=False, reply_random=False):
    """Adds a ballot set to a debate.

    ``debate`` is the Debate to which the ballot set should be added.
    ``submitter_type`` is a valid value of BallotSubmission.submitter_type.

• Read up
  Read up

Function handle_tournament has a Cognitive Complexity of 37 (exceeds 8 allowed). Consider refactoring.

Open

    def handle_tournament(self, tournament, **options):

        compare_tournament = Tournament.objects.get(slug=options['compare'])
        debates = Debate.objects.filter(round__tournament=tournament, round__stage=Round.Stage.PRELIMINARY)

• Read up
  Read up

TabbycatTableBuilder has 37 functions (exceeds 20 allowed). Consider refactoring.

Open

class TabbycatTableBuilder(BaseTableBuilder):
    """Extends TableBuilder to add convenience functions specific to
    Tabbycat."""

    ADJ_SYMBOLS = {

Function add_debate_ballot_link_column has a Cognitive Complexity of 33 (exceeds 8 allowed). Consider refactoring.

Open

    def add_debate_ballot_link_column(self, debates, show_ballot=False):
        ballot_links_header = {'key': "ballot", 'icon': 'search',
                               'tooltip': _("The ballot you submitted")}
        no_ballot = _("No Ballot")

• Read up
  Read up

Function clean_speakers has a Cognitive Complexity of 32 (exceeds 8 allowed). Consider refactoring.

Open

    def clean_speakers(self, cleaned_data):
        """Checks that the speaker selections are valid."""

        # Pull team info again, in case it's changed since the form was loaded.
        if self.choosing_sides:

• Read up
  Read up

Function add_debate_results_columns has a Cognitive Complexity of 32 (exceeds 8 allowed). Consider refactoring.

Open

    def add_debate_results_columns(self, debates, iron=False, n_cols=None):
        all_sides_confirmed = all(debate.sides_confirmed for debate in debates)  # should already be fetched
        n_cols = n_cols or len(self.tournament.sides)
        side_abbrs = {side: get_side_name(self.tournament, side, 'abbr') for side in range(n_cols)}

• Read up
  Read up

Function calculate_anticipated_draw has a Cognitive Complexity of 32 (exceeds 8 allowed). Consider refactoring.

Open

def calculate_anticipated_draw(round):
    """Calculates an anticipated draw for the next round, based on the draw for
    the last round. Returns a list of tuples
        `(bracket_min, bracket_max, liveness)`,
    being the minimum and maximum brackets possible for that room, and the

• Read up
  Read up