Revert "fixed build error"

This reverts commit 6641c2c.

agents_4e.py

@@ -113,11 +113,9 @@ def new_program(percept):
         action = old_program(percept)
         print('{} perceives {} and does {}'.format(agent, percept, action))
         return action
-
     agent.program = new_program
     return agent
 
-
 # ______________________________________________________________________________
 
 
@@ -132,7 +130,6 @@ def program(percept):
         percepts.append(percept)
         action = table.get(tuple(percepts))
         return action
-
     return program
 
 
@@ -149,31 +146,26 @@ def RandomAgentProgram(actions):
     """
     return lambda percept: random.choice(actions)
 
-
 # ______________________________________________________________________________
 
 
 def SimpleReflexAgentProgram(rules, interpret_input):
     """This agent takes action based solely on the percept. [Figure 2.10]"""
-
     def program(percept):
         state = interpret_input(percept)
         rule = rule_match(state, rules)
         action = rule.action
         return action
-
     return program
 
 
 def ModelBasedReflexAgentProgram(rules, update_state, trainsition_model, sensor_model):
     """This agent takes action based on the percept and state. [Figure 2.12]"""
-
     def program(percept):
         program.state = update_state(program.state, program.action, percept, trainsition_model, sensor_model)
         rule = rule_match(program.state, rules)
         action = rule.action
         return action
-
     program.state = program.action = None
     return program
 
@@ -184,7 +176,6 @@ def rule_match(state, rules):
         if rule.matches(state):
             return rule
 
-
 # ______________________________________________________________________________
 
 
@@ -228,7 +219,6 @@ def ReflexVacuumAgent():
     >>> environment.status == {(1,0):'Clean' , (0,0) : 'Clean'}
     True
     """
-
     def program(percept):
         location, status = percept
         if status == 'Dirty':
@@ -237,7 +227,6 @@ def program(percept):
             return 'Right'
         elif location == loc_B:
             return 'Left'
-
     return Agent(program)
 
 
@@ -264,10 +253,8 @@ def program(percept):
             return 'Right'
         elif location == loc_B:
             return 'Left'
-
     return Agent(program)
 
-
 # ______________________________________________________________________________
 
 
@@ -405,22 +392,22 @@ def __add__(self, heading):
         True
         """
         if self.direction == self.R:
-            return {
+            return{
                 self.R: Direction(self.D),
                 self.L: Direction(self.U),
             }.get(heading, None)
         elif self.direction == self.L:
-            return {
+            return{
                 self.R: Direction(self.U),
                 self.L: Direction(self.D),
             }.get(heading, None)
         elif self.direction == self.U:
-            return {
+            return{
                 self.R: Direction(self.R),
                 self.L: Direction(self.L),
             }.get(heading, None)
         elif self.direction == self.D:
-            return {
+            return{
                 self.R: Direction(self.L),
                 self.L: Direction(self.R),
             }.get(heading, None)
@@ -438,13 +425,13 @@ def move_forward(self, from_location):
         """
         x, y = from_location
         if self.direction == self.R:
-            return x + 1, y
+            return (x + 1, y)
         elif self.direction == self.L:
-            return x - 1, y
+            return (x - 1, y)
         elif self.direction == self.U:
-            return x, y - 1
+            return (x, y - 1)
         elif self.direction == self.D:
-            return x, y + 1
+            return (x, y + 1)
 
 
 class XYEnvironment(Environment):
@@ -475,7 +462,7 @@ def things_near(self, location, radius=None):
         radius2 = radius * radius
         return [(thing, radius2 - distance_squared(location, thing.location))
                 for thing in self.things if distance_squared(
-                location, thing.location) <= radius2]
+                                                location, thing.location) <= radius2]
 
     def percept(self, agent):
         """By default, agent perceives things within a default radius."""
@@ -489,17 +476,17 @@ def execute_action(self, agent, action):
             agent.direction += Direction.L
         elif action == 'Forward':
             agent.bump = self.move_to(agent, agent.direction.move_forward(agent.location))
