Style: address pep8 warnings.

darius · darius · commit 194a2f192414 · 2016-04-17T01:57:34.000-04:00
diff --git a/csp.py b/csp.py
@@ -106,8 +106,9 @@ def result(self, state, action):
     def goal_test(self, state):
         "The goal is to assign all variables, with all constraints satisfied."
         assignment = dict(state)
-        return (len(assignment) == len(self.variables) and
-                all(self.nconflicts(variables, assignment[variables], assignment) == 0 for variables in  self.variables))
+        return (len(assignment) == len(self.variables)
+                and all(self.nconflicts(variables, assignment[variables], assignment) == 0
+                        for variables in self.variables))
 
     # These are for constraint propagation
 
@@ -663,4 +664,3 @@ def solve_zebra(algorithm=min_conflicts, **args):
                 print(var, end=' ')
         print()
     return ans['Zebra'], ans['Water'], z.nassigns, ans
-
diff --git a/games.py b/games.py
@@ -232,7 +232,7 @@ def terminal_test(self, state):
         return state not in ('A', 'B', 'C', 'D')
 
     def to_move(self, state):
-        return  'MIN' if state in 'BCD' else 'MAX'
+        return 'MIN' if state in 'BCD' else 'MAX'
 
 
 class TicTacToe(Game):
@@ -266,7 +266,7 @@ def result(self, state, move):
 
     def utility(self, state, player):
         "Return the value to player; 1 for win, -1 for loss, 0 otherwise."
-        return  state.utility if player == 'X' else -state.utility
+        return state.utility if player == 'X' else -state.utility
 
     def terminal_test(self, state):
         "A state is terminal if it is won or there are no empty squares."
@@ -343,7 +343,7 @@ def mouse_click(self, x, y):
         if player == 'human':
             x, y = int(3*x/self.width) + 1, int(3*y/self.height) + 1
             if (x, y) not in self.ttt.actions(self.state):
-                #Invalid move
+                # Invalid move
                 return
             move = (x, y)
         elif player == 'alphabeta':
@@ -368,14 +368,14 @@ def draw_board(self):
                 self.draw_x(mark)
             elif board[mark] == 'O':
                 self.draw_o(mark)
-        #End game message
         if self.ttt.terminal_test(self.state):
+            # End game message
             utility = self.ttt.utility(self.state, self.ttt.to_move(self.ttt.initial))
             if utility == 0:
                 self.text_n('Game Draw!', 0.1, 0.1)
             else:
                 self.text_n('Player {} wins!'.format(1 if utility>0 else 2), 0.1, 0.1)
-        else:  #print which player's turn it is
+        else:  # Print which player's turn it is
             self.text_n("Player {}'s move({})".format(self.turn+1, self.players[self.turn]), 0.1, 0.1)
 
         self.update()
diff --git a/ipyviews.py b/ipyviews.py
@@ -133,7 +133,7 @@ def handle_click(self, coordinates):
     def map_to_render(self):
         default_representation = {"val": "default", "tooltip": ""}
         world_map = [[copy.deepcopy(default_representation) for _ in range(self.world.width)]
-                        for _ in range(self.world.height)]
+                     for _ in range(self.world.height)]
 
         for thing in self.world.things:
             row, column = thing.location
@@ -150,6 +150,7 @@ def map_to_render(self):
 
     def show(self):
         clear_output()
