class ControllerTests(unittest.TestCase):
"""Unit tests for the Controller class"""
def setUp(self):
"""A controller with basic configuration."""
self.ip_addr = '127.0.0.1'
self.port = '8000'
urllib.request.urlopen = MagicMock(return_value=5)
self.sensor = Sensor(self.ip_addr, self.port)
self.pump = Pump(self.ip_addr, self.port)
self.pump.set_state(MagicMock(return_value=True))
self.decider = Decider(100, 0.05)
self.controller = Controller(self.sensor, self.pump, self.decider)
def test_controller_tick(self):
"""Verify the Controller ticks as expected"""
self.sensor.measure = MagicMock(return_value=110)
self.pump.get_state = MagicMock(return_value=self.pump.PUMP_IN)
self.decider.decide = MagicMock(return_value=self.pump.PUMP_OFF)
self.pump.set_state = MagicMock(return_value=True)
self.controller.tick()
self.sensor.measure.assert_called_with()
self.pump.get_state.assert_called_with()
self.decider.decide.assert_called_with(110, self.pump.PUMP_IN)
self.pump.set_state.assert_called_with(self.pump.PUMP_OFF)
def test_integration(self):
'''
I can see how you could use mocks to provide data for classes that
aren't
actually implemented yet. However, since both the set_state and
get_state methods of pump are overridden the code doesn't seem to
really
test anything except that it doesn't crash.
The important part, the decide method, is covered in the unit tests
so I guess this mock method is as good as we can test until the
pump and sensor are actually hooked up to live objects.
I can see how the test can be converted to test real objects by just
taking out the mock method assignments.
'''
decider = Decider(4, 3)
pump = Pump('127.0.0.1', 8000)
pump.set_state = MagicMock(return_value=False)
pump.get_state = MagicMock(return_value=Pump.PUMP_OFF)
sensor = Sensor('127.0.0.1', 8000)
sensor.measure = MagicMock(return_value=3)
controller = Controller(sensor, pump, decider)
self.assertEqual(controller.tick(), False)
def __init__(self, refPath, dataPath, dbFilename):
GPIO.cleanup()
GPIO.setmode(GPIO.BCM)
GPIO.setup(self.AUTO_START_GPIO_PIN, GPIO.IN, pull_up_down=GPIO.PUD_UP)
self.__i2c = I2C(2)
self.__analog = Analog(sel.__i2c.getLock(), 0x49)
self.default = Default()
self.database = Database(dataPath, dbFilename)
self.waterlevel = Waterlevel(debug, self.database)
self.light = Light(self.database)
self.curtain = Curtain(self.database)
self.pressure = Pressure(self.database, self.default, self.__analog)
self.temperature = Temperature("28-0417716a37ff", self.database)
self.redox = Redox(debug, self.database, self.default, self.__analog)
self.ph = PH(debug, self.database, self.default, self.__analog,
self.temperature)
self.robot = Robot(debug, self.database)
self.pump = Pump(debug, self.database, self.default, self.robot,
self.redox, self.ph, self.temperature)
self.panel = Panel(debug, self.database, self.default, self.pump,
self.redox, self.ph, self.__i2c)
self.statistic = Statistic(debug, self.pump, self.robot, self.redox,
self.ph, self.temperature, self.pressure,
self.waterlevel)
self.refPath = refPath
self.__autoSaveTick = 0
self.__today = date.today().day - 1
debug.TRACE(debug.DEBUG, "Initialisation done (Verbosity level: %s)\n",
debug)
def test_controller_tick(self):
"""test the tick function in the controller"""
sensor = Sensor('127.0.0.1', 8000)
pump = Pump('127.0.0.1', 8000)
dec = Decider(100, .05)
con = Controller(sensor, pump, dec)
# liquid height
sensor.measure = MagicMock(return_value=94)
# state of pump
pump.get_state = MagicMock(return_value=pump.PUMP_IN)
# decider next state for pump
dec.decide = MagicMock(return_value=pump.PUMP_IN)
# this line was added to fix my error
pump.set_state = MagicMock(return_value=True)
con.tick()
sensor.measure.assert_called_with()
pump.get_state.assert_called_with()
dec.decide.assert_called_with(94, pump.PUMP_IN, actions)
def test_decide(self):
"""
Method to test decide function
"""
pump = Pump('127.0.0.1', 8000)
sensor = Sensor('127.0.0.1', 8000)
pump.set_state = MagicMock(return_value=True)
decider = Decider(10., 0.05)
controller = Controller(sensor, pump, decider)
self.assertEqual(decider.decide(1.0, int(0), controller.actions),
controller.actions['PUMP_IN'])
self.assertEqual(decider.decide(20.0, int(0), controller.actions),
controller.actions['PUMP_OUT'])
self.assertEqual(decider.decide(10.0, int(0), controller.actions),
controller.actions['PUMP_OFF'])
self.assertEqual(decider.decide(20.0, int(1), controller.actions),
controller.actions['PUMP_OFF'])
self.assertEqual(decider.decide(1.0, int(1), controller.actions),
controller.actions['PUMP_IN'])
self.assertEqual(decider.decide(1.0, int(-1), controller.actions),
controller.actions['PUMP_OFF'])
self.assertEqual(decider.decide(20.0, int(-1), controller.actions),
controller.actions['PUMP_OUT'])
with self.assertRaises(ValueError):
decider.decide(10., 2.5, controller.actions)
def setUp(self):
""" setup """
self.pump = Pump('127.0.0.1', 8000)
self.decider = Decider(100, 0.05)
self.sensor = Sensor('127.0.0.1', '8001')
self.controller = Controller(self.sensor, self.pump, self.decider)
self.actions = self.controller.actions
def main():
with open ('flowstudy.csv', newline='') as csvfile:
flowreader = csv.reader(csvfile, delimiter=',')
for row in flowreader:
flowrates.append({"date": datetime.strptime(row[0], '%m/%d/%Y %H:%M'), "flowrate": float(row[1])})
for d in flowrates:
hour = d["date"].hour
Hourly[hour].append(d["flowrate"])
Length[hour] = Length[hour] + 1
for i in range(24):
Average[i] = statistics.mean(Hourly[i])
Deviation[i] = statistics.stdev(Hourly[i])
Hourly[i] = sorted(Hourly[i])
# Years of predicted data
predicted_data = []
for i in range(YEARS * 365 * 24):
predicted_data.extend(stats.norm.rvs(Average[i % 24], Deviation[i % 24], size=1))
# Initalize two pumps
A = Pump()
B = Pump()
hourly_data = []
#with open ('pumps.json', 'r') as output:
# json.read((A.__dict__, B.__dict__), output)
for i in predicted_data:
gpm = convert_to_gpm(i)
temp_data = []
temp_data.append(int(gpm))
# This code checks the pumps max flowrate and splits the flow between the two pumps
# and adds a small overhead.
if A.get_max() > gpm:
temp_data.append(A.hours_cost(gpm))
B.idle_wear()
else:
temp_data.append(A.hours_cost(gpm))
temp_data.append(B.hours_cost(gpm))
hourly_data.append(temp_data)
# Print the final numbers
with open ('output/data.csv', 'w') as output:
writer = csv.writer(output, delimiter=',',quotechar='|', quoting=csv.QUOTE_MINIMAL)
for z in hourly_data:
writer.writerow(z)
with open ('output/average.csv', 'w') as output:
writer = csv.writer(output, delimiter=',', quotechar='|', quoting=csv.QUOTE_MINIMAL)
writer.writerow(("Pump A Energy Total Cost", int(A.total_energy_cost)))
writer.writerow(("Pump A Repair Total Cost", int(A.total_repair_cost)))
writer.writerow(("Pump B Energy Total Cost", int(B.total_energy_cost)))
writer.writerow(("Pump B Repair Total Cost", int(B.total_repair_cost)))
writer.writerow(("Pump A Energy Yearly Cost", int(A.total_energy_cost / YEARS)))
writer.writerow(("Pump A Repair Yearly Cost", int(A.total_repair_cost / YEARS)))
writer.writerow(("Pump B Energy Yearly Cost", int(B.total_energy_cost / YEARS)))
writer.writerow(("Pump B Repair Yearly Cost", int(B.total_repair_cost / YEARS)))
def setUp(self):
"""
Sets up controller.
"""
self.sensor = Sensor("127.0.0.1", "8000")
self.pump = Pump("127.0.0.1", "8000")
self.decider = Decider(100, .05)
self.controller = Controller(self.sensor, self.pump, self.decider)
def test_unique_two_delete_not_found(self):
# Delete the zip code from an existing address that doesn't have a zip code.
p = Pump("data/org_def.json")
p.update_data = {1: {u'uri': u'http://vivo.ufl.edu/individual/n765319', u'zip': u'None'}}
[add, sub] = p.update()
self.assertTrue(len(add) == 0 and len(sub) == 0)
def test_unique_one_delete(self):
from rdflib import URIRef, Literal, XSD
p = Pump()
p.update_data = {1: {u'uri': u'http://vivo.ufl.edu/individual/n111669', u'abbreviation': u'None'}}
[add, sub] = p.update()
self.assertTrue(
len(add) == 0 and len(sub) == 1 and (URIRef("http://vivo.ufl.edu/individual/n111669"),
URIRef("http://vivoweb.org/ontology/core#abbreviation"),
Literal("JWRU", datatype=XSD.string)) in sub)
def test_unique_one_add(self):
from rdflib import URIRef, Literal
p = Pump()
p.update_data = {1: {u'uri': u'http://vivo.ufl.edu/individual/n1001011525', u'abbreviation': u'PH9'}}
[add, sub] = p.update()
self.assertTrue(
len(add) == 1 and len(sub) == 0 and (URIRef("http://vivo.ufl.edu/individual/n1001011525"),
URIRef("http://vivoweb.org/ontology/core#abbreviation"),
Literal("PH9")) in add)
def test_without_lang(self):
from rdflib import URIRef, Literal
p = Pump("data/org_def.json", verbose=True)
p.update_data = {1: {u'uri': u'http://vivo.ufl.edu/individual/n928712', u'name': u'Ad ver tising'}}
[add, sub] = p.update()
self.assertTrue(
len(add) == 1 and len(sub) == 1 and (URIRef("http://vivo.ufl.edu/individual/n928712"),
URIRef("http://www.w3.org/2000/01/rdf-schema#label"),
Literal("Ad ver tising")) in add)
def test_without_datatype(self):
from rdflib import URIRef, Literal
p = Pump("data/building_def.json", verbose=True)
p.update_data = {1: {u'uri': u'http://vivo.ufl.edu/individual/n1001011525', u'url': u'http://a'}}
[add, sub] = p.update()
self.assertTrue(
len(add) == 4 and len(sub) == 0 and (None,
URIRef("http://vivoweb.org/ontology/core#linkURI"),
Literal("http://a")) in add)
def test_with_lang(self):
from rdflib import URIRef, Literal
p = Pump("data/building_def.json", verbose=True)
p.update_data = {1: {u'uri': u'http://vivo.ufl.edu/individual/n1001011525', u'name': u'Building 42'}}
[add, sub] = p.update()
self.assertTrue(
len(add) == 1 and len(sub) == 1 and (URIRef("http://vivo.ufl.edu/individual/n1001011525"),
URIRef("http://www.w3.org/2000/01/rdf-schema#label"),
Literal("Building 42", lang="en-US")) in add)
def test_with_datatype(self):
from rdflib import URIRef, Literal, XSD
p = Pump("data/building_def.json", verbose=True)
p.update_data = {1: {u'uri': u'http://vivo.ufl.edu/individual/n1001011525', u'abbreviation': u'PH9'}}
[add, sub] = p.update()
self.assertTrue(
len(add) == 1 and len(sub) == 0 and (URIRef("http://vivo.ufl.edu/individual/n1001011525"),
URIRef("http://vivoweb.org/ontology/core#abbreviation"),
Literal("PH9", datatype=XSD.string)) in add)
def test_multiple_one_delete(self):
# Empty the set of values
p = Pump("data/person_def.json", verbose=True)
p.update_data = {1: {u'uri': u'http://vivo.ufl.edu/individual/n25674',
u'research_areas': u'None'}}
[add, sub] = p.update()
self.assertTrue(len(add) == 0 and len(sub) == 4)
def test_multiple_one_change_nothing(self):
# Do nothing if the multiple values specified match those in VIVO
p = Pump("data/person_def.json", verbose=True)
p.update_data = {1: {u'uri': u'http://vivo.ufl.edu/individual/n1723097935',
u'types': u'person;thing;agent;fac;uf;ufc'}}
[add, sub] = p.update()
self.assertTrue(len(add) == 0 and len(sub) == 0)
def test_dummy(self):
"""
Just some example syntax that you might use
"""
pump = Pump('127.0.0.1', 8000)
pump.set_state = MagicMock(return_value=True)
self.fail("Remove this test.")
def setUp(self):
"""A controller with basic configuration."""
self.ip_addr = '127.0.0.1'
self.port = '8000'
urllib.request.urlopen = MagicMock(return_value=5)
self.sensor = Sensor(self.ip_addr, self.port)
self.pump = Pump(self.ip_addr, self.port)
self.pump.set_state(MagicMock(return_value=True))
self.decider = Decider(100, 0.05)
self.controller = Controller(self.sensor, self.pump, self.decider)
def setUp(self):
pump = Pump('127.0.0.1', 8000)
pump.set_state = MagicMock(return_value=True)
self.actions = {
'PUMP_IN': pump.PUMP_IN,
'PUMP_OUT': pump.PUMP_OUT,
'PUMP_OFF': pump.PUMP_OFF,
}
def test_inject_empty_original_graph(self):
from rdflib import Graph, URIRef
p = Pump(verbose=True)
p.original_graph = Graph()
p.update_data = {1: {u'uri': u'http://vivo.ufl.edu/individual/n8984374104', u'abbreviation': u'None'}}
[add, sub] = p.update()
self.assertTrue(
len(add) == 1 and len(sub) == 0 and (None,
URIRef("http://www.w3.org/1999/02/22-rdf-syntax-ns#type"),
URIRef("http://vivoweb.org/ontology/core#Building")) in add)
def test_decider1(self):
"""Does it return 1 to pump in when below margins? """
pump = Pump('127.0.0.1', 8000)
pump.set_state = MagicMock(return_value=True)
self.decider = Decider(100, 10)
self.actions = {
'PUMP_IN': pump.PUMP_IN,
'PUMP_OUT': pump.PUMP_OUT,
'PUMP_OFF': pump.PUMP_OFF,
}
assert self.decider.decide(50, "PUMP_IN", self.actions) == 1
def test_decider2(self):
""" Does it return 0 to shut off when within margins?"""
pump = Pump('127.0.0.1', 8000)
pump.set_state = MagicMock(return_value=True)
self.decider = Decider(100, 10)
self.actions = {
'PUMP_IN': pump.PUMP_IN,
'PUMP_OUT': pump.PUMP_OUT,
'PUMP_OFF': pump.PUMP_OFF,
}
assert self.decider.decide(101, "PUMP_IN", self.actions) == 0
def test_decider3(self):
"""Does it return -1 to pump out when above margin?"""
pump = Pump('127.0.0.1', 8000)
pump.set_state = MagicMock(return_value=True)
self.decider = Decider(100, 10)
self.actions = {
'PUMP_IN': pump.PUMP_IN,
'PUMP_OUT': pump.PUMP_OUT,
'PUMP_OFF': pump.PUMP_OFF,
}
assert self.decider.decide(250, "PUMP_IN", self.actions) == -1
def setUp(self):
self.decider = Decider(100, .05)
self.sensor = Sensor('127.0.0.1', 8001)
self.pump = Pump('127.0.0.1', 8000)
self.controller = Controller(self.sensor, self.pump, self.decider)
self.actions = {
'PUMP_IN': Pump.PUMP_IN,
'PUMP_OFF': Pump.PUMP_OFF,
'PUMP_OUT': Pump.PUMP_OUT
}
def setUp(self):
self.pump = Pump('127.0.0.1', 8000)
self.sensor = Sensor('127.0.0.1', 7000)
self.decider = Decider(100, 0.5)
self.controller = Controller(self.sensor, self.pump, self.decider)
self.controller.pump.set_state = MagicMock(return_value=True)
self.actions = {
'PUMP_IN': 1,
'PUMP_OFF': 0,
'PUMP_OUT': -1,
}
def test_unique_three_add_partial_path(self):
from rdflib import URIRef, Literal
p = Pump("data/grant_def.json", verbose=True)
# WARNING. This test passes by constructing a new datetime interval. Not clear if this is the desired result.
p.update_data = {1: {u'uri': u'http://vivo.ufl.edu/individual/n42774', u'start_date': u'2006-03-01'}}
[add, sub] = p.update()
self.assertTrue(
len(add) == 5 and len(sub) == 0 and (None,
URIRef("http://vivoweb.org/ontology/core#dateTime"),
Literal("2006-03-01")) in add)
def test_unique_two_delete(self):
from rdflib import URIRef, Literal, XSD
# Delete the zip code on an existing address
p = Pump("data/org_def.json")
p.update_data = {1: {u'uri': u'http://vivo.ufl.edu/individual/n87597', u'zip': u'None'}}
[add, sub] = p.update()
self.assertTrue(
len(add) == 0 and len(sub) == 1 and (URIRef("http://vivo.ufl.edu/individual/n994294"),
URIRef("http://vivoweb.org/ontology/core#addressPostalCode"),
Literal("32611", datatype=XSD.string)) in sub)
def test_unique_three_add_fullpath(self):
from rdflib import URIRef, Literal
p = Pump("data/grant_def.json")
# Add a start date to a grant. There is no date time interval, so a full path will need to be created
p.update_data = {1: {u'uri': u'http://vivo.ufl.edu/individual/n51914', u'start_date': u'2015-03-01'}}
[add, sub] = p.update()
self.assertTrue(
len(add) == 5 and len(sub) == 0 and (None,
URIRef("http://vivoweb.org/ontology/core#dateTime"),
Literal("2015-03-01")) in add)
def test_integration(self):
"""Method docstring."""
sensor = Sensor(self.address, self.port)
pump = Pump(self.address, self.port)
decider = Decider(100, .05)
controller = Controller(sensor, pump, decider)
for level in range(0, 200, 10):
for action in controller.actions.values():
sensor.measure = MagicMock(return_value=level)
pump.get_state = MagicMock(return_value=action)
pump.set_state = MagicMock(return_value=True)
controller.tick()
def test_controller_tick(self):
'''testing controller'''
sensor = Sensor('127.0.0.1', '514')
sensor.measure = MagicMock(return_value=105)
pump = Pump('127.0.0.1', '8000')
pump.get_state = MagicMock(return_value='PUMP_OFF')
pump.set_state = MagicMock(return_value='PUMP_IN')
decider = Decider(100, 0.05)
controller = Controller(sensor, pump, decider)
self.assertTrue(controller.tick())
def test_unique_three_delete(self):
from rdflib import URIRef, Literal, XSD
# WARNING: Delete start date value from existing datetime interval. This may not be the desirable data
# management action
p = Pump("data/grant_def.json", verbose=True)
p.update_data = {1: {u'uri': u'http://vivo.ufl.edu/individual/n650082272', u'start_date': u'None'}}
[add, sub] = p.update()
self.assertTrue(
len(add) == 0 and len(sub) == 1 and (None,
URIRef("http://vivoweb.org/ontology/core#dateTime"),
Literal("2006-07-01T00:00:00", datatype=XSD.dateTime)) in sub)
def test_unique_two_add_to_existing(self):
from rdflib import URIRef, Literal
# Add a zip code to the provost's office at UF. An address already exists, the zip needs to be
# added to the existing address
p = Pump("data/org_def.json")
p.update_data = {1: {u'uri': u'http://vivo.ufl.edu/individual/n765319', u'zip': u'32653'}}
[add, sub] = p.update()
self.assertTrue(
len(add) == 1 and len(sub) == 0 and (URIRef("http://vivo.ufl.edu/individual/n119803"),
URIRef("http://vivoweb.org/ontology/core#addressPostalCode"),
Literal("32653")) in add)
def test_unique_two_add_fullpath(self):
from rdflib import URIRef, Literal
p = Pump("data/org_def.json")
# Add a zip code to Lee County Extension Office. There is no address, so a full path will need
# to be created
p.update_data = {1: {u'uri': u'http://vivo.ufl.edu/individual/n7023301', u'zip': u'32653'}}
[add, sub] = p.update()
self.assertTrue(
len(add) == 4 and len(sub) == 0 and (None,
URIRef("http://vivoweb.org/ontology/core#addressPostalCode"),
Literal("32653")) in add)
def test_multiple_one_change(self):
from rdflib import URIRef
# Change the set of values adding one and removing another
p = Pump("data/person_def.json", verbose=True)
p.update_data = {1: {u'uri': u'http://vivo.ufl.edu/individual/n1723097935',
u'types': u'person;thing;agent;fac;uf;pd'}}
[add, sub] = p.update()
self.assertTrue(len(add) == 1 and len(sub) == 1 and
(URIRef("http://vivo.ufl.edu/individual/n1723097935"),
URIRef("http://www.w3.org/1999/02/22-rdf-syntax-ns#type"),
URIRef("http://vivoweb.org/ontology/core#Postdoc")) in add and
(URIRef("http://vivo.ufl.edu/individual/n1723097935"),
URIRef("http://www.w3.org/1999/02/22-rdf-syntax-ns#type"),
URIRef("http://vivo.ufl.edu/ontology/vivo-ufl/UFCurrentEntity")) in sub)
def test_multiple_one_add(self):
from rdflib import URIRef
# Add multiple values for an attribute to an entity that has no values for the attribute
p = Pump("data/person_def.json", verbose=True)
p.update_data = {1: {u'uri': u'http://vivo.ufl.edu/individual/n1723097935',
u'research_areas': u'http://vivo.ufl.edu/individual/n2551317090;http://vivo.ufl.edu/individual/n157098'}}
[add, sub] = p.update()
self.assertTrue(
len(add) == 2 and len(sub) == 0 and (URIRef("http://vivo.ufl.edu/individual/n1723097935"),
URIRef("http://vivoweb.org/ontology/core#hasResearchArea"),
URIRef("http://vivo.ufl.edu/individual/n2551317090")) in add and
(URIRef("http://vivo.ufl.edu/individual/n1723097935"),
URIRef("http://vivoweb.org/ontology/core#hasResearchArea"),
URIRef("http://vivo.ufl.edu/individual/n157098")) in add)
def test_unique_three_change_xsd(self):
from rdflib import URIRef, Literal, XSD
p = Pump("data/grant_def.json", verbose=True)
# WARNING. This test passes by changing the start date value on an existing datetime interval. Not sure
# if this is the desired behavior.
p.update_data = {1: {u'uri': u'http://vivo.ufl.edu/individual/n650082272', u'start_date': u'2006-03-02'}}
[add, sub] = p.update()
self.assertTrue(
len(add) == 1 and len(sub) == 1 and (None,
URIRef("http://vivoweb.org/ontology/core#dateTime"),
Literal("2006-03-02")) in add and
(None,
URIRef("http://vivoweb.org/ontology/core#dateTime"),
Literal("2006-07-01T00:00:00", datatype=XSD.dateTime)) in sub)
def main():
"""
The main function. Does the work of Simple VIVO
:return: None
"""
import sys
from datetime import datetime
from vivopump import get_args
from pump import Pump
return_code = 0
print datetime.now(), "Start"
args = get_args()
# Create a Pump and use it to perform the requested actions based on arguments
p = Pump(args.defn, args.src, args.verbose, args.nofilters, args.inter, args.intra, args.rdfprefix,
query_parms={'queryuri': args.queryuri,
'username': args.username,
'password': args.password,
'prefix': args.prefix,
'uriprefix': args.uriprefix})
if args.action == 'get':
n_rows = p.get()
print datetime.now(), n_rows, "rows in", args.src
elif args.action == 'update':
try:
[add_graph, sub_graph] = p.update()
except IOError:
print "File not found"
return_code = 1
else:
add_file = open(args.rdfprefix + '_add.rdf', 'w')
print >>add_file, add_graph.serialize(format='nt')
add_file.close()
sub_file = open(args.rdfprefix + '_sub.rdf', 'w')
print >>sub_file, sub_graph.serialize(format='nt')
sub_file.close()
print datetime.now(), len(add_graph), 'triples to add', len(sub_graph), 'triples to sub'
elif args.action == 'summarize':
print p.summarize()
elif args.action == 'serialize':
print p.serialize()
elif args.action == 'test':
print p.test()
else:
print datetime.now(), "Unknown action. Try sv -h for help"
print datetime.now(), "Finish"
sys.exit(return_code)
def main():
try:
joystick = init_pygame()
except Exception:
print "Pygame initialization failed - it MIGHT require (for unknown reasons) root"
print "You can try with root, but that won't be safer"
print
raise
pi = pigpio.pi()
pump = Pump(pi, pin=config.PIN_PUMP)
pump.off()
robot = Robot(pi, config.PIN_SERVO1, config.PIN_SERVO2, config.PIN_SERVO3)
robot.disable()
control = Control(joystick, pump, robot)
try:
control.loop()
finally:
pump.off()
from pump import Pump
from game import Game
PUMP_PORT = "COM3"
if __name__ == "__main__":
pump = Pump(PUMP_PORT)
with pump:
try:
pump.start()
game = Game(pump)
game.start()
except Exception as e:
print e
def test_no_update_file(self):
p = Pump()
with self.assertRaises(IOError):
p.update('data/no_update_file.txt')
def test_normal_case(self):
p = Pump("data/person_def.json", verbose=True)
print p.summarize()
def test_default_usage(self):
p = Pump()
p.update()
self.assertTrue("data/pump_def.json" in p.summarize()) # Using the default definition
def test_missing_uri_column_inject(self):
p = Pump()
p.update_data = {1: {u'overview': u'None'}}
with self.assertRaises(KeyError):
p.update()
def test_not_found(self):
p = Pump("data/person_def.json", verbose=True)
p.update_data = {1: {u'uri': u'http://vivo.ufl.edu/individual/n12345678',
u'remove': u'True'}}
[add, sub] = p.update()
self.assertTrue(len(add) == 0 and len(sub) == 0)
for name, val in vars(args).items():
if val is not None:
program_defaults[name] = val
# Put the final values back in args
for name, val in program_defaults.items():
vars(args)[name] = val
if args.verbose:
print datetime.now(), "Arguments\n", vars(args)
# Create a Pump and use it to perform the requested actions based on arguments
p = Pump(args.defn, args.src, args.verbose, args.nofilters, query_parms={'query_uri': args.queryuri,
'username': args.pwd, 'password': args.pwd},
uri_prefix=args.uriprefix)
if args.action == 'get':
n_rows = p.get(args.src, args.inter, args.intra)
print datetime.now(), n_rows, "rows in", args.src
elif args.action == 'update':
[add_graph, sub_graph] = p.update(args.src, args.inter, args.intra)
add_file = open(args.rdfprefix + '_add.rdf', 'w')
print >>add_file, add_graph.serialize(format='nt')
add_file.close()
sub_file = open(args.rdfprefix + '_sub.rdf', 'w')
print >>sub_file, sub_graph.serialize(format='nt')
sub_file.close()
print datetime.now(), len(add_graph), 'triples to add', len(sub_graph), 'triples to sub'
elif args.action == 'summarize':
print p.summarize()
def test_normal_inject(self):
p = Pump()
p.update_data = {1: {u'uri': u'http://vivo.ufl.edu/individual/n8984374104', u'abbreviation': u'None'}}
p.update()
self.assertTrue("8984374104" in str(p.update_data)) # Using the injected data, not default
def test_small_case(self):
p = Pump("data/person_def.json", verbose=True)
p.update_data = {1: {u'uri': u'http://vivo.ufl.edu/individual/n2084211328',
u'remove': u'True'}}
[add, sub] = p.update()
self.assertTrue(len(add) == 0 and len(sub) == 1)