-        #         elif action == 'Grab':
-        #             things = [thing for thing in self.list_things_at(agent.location)
-        #                     if agent.can_grab(thing)]
-        #             if things:
-        #                 agent.holding.append(things[0])
+#         elif action == 'Grab':
+#             things = [thing for thing in self.list_things_at(agent.location)
+#                     if agent.can_grab(thing)]
+#             if things:
+#                 agent.holding.append(things[0])
         elif action == 'Release':
             if agent.holding:
                 agent.holding.pop()
 
     def default_location(self, thing):
-        return random.choice(self.width), random.choice(self.height)
+        return (random.choice(self.width), random.choice(self.height))
 
     def move_to(self, thing, destination):
         """Move a thing to a new location. Returns True on success or False if there is an Obstacle.
@@ -518,7 +505,7 @@ def move_to(self, thing, destination):
     def add_thing(self, thing, location=(1, 1), exclude_duplicate_class_items=False):
         """Add things to the world. If (exclude_duplicate_class_items) then the item won't be
         added if the location has at least one item of the same class."""
-        if self.is_inbounds(location):
+        if (self.is_inbounds(location)):
             if (exclude_duplicate_class_items and
                     any(isinstance(t, thing.__class__) for t in self.list_things_at(location))):
                 return
@@ -527,14 +514,14 @@ def add_thing(self, thing, location=(1, 1), exclude_duplicate_class_items=False)
     def is_inbounds(self, location):
         """Checks to make sure that the location is inbounds (within walls if we have walls)"""
         x, y = location
-        return not (x < self.x_start or x > self.x_end or y < self.y_start or y > self.y_end)
+        return not (x < self.x_start or x >= self.x_end or y < self.y_start or y >= self.y_end)
 
     def random_location_inbounds(self, exclude=None):
         """Returns a random location that is inbounds (within walls if we have walls)"""
         location = (random.randint(self.x_start, self.x_end),
                     random.randint(self.y_start, self.y_end))
         if exclude is not None:
-            while location == exclude:
+            while(location == exclude):
                 location = (random.randint(self.x_start, self.x_end),
                             random.randint(self.y_start, self.y_end))
         return location
@@ -556,7 +543,7 @@ def add_walls(self):
         for x in range(self.width):
             self.add_thing(Wall(), (x, 0))
             self.add_thing(Wall(), (x, self.height - 1))
-        for y in range(1, self.height - 1):
+        for y in range(1, self.height-1):
             self.add_thing(Wall(), (0, y))
             self.add_thing(Wall(), (self.width - 1, y))
 
@@ -587,7 +574,6 @@ class Obstacle(Thing):
 class Wall(Obstacle):
     pass
 
-
 # ______________________________________________________________________________
 
 
@@ -696,7 +682,6 @@ def __init__(self, coordinates):
         super().__init__()
         self.coordinates = coordinates
 
-
 # ______________________________________________________________________________
 # Vacuum environment
 
@@ -706,6 +691,7 @@ class Dirt(Thing):
 
 
 class VacuumEnvironment(XYEnvironment):
+
     """The environment of [Ex. 2.12]. Agent perceives dirty or clean,
     and bump (into obstacle) or not; 2D discrete world of unknown size;
     performance measure is 100 for each dirt cleaned, and -1 for
@@ -724,7 +710,7 @@ def percept(self, agent):
         Unlike the TrivialVacuumEnvironment, location is NOT perceived."""
         status = ('Dirty' if self.some_things_at(
             agent.location, Dirt) else 'Clean')
-        bump = ('Bump' if agent.bump else 'None')
+        bump = ('Bump' if agent.bump else'None')
         return (status, bump)
 
     def execute_action(self, agent, action):
@@ -743,6 +729,7 @@ def execute_action(self, agent, action):
 
 
 class TrivialVacuumEnvironment(Environment):
+
     """This environment has two locations, A and B. Each can be Dirty
     or Clean. The agent perceives its location and the location's
     status. This serves as an example of how to implement a simple