-        total_html = _GRID_WORLD_HTML.format(self.object_name(), self.map_to_render(),
+        total_html = _GRID_WORLD_HTML.format(
+            self.object_name(), self.map_to_render(),
             self.block_size, json.dumps(self.representation), _JS_GRID_WORLD)
         display(HTML(total_html))
diff --git a/learning.py b/learning.py
@@ -290,7 +290,6 @@ def __init__(self, attr, attrname=None, branches=None):
         self.attrname = attrname or attr
         self.branches = branches or {}
 
-
     def __call__(self, example):
         "Given an example, classify it using the attribute and the branches."
         attrvalue = example[self.attr]
diff --git a/logic.py b/logic.py
@@ -238,7 +238,7 @@ def pl_true(exp, model={}):
     and False if it is false. If the model does not specify the value for
     every proposition, this may return None to indicate 'not obvious';
     this may happen even when the expression is tautological."""
-    if exp == True or exp == False:
+    if exp in (True, False):
         return exp
     op, args = exp.op, exp.args
     if is_prop_symbol(op):
@@ -639,7 +639,7 @@ def inspect_literal(literal):
 def WalkSAT(clauses, p=0.5, max_flips=10000):
     """Checks for satisfiability of all clauses by randomly flipping values of variables
     """
-    # set of all symbols in all clauses
+    # Set of all symbols in all clauses
     symbols = set(sym for clause in clauses for sym in prop_symbols(clause))
     # model is a random assignment of true/false to the symbols in clauses
     model = {s: random.choice([True, False]) for s in symbols}
@@ -655,14 +655,14 @@ def WalkSAT(clauses, p=0.5, max_flips=10000):
         else:
             # Flip the symbol in clause that maximizes number of sat. clauses
             def sat_count(sym):
-                #returns the the number of clauses satisfied after flipping the symbol
+                # Return the the number of clauses satisfied after flipping the symbol.
                 model[sym] = not model[sym]
                 count = len([clause for clause in clauses if pl_true(clause, model)])
                 model[sym] = not model[sym]
                 return count
             sym = argmax(prop_symbols(clause), key=sat_count)
         model[sym] = not model[sym]
-    #If no solution is found within the flip limit, we return failure
+    # If no solution is found within the flip limit, we return failure
     return None
 
 # ______________________________________________________________________________
@@ -686,71 +686,71 @@ def SAT_plan(init, transition, goal, t_max, SAT_solver=dpll_satisfiable):
     """Converts a planning problem to Satisfaction problem by translating it to a cnf sentence.
     [Figure 7.22]"""
 
-    #Functions used by SAT_plan
+    # Functions used by SAT_plan
     def translate_to_SAT(init, transition, goal, time):
         clauses = []
         states = [state for state in transition]
 
-        #Symbol claiming state s at time t
+        # Symbol claiming state s at time t
         state_counter = itertools.count()
         for s in states:
             for t in range(time+1):
-                state_sym[(s, t)] = Expr("State_{}".format(next(state_counter)))
+                state_sym[s, t] = Expr("State_{}".format(next(state_counter)))
 
-        #Add initial state axiom
+        # Add initial state axiom
         clauses.append(state_sym[init, 0])
 
-        #Add goal state axiom
+        # Add goal state axiom
         clauses.append(state_sym[goal, time])
 
-        #All possible transitions
+        # All possible transitions
         transition_counter = itertools.count()
         for s in states:
             for action in transition[s]:
                 s_ = transition[s][action]
                 for t in range(time):
-                    #Action 'action' taken from state 's' at time 't' to reach 's_'
-                    action_sym[(s, action, t)] = Expr("Transition_{}".format(next(transition_counter)))
+                    # Action 'action' taken from state 's' at time 't' to reach 's_'
+                    action_sym[s, action, t] = Expr("Transition_{}".format(next(transition_counter)))
 
                     # Change the state from s to s_
                     clauses.append(action_sym[s, action, t] |'==>'| state_sym[s, t])
                     clauses.append(action_sym[s, action, t] |'==>'| state_sym[s_, t + 1])
 
-        #Allow only one state at any time
+        # Allow only one state at any time
         for t in range(time+1):
-            #must be a state at any time
-            clauses.append(associate('|', [ state_sym[s, t] for s in states ]))
+            # must be a state at any time
+            clauses.append(associate('|', [state_sym[s, t] for s in states]))
 
             for s in states:
                 for s_ in states[states.index(s)+1:]:
-                    #for each pair of states s, s_ only one is possible at time t
+                    # for each pair of states s, s_ only one is possible at time t
                     clauses.append((~state_sym[s, t]) | (~state_sym[s_, t]))
 
-        #Restrict to one transition per timestep
+        # Restrict to one transition per timestep
         for t in range(time):
-            #list of possible transitions at time t
+            # list of possible transitions at time t
             transitions_t = [tr for tr in action_sym if tr[2] == t]
 
-            #make sure atleast one of the transition happens
-            clauses.append(associate('|', [ action_sym[tr] for tr in transitions_t ]))
+            # make sure at least one of the transitions happens
+            clauses.append(associate('|', [action_sym[tr] for tr in transitions_t]))
 
             for tr in transitions_t:
                 for tr_ in transitions_t[transitions_t.index(tr) + 1 :]:
-                    #there cannot be two transitions tr and tr_ at time t
-                    clauses.append((~action_sym[tr]) | (~action_sym[tr_]))
+                    # there cannot be two transitions tr and tr_ at time t
+                    clauses.append(~action_sym[tr] | ~action_sym[tr_])
 
-        #Combine the clauses to form the cnf
+        # Combine the clauses to form the cnf
         return associate('&', clauses)
 
     def extract_solution(model):
-        true_transitions = [ t for t in action_sym if model[action_sym[t]]]
-        #Sort transitions based on time which is the 3rd element of the tuple
+        true_transitions = [t for t in action_sym if model[action_sym[t]]]
+        # Sort transitions based on time, which is the 3rd element of the tuple
         true_transitions.sort(key = lambda x: x[2])
-        return [ action for s, action, time in true_transitions ]
+        return [action for s, action, time in true_transitions]
 
-    #Body of SAT_plan algorithm
+    # Body of SAT_plan algorithm
     for t in range(t_max):
-        #dcitionaries to help extract the solution from model
+        # dictionaries to help extract the solution from model
         state_sym = {}
         action_sym = {}
 
@@ -1062,5 +1062,3 @@ def simp(x):
 def d(y, x):
     "Differentiate and then simplify."
     return simp(diff(y, x))
-
-
diff --git a/mdp.py b/mdp.py
@@ -102,9 +102,9 @@ def to_arrows(self, policy):
 """
 
 sequential_decision_environment = GridMDP([[-0.04, -0.04, -0.04, +1],
-                      [-0.04, None,  -0.04, -1],
-                      [-0.04, -0.04, -0.04, -0.04]],
-                     terminals=[(3, 2), (3, 1)])
+                                           [-0.04, None,  -0.04, -1],
+                                           [-0.04, -0.04, -0.04, -0.04]],
+                                          terminals=[(3, 2), (3, 1)])
 
 # ______________________________________________________________________________
 
