tests/widget_test.py

Summary

Maintainability

3 wks

Test Coverage

File `widget_test.py` has 2888 lines of code (exceeds 250 allowed). Consider refactoring.
Open

# -*- coding: utf-8 -*-
import sys
import time
import datetime
import pytest

Found in tests/widget_test.py - About 1 wk to fix

Cyclomatic complexity is too high in function test_containers. (123)
Open

def test_containers():

Found in tests/widget_test.py by radon

Read up
Read up
Exclude checks
- Disable engine
- Disable check

Cyclomatic Complexity

Cyclomatic Complexity corresponds to the number of decisions a block of code contains plus 1. This number (also called McCabe number) is equal to the number of linearly independent paths through the code. This number can be used as a guide when testing conditional logic in blocks.

Radon analyzes the AST tree of a Python program to compute Cyclomatic Complexity. Statements have the following effects on Cyclomatic Complexity:

Construct	Effect on CC	Reasoning
if	+1	An if statement is a single decision.
elif	+1	The elif statement adds another decision.
else	+0	The else statement does not cause a new decision. The decision is at the if.
for	+1	There is a decision at the start of the loop.
while	+1	There is a decision at the while statement.
except	+1	Each except branch adds a new conditional path of execution.
finally	+0	The finally block is unconditionally executed.
with	+1	The with statement roughly corresponds to a try/except block (see PEP 343 for details).
assert	+1	The assert statement internally roughly equals a conditional statement.
Comprehension	+1	A list/set/dict comprehension of generator expression is equivalent to a for loop.
Boolean Operator	+1	Every boolean operator (and, or) adds a decision point.

Source: http://radon.readthedocs.org/en/latest/intro.html

Cyclomatic complexity is too high in function test_entries. (98)
Open

def test_entries():
    print("\tTesting entries")
    assert isinstance(app.addEntry("e1"), Entry)
    with pytest.raises(Exception) :
        app.addEntry("e1")

Found in tests/widget_test.py by radon

Read up
Read up
Exclude checks
- Disable engine
- Disable check

Cyclomatic Complexity

Radon analyzes the AST tree of a Python program to compute Cyclomatic Complexity. Statements have the following effects on Cyclomatic Complexity:

Construct	Effect on CC	Reasoning
if	+1	An if statement is a single decision.
elif	+1	The elif statement adds another decision.
else	+0	The else statement does not cause a new decision. The decision is at the if.
for	+1	There is a decision at the start of the loop.
while	+1	There is a decision at the while statement.
except	+1	Each except branch adds a new conditional path of execution.
finally	+0	The finally block is unconditionally executed.
with	+1	The with statement roughly corresponds to a try/except block (see PEP 343 for details).
assert	+1	The assert statement internally roughly equals a conditional statement.
Comprehension	+1	A list/set/dict comprehension of generator expression is equivalent to a for loop.
Boolean Operator	+1	Every boolean operator (and, or) adds a decision point.

Source: http://radon.readthedocs.org/en/latest/intro.html

Function `test_containers` has 346 lines of code (exceeds 25 allowed). Consider refactoring.
Open

def test_containers():
    print("\tTesting containers")

    ## LABEL FRAMES
    lf = app.startLabelFrame("lf1")

Found in tests/widget_test.py - About 1 day to fix

Cyclomatic complexity is too high in function test_gui_properties. (78)
Open

def test_gui_properties():

Found in tests/widget_test.py by radon

Read up
Read up
Exclude checks
- Disable engine
- Disable check

Cyclomatic Complexity

Radon analyzes the AST tree of a Python program to compute Cyclomatic Complexity. Statements have the following effects on Cyclomatic Complexity:

Construct	Effect on CC	Reasoning
if	+1	An if statement is a single decision.
elif	+1	The elif statement adds another decision.
else	+0	The else statement does not cause a new decision. The decision is at the if.
for	+1	There is a decision at the start of the loop.
while	+1	There is a decision at the while statement.
except	+1	Each except branch adds a new conditional path of execution.
finally	+0	The finally block is unconditionally executed.
with	+1	The with statement roughly corresponds to a try/except block (see PEP 343 for details).
assert	+1	The assert statement internally roughly equals a conditional statement.
Comprehension	+1	A list/set/dict comprehension of generator expression is equivalent to a for loop.
Boolean Operator	+1	Every boolean operator (and, or) adds a decision point.

Source: http://radon.readthedocs.org/en/latest/intro.html

Cyclomatic complexity is too high in function test_text_areas. (58)
Open

def test_text_areas():
    print("\tTesting text areas")
    assert isinstance(app.addTextArea("t1"), AjText)
    ta2 = app.addTextArea("t2")
    with pytest.raises(Exception) :

Found in tests/widget_test.py by radon

Read up
Read up
Exclude checks
- Disable engine
- Disable check

Cyclomatic Complexity

Radon analyzes the AST tree of a Python program to compute Cyclomatic Complexity. Statements have the following effects on Cyclomatic Complexity:

Construct	Effect on CC	Reasoning
if	+1	An if statement is a single decision.
elif	+1	The elif statement adds another decision.
else	+0	The else statement does not cause a new decision. The decision is at the if.
for	+1	There is a decision at the start of the loop.
while	+1	There is a decision at the while statement.
except	+1	Each except branch adds a new conditional path of execution.
finally	+0	The finally block is unconditionally executed.
with	+1	The with statement roughly corresponds to a try/except block (see PEP 343 for details).
assert	+1	The assert statement internally roughly equals a conditional statement.
Comprehension	+1	A list/set/dict comprehension of generator expression is equivalent to a for loop.
Boolean Operator	+1	Every boolean operator (and, or) adds a decision point.

Source: http://radon.readthedocs.org/en/latest/intro.html

Cyclomatic complexity is too high in function test_lists. (43)
Open

def test_lists():
    print("\tTesting lists")

    assert isinstance(app.addListBox("l1", LIST_ONE), Listbox)
    app.addListBox("l2", LIST_TWO)

Found in tests/widget_test.py by radon

Read up
Read up
Exclude checks
- Disable engine
- Disable check

Cyclomatic Complexity

Radon analyzes the AST tree of a Python program to compute Cyclomatic Complexity. Statements have the following effects on Cyclomatic Complexity:

Construct	Effect on CC	Reasoning
if	+1	An if statement is a single decision.
elif	+1	The elif statement adds another decision.
else	+0	The else statement does not cause a new decision. The decision is at the if.
for	+1	There is a decision at the start of the loop.
while	+1	There is a decision at the while statement.
except	+1	Each except branch adds a new conditional path of execution.
finally	+0	The finally block is unconditionally executed.
with	+1	The with statement roughly corresponds to a try/except block (see PEP 343 for details).
assert	+1	The assert statement internally roughly equals a conditional statement.
Comprehension	+1	A list/set/dict comprehension of generator expression is equivalent to a for loop.
Boolean Operator	+1	Every boolean operator (and, or) adds a decision point.

Source: http://radon.readthedocs.org/en/latest/intro.html

