Style: address pep8 warnings.

Author: reachtarunhere

tests/test_csp.py

@@ -1,6 +1,7 @@
 import pytest
 from csp import *   #noqa
 
+
 def test_backtracking_search():
     assert (backtracking_search(australia) is not None) == True
     assert (backtracking_search(australia, select_unassigned_variable=mrv) is not None) == True
@@ -12,14 +13,15 @@ def test_backtracking_search():
     assert (backtracking_search(usa, select_unassigned_variable=mrv,
                                 order_domain_values=lcv, inference=mac) is not None) == True
 
+
 def test_universal_dict():
     d = UniversalDict(42)
     assert d['life'] == 42
 
+
 def test_parse_neighbours():
     assert parse_neighbors('X: Y Z; Y: Z') == {'Y': ['X', 'Z'], 'X': ['Y', 'Z'], 'Z': ['X', 'Y']}
 
 
-
 if __name__ == "__main__":
     pytest.main()

tests/test_games.py

@@ -18,7 +18,7 @@ def gen_state(to_move='X', x_positions=[], o_positions=[], h=3, v=3, k=3):
     and how many consecutive X's or O's required to win, return the corresponding
     game state"""
 
-    moves = set([(x, y) for x in range(1, h+1) for y in range(1, v+1)]) \
+    moves = set([(x, y) for x in range(1, h + 1) for y in range(1, v + 1)]) \
         - set(x_positions) - set(o_positions)
     moves = list(moves)
     board = {}

tests/test_learning.py

@@ -1,13 +1,14 @@
 import pytest
 from learning import parse_csv, weighted_mode, weighted_replicate
 
+
 def test_parse_csv():
     assert parse_csv('1, 2, 3 \n 0, 2, na') == [[1, 2, 3], [0, 2, 'na']]
 
 
 def test_weighted_mode():
-    assert weighted_mode('abbaa', [1,2,3,1,2]) == 'b'
+    assert weighted_mode('abbaa', [1, 2, 3, 1, 2]) == 'b'
 
 
 def test_weighted_replicate():
-    assert weighted_replicate('ABC', [1,2,1], 4) == ['A', 'B', 'B', 'C']
+    assert weighted_replicate('ABC', [1, 2, 1], 4) == ['A', 'B', 'B', 'C']

tests/test_logic.py

@@ -9,9 +9,11 @@ def test_expr():
     assert (expr_handle_infix_ops('P & Q ==> R & ~S')
             == "P & Q |'==>'| R & ~S")
 
+
 def test_extend():
     assert extend({x: 1}, y, 2) == {x: 1, y: 2}
 
+
 def test_PropKB():
     kb = PropKB()
     assert count(kb.ask(expr) for expr in [A, C, D, E, Q]) is 0
@@ -33,44 +35,44 @@ def test_KB_wumpus():
     # TODO: Let's just use P11, P12, ... = symbols('P11, P12, ...')
     P = {}
     B = {}
-    P[1,1] = Symbol("P[1,1]")
-    P[1,2] = Symbol("P[1,2]")
-    P[2,1] = Symbol("P[2,1]")
-    P[2,2] = Symbol("P[2,2]")
-    P[3,1] = Symbol("P[3,1]")
-    B[1,1] = Symbol("B[1,1]")
-    B[2,1] = Symbol("B[2,1]")
-
-    kb_wumpus.tell(~P[1,1])
-    kb_wumpus.tell(B[1,1] |'<=>'| ((P[1,2] | P[2,1])))
-    kb_wumpus.tell(B[2,1] |'<=>'| ((P[1,1] | P[2,2] | P[3,1])))
-    kb_wumpus.tell(~B[1,1])
-    kb_wumpus.tell(B[2,1])
+    P[1, 1] = Symbol("P[1,1]")
+    P[1, 2] = Symbol("P[1,2]")
+    P[2, 1] = Symbol("P[2,1]")
+    P[2, 2] = Symbol("P[2,2]")
+    P[3, 1] = Symbol("P[3,1]")
+    B[1, 1] = Symbol("B[1,1]")
+    B[2, 1] = Symbol("B[2,1]")
+
+    kb_wumpus.tell(~P[1, 1])
+    kb_wumpus.tell(B[1, 1] | '<=>' | ((P[1, 2] | P[2, 1])))
+    kb_wumpus.tell(B[2, 1] | '<=>' | ((P[1, 1] | P[2, 2] | P[3, 1])))
+    kb_wumpus.tell(~B[1, 1])
+    kb_wumpus.tell(B[2, 1])
 
     # Statement: There is no pit in [1,1].
-    assert kb_wumpus.ask(~P[1,1]) == {}
+    assert kb_wumpus.ask(~P[1, 1]) == {}
 
     # Statement: There is no pit in [1,2].
-    assert kb_wumpus.ask(~P[1,2]) == {}
+    assert kb_wumpus.ask(~P[1, 2]) == {}
 
     # Statement: There is a pit in [2,2].
-    assert kb_wumpus.ask(P[2,2]) == False
+    assert kb_wumpus.ask(P[2, 2]) == False
 
     # Statement: There is a pit in [3,1].
-    assert kb_wumpus.ask(P[3,1]) == False
+    assert kb_wumpus.ask(P[3, 1]) == False
 
     # Statement: Neither [1,2] nor [2,1] contains a pit.
-    assert kb_wumpus.ask(~P[1,2] & ~P[2,1]) == {}
+    assert kb_wumpus.ask(~P[1, 2] & ~P[2, 1]) == {}
 
     # Statement: There is a pit in either [2,2] or [3,1].
-    assert kb_wumpus.ask(P[2,2] | P[3,1]) == {}
+    assert kb_wumpus.ask(P[2, 2] | P[3, 1]) == {}
 
 
 def test_definite_clause():
-    assert     is_definite_clause(expr('A & B & C & D ==> E'))
-    assert     is_definite_clause(expr('Farmer(Mac)'))
+    assert is_definite_clause(expr('A & B & C & D ==> E'))
+    assert is_definite_clause(expr('Farmer(Mac)'))
     assert not is_definite_clause(expr('~Farmer(Mac)'))
-    assert     is_definite_clause(expr('(Farmer(f) & Rabbit(r)) ==> Hates(f, r)'))
+    assert is_definite_clause(expr('(Farmer(f) & Rabbit(r)) ==> Hates(f, r)'))
     assert not is_definite_clause(expr('(Farmer(f) & ~Rabbit(r)) ==> Hates(f, r)'))
     assert not is_definite_clause(expr('(Farmer(f) | Rabbit(r)) ==> Hates(f, r)'))
 
@@ -79,12 +81,13 @@ def test_pl_true():
     assert pl_true(P, {}) is None
     assert pl_true(P, {P: False}) is False
     assert pl_true(P | Q, {P: True}) is True
-    assert pl_true((A|B)&(C|D), {A: False, B: True, D: True}) is True
-    assert pl_true((A&B)&(C|D), {A: False, B: True, D: True}) is False
-    assert pl_true((A&B)|(A&C), {A: False, B: True, C: True}) is False
-    assert pl_true((A|B)&(C|D), {A: True, D: False}) is None
+    assert pl_true((A | B) & (C | D), {A: False, B: True, D: True}) is True
+    assert pl_true((A & B) & (C | D), {A: False, B: True, D: True}) is False
+    assert pl_true((A & B) | (A & C), {A: False, B: True, C: True}) is False
+    assert pl_true((A | B) & (C | D), {A: True, D: False}) is None
     assert pl_true(P | P, {}) is None
 
+
 def test_tt_true():
     assert tt_true(P | ~P)
     assert tt_true('~~P <=> P')
@@ -103,48 +106,56 @@ def test_tt_true():
     assert tt_true('(A & (B | C)) <=> ((A & B) | (A & C))')
     assert tt_true('(A | (B & C)) <=> ((A | B) & (A | C))')
 
+
 def test_dpll():
     assert (dpll_satisfiable(A & ~B & C & (A | ~D) & (~E | ~D) & (C | ~D) & (~A | ~F) & (E | ~F)
                              & (~D | ~F) & (B | ~C | D) & (A | ~E | F) & (~A | E | D))
             == {B: False, C: True, A: True, F: False, D: True, E: False})
-    assert dpll_satisfiable(A&~B) == {A: True, B: False}
-    assert dpll_satisfiable(P&~P) == False
+    assert dpll_satisfiable(A & ~B) == {A: True, B: False}
+    assert dpll_satisfiable(P & ~P) == False
 
 
 def test_unify():
     assert unify(x, x, {}) == {}
     assert unify(x, 3, {}) == {x: 3}
 
+
 def test_pl_fc_entails():
     assert pl_fc_entails(horn_clauses_KB, expr('Q'))
     assert not pl_fc_entails(horn_clauses_KB, expr('SomethingSilly'))
 
+
 def test_tt_entails():
     assert tt_entails(P & Q, Q)
     assert not tt_entails(P | Q, Q)
     assert tt_entails(A & (B | C) & E & F & ~(P | Q), A & E & F & ~P & ~Q)
 
+
 def test_eliminate_implications():
     assert repr(eliminate_implications('A ==> (~B <== C)')) == '((~B | ~C) | ~A)'
     assert repr(eliminate_implications(A ^ B)) == '((A & ~B) | (~A & B))'
     assert repr(eliminate_implications(A & B | C & ~D)) == '((A & B) | (C & ~D))'
 
+
 def test_dissociate():
     assert dissociate('&', [A & B]) == [A, B]
     assert dissociate('|', [A, B, C & D, P | Q]) == [A, B, C & D, P, Q]
     assert dissociate('&', [A, B, C & D, P | Q]) == [A, B, C, D, P | Q]
 
+
 def test_associate():
     assert (repr(associate('&', [(A & B), (B | C), (B & C)]))
             == '(A & B & (B | C) & B & C)')
     assert (repr(associate('|', [A | (B | (C | (A & B)))]))
             == '(A | B | C | (A & B))')
 
+
 def test_move_not_inwards():
     assert repr(move_not_inwards(~(A | B))) == '(~A & ~B)'
     assert repr(move_not_inwards(~(A & B))) == '(~A | ~B)'
     assert repr(move_not_inwards(~(~(A | ~B) | ~~C))) == '((A | ~B) & ~C)'
 
+
 def test_to_cnf():
     assert (repr(to_cnf(wumpus_world_inference & ~expr('~P12'))) ==
             "((~P12 | B11) & (~P21 | B11) & (P12 | P21 | ~B11) & ~B11 & P12)")
@@ -154,36 +165,40 @@ def test_to_cnf():
     assert repr(to_cnf("A & (B | (D & E))")) == '(A & (D | B) & (E | B))'
     assert repr(to_cnf("A | (B | (C | (D & E)))")) == '((D | A | B | C) & (E | A | B | C))'
 
+
 def test_standardize_variables():
     e = expr('F(a, b, c) & G(c, A, 23)')
     assert len(variables(standardize_variables(e))) == 3
     #assert variables(e).intersection(variables(standardize_variables(e))) == {}
     assert is_variable(standardize_variables(expr('x')))
 
+
 def test_fol_bc_ask():
     def test_ask(query, kb=None):
         q = expr(query)
         test_variables = variables(q)
         answers = fol_bc_ask(kb or test_kb, q)
         return sorted(
             [dict((x, v) for x, v in list(a.items()) if x in test_variables)
-             for a in answers],  key=repr)
+             for a in answers], key=repr)
     assert repr(test_ask('Farmer(x)')) == '[{x: Mac}]'
     assert repr(test_ask('Human(x)')) == '[{x: Mac}, {x: MrsMac}]'
     assert repr(test_ask('Rabbit(x)')) == '[{x: MrsRabbit}, {x: Pete}]'
     assert repr(test_ask('Criminal(x)', crime_kb)) == '[{x: West}]'
 
+
 def test_d():
-    assert d(x*x - x, x) == 2*x - 1
+    assert d(x * x - x, x) == 2 * x - 1
+
 
 def test_WalkSAT():
-    def check_SAT(clauses, single_solution = {}):
+    def check_SAT(clauses, single_solution={}):
         # Make sure the solution is correct if it is returned by WalkSat
         # Sometimes WalkSat may run out of flips before finding a solution
         soln = WalkSAT(clauses)
         if soln:
             assert all(pl_true(x, soln) for x in clauses)
-            if single_solution:  #Cross check the solution if only one exists
+            if single_solution:  # Cross check the solution if only one exists
                 assert all(pl_true(x, single_solution) for x in clauses)
                 assert soln == single_solution
     # Test WalkSat for problems with solution
@@ -195,18 +210,19 @@ def check_SAT(clauses, single_solution = {}):
     assert WalkSAT([A | B, ~A, ~(B | C), C | D, P | Q], 0.5, 100) is None
     assert WalkSAT([A | B, B & C, C | D, D & A, P, ~P], 0.5, 100) is None
 
+
 def test_SAT_plan():
-    transition = {'A':{'Left': 'A', 'Right': 'B'},
-                  'B':{'Left': 'A', 'Right': 'C'},
-                  'C':{'Left': 'B', 'Right': 'C'}}
+    transition = {'A': {'Left': 'A', 'Right': 'B'},
+                  'B': {'Left': 'A', 'Right': 'C'},
+                  'C': {'Left': 'B', 'Right': 'C'}}
     assert SAT_plan('A', transition, 'C', 2) is None
     assert SAT_plan('A', transition, 'B', 3) == ['Right']
     assert SAT_plan('C', transition, 'A', 3) == ['Left', 'Left']
 
-    transition = {(0, 0):{'Right': (0, 1), 'Down': (1, 0)},
-                  (0, 1):{'Left': (1, 0), 'Down': (1, 1)},
-                  (1, 0):{'Right': (1, 0), 'Up': (1, 0), 'Left': (1, 0), 'Down': (1, 0)},
-                  (1, 1):{'Left': (1, 0), 'Up': (0, 1)}}
+    transition = {(0, 0): {'Right': (0, 1), 'Down': (1, 0)},
+                  (0, 1): {'Left': (1, 0), 'Down': (1, 1)},
+                  (1, 0): {'Right': (1, 0), 'Up': (1, 0), 'Left': (1, 0), 'Down': (1, 0)},
+                  (1, 1): {'Left': (1, 0), 'Up': (0, 1)}}
     assert SAT_plan((0, 0), transition, (1, 1), 4) == ['Right', 'Down']
 
 

tests/test_mdp.py

@@ -1,6 +1,7 @@
 import pytest
 from mdp import *  # noqa
 
+
 def test_value_iteration():
     assert value_iteration(sequential_decision_environment, .01) == {(3, 2): 1.0, (3, 1): -1.0,
                                         (3, 0): 0.12958868267972745, (0, 1): 0.39810203830605462,

tests/test_nlp.py

@@ -1,9 +1,10 @@
 import pytest
 from nlp import *
 
+
 def test_rules():
-    assert Rules(A = "B C | D E") == {'A': [['B', 'C'], ['D', 'E']]}
+    assert Rules(A="B C | D E") == {'A': [['B', 'C'], ['D', 'E']]}
 
 
 def test_lexicon():
-    assert Lexicon(Art = "the | a | an") == {'Art': ['the', 'a', 'an']}
+    assert Lexicon(Art="the | a | an") == {'Art': ['the', 'a', 'an']}

tests/test_planning.py

@@ -2,6 +2,7 @@
 from utils import expr
 from logic import FolKB
 
+
 def test_action():
     precond = [[expr("P(x)"), expr("Q(y, z)")]
                ,[expr("Q(x)")]]
@@ -18,15 +19,16 @@ def test_action():
     assert test_kb.ask(expr("Q(B, C)")) is not False
     assert not a.check_precond(test_kb, args)
 
+
 def test_air_cargo():
     p = air_cargo()
     assert p.goal_test() is False
-    solution =[expr("Load(C1 , P1, SFO)"),
-               expr("Fly(P1, SFO, JFK)"),
-               expr("Unload(C1, P1, JFK)"),
-               expr("Load(C2, P2, JFK)"),
-               expr("Fly(P2, JFK, SFO)"),
-               expr("Unload (C2, P2, SFO)")]
+    solution = [expr("Load(C1 , P1, SFO)"),
+                expr("Fly(P1, SFO, JFK)"),
+                expr("Unload(C1, P1, JFK)"),
+                expr("Load(C2, P2, JFK)"),
+                expr("Fly(P2, JFK, SFO)"),
+                expr("Unload (C2, P2, SFO)")]
 
     for action in solution:
         p.act(action)

tests/test_probability.py

@@ -119,6 +119,7 @@ def test_forward_backward():
     assert rounder(forward_backward(umbrellaHMM, umbrella_evidence, umbrella_prior)) == [[0.5871, 0.4129],
                  [0.7177, 0.2823], [0.2324, 0.7676], [0.6072, 0.3928], [0.2324, 0.7676], [0.7177, 0.2823]]
 
+
 def test_fixed_lag_smoothing():
     umbrella_evidence = [T, F, T, F, T]
     e_t = F

tests/test_search.py

@@ -23,22 +23,27 @@ def test_depth_first_graph_search():
     solution = depth_first_graph_search(romania_problem).solution()
     assert solution[-1] == 'Bucharest'
 
+
 def test_iterative_deepening_search():
     assert iterative_deepening_search(romania_problem).solution() == ['Sibiu', 'Fagaras', 'Bucharest']
 
+
 def test_depth_limited_search():
     solution_3 = depth_limited_search(romania_problem, 3).solution()
     assert solution_3[-1] == 'Bucharest'
     assert depth_limited_search(romania_problem, 2) == 'cutoff'
     solution_50 = depth_limited_search(romania_problem).solution()
     assert solution_50[-1] == 'Bucharest'
 
+
 def test_astar_search():
     assert astar_search(romania_problem).solution() == ['Sibiu', 'Rimnicu', 'Pitesti', 'Bucharest']
 
+
 def test_recursive_best_first_search():
     assert recursive_best_first_search(romania_problem).solution() == ['Sibiu', 'Rimnicu', 'Pitesti', 'Bucharest']
 
+
 def test_BoggleFinder():
     board = list('SARTELNID')
     """
@@ -50,6 +55,7 @@ def test_BoggleFinder():
     f = BoggleFinder(board)
     assert len(f) == 206
 
+
 def test_and_or_graph_search():
     def run_plan(state, problem, plan):
         if problem.goal_test(state):
@@ -61,6 +67,7 @@ def run_plan(state, problem, plan):
     plan = and_or_graph_search(vacumm_world)
     assert run_plan('State_1', vacumm_world, plan)
 
+
 def test_LRTAStarAgent():
     my_agent = LRTAStarAgent(LRTA_problem)
     assert my_agent('State_3') == 'Right'
@@ -104,7 +111,7 @@ def test_LRTAStarAgent():
 
 >>> boggle_hill_climbing(list('ABCDEFGHI'), verbose=False)
 (['E', 'P', 'R', 'D', 'O', 'A', 'G', 'S', 'T'], 123)
-"""    
+"""
 
 if __name__ == '__main__':
     pytest.main()