diff --git a/nlp.py b/nlp.py
@@ -182,6 +182,3 @@ def extender(self, edge):
         for (i, j, A, alpha, B1b) in self.chart[j]:
             if B1b and B == B1b[0]:
                 self.add_edge([i, k, A, alpha + [edge], B1b[1:]])
-
-
-
diff --git a/probability.py b/probability.py
@@ -526,7 +526,7 @@ class HiddenMarkovModel:
 
     """ A Hidden markov model which takes Transition model and Sensor model as inputs"""
 
-    def __init__(self, transition_model, sensor_model, prior= [0.5, 0.5]):
+    def __init__(self, transition_model, sensor_model, prior=[0.5, 0.5]):
         self.transition_model = transition_model
         self.sensor_model = sensor_model
         self.prior = prior
@@ -598,7 +598,7 @@ def fixed_lag_smoothing(e_t, HMM, d, ev, t):
     O_t = vector_to_diagonal(HMM.sensor_dist(e_t))
     if t > d:
         f = forward(HMM, f, e_t)
-        O_tmd = vector_to_diagonal(HMM.sensor_dist(ev[t- d]))
+        O_tmd = vector_to_diagonal(HMM.sensor_dist(ev[t - d]))
         B = matrix_multiplication(inverse_matrix(O_tmd), inverse_matrix(T_model), B, T_model, O_t)
     else:
         B = matrix_multiplication(B, T_model, O_t)
diff --git a/rl.py b/rl.py
@@ -54,7 +54,7 @@ def __call__(self, percept):
         return self.a
 
     def update_state(self, percept):
-        ''' To be overriden in most cases. The default case
+        ''' To be overridden in most cases. The default case
         assumes th percept to be of type (state, reward)'''
         return percept
 
@@ -104,19 +104,20 @@ def __call__(self, percept):
         Q, Nsa, s, a, r = self.Q, self.Nsa, self.s, self.a, self.r
         alpha, gamma, terminals, actions_in_state = self.alpha, self.gamma, self.terminals, self.actions_in_state
         if s1 in terminals:
-            Q[(s1, None)] = r1
+            Q[s1, None] = r1
         if s is not None:
-            Nsa[(s, a)] += 1
-            Q[(s, a)] += alpha(Nsa[(s, a)])*(r+gamma*max([Q[(s1, a1)] for a1 in actions_in_state(s1)])-Q[(s, a)])
+            Nsa[s, a] += 1
+            Q[s, a] += alpha(Nsa[s, a]) * (r + gamma * max(Q[s1, a1] for a1 in actions_in_state(s1))
+                                             - Q[s, a])
         if s1 in terminals:
             self.s = self.a = self.r = None
         else:
             self.s, self.r = s1, r1
-            self.a = argmax(actions_in_state(s1), key=lambda a1: self.f(Q[(s1, a1)], Nsa[(s1, a1)]))
+            self.a = argmax(actions_in_state(s1), key=lambda a1: self.f(Q[s1, a1], Nsa[s1, a1]))
         return self.a
 
     def update_state(self, percept):
-        ''' To be overriden in most cases. The default case
+        ''' To be overridden in most cases. The default case
         assumes the percept to be of type (state, reward)'''
         return percept
 