Function `test_entries` has 197 lines of code (exceeds 25 allowed). Consider refactoring.
Open

def test_entries():
    print("\tTesting entries")
    assert isinstance(app.addEntry("e1"), Entry)
    with pytest.raises(Exception) :
        app.addEntry("e1")

Found in tests/widget_test.py - About 7 hrs to fix

Cyclomatic complexity is too high in function test_checks. (42)
Open

def test_checks():
    print("\tTesting checks")
    assert isinstance(app.addCheckBox(TEXT_ONE), Checkbutton)
    app.addCheckBox(TEXT_TWO)
    with pytest.raises(Exception):

Found in tests/widget_test.py by radon

Read up
Read up
Exclude checks
- Disable engine
- Disable check

Cyclomatic Complexity

Radon analyzes the AST tree of a Python program to compute Cyclomatic Complexity. Statements have the following effects on Cyclomatic Complexity:

Construct	Effect on CC	Reasoning
if	+1	An if statement is a single decision.
elif	+1	The elif statement adds another decision.
else	+0	The else statement does not cause a new decision. The decision is at the if.
for	+1	There is a decision at the start of the loop.
while	+1	There is a decision at the while statement.
except	+1	Each except branch adds a new conditional path of execution.
finally	+0	The finally block is unconditionally executed.
with	+1	The with statement roughly corresponds to a try/except block (see PEP 343 for details).
assert	+1	The assert statement internally roughly equals a conditional statement.
Comprehension	+1	A list/set/dict comprehension of generator expression is equivalent to a for loop.
Boolean Operator	+1	Every boolean operator (and, or) adds a decision point.

Source: http://radon.readthedocs.org/en/latest/intro.html

Cyclomatic complexity is too high in function test_options. (41)
Open

def test_options():
    print("\tTesting options")
    # add two option boxes
    assert isinstance(app.addOptionBox("l1", LIST_ONE), OptionMenu)
    app.addOptionBox("l2", LIST_TWO)

Found in tests/widget_test.py by radon

Read up
Read up
Exclude checks
- Disable engine
- Disable check

Cyclomatic Complexity

Radon analyzes the AST tree of a Python program to compute Cyclomatic Complexity. Statements have the following effects on Cyclomatic Complexity:

Construct	Effect on CC	Reasoning
if	+1	An if statement is a single decision.
elif	+1	The elif statement adds another decision.
else	+0	The else statement does not cause a new decision. The decision is at the if.
for	+1	There is a decision at the start of the loop.
while	+1	There is a decision at the while statement.
except	+1	Each except branch adds a new conditional path of execution.
finally	+0	The finally block is unconditionally executed.
with	+1	The with statement roughly corresponds to a try/except block (see PEP 343 for details).
assert	+1	The assert statement internally roughly equals a conditional statement.
Comprehension	+1	A list/set/dict comprehension of generator expression is equivalent to a for loop.
Boolean Operator	+1	Every boolean operator (and, or) adds a decision point.

Source: http://radon.readthedocs.org/en/latest/intro.html

Cyclomatic complexity is too high in function test_scales. (35)
Open

def test_scales():
    print("\tTesting scales")
    assert isinstance(app.addScale("s1"), Scale)
    app.addScale("s2")
    with pytest.raises(Exception) :

Found in tests/widget_test.py by radon

Read up
Read up
Exclude checks
- Disable engine
- Disable check

Cyclomatic Complexity

Radon analyzes the AST tree of a Python program to compute Cyclomatic Complexity. Statements have the following effects on Cyclomatic Complexity:

Construct	Effect on CC	Reasoning
if	+1	An if statement is a single decision.
elif	+1	The elif statement adds another decision.
else	+0	The else statement does not cause a new decision. The decision is at the if.
for	+1	There is a decision at the start of the loop.
while	+1	There is a decision at the while statement.
except	+1	Each except branch adds a new conditional path of execution.
finally	+0	The finally block is unconditionally executed.
with	+1	The with statement roughly corresponds to a try/except block (see PEP 343 for details).
assert	+1	The assert statement internally roughly equals a conditional statement.
Comprehension	+1	A list/set/dict comprehension of generator expression is equivalent to a for loop.
Boolean Operator	+1	Every boolean operator (and, or) adds a decision point.

Source: http://radon.readthedocs.org/en/latest/intro.html

Function `test_gui_properties` has 141 lines of code (exceeds 25 allowed). Consider refactoring.
Open