@@ -779,7 +766,6 @@ def default_location(self, thing):
         """Agents start in either location at random."""
         return random.choice([loc_A, loc_B])
 
-
 # ______________________________________________________________________________
 # The Wumpus World
 
@@ -789,7 +775,6 @@ class Gold(Thing):
     def __eq__(self, rhs):
         """All Gold are equal"""
         return rhs.__class__ == Gold
-
     pass
 
 
@@ -839,7 +824,6 @@ def can_grab(self, thing):
 
 class WumpusEnvironment(XYEnvironment):
     pit_probability = 0.2  # Probability to spawn a pit in a location. (From Chapter 7.2)
-
     # Room should be 4x4 grid of rooms. The extra 2 for walls
 
     def __init__(self, agent_program, width=6, height=6):
@@ -917,9 +901,12 @@ def percept(self, agent):
         """Return things in adjacent (not diagonal) cells of the agent.
         Result format: [Left, Right, Up, Down, Center / Current location]"""
         x, y = agent.location
-        result = [self.percepts_from(agent, (x - 1, y)), self.percepts_from(agent, (x + 1, y)),
-                  self.percepts_from(agent, (x, y - 1)), self.percepts_from(agent, (x, y + 1)),
-                  self.percepts_from(agent, (x, y))]
+        result = []
+        result.append(self.percepts_from(agent, (x - 1, y)))
+        result.append(self.percepts_from(agent, (x + 1, y)))
+        result.append(self.percepts_from(agent, (x, y - 1)))
+        result.append(self.percepts_from(agent, (x, y + 1)))
+        result.append(self.percepts_from(agent, (x, y)))
 
         """The wumpus gives out a loud scream once it's killed."""
         wumpus = [thing for thing in self.things if isinstance(thing, Wumpus)]
@@ -962,7 +949,7 @@ def execute_action(self, agent, action):
             """The arrow travels straight down the path the agent is facing"""
             if agent.has_arrow:
                 arrow_travel = agent.direction.move_forward(agent.location)
-                while self.is_inbounds(arrow_travel):
+                while(self.is_inbounds(arrow_travel)):
                     wumpus = [thing for thing in self.list_things_at(arrow_travel)
                               if isinstance(thing, Wumpus)]
                     if len(wumpus):
@@ -992,13 +979,12 @@ def is_done(self):
                 print("Death by {} [-1000].".format(explorer[0].killed_by))
         else:
             print("Explorer climbed out {}."
-                .format(
-                "with Gold [+1000]!" if Gold() not in self.things else "without Gold [+0]"))
+                  .format(
+                      "with Gold [+1000]!" if Gold() not in self.things else "without Gold [+0]"))
         return True
 
-    # TODO: Arrow needs to be implemented
-
 
+    # TODO: Arrow needs to be implemented
 # ______________________________________________________________________________
 
 
