def test_SimultaneousSentAndError(self): ie1, ie2 = InjectEvent(1, None), InjectEvent(2, None) events = Events([ie1, ie2]) se1 = SentEvent(1.5, None) events.schedule(se1) se2 = SentEvent(2, None) events.schedule(se2) ee = ErrorEvent(1.5) events.schedule(ee) self.assertEqual(events.next(), ie1) self.assertEqual(events.next(), se1) self.assertEqual(events.next(), ee) self.assertEqual(events.next(), ie2) self.assertEqual(events.hasNext(), False)
def __init__(self, active=None, caldav=None, aiyo=None, load=False, generate=False, localonly=False, previous=None):
self.active = None
self.caldav = None
self.aiyo = None
if active is None: active = []
if caldav is None: caldav = []
if aiyo is None: aiyo = []
if load:
self.active, self.caldav = self.load_from_file()
self.aiyo = aiyo
elif generate:
self.generate(active=active, caldav=caldav, aiyo=aiyo, localonly=localonly, previous=previous)
else:
self.active = Events(active, name='aiyo')
self.caldav = Events(caldav, name='caldav')
self.aiyo = aiyo
def trial5(self, animate=False, seq='1', save=False):
a_pos = (200, 250)
a_vel = (0, 0)
b_pos = (830, 50)
b_vel = (-300, 45)
e_pos = (300, 150)
e_vel = (0, 0)
if animate:
E = Events(a_pos, a_vel, b_pos, b_vel, e_pos, e_vel)
summary = E.get_summary(animate, seq, save)
return summary
E = Explanations(a_pos, a_vel, b_pos, b_vel, e_pos, e_vel)
results = E.posterior_explanations()
return results
def give_xp(self, amm):
new_xp = self.data["xp"] + amm
new_data = {
'xp': new_xp
}
if new_xp >= self.xp_per_level:
new_level = self.data["level"] + new_xp // self.xp_per_level
new_xp = new_xp % self.xp_per_level
new_data = {
'xp': new_xp,
'level': new_level
}
self.update_data(new_data)
Events.emit("set_xp", self.data['xp'], self.data['level'])
def LoadEvents():
print("Загружаем файл событий...")
eventsFile = open("jsons/events.json", "rt")
allEvents = json.load(eventsFile)
eventsFile.close()
events = Events(allEvents)
print("Было загружено {} актов".format(len(events.acts)))
return events
def trial16(self, animate=False, seq='1', save=False):
a_pos = (830, 170)
a_vel = (-300, 56)
b_pos = (830, 430)
b_vel = (-225, -45.5)
e_pos = (170, 300)
e_vel = (0, 0)
if animate:
E = Events(a_pos, a_vel, b_pos, b_vel, e_pos, e_vel)
summary = E.get_summary(animate, seq, save)
return summary
E = Explanations(a_pos, a_vel, b_pos, b_vel, e_pos, e_vel)
results = E.posterior_explanations()
return results
def test_eventsFromFile(self):
events = Events.fromFile('tests/example/events.in')
self.assertEqual(events.next().time, 1)
self.assertEqual(events.next().time, 2)
self.assertEqual(events.next().packet, 3)
self.assertEqual(events.next().packet, 4)
self.assertEqual(events.next().time, 5)
self.assertTrue(events.hasNextNow(5))
self.assertEqual(events.next().packet, 4)
def __init__(self, loop, socket, peeraddr):
self.loop_ = loop
self.socket_ = Socket(socket)
self.peeraddr_ = peeraddr
self.events_ = Events(self.socket_.getSocketFd(), kEevntRead)
self.handle_ = Handle(self.events_)
self.recvBuffer_ = ''
self.writeBuffer_ = ''
self.messageCb_ = defMessageCallback
def __init__(self, arg1, arg2, arg3):
placeholdEvent = Events()
self.buildingName = arg1
self.roomNumber = arg2
self.roomName = arg1 + " " + arg2 #Combination of room name and number, for ease of printing data
self.timeSlotsCount = 28 #8:00AM-9:30PM in 30 min increments,see comment at bottom for complete breakdown
self.timeSlots = [placeholdEvent] * self.timeSlotsCount
self.roomCapacity = arg3
self.dayOfWeek = 1 #int value for day of week, see comment at bottom for complete breakdown
def test_eventsFromFile(self):
events = Events.fromFile('tests/example/events.in')
self.assertEqual(events.next().time, 1)
self.assertEqual(events.next().time, 2)
self.assertEqual(events.next().packet, 3)
self.assertEqual(events.next().packet, 4)
self.assertEqual(events.next().time, 5)
self.assertTrue(events.hasNextNow(5))
self.assertEqual(events.next().packet, 4)
def new():
form = eventsForm(request.form)
allE = []
eventFire = firebase.FirebaseApplication('https://oopproject-f5214.firebaseio.com/ ')
allEvent = eventFire.get('Events', None)
if request.method == 'POST' and form.validate():
title = form.title.data
location = form.location.data
category = form.category.data
timestart = form.timeStart.data
timeend = form.timeEnd.data
description = form.description.data
date = form.date.data
event = Events(title,location,category,timestart,timeend,description,date)
# This is to make the events name +1
try:
count = len(allEvent) +1
except TypeError:
count = 1
# Search from a certain key to print the entire key
# for key in allEvent:
# if allEvent[key]['title'] == 'kenneth is hensum':
# print(allEvent[key])
#If I want to get a certain key(title) from the test2 database
# for key in allEvent:
# if key == 'test2':
# print(allEvent[key])
#
eventFire.put('Events','number'+str(count),{
'title': event.get_title(),
'location': event.get_location(),
'category': event.get_category(),
'timeStart': event.get_timestart(),
'timeEnd': event.get_timeend(),
'description': event.get_description(),
'date': event.get_date()
})
try:
for key in allEvent:
allE.append(allEvent[key])
allE = reversed(allE)
except TypeError:
allE = []
return render_template('showEvent.html', form=form, allE=allE)
def getAllEvent(self):
rawEvents = super().get(table=self.tablename)
if rawEvents is not None:
events = []
for rawEvent in rawEvents:
events.append(Events(date=rawEvent[4], duration=rawEvent[2], description=rawEvent[1], client=rawEvent[0],
payed=rawEvent[3], key=rawEvent[5]))
return events
else:
return None
def __init__(self, loop):
self.loop_ = loop
self.serversd_ = Socket()
self.serversd_.bind()
self.serversd_.listen(100)
self.conns_ = {}
self.events_ = Events(self.serversd_.getSocketFd(), kEevntRead)
self.handle_ = Handle(self.events_, self.serverReadCb)
self.loop_.addHandle(self.handle_)
self.messageCb_ = defMessageCallback
def __init__(self):
super(App, self).__init__()
self.setup_pygame()
self.events = Events()
self.lane = Lane(self.events)
self.lane.add_support_point(100, 100)
self.lane.add_support_point(200, 100)
self.lane.add_support_point(200, 200)
self.lane.add_support_point(100, 200)
self.cars = []
for k in range(4):
self.cars.append(
Car(x=150 + k * 5,
y=100,
theta=np.random.randint(0, 360),
speed=np.random.randint(45, 180)))
# self.cars.append(Car(x=250,y=100,theta=-45,speed=2*90))
self.action = None
self.human = HumanController()
self.heuristic = Heuristic(self.lane)
Node.heuristic = self.heuristic
self.onestep = OneStepLookaheadController(self.cars, self.lane,
self.heuristic)
self.nstep = NStepLookaheadController(self.cars, self.lane,
self.heuristic, 2)
self.bestfirst = BestFirstController(self.cars, self.lane,
self.heuristic)
self.controller = self.bestfirst
# self.window = Window(self.screen, self.events, 300, 200, "caption")
self.grid = Grid(50, 50, *self.size)
self.last_distance_grid_update = time() - 10
self.update_distance_grid()
self.done = False
self.register_events()
self.spin()
def __init__(self, x, y, width, height, sprite):
DynamicComp.__init__(self, x, y, width, height, sprite)
self.input_vector = Vector2()
self.speed = 300
self.hp = GameData.player_data["max_hp"]
self.invincible = False
self.invincibility_time = 2
self.invincible_alpha = 120
self.current_powerup = None
GameData.player = self
self.invincibility_timer = Timer(self.invincibility_timeout)
self.add_component(self.invincibility_timer)
self.powerup_timer = Timer(self.powerup_timeout)
self.add_component(self.powerup_timer)
self.init()
Events.connect("powerup_picked", self, self.powerup_picked)
def test_injectWait_WithSent(self):
events = Events([InjectEvent(1, None), InjectEvent(2, None)])
events.schedule(SentEvent(1, "ALG"))
events.schedule(WaitEvent())
event = events.next()
self.assertIsInstance(event, InjectEvent)
self.assertEqual(event.time, 1)
event = events.next()
self.assertIsInstance(event, ErrorEvent)
self.assertEqual(event.time, 1)
event = events.next()
self.assertIsInstance(event, InjectEvent)
self.assertEqual(event.time, 2)
def __init__(self, data={}):
self.data = deepcopy(data)
self.xp_per_level = 20
Events.connect("coin_picked", self, self.coin_picked)
Events.connect("level_completed", self, self.level_completed)
Events.connect("give_xp", self, self.give_xp)
def __init__(self, session, spirit):
self.logger = logging.getLogger("Spirit")
self.session = session
self.spirit = spirit
self.room = None
self.spirit.players.append(self)
# Defined once the client requests it (see handleRandomKey)
self.randomKey = None
self.event = Events()
def test_invoice_creator(self):
self.events = [
Events(date="11/09/2001",
duration="4",
description="",
client="Federico Scarpa",
key="123",
payed=False)
]
tex = invoice_creator("/home/matteo/Documenti/workTracker",
self.events, "Federico Scarpa")
if tex.write():
self.assertEqual(True, True)
def test_adversaryFinishesBeforeAlgorithm(self): class Model: packets = [1, 2, 3] se1, se2 = SentEvent(1, SL(Model())), SentEvent(1, SiroccoThm9(Model())) events = Events([]) events.schedule(se1) events.schedule(se2) self.assertEqual(events.next(), se2) self.assertEqual(events.next(), se1) events = Events([]) events.schedule(se2) events.schedule(se1) self.assertEqual(events.next(), se2) self.assertEqual(events.next(), se1)
def generate(self, active=None, caldav=None, aiyo=None, localonly=False, previous=None):
aiyo = FileTodos(title='Todos')
projects = []
categories = []
categories = [ f for f in os.listdir(universe.dataroot) if (os.path.isdir(os.path.join(universe.dataroot,f)) and not f.startswith('.')) ]
for category in categories:
category_projects = []
category_projects = [ f for f in os.listdir(os.path.join(universe.dataroot, category)) if (os.path.isfile(os.path.join(universe.dataroot, category, f)) and not f.startswith('.')) ]
category_todos = FileTodos(title=category, level=-1)
for category_project in category_projects:
tasks = tasklist_read(category_project, category)
category_todos.add_child(tasks)
aiyo.add_child(category_todos)
if not localonly:
caldav = []
caldav_error = False
for tasklistname in aiyo.child_names() + universe.auxlists:
client, calendar, tasks = caldav_load(tasklistname)
#print ' ', tasklistname, client, calendar, tasks
if (client is None or calendar is None or tasks is None):
caldav_error = True
else:
caldav.extend(tasks)
if caldav_error:
self.caldav = None
else:
self.caldav = Events(caldav, name='caldav')
active = aiyo.find_active()
#print 'here_no update'
aiyo.find_next_actions(set_updated=False)
self.active = Events(active, name='aiyo')
self.aiyo = aiyo
if not localonly:
self.sort_groups(previous=previous)
def create_forum():
form = eventsForm(request.form)
allE = []
eventFire = firebase.FirebaseApplication(
'https://oopproject-f5214.firebaseio.com/ ')
allEvent = eventFire.get('Events', None)
if request.method == 'POST':
title = form.title.data
location = form.location.data
category = form.category.data
timestart = form.timeStart.data
timeend = form.timeEnd.data
description = form.description.data
date = form.date.data
event = Events(title, location, category, timestart, timeend,
description, date)
try:
count = len(allEvent) + 1
except TypeError:
count = 1
eventFire.put(
'Events', 'number' + str(count), {
'title': event.get_title(),
'location': event.get_location(),
'category': event.get_category(),
'timeStart': event.get_timestart(),
'timeEnd': event.get_timeend(),
'description': event.get_description(),
'date': event.get_date()
})
try:
for key in allEvent:
allE.append(allEvent[key])
allE = reversed(allE)
except TypeError:
allE = []
return render_template('createEvent.html', form=form)
def test_injectWait_WithSent(self): events = Events([InjectEvent(1, None), InjectEvent(2, None)]) events.schedule(SentEvent(1, "ALG")) events.schedule(WaitEvent()) event = events.next() self.assertIsInstance(event, InjectEvent) self.assertEqual(event.time, 1) event = events.next() self.assertIsInstance(event, ErrorEvent) self.assertEqual(event.time, 1) event = events.next() self.assertIsInstance(event, InjectEvent) self.assertEqual(event.time, 2)
class User:
_id = None
_firstName = None
_lastName = None
_email = None
_events = Events()
def get_id(self):
return self._id
def set_id(self, id):
self._id = id
def get_firstName(self):
return self._firstName
def set_firstName(self, firstName):
self._firstName = firstName
def get_lastName(self):
return self._lastName
def set_lastName(self, lastName):
self._lastName = lastName
def get_email(self):
return self._email
def set_email(self, email):
self._email = email
def get_events(self):
return self._events
def set_events_collection(self, events):
self.events = events
def __str__(self):
return "%s %s ( %s )" % (self.get_firstName(), self.get_lastName(),
self.get_email())
def trial7(self, animate=False, seq='1', save=False):
a_pos = (350, 300)
a_vel = (0, 0)
b_pos = (830, 300)
b_vel = (-300, 0)
e_pos = (150, 300)
e_vel = (0, 0)
if animate:
E = Events(a_pos, a_vel, b_pos, b_vel, e_pos, e_vel)
E.simulate(animate, seq, save)
return
E = Explanations(a_pos, a_vel, b_pos, b_vel, e_pos, e_vel)
results = E.posterior_explanations()
return results
def __init__(self):
super(App, self).__init__()
self.setup_pygame()
self.events = Events()
self.lane = Lane(self.events)
self.lane.add_support_point(100,100)
self.lane.add_support_point(200,100)
self.lane.add_support_point(200,200)
self.lane.add_support_point(100,200)
self.cars = []
for k in range(4):
self.cars.append(Car(x=150+k*5,y=100,theta=np.random.randint(0,360),speed=np.random.randint(45,180)))
# self.cars.append(Car(x=250,y=100,theta=-45,speed=2*90))
self.action = None
self.human = HumanController()
self.heuristic = Heuristic(self.lane)
Node.heuristic = self.heuristic
self.onestep = OneStepLookaheadController(self.cars,self.lane,self.heuristic)
self.nstep = NStepLookaheadController(self.cars,self.lane, self.heuristic, 2)
self.bestfirst = BestFirstController(self.cars,self.lane, self.heuristic)
self.controller = self.bestfirst
# self.window = Window(self.screen, self.events, 300, 200, "caption")
self.grid = Grid(50,50,*self.size)
self.last_distance_grid_update = time() - 10
self.update_distance_grid()
self.done = False
self.register_events()
self.spin()
def check_collisions(self):
# coins collision
coins_collisions = Physics.get_collisions(self,
CollisionTypes.pickable)
for coin in coins_collisions:
Events.emit("coin_picked", coin)
# enemy collision
enemy_collisions = Physics.get_collisions(self, CollisionTypes.enemy)
if len(enemy_collisions):
if self.invincible is False:
self.player_hurt(enemy_collisions[0].damage)
elif self.current_powerup == PowerupTypes.invincibility:
Events.emit("enemy_killed", enemy_collisions[0])
# powerup collision
if self.current_powerup is None:
powerup_colls = Physics.get_collisions(self,
CollisionTypes.powerup)
if len(powerup_colls):
Events.emit("powerup_picked", powerup_colls[0])
def construct(self):
"""
stores Voronoi diagram in self.diagram
:return: None
"""
events = Events()
for s in self.diagram.sites:
event = Event(s.point[1], EventType.site, site=s, point=s.point)
events.insert(event)
not_valid_events = set()
while not events.empty():
event = events.pop()
if event in not_valid_events:
continue
if event.type == EventType.site:
self.handle_site_event(event, not_valid_events, events)
else:
self.handle_circle_event(event, not_valid_events, events)
def update_active(self):
new_active = Events(self.aiyo.find_active(), name='aiyo')
additions = Events(name='additions')
removals = Events(name='removals')
updated = Events(name='updated')
for task in self.active.events:
if not new_active.task_is_present(task):
# Task has been removed
removals.add(task)
for task in new_active.events:
if not self.active.task_is_present(task):
# Task has been added
additions.add(task)
self.active = new_active
for task in self.active.events:
if task.updated:
updated.add(task)
return additions, removals, updated
def test_canPerformExperiment1(self): # t=0 ie1, ie2 = InjectEvent(0, 3), InjectEvent(0, 5) events = Events([ie1, ie2]) self.assertEqual(events.next(), ie1) self.assertEqual(events.next(), ie2) se1, se2 = SentEvent(3, "alg"), SentEvent(5, "adv") events.schedule(se1) events.schedule(se2) ee1 = ErrorEvent(5) events.schedule(ee1) # t=3 self.assertEqual(events.next(), se1) se3 = SentEvent(8, "alg") events.schedule(se3) ee2 = ErrorEvent(8) events.schedule(ee2) # t=5 self.assertEqual(events.next(), se2) self.assertEqual(events.next(), ee1) se4 = SentEvent(8, "adv") events.schedule(se4) # t=8 self.assertEqual(events.next(), se4) self.assertEqual(events.next(), ee2) self.assertFalse(events.hasNext())
class Spheniscidae(LineReceiver, object):
delimiter = "\x00"
def __init__(self, session, spirit):
self.logger = logging.getLogger("Spirit")
self.session = session
self.spirit = spirit
self.room = None
self.spirit.players.append(self)
# Defined once the client requests it (see handleRandomKey)
self.randomKey = None
self.event = Events()
def sendErrorAndDisconnect(self, error):
self.sendError(error)
self.transport.loseConnection()
def sendError(self, error):
self.sendXt("e", error)
# TODO: Replace * with actual port
def sendPolicyFile(self):
self.sendLine("<cross-domain-policy><allow-access-from domain='*' to-ports='*' /></cross-domain-policy>")
def handleXmlData(self, data):
self.logger.debug("Received XML data: {0}".format(data))
elementTree = ET.fromstring(data)
if elementTree.tag == "policy-file-request":
self.sendPolicyFile()
elif elementTree.tag == "msg":
self.logger.debug("Received valid XML data")
try:
bodyTag = elementTree[0]
action = bodyTag.get("action")
if self.event.exists(action):
self.event.emit(action, self, bodyTag)
else:
self.logger.warn("Packet did not contain a valid action attribute!")
except IndexError:
self.logger.warn("Received invalid XML data (didn't contain a body tag)")
else:
self.logger.warn("Received invalid XML data!")
self.event.emit("received-xml", elementTree)
def handleWorldData(self, data):
self.logger.debug("Received XT data: {0}".format(data))
# First and last elements are blank
parsedData = data.split("%")[1:-1]
packetId = parsedData[2]
if self.event.exists(packetId):
self.event.emit(packetId, self, parsedData)
else:
self.logger.debug("Handler for {0} doesn't exist!".format(packetId))
self.event.emit("received-world", self, data)
# TODO: Clean
def sendXt(self, *data):
data = list(data)
handlerId = data.pop(0)
internalId = self.room.internalId if self.room is not None else -1
mappedData = map(str, data)
xtData = "%".join(mappedData)
line = "%xt%{0}%{1}%{2}%".format(handlerId, internalId, xtData)
self.sendLine(line)
def sendLine(self, line):
super(Spheniscidae, self).sendLine(line)
self.event.emit("sent", self, line)
self.logger.debug("Outgoing data: {0}".format(line))
def lineReceived(self, data):
self.event.emit("received", self, data)
if data.startswith("<"):
self.handleXmlData(data)
else:
self.handleWorldData(data)
def connectionLost(self, reason):
self.logger.info("Client disconnected")
self.spirit.players.remove(self)
try:
self.session.commit()
if hasattr(self, "room") and self.room is not None:
self.room.remove(self)
if hasattr(self, "user"):
self.session.expunge(self.user)
except InvalidRequestError:
self.logger.info("There aren't any transactions in progress")
finally:
self.session.close()
self.event.emit("disconnected", self, reason)
def setUp(self): self.events = Events([])
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Document</title>
</head>
<body>
<div class="container mb-5">
<h1>Your feed for {today.strftime('%d %b %Y')}</h1>
""")
w = Weather()
w.write_weather()
e = Events()
e.write_events()
r = Reddit()
with open(feed_path, "a") as file:
file.write("<h2>Reddit</h2>")
r.fetch_subs_and_write("reactjs")
r.fetch_subs_and_write("webdev")
r.fetch_subs_and_write("frontend")
r.fetch_subs_and_write("python")
r.fetch_subs_and_write("rollerblading")
with open(feed_path, "a") as file:
file.write("<h2>CNA</h2>")
def __init__(self, *kw, **kwargs):
self.logger = logging.getLogger("Spirit")
configFile = kw[0]
with open(configFile, "r") as fileHandle:
self.config = json.load(fileHandle, "utf-8")
serverName = kwargs["server"]
self.server = self.config["Servers"][serverName]
# Set up logging
generalLogDirectory = os.path.dirname(self.server["Logging"]["General"])
errorsLogDirectory = os.path.dirname(self.server["Logging"]["Errors"])
if not os.path.exists(generalLogDirectory):
os.mkdir(generalLogDirectory)
if not os.path.exists(errorsLogDirectory):
os.mkdir(errorsLogDirectory)
universalHandler = RotatingFileHandler(
self.server["Logging"]["General"], maxBytes=2097152, backupCount=3, encoding="utf-8"
)
self.logger.addHandler(universalHandler)
errorHandler = logging.FileHandler(self.server["Logging"]["Errors"])
errorHandler.setLevel(logging.ERROR)
self.logger.addHandler(errorHandler)
engineString = "mysql://{0}:{1}@{2}/{3}".format(
self.config["Database"]["Username"],
self.config["Database"]["Password"],
self.config["Database"]["Address"],
self.config["Database"]["Name"],
)
self.databaseEngine = create_engine(engineString, pool_recycle=3600)
self.createSession = sessionmaker(bind=self.databaseEngine)
self.players = deque()
self.logger.info("Spirit module initialized")
self.loadPlugins()
self.events = Events()
# Used to safely reload modules by keeping track of existing event callbacks
self.handlers = {}
if self.server["World"]:
self.protocol = Penguin
self.loadRooms()
self.loadItems()
self.loadHandlerModules()
self.logger.info("Running world server")
else:
self.protocol = Spheniscidae
self.loadHandlerModules("Spirit.Handlers.Login.Login")
self.logger.info("Running login server")
class EventsTestCase(unittest.TestCase): def setUp(self): self.ie1, self.ie2, self.ie3 = InjectEvent(1.1, None), InjectEvent(4.2, None), InjectEvent(5.9, None) self.events = Events([self.ie1, self.ie2, self.ie3]) def test_createEvents(self): self.assertEqual(self.events.hasNext(), True) def assertHasEventsInOrder(self, order): for e in order: self.assertEqual(self.events.hasNext(), True) ne = self.events.next() self.assertEqual(ne, e) def test_canScheduleSentEvent(self): event = SentEvent(2.7, None) self.events.schedule(event) self.assertHasEventsInOrder([self.ie1, event, self.ie2, self.ie3]) def test_canScheduleSentAndErrorEvent(self): sentEvent, errorEvent = SentEvent(2.7, None), ErrorEvent(2.8) self.events.schedule(sentEvent) self.events.schedule(errorEvent) self.assertHasEventsInOrder([self.ie1, sentEvent, errorEvent, self.ie2, self.ie3]) def test_canScheduleSentAndErrorEventBefore(self): sentEvent, errorEvent = SentEvent(2.9, None), ErrorEvent(2.8) self.events.schedule(sentEvent) self.events.schedule(errorEvent) self.assertHasEventsInOrder([self.ie1, errorEvent, self.ie2, self.ie3]) def test_canGetNextEventInjectBeforeSent(self): se = SentEvent(4.2, None) self.events.schedule(se) self.assertHasEventsInOrder([self.ie1, self.ie2, se, self.ie3])
def get_location():
'''This function return the gps location of all the events in and around santa rosa'''
return Events.getlocations()
if error: events.schedule(ErrorEvent(time + error) if error >= 0 else WaitEvent()) while events.hasNext(): event = events.next() time = event.time log(event) algorithm.notify(event) adversary.notify(event) if events.hasNextNow(time): continue if not algorithm.sending: packet = schedule(algorithm) packet = packet / speedup if packet else None error = adversary.algorithmSchedules(packet) scheduleError(time, error) if not adversary.sending: advpacket = schedule(adversary) error = adversary.adversarySchedules(advpacket) scheduleError(time, error) model = Model.fromFile(sys.argv[4]) algorithm = getattr(Algorithm, sys.argv[1])(model) adversary = getattr(Adversary, sys.argv[2])(model) events = Events.fromFile(sys.argv[3]) play(algorithm, adversary, events, model.speedup)
def setUp(self): self.ie1, self.ie2, self.ie3 = InjectEvent(1.1, None), InjectEvent(4.2, None), InjectEvent(5.9, None) self.events = Events([self.ie1, self.ie2, self.ie3])
def test_withoutSimultaneousEvents(self): ie1, ie2 = InjectEvent(1, None), InjectEvent(2, None) events = Events([ie1, ie2]) nextEvent = events.next() self.assertFalse(events.hasNextNow(nextEvent.time))
def check_collisions_end(self):
# door collision
door_coll = Physics.get_collisions(self, CollisionTypes.door)
if len(door_coll):
Events.emit("level_completed", GameData.current_level.name)
def deduplicate(self, forced=False):
from CaldavClient import ical_event_add, ical_event_delete
duplicates_c = Events([], name='duplicates_caldav')
duplicates_a = Events([], name='duplicates_aiyo')
#names_aiyo = self.aiyo.find_all_names()
tasks_aiyo = self.aiyo.find_all_tasks()
#names_caldav = self.caldav.find_names()
tasks_caldav = self.caldav.events
#for name in names_aiyo:
for task in tasks_aiyo:
#if names_aiyo.count(name) > 1:
if self.aiyo.find_all_task_occurances(task) > 1:
#if not duplicates_a.task_is_present(task):
#if name not in duplicates_a:
duplicates_a.add(task)
# Ensure problematic tasks in aiyo are renamed in caldav too to prevent them being added back to aiyo on next run through (and then again being marked in error - continuously added to inbox...)
if self.caldav.find_all_task_occurances(task) > 0:
duplicates_c.add(task)
# Dangerous for now...
# if names_caldav.count(name) > 1:
# if name not in duplicates_a:
# duplicates_a.append(name)
#for name in names_caldav:
# if names_caldav.count(name) > 1:
# if name not in duplicates_c:
# duplicates_c.append(name)
# if names_aiyo.count(name) > 1:
# if name not in duplicates_c:
# duplicates_c.append(name)
for task in tasks_caldav:
if self.caldav.find_all_task_occurances(task) > 1:
duplicates_c.add(task)
#if not duplicates_c.task_is_present(task):
#if self.aiyo.find_all_task_occurances(task) > 1:
# if not duplicates_c.task_is_present(task):
# # Should be _a below?
# duplicates_c.add(task)
#names = names_aiyo
#for name in names_caldav:
# if name not in names:
# names.append(name)
tasks = Events([], 'alluniquetasks')
tasks.extend(tasks_aiyo)
for task in tasks_caldav:
if not tasks.task_is_present(task):
tasks.add(task)
names = tasks.names
if (duplicates_c.find_number() == 0 and duplicates_a.find_number() == 0):
# No duplicates found!
return True
else:
if not forced:
# Not yet forced, drop out of processing and wait a bit...
report(colour.red + 'Duplicates: ' + ', '.join(duplicates_c.find_names() + duplicates_a.find_names()) + colour.end)
return False
# Actual de-duplication process:
# Deal with caldav duplicates
error('Duplicates found, and persistent, processing now forced')
if duplicates_c.find_number() > 0:
duplicates = []
for task in self.caldav.events:
#report('DEDUP '+task.name+', '+str(task.parents[0]) +', '+str(duplicates_c.task_is_present(task)))
if duplicates_c.task_is_present(task):
duplicates.append(task)
for task in duplicates:
#report(colour.yellow + 'De-duplicating caldav task: ' + task.name + colour.end)
# Temporarily in place
error('De-duplicating caldav task: ' + task.name)
ical_event_delete(task)
renamed = False
while task.name in names:
if not renamed:
task.name = task.name + ' '
renamed = True
task.name = task.name + '-'
names.append(task.name)
ical_event_add(task)
# Doing above now, otherwise need to change to be done by name here
#for task in duplicates_c.events:
# ical_event_delete(task)
# Deal with aiyo duplicates
if duplicates_a.find_number() > 0:
error('Duplicates found in aiyo [UNTESTED], with names: ' + (os.linesep + ' ').join(['']+duplicates_a.names))
duplicates = []
for task in self.aiyo.find_all_tasks():
if duplicates_a.task_is_present(task):
duplicates.append(task)
for task in duplicates:
# Mark as error (superseded)
# task.error = True
# report(colour.yellow + 'Marking task in error: ' + task.to_string(reformat=True) + colour.end)
# Actual deduplication:
error('De-duplicating aiyo task: ' + task.name)
renamed = False
while task.name in names:
if not renamed:
task.name = task.name + ' '
renamed = True
task.name = task.name + '-'
names.append(task.name)
# Deduplication / mark as error end
self.aiyo.make_modified(task)
self.update_active()
# De-duplication done, allow processing to continue
return True
# -*- coding: utf-8 -*-
from BasicSite import *
basics = MainPage(db)
cardDAL = ContentCards(db)
from Events import Events
eventDAL = Events(db)
thisPage = basics.get_my_page()
for pageData in thisPage["pages"]:
if pageData["pageFile"] == request.function:
PAGETYPE = pageData
def index():
cards = cardDAL.get_data_cards(pageID=PAGETYPE["id"])
# THIS PULLS FROM THE EVENTS PAGE
events = eventDAL.get_data_events(pageID=4)
return dict(thisPage=thisPage, cards=cards, events=events)
def rules():
cards = cardDAL.get_data_cards(pageID=PAGETYPE["id"])
return dict(thisPage=thisPage, cards=cards)
def membership():
cards = cardDAL.get_data_cards(pageID=PAGETYPE["id"])
return dict(thisPage=thisPage, cards=cards)
#!/usr/bin/env python3
# should be locate in main directory
import sys
if len(sys.argv) != 3:
print("{} <model-file> <events-file>".format(sys.argv[0]))
sys.exit(1)
from matplotlib import pyplot
pyplot.rcParams["figure.figsize"] = [5.75, 2.5]
from Model import Model
from Events import Events
model, events = Model.fromFile(sys.argv[1]), Events.fromFile(sys.argv[2])
count = dict((p, 0) for p in model.packets)
trace = dict((p, []) for p in model.packets)
cumTrace = []
events.next()
while events.hasNext():
event = events.next()
time, packet = event.time, event.packet
count[packet] += 1
tcount = model.rate * model.probability(packet) * time
trace[packet].append((time, count[packet], tcount, count[packet] / tcount))
cumTrace.append(
(time, sum(count[p] for p in model.packets) / model.rate / time))
def upcomingEventsRaw():
return jsonify(UpcomingEvents=Events().getRawUpcomingEvents())
class Spirit(Factory, object):
def __init__(self, *kw, **kwargs):
self.logger = logging.getLogger("Spirit")
configFile = kw[0]
with open(configFile, "r") as fileHandle:
self.config = json.load(fileHandle, "utf-8")
serverName = kwargs["server"]
self.server = self.config["Servers"][serverName]
# Set up logging
generalLogDirectory = os.path.dirname(self.server["Logging"]["General"])
errorsLogDirectory = os.path.dirname(self.server["Logging"]["Errors"])
if not os.path.exists(generalLogDirectory):
os.mkdir(generalLogDirectory)
if not os.path.exists(errorsLogDirectory):
os.mkdir(errorsLogDirectory)
universalHandler = RotatingFileHandler(
self.server["Logging"]["General"], maxBytes=2097152, backupCount=3, encoding="utf-8"
)
self.logger.addHandler(universalHandler)
errorHandler = logging.FileHandler(self.server["Logging"]["Errors"])
errorHandler.setLevel(logging.ERROR)
self.logger.addHandler(errorHandler)
engineString = "mysql://{0}:{1}@{2}/{3}".format(
self.config["Database"]["Username"],
self.config["Database"]["Password"],
self.config["Database"]["Address"],
self.config["Database"]["Name"],
)
self.databaseEngine = create_engine(engineString, pool_recycle=3600)
self.createSession = sessionmaker(bind=self.databaseEngine)
self.players = deque()
self.logger.info("Spirit module initialized")
self.loadPlugins()
self.events = Events()
# Used to safely reload modules by keeping track of existing event callbacks
self.handlers = {}
if self.server["World"]:
self.protocol = Penguin
self.loadRooms()
self.loadItems()
self.loadHandlerModules()
self.logger.info("Running world server")
else:
self.protocol = Spheniscidae
self.loadHandlerModules("Spirit.Handlers.Login.Login")
self.logger.info("Running login server")
def loadPlugins(self):
if not hasattr(self, "plugins"):
self.plugins = {}
pluginModules = self.getPackageModules(Plugins)
for pluginModule in pluginModules:
self.loadPlugin(pluginModule)
def loadPlugin(self, plugin):
pluginModule, pluginClass = plugin
pluginObject = getattr(pluginModule, pluginClass)()
if Plugins.Plugin.providedBy(pluginObject):
self.plugins[pluginClass] = pluginObject
pluginObject.ready()
else:
self.logger.warn("{0} plugin object doesn't provide the plugin interface".format(pluginClass))
def loadHandlerModules(self, strictLoad=()):
handlerMethods = []
def populateHandlerMethods(moduleObject):
moduleMethods = [
getattr(moduleObject, attribute)
for attribute in dir(moduleObject)
if isinstance(getattr(moduleObject, attribute), FunctionType)
]
for moduleMethod in moduleMethods:
handlerMethods.append(moduleMethod)
for handlerModule in self.getPackageModules(Handlers):
if not strictLoad or strictLoad and handlerModule in strictLoad:
if handlerModule not in sys.modules.keys():
moduleObject = importlib.import_module(handlerModule)
populateHandlerMethods(moduleObject)
else:
self.logger.info("Reloading module {0}".format(handlerModule))
handlersCopy = self.handlers.copy()
for handlerId, handlerMethod in handlersCopy.iteritems():
self.events.off(handlerId, handlerMethod)
self.handlers.pop(handlerId, None)
moduleObject = sys.modules[handlerModule]
moduleObject = reload(moduleObject)
populateHandlerMethods(moduleObject)
for handlerId, listenerList in self.events._listeners.iteritems():
for handlerListener in listenerList:
handlerMethod = handlerListener.func
if handlerMethod in handlerMethods:
self.handlers[handlerId] = handlerMethod
self.logger.info("Handler modules loaded")
def getPackageModules(self, package):
packageModules = []
for importer, moduleName, isPackage in pkgutil.iter_modules(package.__path__):
fullModuleName = "{0}.{1}".format(package.__name__, moduleName)
if isPackage:
subpackageObject = importlib.import_module(fullModuleName, package=package.__path__)
subpackageObjectDirectory = dir(subpackageObject)
if "Plugin" in subpackageObjectDirectory:
packageModules.append((subpackageObject, moduleName))
continue
subPackageModules = self.getPackageModules(subpackageObject)
packageModules = packageModules + subPackageModules
else:
packageModules.append(fullModuleName)
return packageModules
def downloadCrumbs(self, url):
deferredDownload = defer.Deferred()
def handleRequestComplete(resultData):
if not os.path.exists("crumbs"):
os.mkdir("crumbs")
crumbsFile = "crumbs/" + os.path.basename(url)
with open(crumbsFile, "w") as fileHandler:
fileHandler.write(resultData)
deferredDownload.callback(None)
getPage(url).addCallback(handleRequestComplete)
return deferredDownload
def loadItems(self):
if not hasattr(self, "items"):
self.items = {}
def parseItemCrumbs(downloadResult=None):
with open("crumbs/paper_items.json", "r") as fileHandle:
items = json.load(fileHandle)
for item in items:
itemId = item["paper_item_id"]
self.items[itemId] = item["cost"]
self.logger.info("{0} items loaded".format(len(self.items)))
if not os.path.exists("crumbs/paper_items.json"):
self.downloadCrumbs(
"http://cdn.clubpenguin.com/play/en/web_service/game_configs/paper_items.json"
).addCallback(parseItemCrumbs)
else:
parseItemCrumbs()
def loadRooms(self):
if not hasattr(self, "rooms"):
self.rooms = {}
def parseRoomCrumbs(downloadResult=None):
with open("crumbs/rooms.json", "r") as fileHandle:
rooms = json.load(fileHandle).values()
internalId = 0
for room in rooms:
externalId = room["room_id"]
internalId += 1
if not externalId in self.rooms:
self.rooms[externalId] = Room(externalId, internalId)
self.logger.info("{0} rooms loaded".format(len(self.rooms)))
if not os.path.exists("crumbs/rooms.json"):
self.downloadCrumbs("http://cdn.clubpenguin.com/play/en/web_service/game_configs/rooms.json").addCallback(
parseRoomCrumbs
)
else:
parseRoomCrumbs()
def buildProtocol(self, addr):
session = self.createSession()
player = self.protocol(session, self)
return player
def start(self):
self.logger.info("Starting server..")
port = int(self.server["Port"])
self.logger.info("Listening on port {0}".format(port))
reactor.listenTCP(port, self)
reactor.run()
class EmptyEventsTestCase(unittest.TestCase): def setUp(self): self.events = Events([]) def test_createEvents(self): self.assertEqual(self.events.hasNext(), False) def test_canScheduleEvent(self): event = SentEvent(1.1, None) self.events.schedule(event) self.assertEqual(self.events.hasNext(), True) def test_canGetNextScheduledEvent(self): event = SentEvent(1.2, None) self.events.schedule(event) nextEvent = self.events.next() self.assertEqual(nextEvent, event) def test_cannotGetNextEventFromEmpty(self): self.assertEqual(self.events.next(), None) def test_canGetNextEventsInOrder(self): e1, e2, e3 = SentEvent(4.3, None), SentEvent(7.1, None), SentEvent(2.3, None) for e in [e1, e2, e3]: self.events.schedule(e) for e in [e3, e1, e2]: self.assertEqual(self.events.hasNext(), True) nextEvent = self.events.next() self.assertEqual(nextEvent, e) self.assertEqual(self.events.hasNext(), False)
#!/usr/bin/python
import sys
sys.path.append('../src/')
from Events import Events
e = Events()
e.register('../userDesign/hello.py:printHello')
e.register('../userDesign/hello.py:Hello#0', 456)
e.register('../userDesign/hello.py:Hello#0.printText')
print e
e.fire('../userDesign/hello.py:printHello')
e.fire('../userDesign/hello.py:Hello#0.printText', 123, 'ok')
from Tree import *
from Parser import *
def fireNodes(exp, nodes, expects, printFlag=False):
rpn = genRpnList(exp)
#if printFlag: print rpn
mt = MergedTree(rpn)
if printFlag:
mt.printTreeUpDown()
mt.printWishList()
mt.printCandiList()
i = 0
class State(object):
def __init__(self, active=None, caldav=None, aiyo=None, load=False, generate=False, localonly=False, previous=None):
self.active = None
self.caldav = None
self.aiyo = None
if active is None: active = []
if caldav is None: caldav = []
if aiyo is None: aiyo = []
if load:
self.active, self.caldav = self.load_from_file()
self.aiyo = aiyo
elif generate:
self.generate(active=active, caldav=caldav, aiyo=aiyo, localonly=localonly, previous=previous)
else:
self.active = Events(active, name='aiyo')
self.caldav = Events(caldav, name='caldav')
self.aiyo = aiyo
def generate(self, active=None, caldav=None, aiyo=None, localonly=False, previous=None):
aiyo = FileTodos(title='Todos')
projects = []
categories = []
categories = [ f for f in os.listdir(universe.dataroot) if (os.path.isdir(os.path.join(universe.dataroot,f)) and not f.startswith('.')) ]
for category in categories:
category_projects = []
category_projects = [ f for f in os.listdir(os.path.join(universe.dataroot, category)) if (os.path.isfile(os.path.join(universe.dataroot, category, f)) and not f.startswith('.')) ]
category_todos = FileTodos(title=category, level=-1)
for category_project in category_projects:
tasks = tasklist_read(category_project, category)
category_todos.add_child(tasks)
aiyo.add_child(category_todos)
if not localonly:
caldav = []
caldav_error = False
for tasklistname in aiyo.child_names() + universe.auxlists:
client, calendar, tasks = caldav_load(tasklistname)
#print ' ', tasklistname, client, calendar, tasks
if (client is None or calendar is None or tasks is None):
caldav_error = True
else:
caldav.extend(tasks)
if caldav_error:
self.caldav = None
else:
self.caldav = Events(caldav, name='caldav')
active = aiyo.find_active()
#print 'here_no update'
aiyo.find_next_actions(set_updated=False)
self.active = Events(active, name='aiyo')
self.aiyo = aiyo
if not localonly:
self.sort_groups(previous=previous)
# Create state
#return State(active=active, caldav=todo_caldav, aiyo=todo_aiyo)
def deduplicate(self, forced=False):
from CaldavClient import ical_event_add, ical_event_delete
duplicates_c = Events([], name='duplicates_caldav')
duplicates_a = Events([], name='duplicates_aiyo')
#names_aiyo = self.aiyo.find_all_names()
tasks_aiyo = self.aiyo.find_all_tasks()
#names_caldav = self.caldav.find_names()
tasks_caldav = self.caldav.events
#for name in names_aiyo:
for task in tasks_aiyo:
#if names_aiyo.count(name) > 1:
if self.aiyo.find_all_task_occurances(task) > 1:
#if not duplicates_a.task_is_present(task):
#if name not in duplicates_a:
duplicates_a.add(task)
# Ensure problematic tasks in aiyo are renamed in caldav too to prevent them being added back to aiyo on next run through (and then again being marked in error - continuously added to inbox...)
if self.caldav.find_all_task_occurances(task) > 0:
duplicates_c.add(task)
# Dangerous for now...
# if names_caldav.count(name) > 1:
# if name not in duplicates_a:
# duplicates_a.append(name)
#for name in names_caldav:
# if names_caldav.count(name) > 1:
# if name not in duplicates_c:
# duplicates_c.append(name)
# if names_aiyo.count(name) > 1:
# if name not in duplicates_c:
# duplicates_c.append(name)
for task in tasks_caldav:
if self.caldav.find_all_task_occurances(task) > 1:
duplicates_c.add(task)
#if not duplicates_c.task_is_present(task):
#if self.aiyo.find_all_task_occurances(task) > 1:
# if not duplicates_c.task_is_present(task):
# # Should be _a below?
# duplicates_c.add(task)
#names = names_aiyo
#for name in names_caldav:
# if name not in names:
# names.append(name)
tasks = Events([], 'alluniquetasks')
tasks.extend(tasks_aiyo)
for task in tasks_caldav:
if not tasks.task_is_present(task):
tasks.add(task)
names = tasks.names
if (duplicates_c.find_number() == 0 and duplicates_a.find_number() == 0):
# No duplicates found!
return True
else:
if not forced:
# Not yet forced, drop out of processing and wait a bit...
report(colour.red + 'Duplicates: ' + ', '.join(duplicates_c.find_names() + duplicates_a.find_names()) + colour.end)
return False
# Actual de-duplication process:
# Deal with caldav duplicates
error('Duplicates found, and persistent, processing now forced')
if duplicates_c.find_number() > 0:
duplicates = []
for task in self.caldav.events:
#report('DEDUP '+task.name+', '+str(task.parents[0]) +', '+str(duplicates_c.task_is_present(task)))
if duplicates_c.task_is_present(task):
duplicates.append(task)
for task in duplicates:
#report(colour.yellow + 'De-duplicating caldav task: ' + task.name + colour.end)
# Temporarily in place
error('De-duplicating caldav task: ' + task.name)
ical_event_delete(task)
renamed = False
while task.name in names:
if not renamed:
task.name = task.name + ' '
renamed = True
task.name = task.name + '-'
names.append(task.name)
ical_event_add(task)
# Doing above now, otherwise need to change to be done by name here
#for task in duplicates_c.events:
# ical_event_delete(task)
# Deal with aiyo duplicates
if duplicates_a.find_number() > 0:
error('Duplicates found in aiyo [UNTESTED], with names: ' + (os.linesep + ' ').join(['']+duplicates_a.names))
duplicates = []
for task in self.aiyo.find_all_tasks():
if duplicates_a.task_is_present(task):
duplicates.append(task)
for task in duplicates:
# Mark as error (superseded)
# task.error = True
# report(colour.yellow + 'Marking task in error: ' + task.to_string(reformat=True) + colour.end)
# Actual deduplication:
error('De-duplicating aiyo task: ' + task.name)
renamed = False
while task.name in names:
if not renamed:
task.name = task.name + ' '
renamed = True
task.name = task.name + '-'
names.append(task.name)
# Deduplication / mark as error end
self.aiyo.make_modified(task)
self.update_active()
# De-duplication done, allow processing to continue
return True
def update_active(self):
new_active = Events(self.aiyo.find_active(), name='aiyo')
additions = Events(name='additions')
removals = Events(name='removals')
updated = Events(name='updated')
for task in self.active.events:
if not new_active.task_is_present(task):
# Task has been removed
removals.add(task)
for task in new_active.events:
if not self.active.task_is_present(task):
# Task has been added
additions.add(task)
self.active = new_active
for task in self.active.events:
if task.updated:
updated.add(task)
return additions, removals, updated
def show_active(self):
report('Active tasks:')
for i in range(len(self.active.events)):
report(' ' + str(i+1) + ' ' + self.active.events[i].name.encode('utf-8'))
def sort_groups(self, previous=None):
if previous is None:
previous = self
if not self.is_valid():
return
for task in self.caldav.events:
# If parent exists, group already known
if task.parents[0] in self.aiyo.child_names(): continue
parents = ['home']
matches = []
if task.parents[0] == 'wait':
task.set_wait()
matches = previous.active.find_tasks_by_name(name=task.name, check_is_wait=True)
if len(matches) == 0:
matches = previous.active.find_tasks_by_name(name=task.name)
if len(matches) > 1:
matches_again = []
for match in matches:
#print match.name, '|', match.parents[0], '|', match.group(), '|', not self.caldav.contains_task_by_name_group(match.name, match.parents[0])
if not previous.caldav.contains_task_by_name_group(match.name, match.parents[0]):
matches_again.append(match)
if len(matches_again) == 1:
parents = matches_again[0].parents
else:
error('Multiple matches to locate waiting task: ' + task.name +' defaulting to: home')
elif len(matches) > 0:
if len(matches[0].parents) > 0:
parents = matches[0].parents
task.parents = parents
#report(colour.yellow + 'Wait task: ' + task.name + ' (identified to parent: ' + '|'.join(task.parents) + ')' + colour.end)
def is_valid(self, localonly=False):
if self.active is None:
return False
if self.aiyo is None:
return False
if not localonly:
if self.caldav is None:
return False
return True
def load_from_file(self):
active, caldav = None, None
if os.path.exists(universe.statefile):
try:
f = open(universe.statefile, 'rb' )
active, caldav = pickle.load(f)
f.close()
except Exception, e:
error('Error loading state file, exception: ' + str(e))
pass
return active, caldav
#!/usr/bin/env python3
# should be locate in main directory
import sys
if len(sys.argv) != 3:
print("{} <model-file> <events-file>".format(sys.argv[0]))
sys.exit(1)
from matplotlib import pyplot
pyplot.rcParams["figure.figsize"] = [5.75, 2.5]
from Model import Model
from Events import Events
model, events = Model.fromFile(sys.argv[1]), Events.fromFile(sys.argv[2])
count = dict((p, 0) for p in model.packets)
trace = dict((p, []) for p in model.packets)
cumTrace = []
events.next()
while events.hasNext():
event = events.next()
time, packet = event.time, event.packet
count[packet] += 1
tcount = model.rate * model.probability(packet) * time
trace[packet].append((time, count[packet], tcount, count[packet] / tcount))
cumTrace.append((time, sum(count[p] for p in model.packets) / model.rate / time))
lr, = pyplot.plot(list(map(lambda e: e[0], cumTrace)), [1] * len(cumTrace))
def diff(state, state_previous):
debug=False
state.expire()
state.prioritycurrent()
# changes
changes = find_changes(state.active, state_previous.active)
changes = find_changes(state.caldav, state_previous.caldav, changes=changes, caldav=True)
# Check changes to aiyo, for later application to caldav
caldav_to_add = Events(name='caldav_to_add')
caldav_to_remove = Events(name='caldav_to_remove')
# deletions
if debug: report('AIYO -> CALDAV check', debug=True)
for task in state_previous.active.events:
if not state.active.task_is_present(task):
# Task has been removed, remove from caldav
caldav_to_remove.add(task)
# additons
for task in state.active.events:
if not state_previous.active.task_is_present(task):
# Task has been added, add to caldav
caldav_to_add.add(task)
if debug: report('CALDAV -> AIYO', debug=True)
# Check changes to caldav, apply to aiyo
# deletions
#update_active_required = False
update_active_required = True
for task in state_previous.caldav.events:
if not state.caldav.task_is_present(task):
update_active_required = True
state.active.remove(task)
# recurrance
new = state.aiyo.recur(task)
if new is not None:
if new.is_active():
report(colour.magenta + ' recurring task is still active' + colour.end, debug=True)
state.active.add(new)
caldav_to_add.add(new)
# Checks if active and adds back in here (no need to wait for next run to mop up)
#state.aiyo.remove(task)
if update_active_required:
#state.show_active()
if debug: report(' Updating ACTIVE', debug=True)
additions, removals, updated = state.update_active()
#state.show_active()
# additons
for task in state.caldav.events:
#if task.group() == 'wait':
# report(task.name + '|' + task.parents[0])
# for t in state_previous.caldav.events:
# report(' ' + t.name + ' | ' + t.parents[0])
if not state_previous.caldav.task_is_present(task):
# Ensure trigger due is also applied to due
# Now done above
#ical_event_update(task, due=True)
#update_active_required = True
if debug: print 'new', task.to_string(reformat=True, show_where=True)
state.active.add(task)
state.aiyo.add(task)
# Extra step to deal with additions and removals in recur above - do better?
for task in removals.events:
caldav_to_remove.add(task)
report(colour.red + 'Task since removed from active: ' + task.name + ' (group: ' + task.group() +')' + colour.end)
for task in additions.events:
caldav_to_add.add(task)
report(colour.red + 'Task since added to active: ' + task.name + ' (group: ' + task.group() +')' + colour.end)
if debug: report('AIYO -> CALDAV', debug=True)
# Changes to aiyo, apply to caldav
for task in caldav_to_remove.events:
state.caldav.remove(task)
for task in caldav_to_add.events:
state.caldav.add(task)
# Changes to this task are dealt with here, clear updated flag for now
task.updated = False
if debug: report('SANITY', debug=True)
# Sanity check, mopping up (SHOULD DO NOTHING!)
for task in state.active.events:
if not state.caldav.task_is_present(task):
report(colour.red + 'Sanity: Task missing from caldav: ' + task.name + ' (group: ' + task.group() +')' + colour.end)
# Task in active, not in caldav, add to caldav
# Note the optional fields like starttext, hold, etc could be problematic in the sanity check
state.caldav.add(task)
for task in state.caldav.events:
if not state.active.task_is_present(task):
report(colour.red + 'Sanity: Task missing from active: ' + task.name + ' (group: ' + task.group() +')' + colour.end)
# Task in caldav, not in active, add to active
# Note the optional fields like starttext, hold, etc could be problematic in the sanity check
state.active.add(task)
if debug: report('CHANGE', debug=True)
# changes
change_names = []
for change in changes:
change_names.append(change.name)
if len(changes) > 0:
report(colour.blue + 'Identified possible changes in:' + colour.end + ' ' + (os.linesep+' ').join([''] + change_names))
for change in changes:
task_a = state.active.find_task(change)
task_a_p = state_previous.active.find_task(change)
task_c = state.caldav.find_task(change)
task_c_p = state_previous.caldav.find_task(change)
# Improve the detection of changes to deal with the following better?
if ((task_a is None) and (task_c is None) and (task_a_p is not None) and (task_c_p is not None)):
report(colour.blue + 'Note for task' + colour.end + ' ' + change.name + ' ' + colour.blue + 'these changes are consistent with a simultaneous removal from both active and caldav, so ignoring (used to raise an error).' + colour.end)
continue
if any(x is None for x in [task_a, task_a_p, task_c, task_c_p]):
detail = ''
if task_a is None: detail = detail + os.linesep + ' active does not contain: ' + change.name
if task_a_p is None: detail = detail + os.linesep + ' active previous does not contain: ' + change.name
if task_c is None: detail = detail + os.linesep + ' caldav does not contain: ' + change.name
if task_c_p is None: detail = detail + os.linesep + ' caldav previous does not contain: ' + change.name
error('Task can not be found in one of the four collections: ' + change.name + detail)
continue
change_a = task_a != task_a_p
change_c = task_c != task_c_p
#print 'change_a', change_a
#print 'change_c', change_c
if change_c:
state.aiyo.update(task_c, previous=task_c_p, caldavsource=True)
if change_a:
task_c.update(task_a, previous=task_a_p, caldav=True)
#updated_next_actions = state.aiyo.find_next_actions()
#print updated_next_actions
state.aiyo.find_next_actions()
#for task_a in state.active.events:
# task_a_p = state_previous.active.find_task(task_a)
# if task_a.next_action != task_a_p.next_action:
# task_a.set_updated(follow=False)
# print task_a.name, task_a.next_action
# Clean up other changes to caldav required:
additions, removals, updated = state.update_active()
for task_a in updated.events:
# TODO
task_a_p = state_previous.active.find_task(task_a)
task_c = state.caldav.find_task(task_a)
if (task_a_p is None or task_c is None):
detail = ''
if task_a_p is None: detail = detail + os.linesep + ' active previous does not contain: ' + task_a.name
if task_c is None: detail = detail + os.linesep + ' caldav does not contain: ' + change.name
error('Task can not be found in one of the four collections: ' + task_a.name + detail)
continue
report(colour.red + 'Task update discovered: ' + task_a.name + ' (group: ' + task_a.group() +')' + colour.end)
task_c.update(task_a, previous=task_a_p, caldav=True)
for task in additions.events:
state.caldav.add(task)
for task in removals.events:
state.caldav.remove(task)
return state
def upcomingEvents():
return jsonify(UpcomingEvents=Events().getUpcomingEvents())
def test_SimultaneousSentAndError(self):
ie1, ie2 = InjectEvent(1, None), InjectEvent(2, None)
events = Events([ie1, ie2])
se1 = SentEvent(1.5, None)
events.schedule(se1)
se2 = SentEvent(2, None)
events.schedule(se2)
ee = ErrorEvent(1.5)
events.schedule(ee)
self.assertEqual(events.next(), ie1)
self.assertEqual(events.next(), se1)
self.assertEqual(events.next(), ee)
self.assertEqual(events.next(), ie2)
self.assertEqual(events.hasNext(), False)
#Code to add events within the room
j = 1
cursor2 = connection.cursor()
cursor3 = connection.cursor()
for i in range(len(roomList)):
query1 = "Select resID, eventName, courseNum, profID, startTime from events where roomID = " + str(
idList[i]) + " Limit 14"
cursor2.execute(query1)
j = 1
for resID, eventName, courseNum, profID, startTime in cursor2.fetchall():
cursor3.execute("Select lname from prof where profID = " + str(profID))
try:
lastName = cursor3.fetchone()[0]
except:
lastName = "Unknown"
timeSlot = (int(str(startTime)[:2]) - 8) * 2 // 1 + (
int(str(startTime)[3:5]) // 29)
#print("Time: ", startTime, "timeSlot", timeSlot, "--", (int(str(startTime)[3:5]) // 29 ), )
roomList[i].addEvent(
timeSlot,
Events(eventName, courseNum, " ", "1", str(lastName),
"TTH" + str(timeSlot), 50))
j += 1 #index for adding events
interface = Tk()
interface.geometry("800x600")
interface.configure(bg="black")
window1 = GUI_Main(interface, roomList)
testBuilding = input("Class Name: ")
class App(object):
"""docstring for App"""
def __init__(self):
super(App, self).__init__()
self.setup_pygame()
self.events = Events()
self.lane = Lane(self.events)
self.lane.add_support_point(100,100)
self.lane.add_support_point(200,100)
self.lane.add_support_point(200,200)
self.lane.add_support_point(100,200)
self.cars = []
for k in range(4):
self.cars.append(Car(x=150+k*5,y=100,theta=np.random.randint(0,360),speed=np.random.randint(45,180)))
# self.cars.append(Car(x=250,y=100,theta=-45,speed=2*90))
self.action = None
self.human = HumanController()
self.heuristic = Heuristic(self.lane)
Node.heuristic = self.heuristic
self.onestep = OneStepLookaheadController(self.cars,self.lane,self.heuristic)
self.nstep = NStepLookaheadController(self.cars,self.lane, self.heuristic, 2)
self.bestfirst = BestFirstController(self.cars,self.lane, self.heuristic)
self.controller = self.bestfirst
# self.window = Window(self.screen, self.events, 300, 200, "caption")
self.grid = Grid(50,50,*self.size)
self.last_distance_grid_update = time() - 10
self.update_distance_grid()
self.done = False
self.register_events()
self.spin()
def setup_pygame(self):
pygame.init()
# Set the width and height of the screen [width, height]
self.size = (700, 500)
self.screen = pygame.display.set_mode(self.size)
self.font = pygame.font.SysFont("arial",10)
pygame.display.set_caption("My Game")
def draw_string(self,string,x,y,color=Draw.BLACK):
Draw.draw_string(self.screen,self.font,string,x,y,color)
def draw(self):
self.grid.draw(self.screen)
self.lane.draw(self.screen)
# Draw car
for car in self.cars:
if self.controller is not None:
if hasattr(self.controller,"action"):
car.draw(self.screen, self.controller.action)
self.controller.draw(self.screen, car)
else:
car.draw(self.screen)
def input(self):
# get mouse info
cursor = pygame.mouse.get_pos()
(left_button, middle_button, right_button) = pygame.mouse.get_pressed()
keys = pygame.key.get_pressed()
if self.lane.selected is not None:
if keys[pygame.K_DELETE]:
self.lane.remove_support_point(self.lane.selected)
self.lane.selected = None
self.update_distance_grid()
if keys[pygame.K_SPACE]:
for car in self.cars:
# save original speed
if not hasattr(car,"speed_on"):
car.speed_on = car.speed
# toggle speed
car.speed = car.speed_on - car.speed
if keys[pygame.K_RETURN]:
self.controller = self.human if self.controller != self.human else self.onestep
def update_distance_grid(self):
# return
if time() - self.last_distance_grid_update > 1 / 5:
self.last_distance_grid_update = time()
for i in range(self.grid.width):
for j in range(self.grid.height):
x,y = self.grid.xs[i], self.grid.ys[j]
closest_idx = self.lane.closest_sampled_idx(x, y)
distance = Utils.distance_between(
(self.lane.sampled_x[closest_idx],self.lane.sampled_y[closest_idx]),
(x,y))
# diff = np.array([self.lane.sampled_x[closest_idx]-x,self.lane.sampled_y[closest_idx]-y])
# distance = math.sqrt(np.sum(np.square(diff)))
self.grid.data[i,j] = distance*distance
def register_events(self):
self.events.register_callback("quit", self.on_quit)
self.events.register_callback("laneupdate", self.on_laneupdate)
def on_quit(self, args):
self.done = True
def on_laneupdate(self, lane):
if lane == self.lane:
if self.lane.selected is None:
self.update_distance_grid()
# pass
def spin(self):
# Loop until the user clicks the close button.
self.done = False
# Used to manage how fast the screen updates
clock = pygame.time.Clock()
self.last_time = time()
# -------- Main Program Loop -----------
while not self.done:
dt = time()-self.last_time
self.last_time = time()
# --- Main event loop
for event in pygame.event.get(): # User did something
if event.type in self.events.pygame_mappings:
self.events.fire_callbacks(self.events.pygame_mappings[event.type], event)
# if event.type == pygame.QUIT: # If user clicked close
# done = True # Flag that we are done so we exit this loop
self.input()
# --- Game logic should go here
if self.controller is not None:
for car in self.cars:
action = self.controller.compute_action(car)
self.controller.action = action
car.forward(action,dt)
# --- Drawing code should go here
# First, clear the screen to white. Don't put other drawing commands
# above this, or they will be erased with this command.
self.screen.fill(Draw.WHITE)
self.draw()
# --- Go ahead and update the screen with what we've drawn.
pygame.display.flip()
# --- Limit to 60 frames per second
clock.tick(60)
# Close the window and quit.
# If you forget this line, the program will 'hang'
# on exit if running from IDLE.
pygame.quit()
def searchDB(self, keywords, searchRooms, searchEvents):
#search db based on keywords
#search rooms for keywords if searchRooms = 1
#search events for keywords is searchEvents = 1
#place correct itmes in roomList
roomList = []
#print ("DEBUG: ", searchEvents.get())
#TESTING
idList = []
searchKeywords = str(keywords.get()).split()
if str(keywords.get()) == "" or searchRooms.get() == 0:
query1 = "select roomid, building, roomnum, capacity from rooms"
cursor.execute(query1)
elif searchRooms.get() == 1:
if (len(searchKeywords) > 1):
query1 = "select roomid, building, roomnum, capacity from rooms where CAST (roomnum AS text) ILIKE '%" + searchKeywords[
0] + "' and building ILIKE '%" + searchKeywords[1] + "%'"
cursor.execute(query1)
for roomid, building, roomnum, capacity in cursor.fetchall():
roomList.append(Room(building, str(roomnum), str(capacity)))
idList.append(roomid)
query2 = "select roomid, building, roomnum, capacity from rooms where CAST (roomnum AS text) ILIKE '%" + searchKeywords[
1] + "%' and building ILIKE '%" + searchKeywords[0] + "%'"
cursor.execute(query2)
#cursor.execute(query1)
else:
query1 = "select roomid, building, roomnum, capacity from rooms where CAST (roomnum AS text) ILIKE '%" + searchKeywords[
0] + "%' or building ILIKE '%" + searchKeywords[0] + "%'"
cursor.execute(query1)
for roomid, building, roomnum, capacity in cursor.fetchall():
roomList.append(Room(building, str(roomnum), str(capacity)))
idList.append(roomid)
#end testing
#Code to add events within the room
j = 1
cursor2 = connection.cursor()
cursor3 = connection.cursor()
for i in range(len(roomList)):
if searchEvents.get() == 1:
if len(searchKeywords) > 1:
query1 = "Select resID, eventName, courseNum, profID, startTime from events where roomID = " + str(
idList[i]) + " AND ( eventName ILIKE '%" + searchKeywords[
0] + "%' OR eventName ILIKE '%" + searchKeywords[
1] + "%' )"
else:
query1 = "Select resID, eventName, courseNum, profID, startTime from events where roomID = " + str(
idList[i]) + " AND eventName ILIKE '%" + keywords.get(
) + "%'"
else:
query1 = "Select resID, eventName, courseNum, profID, startTime from events where roomID = " + str(
idList[i])
cursor2.execute(query1)
j = 1
for resID, eventName, courseNum, profID, startTime in cursor2.fetchall(
):
cursor3.execute("Select lname from prof where profID = " +
str(profID))
try:
lastName = cursor3.fetchone()[0]
except:
lastName = "Unknown"
timeSlot = (int(str(startTime)[:2]) -
8) * 2 // 1 + (int(str(startTime)[3:5]) // 29) // 1
roomList[i].addEvent(
timeSlot,
Events(eventName, courseNum, " ", "1", str(lastName),
"TTH" + str(timeSlot), 50))
j += 1 #index for adding events
return roomList
def test_eventsFromFileNoFile(self):
with self.assertRaises(FileNotFoundError):
events = Events.fromFile('tests/example/events.inXXX')