def test_gui_properties():

    def propFunc(param=None): return True

    app.config(

Found in tests/widget_test.py - About 5 hrs to fix

Cyclomatic complexity is too high in function test_spins. (28)
Open

def test_spins():
    print("\tTesting spins")

    assert isinstance(app.addSpinBox("s1", ["a", "b", "c", "d", "e"]), Spinbox)
    app.addSpinBox("s2", ["a", "b", "c", "d", "e"])

Found in tests/widget_test.py by radon

Read up
Read up
Exclude checks
- Disable engine
- Disable check

Cyclomatic Complexity

Radon analyzes the AST tree of a Python program to compute Cyclomatic Complexity. Statements have the following effects on Cyclomatic Complexity:

Construct	Effect on CC	Reasoning
if	+1	An if statement is a single decision.
elif	+1	The elif statement adds another decision.
else	+0	The else statement does not cause a new decision. The decision is at the if.
for	+1	There is a decision at the start of the loop.
while	+1	There is a decision at the while statement.
except	+1	Each except branch adds a new conditional path of execution.
finally	+0	The finally block is unconditionally executed.
with	+1	The with statement roughly corresponds to a try/except block (see PEP 343 for details).
assert	+1	The assert statement internally roughly equals a conditional statement.
Comprehension	+1	A list/set/dict comprehension of generator expression is equivalent to a for loop.
Boolean Operator	+1	Every boolean operator (and, or) adds a decision point.

Source: http://radon.readthedocs.org/en/latest/intro.html

Cyclomatic complexity is too high in function test_properties. (26)
Open

def test_properties():
    print("\tTesting properties")

    app.startToggleFrame("PP_frame")
    assert isinstance(app.addProperties("tog_p1", HASH_ONE), Properties)

Found in tests/widget_test.py by radon

Read up
Read up
Exclude checks
- Disable engine
- Disable check

Cyclomatic Complexity

Radon analyzes the AST tree of a Python program to compute Cyclomatic Complexity. Statements have the following effects on Cyclomatic Complexity:

Construct	Effect on CC	Reasoning
if	+1	An if statement is a single decision.
elif	+1	The elif statement adds another decision.
else	+0	The else statement does not cause a new decision. The decision is at the if.
for	+1	There is a decision at the start of the loop.
while	+1	There is a decision at the while statement.
except	+1	Each except branch adds a new conditional path of execution.
finally	+0	The finally block is unconditionally executed.
with	+1	The with statement roughly corresponds to a try/except block (see PEP 343 for details).
assert	+1	The assert statement internally roughly equals a conditional statement.
Comprehension	+1	A list/set/dict comprehension of generator expression is equivalent to a for loop.
Boolean Operator	+1	Every boolean operator (and, or) adds a decision point.

Source: http://radon.readthedocs.org/en/latest/intro.html

Function `test_text_areas` has 125 lines of code (exceeds 25 allowed). Consider refactoring.
Open

def test_text_areas():
    print("\tTesting text areas")
    assert isinstance(app.addTextArea("t1"), AjText)
    ta2 = app.addTextArea("t2")
    with pytest.raises(Exception) :

Found in tests/widget_test.py - About 5 hrs to fix

Cyclomatic complexity is too high in function test_date_pickers. (24)
Open

def test_date_pickers():
    print("\tTesting date pickers")
    app.addDatePicker("d1")
    with pytest.raises(Exception) :
        app.addDatePicker("d1")

Found in tests/widget_test.py by radon

Read up
Read up
Exclude checks
- Disable engine
- Disable check

Cyclomatic Complexity

Radon analyzes the AST tree of a Python program to compute Cyclomatic Complexity. Statements have the following effects on Cyclomatic Complexity:

Construct	Effect on CC	Reasoning
if	+1	An if statement is a single decision.
elif	+1	The elif statement adds another decision.
else	+0	The else statement does not cause a new decision. The decision is at the if.
for	+1	There is a decision at the start of the loop.
while	+1	There is a decision at the while statement.
except	+1	Each except branch adds a new conditional path of execution.
finally	+0	The finally block is unconditionally executed.
with	+1	The with statement roughly corresponds to a try/except block (see PEP 343 for details).
assert	+1	The assert statement internally roughly equals a conditional statement.
Comprehension	+1	A list/set/dict comprehension of generator expression is equivalent to a for loop.
Boolean Operator	+1	Every boolean operator (and, or) adds a decision point.

Source: http://radon.readthedocs.org/en/latest/intro.html

Cyclomatic complexity is too high in function test_labels. (23)
Open

def test_labels():
    print("\tTesting labels")
    assert isinstance(app.addEmptyLabel("el1"), Label)
    assert isinstance(app.addLabel("l0", TEXT_ONE), Label)
    with pytest.raises(Exception) :

Found in tests/widget_test.py by radon

Read up
Read up
Exclude checks
- Disable engine
- Disable check

Cyclomatic Complexity

Radon analyzes the AST tree of a Python program to compute Cyclomatic Complexity. Statements have the following effects on Cyclomatic Complexity:

Construct	Effect on CC	Reasoning
if	+1	An if statement is a single decision.
elif	+1	The elif statement adds another decision.
else	+0	The else statement does not cause a new decision. The decision is at the if.
for	+1	There is a decision at the start of the loop.
while	+1	There is a decision at the while statement.
except	+1	Each except branch adds a new conditional path of execution.
finally	+0	The finally block is unconditionally executed.
with	+1	The with statement roughly corresponds to a try/except block (see PEP 343 for details).
assert	+1	The assert statement internally roughly equals a conditional statement.
Comprehension	+1	A list/set/dict comprehension of generator expression is equivalent to a for loop.
Boolean Operator	+1	Every boolean operator (and, or) adds a decision point.

Source: http://radon.readthedocs.org/en/latest/intro.html

Function `test_lists` has 102 lines of code (exceeds 25 allowed). Consider refactoring.
Open

def test_lists():
    print("\tTesting lists")

    assert isinstance(app.addListBox("l1", LIST_ONE), Listbox)
    app.addListBox("l2", LIST_TWO)

Found in tests/widget_test.py - About 4 hrs to fix

Cyclomatic complexity is too high in function test_message_boxes. (19)
Open

def test_message_boxes():
    print("\tTesting messages")
    assert isinstance(app.addMessage("m1", TEXT_ONE), Message)
    app.addMessage("m2", TEXT_TWO)
    with pytest.raises(Exception) :

Found in tests/widget_test.py by radon

Read up
Read up
Exclude checks
- Disable engine
- Disable check

Cyclomatic Complexity

Radon analyzes the AST tree of a Python program to compute Cyclomatic Complexity. Statements have the following effects on Cyclomatic Complexity:

Construct	Effect on CC	Reasoning
if	+1	An if statement is a single decision.
elif	+1	The elif statement adds another decision.
else	+0	The else statement does not cause a new decision. The decision is at the if.
for	+1	There is a decision at the start of the loop.
while	+1	There is a decision at the while statement.
except	+1	Each except branch adds a new conditional path of execution.
finally	+0	The finally block is unconditionally executed.
with	+1	The with statement roughly corresponds to a try/except block (see PEP 343 for details).
assert	+1	The assert statement internally roughly equals a conditional statement.
Comprehension	+1	A list/set/dict comprehension of generator expression is equivalent to a for loop.
Boolean Operator	+1	Every boolean operator (and, or) adds a decision point.

Source: http://radon.readthedocs.org/en/latest/intro.html

Cyclomatic complexity is too high in function test_buttons. (19)
Open

def test_buttons():
    print("\tTesting buttons")
    with pytest.raises(Exception) :
        app.addButton(["brk1", "brk1", "brk1", "brk1"], [None, None])

Found in tests/widget_test.py by radon

Read up
Read up
Exclude checks
- Disable engine
- Disable check

Cyclomatic Complexity

Radon analyzes the AST tree of a Python program to compute Cyclomatic Complexity. Statements have the following effects on Cyclomatic Complexity:

Construct	Effect on CC	Reasoning
if	+1	An if statement is a single decision.
elif	+1	The elif statement adds another decision.
else	+0	The else statement does not cause a new decision. The decision is at the if.
for	+1	There is a decision at the start of the loop.
while	+1	There is a decision at the while statement.
except	+1	Each except branch adds a new conditional path of execution.
finally	+0	The finally block is unconditionally executed.
with	+1	The with statement roughly corresponds to a try/except block (see PEP 343 for details).
assert	+1	The assert statement internally roughly equals a conditional statement.
Comprehension	+1	A list/set/dict comprehension of generator expression is equivalent to a for loop.
Boolean Operator	+1	Every boolean operator (and, or) adds a decision point.

Source: http://radon.readthedocs.org/en/latest/intro.html

Cyclomatic complexity is too high in function test_radios. (18)
Open

def test_radios():
    print("\tTesting radios")
    assert isinstance(app.addRadioButton("rb", TEXT_ONE), Radiobutton)

    app.addRadioButton("rb", TEXT_TWO)

Found in tests/widget_test.py by radon

Read up
Read up
Exclude checks
- Disable engine
- Disable check

Cyclomatic Complexity

Radon analyzes the AST tree of a Python program to compute Cyclomatic Complexity. Statements have the following effects on Cyclomatic Complexity:

Construct	Effect on CC	Reasoning
if	+1	An if statement is a single decision.
elif	+1	The elif statement adds another decision.
else	+0	The else statement does not cause a new decision. The decision is at the if.
for	+1	There is a decision at the start of the loop.
while	+1	There is a decision at the while statement.
except	+1	Each except branch adds a new conditional path of execution.
finally	+0	The finally block is unconditionally executed.
with	+1	The with statement roughly corresponds to a try/except block (see PEP 343 for details).
assert	+1	The assert statement internally roughly equals a conditional statement.
Comprehension	+1	A list/set/dict comprehension of generator expression is equivalent to a for loop.
Boolean Operator	+1	Every boolean operator (and, or) adds a decision point.

Source: http://radon.readthedocs.org/en/latest/intro.html

Cyclomatic complexity is too high in function test_menus. (15)
Open

def test_menus():
    print("\tTesting Menubar")

    app.addMenuList("a", LIST_ONE, tester_function)
    app.createMenu("MEN2")

Found in tests/widget_test.py by radon

Read up
Read up
Exclude checks
- Disable engine
- Disable check

Cyclomatic Complexity

Radon analyzes the AST tree of a Python program to compute Cyclomatic Complexity. Statements have the following effects on Cyclomatic Complexity:

Construct	Effect on CC	Reasoning
if	+1	An if statement is a single decision.
elif	+1	The elif statement adds another decision.
else	+0	The else statement does not cause a new decision. The decision is at the if.
for	+1	There is a decision at the start of the loop.
while	+1	There is a decision at the while statement.
except	+1	Each except branch adds a new conditional path of execution.
finally	+0	The finally block is unconditionally executed.
with	+1	The with statement roughly corresponds to a try/except block (see PEP 343 for details).
assert	+1	The assert statement internally roughly equals a conditional statement.
Comprehension	+1	A list/set/dict comprehension of generator expression is equivalent to a for loop.
Boolean Operator	+1	Every boolean operator (and, or) adds a decision point.

Source: http://radon.readthedocs.org/en/latest/intro.html

Function `test_options` has 83 lines of code (exceeds 25 allowed). Consider refactoring.
Open

def test_options():
    print("\tTesting options")
    # add two option boxes
    assert isinstance(app.addOptionBox("l1", LIST_ONE), OptionMenu)
    app.addOptionBox("l2", LIST_TWO)

Found in tests/widget_test.py - About 3 hrs to fix

Function `test_scales` has 82 lines of code (exceeds 25 allowed). Consider refactoring.
Open

def test_scales():
    print("\tTesting scales")
    assert isinstance(app.addScale("s1"), Scale)
    app.addScale("s2")
    with pytest.raises(Exception) :

Found in tests/widget_test.py - About 3 hrs to fix

Cyclomatic complexity is too high in function test_gui_options. (13)
Open

def test_gui_options():
    print("\tTesting gui options")
    app.setTitle("New title")
    assert app.getTitle() == "New title"
    assert app.title == "New title"

Found in tests/widget_test.py by radon

Read up
Read up
Exclude checks
- Disable engine
- Disable check

Cyclomatic Complexity

Radon analyzes the AST tree of a Python program to compute Cyclomatic Complexity. Statements have the following effects on Cyclomatic Complexity:

Construct	Effect on CC	Reasoning
if	+1	An if statement is a single decision.
elif	+1	The elif statement adds another decision.
else	+0	The else statement does not cause a new decision. The decision is at the if.
for	+1	There is a decision at the start of the loop.
while	+1	There is a decision at the while statement.
except	+1	Each except branch adds a new conditional path of execution.
finally	+0	The finally block is unconditionally executed.
with	+1	The with statement roughly corresponds to a try/except block (see PEP 343 for details).
assert	+1	The assert statement internally roughly equals a conditional statement.
Comprehension	+1	A list/set/dict comprehension of generator expression is equivalent to a for loop.
Boolean Operator	+1	Every boolean operator (and, or) adds a decision point.

Source: http://radon.readthedocs.org/en/latest/intro.html

Function `test_checks` has 68 lines of code (exceeds 25 allowed). Consider refactoring.
Open

def test_checks():
    print("\tTesting checks")
    assert isinstance(app.addCheckBox(TEXT_ONE), Checkbutton)
    app.addCheckBox(TEXT_TWO)
    with pytest.raises(Exception):

Found in tests/widget_test.py - About 2 hrs to fix

Cyclomatic complexity is too high in function test_status. (11)
Open

def test_status():
    print("\tTesting Statusbar")

    app.addStatusbar(TEXT_ONE, 4, "RIGHT")
    assert len(app._statusFields) == 4

Found in tests/widget_test.py by radon

Read up
Read up
Exclude checks
- Disable engine
- Disable check

Cyclomatic Complexity

Radon analyzes the AST tree of a Python program to compute Cyclomatic Complexity. Statements have the following effects on Cyclomatic Complexity:

Construct	Effect on CC	Reasoning
if	+1	An if statement is a single decision.
elif	+1	The elif statement adds another decision.
else	+0	The else statement does not cause a new decision. The decision is at the if.
for	+1	There is a decision at the start of the loop.
while	+1	There is a decision at the while statement.
except	+1	Each except branch adds a new conditional path of execution.
finally	+0	The finally block is unconditionally executed.
with	+1	The with statement roughly corresponds to a try/except block (see PEP 343 for details).
assert	+1	The assert statement internally roughly equals a conditional statement.
Comprehension	+1	A list/set/dict comprehension of generator expression is equivalent to a for loop.
Boolean Operator	+1	Every boolean operator (and, or) adds a decision point.

Source: http://radon.readthedocs.org/en/latest/intro.html

Cyclomatic complexity is too high in function test_meters. (10)
Open

def test_meters():
    print("\tTesting meters")
    assert isinstance(app.addMeter("m1"), Meter)
    with pytest.raises(Exception) :
        app.addMeter("m1")

Found in tests/widget_test.py by radon

Read up
Read up
Exclude checks
- Disable engine
- Disable check

Cyclomatic Complexity

Radon analyzes the AST tree of a Python program to compute Cyclomatic Complexity. Statements have the following effects on Cyclomatic Complexity:

Construct	Effect on CC	Reasoning
if	+1	An if statement is a single decision.
elif	+1	The elif statement adds another decision.
else	+0	The else statement does not cause a new decision. The decision is at the if.
for	+1	There is a decision at the start of the loop.
while	+1	There is a decision at the while statement.
except	+1	Each except branch adds a new conditional path of execution.
finally	+0	The finally block is unconditionally executed.
with	+1	The with statement roughly corresponds to a try/except block (see PEP 343 for details).
assert	+1	The assert statement internally roughly equals a conditional statement.
Comprehension	+1	A list/set/dict comprehension of generator expression is equivalent to a for loop.
Boolean Operator	+1	Every boolean operator (and, or) adds a decision point.

Source: http://radon.readthedocs.org/en/latest/intro.html

Cyclomatic complexity is too high in function test_images. (10)
Open

def test_images():
    print("\tTesting images")

    assert isinstance(app.addImage("im1", "1_flash.gif", compound="left"), PhotoImage)
    with pytest.raises(Exception) :

Found in tests/widget_test.py by radon

Read up
Read up
Exclude checks
- Disable engine
- Disable check

Cyclomatic Complexity

Radon analyzes the AST tree of a Python program to compute Cyclomatic Complexity. Statements have the following effects on Cyclomatic Complexity:

Construct	Effect on CC	Reasoning
if	+1	An if statement is a single decision.
elif	+1	The elif statement adds another decision.
else	+0	The else statement does not cause a new decision. The decision is at the if.
for	+1	There is a decision at the start of the loop.
while	+1	There is a decision at the while statement.
except	+1	Each except branch adds a new conditional path of execution.
finally	+0	The finally block is unconditionally executed.
with	+1	The with statement roughly corresponds to a try/except block (see PEP 343 for details).
assert	+1	The assert statement internally roughly equals a conditional statement.
Comprehension	+1	A list/set/dict comprehension of generator expression is equivalent to a for loop.
Boolean Operator	+1	Every boolean operator (and, or) adds a decision point.

Source: http://radon.readthedocs.org/en/latest/intro.html

Cyclomatic complexity is too high in function testScrollPaneScrolling. (9)
Open

def testScrollPaneScrolling(sp):
    event = Event()

    sp._mouseEnter(event)
    sp._mouseLeave(event)

Found in tests/widget_test.py by radon

Read up
Read up
Exclude checks
- Disable engine
- Disable check

Cyclomatic Complexity

Radon analyzes the AST tree of a Python program to compute Cyclomatic Complexity. Statements have the following effects on Cyclomatic Complexity:

Construct	Effect on CC	Reasoning
if	+1	An if statement is a single decision.
elif	+1	The elif statement adds another decision.
else	+0	The else statement does not cause a new decision. The decision is at the if.
for	+1	There is a decision at the start of the loop.
while	+1	There is a decision at the while statement.
except	+1	Each except branch adds a new conditional path of execution.
finally	+0	The finally block is unconditionally executed.
with	+1	The with statement roughly corresponds to a try/except block (see PEP 343 for details).
assert	+1	The assert statement internally roughly equals a conditional statement.
Comprehension	+1	A list/set/dict comprehension of generator expression is equivalent to a for loop.
Boolean Operator	+1	Every boolean operator (and, or) adds a decision point.

Source: http://radon.readthedocs.org/en/latest/intro.html

Function `test_gui_options` has 57 lines of code (exceeds 25 allowed). Consider refactoring.
Open

def test_gui_options():
    print("\tTesting gui options")
    app.setTitle("New title")
    assert app.getTitle() == "New title"
    assert app.title == "New title"

Found in tests/widget_test.py - About 2 hrs to fix

Function `test_setters` has 55 lines of code (exceeds 25 allowed). Consider refactoring.
Open

def test_setters(widg_type, widg_id, widg_val=None):
    print("\tTesting setters")
    exec("app.set" + widg_type + "Bg(\""+widg_id +"\", \"red\")")
    exec("app.set" + widg_type + "Fg(\""+widg_id +"\", \"red\")")
    exec("app.set" + widg_type + "DisabledFg(\""+widg_id +"\", \"red\")")

Found in tests/widget_test.py - About 2 hrs to fix

Function `test_properties` has 55 lines of code (exceeds 25 allowed). Consider refactoring.
Open

def test_properties():
    print("\tTesting properties")

    app.startToggleFrame("PP_frame")
    assert isinstance(app.addProperties("tog_p1", HASH_ONE), Properties)

Found in tests/widget_test.py - About 2 hrs to fix

Function `test_menus` has 55 lines of code (exceeds 25 allowed). Consider refactoring.
Open

def test_menus():
    print("\tTesting Menubar")

    app.addMenuList("a", LIST_ONE, tester_function)
    app.createMenu("MEN2")

Found in tests/widget_test.py - About 2 hrs to fix

Cyclomatic complexity is too high in function test_sets. (8)
Open

def test_sets():
    print("\tTesting setters")
    app.setLabelBg("xx1", COL_ONE)
    app.setLabelFg("xx1", COL_TWO)
    app.setLabelDisabledFg("xx1", COL_THREE)

Found in tests/widget_test.py by radon

Read up
Read up
Exclude checks
- Disable engine
- Disable check

Cyclomatic Complexity

Radon analyzes the AST tree of a Python program to compute Cyclomatic Complexity. Statements have the following effects on Cyclomatic Complexity:

Construct	Effect on CC	Reasoning
if	+1	An if statement is a single decision.
elif	+1	The elif statement adds another decision.
else	+0	The else statement does not cause a new decision. The decision is at the if.
for	+1	There is a decision at the start of the loop.
while	+1	There is a decision at the while statement.
except	+1	Each except branch adds a new conditional path of execution.
finally	+0	The finally block is unconditionally executed.
with	+1	The with statement roughly corresponds to a try/except block (see PEP 343 for details).
assert	+1	The assert statement internally roughly equals a conditional statement.
Comprehension	+1	A list/set/dict comprehension of generator expression is equivalent to a for loop.
Boolean Operator	+1	Every boolean operator (and, or) adds a decision point.

Source: http://radon.readthedocs.org/en/latest/intro.html

Cyclomatic complexity is too high in function test_googlemap. (7)
Open

def test_googlemap():
    print("\tTesting GoogleMaps:", PY_VER)
    gm2 = app.addGoogleMap("gm2")
    with pytest.raises(Exception) :
        app.addGoogleMap("gm2")

Found in tests/widget_test.py by radon

Read up
Read up
Exclude checks
- Disable engine
- Disable check

Cyclomatic Complexity

Radon analyzes the AST tree of a Python program to compute Cyclomatic Complexity. Statements have the following effects on Cyclomatic Complexity:

Construct	Effect on CC	Reasoning
if	+1	An if statement is a single decision.
elif	+1	The elif statement adds another decision.
else	+0	The else statement does not cause a new decision. The decision is at the if.
for	+1	There is a decision at the start of the loop.
while	+1	There is a decision at the while statement.
except	+1	Each except branch adds a new conditional path of execution.
finally	+0	The finally block is unconditionally executed.
with	+1	The with statement roughly corresponds to a try/except block (see PEP 343 for details).
assert	+1	The assert statement internally roughly equals a conditional statement.
Comprehension	+1	A list/set/dict comprehension of generator expression is equivalent to a for loop.
Boolean Operator	+1	Every boolean operator (and, or) adds a decision point.

Source: http://radon.readthedocs.org/en/latest/intro.html

Function `test_date_pickers` has 47 lines of code (exceeds 25 allowed). Consider refactoring.
Open

def test_date_pickers():
    print("\tTesting date pickers")
    app.addDatePicker("d1")
    with pytest.raises(Exception) :
        app.addDatePicker("d1")

Found in tests/widget_test.py - About 1 hr to fix

Cyclomatic complexity is too high in function test_sounds. (6)
Open

def test_sounds():
    print("\tTesting sounds")
# only support windows
    app.bell()
    try:

Found in tests/widget_test.py by radon

Read up
Read up
Exclude checks
- Disable engine
- Disable check

Cyclomatic Complexity

Radon analyzes the AST tree of a Python program to compute Cyclomatic Complexity. Statements have the following effects on Cyclomatic Complexity:

Construct	Effect on CC	Reasoning
if	+1	An if statement is a single decision.
elif	+1	The elif statement adds another decision.
else	+0	The else statement does not cause a new decision. The decision is at the if.
for	+1	There is a decision at the start of the loop.
while	+1	There is a decision at the while statement.
except	+1	Each except branch adds a new conditional path of execution.
finally	+0	The finally block is unconditionally executed.
with	+1	The with statement roughly corresponds to a try/except block (see PEP 343 for details).
assert	+1	The assert statement internally roughly equals a conditional statement.
Comprehension	+1	A list/set/dict comprehension of generator expression is equivalent to a for loop.
Boolean Operator	+1	Every boolean operator (and, or) adds a decision point.

Source: http://radon.readthedocs.org/en/latest/intro.html

Cyclomatic complexity is too high in function test_gui. (6)
Open

def test_gui(btn=None):
    print("Testing GUI")
    global doStop
    if doStop == 0:
        test_pop_ups()

Found in tests/widget_test.py by radon

Read up
Read up
Exclude checks
- Disable engine
- Disable check

Cyclomatic Complexity

Radon analyzes the AST tree of a Python program to compute Cyclomatic Complexity. Statements have the following effects on Cyclomatic Complexity:

Construct	Effect on CC	Reasoning
if	+1	An if statement is a single decision.
elif	+1	The elif statement adds another decision.
else	+0	The else statement does not cause a new decision. The decision is at the if.
for	+1	There is a decision at the start of the loop.
while	+1	There is a decision at the while statement.
except	+1	Each except branch adds a new conditional path of execution.
finally	+0	The finally block is unconditionally executed.
with	+1	The with statement roughly corresponds to a try/except block (see PEP 343 for details).
assert	+1	The assert statement internally roughly equals a conditional statement.
Comprehension	+1	A list/set/dict comprehension of generator expression is equivalent to a for loop.
Boolean Operator	+1	Every boolean operator (and, or) adds a decision point.

Source: http://radon.readthedocs.org/en/latest/intro.html

Cyclomatic complexity is too high in function test_gui4. (6)
Open

def test_gui4(btn=None):
    print("Testing GUI4")
    global doStopAgain
    if doStopAgain == 2:
        press(None)

Found in tests/widget_test.py by radon

Read up
Read up
Exclude checks
- Disable engine
- Disable check

Cyclomatic Complexity

Radon analyzes the AST tree of a Python program to compute Cyclomatic Complexity. Statements have the following effects on Cyclomatic Complexity:

Construct	Effect on CC	Reasoning
if	+1	An if statement is a single decision.
elif	+1	The elif statement adds another decision.
else	+0	The else statement does not cause a new decision. The decision is at the if.
for	+1	There is a decision at the start of the loop.
while	+1	There is a decision at the while statement.
except	+1	Each except branch adds a new conditional path of execution.
finally	+0	The finally block is unconditionally executed.
with	+1	The with statement roughly corresponds to a try/except block (see PEP 343 for details).
assert	+1	The assert statement internally roughly equals a conditional statement.
Comprehension	+1	A list/set/dict comprehension of generator expression is equivalent to a for loop.
Boolean Operator	+1	Every boolean operator (and, or) adds a decision point.

Source: http://radon.readthedocs.org/en/latest/intro.html

Function `test_labels` has 45 lines of code (exceeds 25 allowed). Consider refactoring.
Open

def test_labels():
    print("\tTesting labels")
    assert isinstance(app.addEmptyLabel("el1"), Label)
    assert isinstance(app.addLabel("l0", TEXT_ONE), Label)
    with pytest.raises(Exception) :

Found in tests/widget_test.py - About 1 hr to fix

Function `test_toolbars` has 44 lines of code (exceeds 25 allowed). Consider refactoring.
Open

def test_toolbars():
    print("\tTesting Toolbar")

    app.addToolbar(["a", "b", "c", "ABOUT"], 
        [tester_function, tester_function, tester_function, tester_function],

Found in tests/widget_test.py - About 1 hr to fix

Function `test_images` has 44 lines of code (exceeds 25 allowed). Consider refactoring.
Open

def test_images():
    print("\tTesting images")

    assert isinstance(app.addImage("im1", "1_flash.gif", compound="left"), PhotoImage)
    with pytest.raises(Exception) :

Found in tests/widget_test.py - About 1 hr to fix

Function `test_spins` has 40 lines of code (exceeds 25 allowed). Consider refactoring.
Open

def test_spins():
    print("\tTesting spins")

    assert isinstance(app.addSpinBox("s1", ["a", "b", "c", "d", "e"]), Spinbox)
    app.addSpinBox("s2", ["a", "b", "c", "d", "e"])

Found in tests/widget_test.py - About 1 hr to fix

Function `test_buttons` has 37 lines of code (exceeds 25 allowed). Consider refactoring.
Open

def test_buttons():
    print("\tTesting buttons")
    with pytest.raises(Exception) :
        app.addButton(["brk1", "brk1", "brk1", "brk1"], [None, None])

Found in tests/widget_test.py - About 1 hr to fix

Function `test_radios` has 37 lines of code (exceeds 25 allowed). Consider refactoring.
Open

def test_radios():
    print("\tTesting radios")
    assert isinstance(app.addRadioButton("rb", TEXT_ONE), Radiobutton)

    app.addRadioButton("rb", TEXT_TWO)

Found in tests/widget_test.py - About 1 hr to fix

Function `test_message_boxes` has 34 lines of code (exceeds 25 allowed). Consider refactoring.
Open

def test_message_boxes():
    print("\tTesting messages")
    assert isinstance(app.addMessage("m1", TEXT_ONE), Message)
    app.addMessage("m2", TEXT_TWO)
    with pytest.raises(Exception) :

Found in tests/widget_test.py - About 1 hr to fix

Function `test_status` has 31 lines of code (exceeds 25 allowed). Consider refactoring.
Open

def test_status():
    print("\tTesting Statusbar")

    app.addStatusbar(TEXT_ONE, 4, "RIGHT")
    assert len(app._statusFields) == 4

Found in tests/widget_test.py - About 1 hr to fix

Function `testScrollPaneScrolling` has 30 lines of code (exceeds 25 allowed). Consider refactoring.
Open

def testScrollPaneScrolling(sp):
    event = Event()

    sp._mouseEnter(event)
    sp._mouseLeave(event)

Found in tests/widget_test.py - About 1 hr to fix

Function `testScrollPaneScrolling` has a Cognitive Complexity of 10 (exceeds 5 allowed). Consider refactoring.
Open

def testScrollPaneScrolling(sp):
    event = Event()

    sp._mouseEnter(event)
    sp._mouseLeave(event)

Found in tests/widget_test.py - About 1 hr to fix

Read up
Read up

Cognitive Complexity

Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

A method's cognitive complexity is based on a few simple rules:

Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
Code is considered more complex for each "break in the linear flow of the code"
Code is considered more complex when "flow breaking structures are nested"

Cognitive Complexity

A method's cognitive complexity is based on a few simple rules:

Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
Code is considered more complex for each "break in the linear flow of the code"
Code is considered more complex when "flow breaking structures are nested"

Cognitive Complexity

A method's cognitive complexity is based on a few simple rules:

Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
Code is considered more complex for each "break in the linear flow of the code"
Code is considered more complex when "flow breaking structures are nested"

Cognitive Complexity

A method's cognitive complexity is based on a few simple rules:

Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
Code is considered more complex for each "break in the linear flow of the code"
Code is considered more complex when "flow breaking structures are nested"

Duplicated Code

Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

Tuning

This issue has a mass of 74.

We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

Refactorings

Duplicated Code

Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

Tuning

This issue has a mass of 74.

We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

Refactorings

Duplicated Code

Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

Tuning

This issue has a mass of 72.

We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

Refactorings

Duplicated Code

Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

Tuning

This issue has a mass of 72.

We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

Refactorings

Duplicated Code

Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

Tuning

This issue has a mass of 58.

We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

Refactorings

Duplicated Code

Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

Tuning

This issue has a mass of 44.

We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

Refactorings

Duplicated Code

Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

Tuning

This issue has a mass of 44.

We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

Refactorings

Duplicated Code

Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

Tuning

This issue has a mass of 44.

We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

Refactorings

Duplicated Code

Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

Tuning

This issue has a mass of 44.

We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

Refactorings

Duplicated Code

Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

Tuning

This issue has a mass of 44.

We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

Refactorings

Duplicated Code

Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

Tuning

This issue has a mass of 44.

We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

Refactorings

Duplicated Code

Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

Tuning

This issue has a mass of 40.

We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

Refactorings

Duplicated Code

Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

Tuning

This issue has a mass of 40.

We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

Refactorings

Duplicated Code

Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

Tuning

This issue has a mass of 40.

We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

Refactorings

Duplicated Code

Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

Tuning

This issue has a mass of 40.

We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

Refactorings

Duplicated Code

Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

Tuning

This issue has a mass of 37.

We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

Refactorings

Duplicated Code

Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

Tuning

This issue has a mass of 37.

We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

Refactorings

Duplicated Code

Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

Tuning

This issue has a mass of 35.

We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

Refactorings

Duplicated Code

Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

Tuning

This issue has a mass of 35.

We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

Refactorings

Duplicated Code

Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

Tuning

This issue has a mass of 34.

We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

Refactorings

Duplicated Code

Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

Tuning

This issue has a mass of 34.

We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

Refactorings

Duplicated Code

Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

Tuning

This issue has a mass of 33.

We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

Refactorings

Duplicated Code

Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

Tuning

This issue has a mass of 33.

We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

Refactorings

Duplicated Code

Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

Tuning

This issue has a mass of 33.

We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

Refactorings

Duplicated Code

Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

Tuning

This issue has a mass of 33.

We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

Refactorings

Method definitions inside a class are separated by a single blank
line.

Extra blank lines may be used (sparingly) to separate groups of
related functions.  Blank lines may be omitted between a bunch of
related one-liners (e.g. a set of dummy implementations).

Use blank lines in functions, sparingly, to indicate logical
sections.

Okay: def a():\n    pass\n\n\ndef b():\n    pass
Okay: def a():\n    pass\n\n\nasync def b():\n    pass
Okay: def a():\n    pass\n\n\n# Foo\n# Bar\n\ndef b():\n    pass
Okay: default = 1\nfoo = 1
Okay: classify = 1\nfoo = 1

E301: class Foo:\n    b = 0\n    def bar():\n        pass
E302: def a():\n    pass\n\ndef b(n):\n    pass
E302: def a():\n    pass\n\nasync def b(n):\n    pass
E303: def a():\n    pass\n\n\n\ndef b(n):\n    pass
E303: def a():\n\n\n\n    pass
E304: @decorator\n\ndef a():\n    pass
E305: def a():\n    pass\na()
E306: def a():\n    def b():\n        pass\n    def c():\n        pass

Whitespace after '('
Open

    print( app.getEntry("lne1") )

jarvisteach/appJar

Summary

Maintainability

Test Coverage

File widget_test.py has 2888 lines of code (exceeds 250 allowed). Consider refactoring. Open

Cyclomatic complexity is too high in function test_containers. (123) Open

Cyclomatic Complexity

Cyclomatic complexity is too high in function test_entries. (98) Open

Cyclomatic Complexity

Function test_containers has 346 lines of code (exceeds 25 allowed). Consider refactoring. Open

Cyclomatic complexity is too high in function test_gui_properties. (78) Open

Cyclomatic Complexity

Cyclomatic complexity is too high in function test_text_areas. (58) Open

Cyclomatic Complexity

Cyclomatic complexity is too high in function test_lists. (43) Open

Cyclomatic Complexity

Function test_entries has 197 lines of code (exceeds 25 allowed). Consider refactoring. Open

Cyclomatic complexity is too high in function test_checks. (42) Open

Cyclomatic Complexity

Cyclomatic complexity is too high in function test_options. (41) Open

Cyclomatic Complexity

Cyclomatic complexity is too high in function test_scales. (35) Open

Cyclomatic Complexity

Function test_gui_properties has 141 lines of code (exceeds 25 allowed). Consider refactoring. Open

Cyclomatic complexity is too high in function test_spins. (28) Open

Cyclomatic Complexity

Cyclomatic complexity is too high in function test_properties. (26) Open

Cyclomatic Complexity

Function test_text_areas has 125 lines of code (exceeds 25 allowed). Consider refactoring. Open

Cyclomatic complexity is too high in function test_date_pickers. (24) Open

Cyclomatic Complexity

Cyclomatic complexity is too high in function test_labels. (23) Open

Cyclomatic Complexity

Function test_lists has 102 lines of code (exceeds 25 allowed). Consider refactoring. Open

Cyclomatic complexity is too high in function test_message_boxes. (19) Open

Cyclomatic Complexity

Cyclomatic complexity is too high in function test_buttons. (19) Open

Cyclomatic Complexity

Cyclomatic complexity is too high in function test_radios. (18) Open

Cyclomatic Complexity

Cyclomatic complexity is too high in function test_menus. (15) Open

Cyclomatic Complexity

Function test_options has 83 lines of code (exceeds 25 allowed). Consider refactoring. Open

Function test_scales has 82 lines of code (exceeds 25 allowed). Consider refactoring. Open

Cyclomatic complexity is too high in function test_gui_options. (13) Open

Cyclomatic Complexity

Function test_checks has 68 lines of code (exceeds 25 allowed). Consider refactoring. Open

Cyclomatic complexity is too high in function test_status. (11) Open

Cyclomatic Complexity

Cyclomatic complexity is too high in function test_meters. (10) Open

Cyclomatic Complexity

Cyclomatic complexity is too high in function test_images. (10) Open

Cyclomatic Complexity

Cyclomatic complexity is too high in function testScrollPaneScrolling. (9) Open

Cyclomatic Complexity

Function test_gui_options has 57 lines of code (exceeds 25 allowed). Consider refactoring. Open

Function test_setters has 55 lines of code (exceeds 25 allowed). Consider refactoring. Open

Function test_properties has 55 lines of code (exceeds 25 allowed). Consider refactoring. Open

Function test_menus has 55 lines of code (exceeds 25 allowed). Consider refactoring. Open

Cyclomatic complexity is too high in function test_sets. (8) Open

Cyclomatic Complexity

Cyclomatic complexity is too high in function test_googlemap. (7) Open

Cyclomatic Complexity

Function test_date_pickers has 47 lines of code (exceeds 25 allowed). Consider refactoring. Open

Cyclomatic complexity is too high in function test_sounds. (6) Open

Cyclomatic Complexity

Cyclomatic complexity is too high in function test_gui. (6) Open

Cyclomatic Complexity

Cyclomatic complexity is too high in function test_gui4. (6) Open

Cyclomatic Complexity

Function test_labels has 45 lines of code (exceeds 25 allowed). Consider refactoring. Open

Function test_toolbars has 44 lines of code (exceeds 25 allowed). Consider refactoring. Open

Function test_images has 44 lines of code (exceeds 25 allowed). Consider refactoring. Open

Function test_spins has 40 lines of code (exceeds 25 allowed). Consider refactoring. Open

Function test_buttons has 37 lines of code (exceeds 25 allowed). Consider refactoring. Open

Function test_radios has 37 lines of code (exceeds 25 allowed). Consider refactoring. Open

Function test_message_boxes has 34 lines of code (exceeds 25 allowed). Consider refactoring. Open

Function test_status has 31 lines of code (exceeds 25 allowed). Consider refactoring. Open

Function testScrollPaneScrolling has 30 lines of code (exceeds 25 allowed). Consider refactoring. Open

Function testScrollPaneScrolling has a Cognitive Complexity of 10 (exceeds 5 allowed). Consider refactoring. Open

File `widget_test.py` has 2888 lines of code (exceeds 250 allowed). Consider refactoring.
Open

Cyclomatic complexity is too high in function test_containers. (123)
Open

Cyclomatic complexity is too high in function test_entries. (98)
Open

Function `test_containers` has 346 lines of code (exceeds 25 allowed). Consider refactoring.
Open

Cyclomatic complexity is too high in function test_gui_properties. (78)
Open

Cyclomatic complexity is too high in function test_text_areas. (58)
Open

Cyclomatic complexity is too high in function test_lists. (43)
Open

Function `test_entries` has 197 lines of code (exceeds 25 allowed). Consider refactoring.
Open

Cyclomatic complexity is too high in function test_checks. (42)
Open

Cyclomatic complexity is too high in function test_options. (41)
Open

Cyclomatic complexity is too high in function test_scales. (35)
Open

Function `test_gui_properties` has 141 lines of code (exceeds 25 allowed). Consider refactoring.
Open

Cyclomatic complexity is too high in function test_spins. (28)
Open

Cyclomatic complexity is too high in function test_properties. (26)
Open

Function `test_text_areas` has 125 lines of code (exceeds 25 allowed). Consider refactoring.
Open

Cyclomatic complexity is too high in function test_date_pickers. (24)
Open

Cyclomatic complexity is too high in function test_labels. (23)
Open

Function `test_lists` has 102 lines of code (exceeds 25 allowed). Consider refactoring.
Open

Cyclomatic complexity is too high in function test_message_boxes. (19)
Open

Cyclomatic complexity is too high in function test_buttons. (19)
Open

Cyclomatic complexity is too high in function test_radios. (18)
Open

Cyclomatic complexity is too high in function test_menus. (15)
Open

Function `test_options` has 83 lines of code (exceeds 25 allowed). Consider refactoring.
Open

Function `test_scales` has 82 lines of code (exceeds 25 allowed). Consider refactoring.
Open

Cyclomatic complexity is too high in function test_gui_options. (13)
Open

Function `test_checks` has 68 lines of code (exceeds 25 allowed). Consider refactoring.
Open

Cyclomatic complexity is too high in function test_status. (11)
Open

Cyclomatic complexity is too high in function test_meters. (10)
Open

Cyclomatic complexity is too high in function test_images. (10)
Open

Cyclomatic complexity is too high in function testScrollPaneScrolling. (9)
Open

Function `test_gui_options` has 57 lines of code (exceeds 25 allowed). Consider refactoring.
Open

Function `test_setters` has 55 lines of code (exceeds 25 allowed). Consider refactoring.
Open

Function `test_properties` has 55 lines of code (exceeds 25 allowed). Consider refactoring.
Open

Function `test_menus` has 55 lines of code (exceeds 25 allowed). Consider refactoring.
Open

Cyclomatic complexity is too high in function test_sets. (8)
Open

Cyclomatic complexity is too high in function test_googlemap. (7)
Open

Function `test_date_pickers` has 47 lines of code (exceeds 25 allowed). Consider refactoring.
Open

Cyclomatic complexity is too high in function test_sounds. (6)
Open

Cyclomatic complexity is too high in function test_gui. (6)
Open

Cyclomatic complexity is too high in function test_gui4. (6)
Open

Function `test_labels` has 45 lines of code (exceeds 25 allowed). Consider refactoring.
Open

Function `test_toolbars` has 44 lines of code (exceeds 25 allowed). Consider refactoring.
Open

Function `test_images` has 44 lines of code (exceeds 25 allowed). Consider refactoring.
Open

Function `test_spins` has 40 lines of code (exceeds 25 allowed). Consider refactoring.
Open

Function `test_buttons` has 37 lines of code (exceeds 25 allowed). Consider refactoring.
Open

Function `test_radios` has 37 lines of code (exceeds 25 allowed). Consider refactoring.
Open

Function `test_message_boxes` has 34 lines of code (exceeds 25 allowed). Consider refactoring.
Open

Function `test_status` has 31 lines of code (exceeds 25 allowed). Consider refactoring.
Open

Function `testScrollPaneScrolling` has 30 lines of code (exceeds 25 allowed). Consider refactoring.
Open

Function `testScrollPaneScrolling` has a Cognitive Complexity of 10 (exceeds 5 allowed). Consider refactoring.
Open

Avoid deeply nested control flow statements.
Open

Avoid deeply nested control flow statements.
Open

Avoid deeply nested control flow statements.
Open

Avoid deeply nested control flow statements.
Open

Avoid deeply nested control flow statements.
Open

Avoid deeply nested control flow statements.
Open

Function `compareDictionaries` has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring.
Open

Function `test_options` has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring.
Open

Function `test_gui` has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring.
Open

Similar blocks of code found in 2 locations. Consider refactoring.
Open

Similar blocks of code found in 2 locations. Consider refactoring.
Open

Similar blocks of code found in 2 locations. Consider refactoring.
Open

Similar blocks of code found in 2 locations. Consider refactoring.
Open

Similar blocks of code found in 2 locations. Consider refactoring.
Open

Identical blocks of code found in 2 locations. Consider refactoring.
Open

Identical blocks of code found in 2 locations. Consider refactoring.
Open

Identical blocks of code found in 2 locations. Consider refactoring.
Open

Identical blocks of code found in 2 locations. Consider refactoring.
Open

Similar blocks of code found in 2 locations. Consider refactoring.
Open