@@ -1030,16 +1016,13 @@ def test_agent(AgentFactory, steps, envs):
     >>> result == 5
     True
     """
-
     def score(env):
         agent = AgentFactory()
         env.add_thing(agent)
         env.run(steps)
         return agent.performance
-
     return mean(map(score, envs))
 
-
 # _________________________________________________________________________
 
 

tests/test_agents_4e.py

@@ -1,12 +1,12 @@
 import random
-
-from agents_4e import Agent
 from agents_4e import Direction
-from agents_4e import ReflexVacuumAgent, ModelBasedVacuumAgent, TrivialVacuumEnvironment, compare_agents, \
-    RandomVacuumAgent, TableDrivenVacuumAgent, TableDrivenAgentProgram, RandomAgentProgram, \
-    SimpleReflexAgentProgram, ModelBasedReflexAgentProgram
+from agents_4e import Agent
+from agents_4e import ReflexVacuumAgent, ModelBasedVacuumAgent, TrivialVacuumEnvironment, compare_agents,\
+                   RandomVacuumAgent, TableDrivenVacuumAgent, TableDrivenAgentProgram, RandomAgentProgram, \
+		           SimpleReflexAgentProgram, ModelBasedReflexAgentProgram, rule_match
 from agents_4e import Wall, Gold, Explorer, Thing, Bump, Glitter, WumpusEnvironment, Pit, \
-    VacuumEnvironment, Dirt
+                   VacuumEnvironment, Dirt
+
 
 random.seed("aima-python")
 
@@ -58,12 +58,12 @@ def test_add():
     assert l2.direction == Direction.D
 
 
-def test_RandomAgentProgram():
-    # create a list of all the actions a vacuum cleaner can perform
+def test_RandomAgentProgram() :
+    #create a list of all the actions a vacuum cleaner can perform
     list = ['Right', 'Left', 'Suck', 'NoOp']
     # create a program and then an object of the RandomAgentProgram
     program = RandomAgentProgram(list)
-
+    
     agent = Agent(program)
     # create an object of TrivialVacuumEnvironment
     environment = TrivialVacuumEnvironment()
@@ -72,10 +72,10 @@ def test_RandomAgentProgram():
     # run the environment
     environment.run()
     # check final status of the environment
-    assert environment.status == {(1, 0): 'Clean', (0, 0): 'Clean'}
+    assert environment.status == {(1, 0): 'Clean' , (0, 0): 'Clean'}
 
 
-def test_RandomVacuumAgent():
+def test_RandomVacuumAgent() :
     # create an object of the RandomVacuumAgent
     agent = RandomVacuumAgent()
     # create an object of TrivialVacuumEnvironment
@@ -85,7 +85,7 @@ def test_RandomVacuumAgent():
     # run the environment
     environment.run()
     # check final status of the environment
-    assert environment.status == {(1, 0): 'Clean', (0, 0): 'Clean'}
+    assert environment.status == {(1,0):'Clean' , (0,0) : 'Clean'}
 
 
 def test_TableDrivenAgent():
@@ -109,21 +109,22 @@ def test_TableDrivenAgent():
     # create an object of TrivialVacuumEnvironment
     environment = TrivialVacuumEnvironment()
     # initializing some environment status
-    environment.status = {loc_A: 'Dirty', loc_B: 'Dirty'}
+    environment.status = {loc_A:'Dirty', loc_B:'Dirty'}
     # add agent to the environment
-    environment.add_thing(agent, location=(1, 0))
+    environment.add_thing(agent)
+
     # run the environment by single step everytime to check how environment evolves using TableDrivenAgentProgram
-    environment.run(steps=1)
-    assert environment.status == {(1, 0): 'Clean', (0, 0): 'Dirty'}
+    environment.run(steps = 1)
+    assert environment.status == {(1,0): 'Clean', (0,0): 'Dirty'}
 
-    environment.run(steps=1)
-    assert environment.status == {(1, 0): 'Clean', (0, 0): 'Dirty'}
+    environment.run(steps = 1)
+    assert environment.status == {(1,0): 'Clean', (0,0): 'Dirty'}
 
-    environment.run(steps=1)
-    assert environment.status == {(1, 0): 'Clean', (0, 0): 'Clean'}
+    environment.run(steps = 1)
+    assert environment.status == {(1,0): 'Clean', (0,0): 'Clean'}
 
 
-def test_ReflexVacuumAgent():
+def test_ReflexVacuumAgent() :
     # create an object of the ReflexVacuumAgent
     agent = ReflexVacuumAgent()
     # create an object of TrivialVacuumEnvironment
@@ -133,31 +134,31 @@ def test_ReflexVacuumAgent():
     # run the environment
     environment.run()
     # check final status of the environment
-    assert environment.status == {(1, 0): 'Clean', (0, 0): 'Clean'}
+    assert environment.status == {(1,0):'Clean' , (0,0) : 'Clean'}
 
 
 def test_SimpleReflexAgentProgram():
     class Rule:
-
+        
         def __init__(self, state, action):
             self.__state = state
             self.action = action
-
+            
         def matches(self, state):
             return self.__state == state
-
+        
     loc_A = (0, 0)
     loc_B = (1, 0)
-
+    
     # create rules for a two state Vacuum Environment
     rules = [Rule((loc_A, "Dirty"), "Suck"), Rule((loc_A, "Clean"), "Right"),
-             Rule((loc_B, "Dirty"), "Suck"), Rule((loc_B, "Clean"), "Left")]
-
+            Rule((loc_B, "Dirty"), "Suck"), Rule((loc_B, "Clean"), "Left")]
+    
     def interpret_input(state):
         return state
-
+    
     # create a program and then an object of the SimpleReflexAgentProgram
-    program = SimpleReflexAgentProgram(rules, interpret_input)
+    program = SimpleReflexAgentProgram(rules, interpret_input) 
     agent = Agent(program)
     # create an object of TrivialVacuumEnvironment
     environment = TrivialVacuumEnvironment()
@@ -166,7 +167,7 @@ def interpret_input(state):
     # run the environment
     environment.run()
     # check final status of the environment
-    assert environment.status == {(1, 0): 'Clean', (0, 0): 'Clean'}
+    assert environment.status == {(1,0):'Clean' , (0,0) : 'Clean'}
 
 
 def test_ModelBasedReflexAgentProgram():
@@ -184,7 +185,7 @@ def matches(self, state):
 
     # create rules for a two-state vacuum environment
     rules = [Rule((loc_A, "Dirty"), "Suck"), Rule((loc_A, "Clean"), "Right"),
-             Rule((loc_B, "Dirty"), "Suck"), Rule((loc_B, "Clean"), "Left")]
+            Rule((loc_B, "Dirty"), "Suck"), Rule((loc_B, "Clean"), "Left")]
 
     def update_state(state, action, percept, transition_model, sensor_model):
         return percept
@@ -202,7 +203,7 @@ def update_state(state, action, percept, transition_model, sensor_model):
     assert environment.status == {(1, 0): 'Clean', (0, 0): 'Clean'}
 
 
-def test_ModelBasedVacuumAgent():
+def test_ModelBasedVacuumAgent() :
     # create an object of the ModelBasedVacuumAgent
     agent = ModelBasedVacuumAgent()
     # create an object of TrivialVacuumEnvironment
@@ -212,10 +213,10 @@ def test_ModelBasedVacuumAgent():
     # run the environment
     environment.run()
     # check final status of the environment
-    assert environment.status == {(1, 0): 'Clean', (0, 0): 'Clean'}
+    assert environment.status == {(1,0):'Clean' , (0,0) : 'Clean'}
 
 
-def test_TableDrivenVacuumAgent():
+def test_TableDrivenVacuumAgent() :
     # create an object of the TableDrivenVacuumAgent
     agent = TableDrivenVacuumAgent()
     # create an object of the TrivialVacuumEnvironment
@@ -225,10 +226,10 @@ def test_TableDrivenVacuumAgent():
     # run the environment
     environment.run()
     # check final status of the environment
-    assert environment.status == {(1, 0): 'Clean', (0, 0): 'Clean'}
+    assert environment.status == {(1, 0):'Clean', (0, 0):'Clean'}
 
 
-def test_compare_agents():
+def test_compare_agents() :
     environment = TrivialVacuumEnvironment
     agents = [ModelBasedVacuumAgent, ReflexVacuumAgent]
 
@@ -262,96 +263,90 @@ def test_TableDrivenAgentProgram():
 def test_Agent():
     def constant_prog(percept):
         return percept
-
     agent = Agent(constant_prog)
     result = agent.program(5)
     assert result == 5
 
-
 def test_VacuumEnvironment():
     # Initialize Vacuum Environment
-    v = VacuumEnvironment(6, 6)
-    # Get an agent
+    v = VacuumEnvironment(6,6)
+    #Get an agent
     agent = ModelBasedVacuumAgent()
     agent.direction = Direction(Direction.R)
     v.add_thing(agent)
-    v.add_thing(Dirt(), location=(2, 1))
+    v.add_thing(Dirt(), location=(2,1))
 
     # Check if things are added properly
     assert len([x for x in v.things if isinstance(x, Wall)]) == 20
     assert len([x for x in v.things if isinstance(x, Dirt)]) == 1
 
-    # Let the action begin!
+    #Let the action begin!
     assert v.percept(agent) == ("Clean", "None")
     v.execute_action(agent, "Forward")
     assert v.percept(agent) == ("Dirty", "None")
     v.execute_action(agent, "TurnLeft")
     v.execute_action(agent, "Forward")
     assert v.percept(agent) == ("Dirty", "Bump")
     v.execute_action(agent, "Suck")
-    assert v.percept(agent) == ("Clean", "None")
+    assert  v.percept(agent) == ("Clean", "None")
     old_performance = agent.performance
     v.execute_action(agent, "NoOp")
     assert old_performance == agent.performance
 
-
 def test_WumpusEnvironment():
     def constant_prog(percept):
         return percept
-
     # Initialize Wumpus Environment
     w = WumpusEnvironment(constant_prog)
 
-    # Check if things are added properly
+    #Check if things are added properly
     assert len([x for x in w.things if isinstance(x, Wall)]) == 20
     assert any(map(lambda x: isinstance(x, Gold), w.things))
     assert any(map(lambda x: isinstance(x, Explorer), w.things))
-    assert not any(map(lambda x: not isinstance(x, Thing), w.things))
+    assert not any(map(lambda x: not isinstance(x,Thing), w.things))
 
-    # Check that gold and wumpus are not present on (1,1)
-    assert not any(map(lambda x: isinstance(x, Gold) or isinstance(x, WumpusEnvironment),
-                       w.list_things_at((1, 1))))
+    #Check that gold and wumpus are not present on (1,1)
+    assert not any(map(lambda x: isinstance(x, Gold) or isinstance(x,WumpusEnvironment), 
+                    w.list_things_at((1, 1)))) 
 
-    # Check if w.get_world() segments objects correctly
+    #Check if w.get_world() segments objects correctly
     assert len(w.get_world()) == 6
     for row in w.get_world():
         assert len(row) == 6
 
-    # Start the game!
+    #Start the game!
     agent = [x for x in w.things if isinstance(x, Explorer)][0]
     gold = [x for x in w.things if isinstance(x, Gold)][0]
     pit = [x for x in w.things if isinstance(x, Pit)][0]
 
-    assert not w.is_done()
+    assert w.is_done()==False
 
-    # Check Walls
+    #Check Walls
     agent.location = (1, 2)
     percepts = w.percept(agent)
     assert len(percepts) == 5
-    assert any(map(lambda x: isinstance(x, Bump), percepts[0]))
+    assert any(map(lambda x: isinstance(x,Bump), percepts[0]))
 
-    # Check Gold
+    #Check Gold
     agent.location = gold.location
     percepts = w.percept(agent)
-    assert any(map(lambda x: isinstance(x, Glitter), percepts[4]))
-    agent.location = (gold.location[0], gold.location[1] + 1)
+    assert any(map(lambda x: isinstance(x,Glitter), percepts[4]))
+    agent.location = (gold.location[0], gold.location[1]+1)
     percepts = w.percept(agent)
-    assert not any(map(lambda x: isinstance(x, Glitter), percepts[4]))
+    assert not any(map(lambda x: isinstance(x,Glitter), percepts[4]))
 
-    # Check agent death
+    #Check agent death
     agent.location = pit.location
-    assert w.in_danger(agent)
-    assert not agent.alive
+    assert w.in_danger(agent) == True
+    assert agent.alive == False
     assert agent.killed_by == Pit.__name__
     assert agent.performance == -1000
 
-    assert w.is_done()
-
+    assert w.is_done()==True
 
 def test_WumpusEnvironmentActions():
     def constant_prog(percept):
         return percept
-
     # Initialize Wumpus Environment
     w = WumpusEnvironment(constant_prog)
 
@@ -376,4 +371,4 @@ def constant_prog(percept):
     w.execute_action(agent, 'Climb')
     assert not any(map(lambda x: isinstance(x, Explorer), w.things))
 
-    assert w.is_done()
+    assert w.is_done()==True