diff --git a/search.py b/search.py
@@ -51,8 +51,9 @@ def result(self, state, action):
 
     def goal_test(self, state):
         """Return True if the state is a goal. The default method compares the
-        state to self.goal or checks for state in self.goal if it is a list, as specified in the constructor. Override this
-        method if checking against a single self.goal is not enough."""
+        state to self.goal or checks for state in self.goal if it is a
+        list, as specified in the constructor. Override this method if
+        checking against a single self.goal is not enough."""
         if isinstance(self.goal, list):
             return is_in(state, self.goal)
         else:
@@ -411,7 +412,7 @@ def or_search(state, problem, path):
 
     def and_search(states, problem, path):
         "returns plan in form of dictionary where we take action plan[s] if we reach state s"  # noqa
-        plan = dict()
+        plan = {}
         for s in states:
             plan[s] = or_search(s, problem, path)
             if plan[s] is None:
@@ -464,7 +465,7 @@ def __call__(self, percept):
         return self.a
 
     def update_state(self, percept):
-        '''To be overriden in most cases. The default case
+        '''To be overridden in most cases. The default case
         assumes the percept to be of type state.'''
         return percept
 
@@ -535,12 +536,12 @@ def __call__(self, s1):     # as of now s1 is a state rather than a percept
                 # self.result[(self.s, self.a)] = s1    # no need as we are using problem.output
 
                 # minimum cost for action b in problem.actions(s)
-                self.H[self.s] = min([self.LRTA_cost(self.s, b, self.problem.output(self.s, b), self.H)
-                                    for b in self.problem.actions(self.s)])
+                self.H[self.s] = min(self.LRTA_cost(self.s, b, self.problem.output(self.s, b), self.H)
+                                     for b in self.problem.actions(self.s))
 
             # costs for action b in problem.actions(s1)
             costs = [self.LRTA_cost(s1, b, self.problem.output(s1, b), self.H)
-                        for b in self.problem.actions(s1)]
+                     for b in self.problem.actions(s1)]
             # an action b in problem.actions(s1) that minimizes costs
             self.a = list(self.problem.actions(s1))[costs.index(min(costs))]
 
@@ -780,8 +781,8 @@ def distance_to_node(n):
     NT=dict(WA=1, Q=1),
     NSW=dict(Q=1, V=1)))
 australia_map.locations = dict(WA=(120, 24), NT=(135, 20), SA=(135, 30),
-                           Q=(145, 20), NSW=(145, 32), T=(145, 42),
-                           V=(145, 37))
+                               Q=(145, 20), NSW=(145, 32), T=(145, 42),
+                               V=(145, 37))
 
 
 class GraphProblem(Problem):
@@ -813,8 +814,10 @@ def h(self, node):
 
 class GraphProblemStochastic(GraphProblem):
     """
-    A version of Graph Problem where an action can lead to undeterministic output i.e. multiple possible states
-    Define the graph as dict(A = dict(Action = [[<Result 1>, <Result 2>, ...],<cost>], ...), ...)
+    A version of GraphProblem where an action can lead to
+    nondeterministic output i.e. multiple possible states
+
+    Define the graph as dict(A = dict(Action = [[<Result 1>, <Result 2>, ...], <cost>], ...), ...)
     A the dictionary format is different, make sure the graph is created as a directed graph
     """
 
@@ -1153,7 +1156,3 @@ def compare_graph_searchers():
                                 GraphProblem('Q', 'WA', australia_map)],
                       header=['Searcher', 'romania_map(Arad, Bucharest)',
                               'romania_map(Oradea, Neamt)', 'australia_map'])
-
-# ______________________________________________________________________________
-
-
diff --git a/utils.py b/utils.py
@@ -191,7 +191,7 @@ def weighted_sampler(seq, weights):
 
     return lambda: seq[bisect.bisect(totals, random.uniform(0, totals[-1]))]
 
-def rounder(numbers, d = 4):
+def rounder(numbers, d=4):
     "Round a single number, or sequence of numbers, to d decimal places."
     if isinstance(numbers, (int, float)):
         return round(numbers, d)
