def add_event_to_channel(self, orig, channel_idx):
if orig in self.origs[channel_idx]:
return self.orig2e[channel_idx][orig]
event_idx = self.sizes[channel_idx]
e = events.Event(event_idx, orig)
self.i2e[channel_idx][event_idx] = e
self.orig2e[channel_idx][orig] = e
self.events[channel_idx].add(e)
self.origs[channel_idx].add(orig)
return e
def Update(self, timeElapsed):
if self.moveOrder is not None:
direction = np.array(self.moveOrder) - np.array(self.pos)
dirMag = np.linalg.norm(direction, ord=2)
if dirMag > 0.:
direction /= dirMag
if dirMag < timeElapsed * self.speed:
self.pos = self.moveOrder
self.moveOrder = None
else:
self.pos += direction * timeElapsed * self.speed
if self.attackOrder is not None:
event = events.Event("getpos")
event.objId = self.attackOrder
getEnemyPosRet = self.mediator.Send(event)
getEnemyPos = getEnemyPosRet[0]
direction = getEnemyPos - np.array(self.pos)
dirMag = np.linalg.norm(direction, ord=2)
if dirMag > 0.:
direction /= dirMag
if dirMag > self.attackRange * 0.95:
self.pos += direction * timeElapsed * self.speed
if dirMag <= self.attackRange:
#Check if we can fire
durationSinceFiring = None
timeNow = (pygame.time.get_ticks() / 1000.)
if self.fireTime is not None:
durationSinceFiring = timeNow - self.fireTime
if durationSinceFiring is None or self.firePeriod < durationSinceFiring:
self.fireTime = timeNow
fireEvent = events.Event("fireshell")
fireEvent.targetPos = getEnemyPos.copy()
fireEvent.targetId = self.attackOrder
fireEvent.firerId = self.objId
fireEvent.playerId = self.playerId
fireEvent.firerPos = self.pos.copy()
fireEvent.speed = 100.
self.mediator.Send(fireEvent)
def triggerEvent(self, eventType, **params): #{{{
utils.logger.debug("Model " + str(self) + " triggered eventType: "+str(eventType)+ " params: "+str(params))
subscriptionsCopy = copy.copy(self.__subscriptions)
for typ, method, subscriptionID, sessionID in subscriptionsCopy:
if typ == eventType:
event = events.Event(self, eventType, params)
try:
method(event)
except:
utils.logger.exception('Exception while event triggering')
def on_privmsg(event):
if BOT is None: return
if BOT.in_batch: return
prefix = BOT.prefix if event.target.startswith("#") else ""
if event.message.startswith(prefix):
parts = event.message.split(" ")
parts[0] = parts[0][len(prefix):]
event_out = events.Event("command_" + parts.pop(0), parts=parts)
event_out.data.update(event.data)
BOT.event_manager(event_out)
def onEvent(self, event):
self.log.append(event)
if event.type == events.MOTION_EVENT:
brightness_control = events.Event(events.BRIGHTNESS_CONTROL_EVENT,
event.fire_time + CLOUD_DELAY,
"cloud", "cloud")
brightness_control.params = {
"light_brightness": 0.7,
"light_id": event.source
}
self._writeCount = self._writeCount + 1
return [brightness_control]
if event.type == events.BRIGHTNESS_CONTROL_EVENT:
brightness_control = events.Event(events.BRIGHTNESS_CONTROL_EVENT,
event.fire_time + CLOUD_DELAY,
"cloud",
event.params["light_id"])
brightness_control.params = {
"light_brightness": event.params["light_brightness"],
"light_id": event.params["light_id"]
}
new_network_send = events.Event(events.NETWORK_SEND,
event.fire_time + CLOUD_DELAY,
"cloud", self.node)
new_network_send.params = {
"src": "cloud",
"dest": event.params["light_id"],
"payload": brightness_control,
"proto": events.UDP_SEND
}
self._readCount = self._readCount + 1
return [new_network_send]
if event.type == events.UPDATE_DEFAULT_BRIGHTNESS_EVENT:
return []
if event.type == events.EXIT_EVENT:
self._time = event.fire_time
return []
def __ProcessLogoutResp(self, logout_resp):
try:
cmd = self.__cmds[logout_resp.InitiatorTaskTag]
cmd.resp_pdu = logout_resp
if logout_resp.Response == pdu.LogoutRespPDU.RESPONSE_SUCC:
#self.ProcessEvent(event)
self.__init_event_listener.Signal(
events.Event(events.Event.ID_LOGGED_OUT))
except KeyError:
self.logger.error("login response for wrong initiator task id")
return
def test_add_and_then_query(self):
T = 12345
n = 1234
timeline = events.Timeline()
slow_timeline = []
ID = 0
for _ in range(n):
t = random.random() * T
timeline.add_event(events.Event(t, ID))
slow_timeline.append(events.Event(t, ID))
ID += 1
for _ in range(n):
bounds = sorted([random.random() * T, random.random() * T])
one = timeline.events_in_range(*bounds)
two = [
e for e in slow_timeline if bounds[0] <= e.time <= bounds[1]
]
self.assertEqual(sorted_time_description(one),
sorted_time_description(two), "Test 1 failed.")
def list_onboarded_users(self, owner_id, offset=0, limit=20):
new_user_event = events.Event("Users Create User", self.db, self.logger)
user_count = new_user_event.get_event_count(owner_id)
all_users = new_user_event.get_latest_events(user_count)
sliced_users = all_users[offset:limit]
output = []
for each in sliced_users:
json_data = json.loads(each[0])
if "new_user_id" in json_data:
output.append(self.get_user_info(json_data["new_user_id"]))
return output
def add_event_to_all(self, orig):
''' Adds an event (the original event, not an index) to all channels '''
if orig in self.origs[0]: # TODO
return self.orig2e[0][orig]
for channel_idx in range(self.num_channels):
event_idx = self.sizes[channel_idx]
e = events.Event(event_idx, orig)
self.i2e[channel_idx][event_idx] = e
self.orig2e[channel_idx][orig] = e
self.events[channel_idx].add(e)
self.origs[channel_idx].add(orig)
return e
def changeTurn(self):
self.turn += 1
if self.turn == len(global_vars.idLookup): self.turn = 0
try:
while not self.eventManager.isMember(
global_vars.idLookup[self.turn]):
self.turn += 1
except:
self.changeTurn()
e = events.Event(type='turn', t=self.turn)
self.eventManager.post(e)
return self.turn
def _tcpReceive(self, event):
tcp_type = event.params["tcp-type"]
if tcp_type == "ACK": return []
event.fire_time += TCP_RECEIVE_DELAY
if self._hosts[event.params["dest"]] == self.id:
if tcp_type == "SYN" or tcp_type == "SYN-ACK":
response = events.Event(
events.TCP_SEND,
event.fire_time,
self.id,
event.params["src"],
params={
"tcp-type": "SYN-ACK" if tcp_type == "SYN" else "ACK",
"seq-no": event.params["seq-no"],
"src": event.params["dest"],
"dest": event.params["src"]
})
if tcp_type == "SYN":
return [response]
elif tcp_type == "SYN-ACK":
message = self._pending_messages[event.params["seq-no"]]
message.fire_time = event.fire_time + TCP_ACK_DELAY
return [response, message]
elif tcp_type == "MSG":
return [
events.Event(events.NETWORK_RECEIVE,
event.fire_time,
self.id,
self.id,
params=event.params)
]
else:
return self._tcpSend(event)
def play():
'''
Main game loop
Accepts user input and posts relevant events, handles pause state, ticks engine, etc.
'''
global oldTime
global turn
paused = False
while True:
for event in pygame.event.get():
if event.type == QUIT:
pygame.quit()
sys.exit()
return
elif event.type == KEYDOWN:
if event.key == K_ESCAPE:
pygame.event.post(pygame.event.Event(QUIT))
if event.key == K_p:
paused ^= True
if event.key == K_r:
global_vars.eventManager.post(events.Event(type='draw terrain'))
if event.key == K_t:
global_vars.eventManager.post(events.Event(type='render tanks'))
if event.key == K_RIGHT or event.key == K_d:
global_vars.eventManager.post(events.Event(type='right down'))
if event.key == K_LEFT or event.key == K_a:
global_vars.eventManager.post(events.Event(type='left down'))
elif event.type == KEYUP:
if event.key == K_RIGHT or event.key == K_d:
global_vars.eventManager.post(events.Event(type='right up'))
if event.key == K_LEFT or event.key == K_a:
global_vars.eventManager.post(events.Event(type='left up'))
elif event.type == MOUSEMOTION:
mousex, mousey = event.pos
elif event.type == MOUSEBUTTONUP:
mousex, mousey = event.pos
e = events.Event(type = 'click', x = mousex, y = mousey)
eventManager.post(e)
turn = ctr.changeTurn()
oldTime = time.time()
if time.time() - oldTime > _fps:
pygame.display.update()
oldTime = time.time()
else:
while time.time() - oldTime < _fps:
pass
if not paused:
tick()
def _udpReceive(self, event):
event.fire_time += UDP_RECEIVE_DELAY
if self._hosts[event.params["dest"]] == self.id:
return [
events.Event(events.NETWORK_RECEIVE,
event.fire_time,
self.id,
self.id,
params=event.params)
]
else:
return self._udpSend(event)
def test_get_uri(self):
'''Simple coverage test to check the get_uri method works under the
following scenarios:
- No page field set and no module (ModuleURI) field set.
- page field set but no module (ModuleURI) field set.
- No page field set but module (ModuleURI) field set.
- page field set and module (ModuleURI) field set.
'''
event = events.Event({})
self.assertEqual('https://unknown/', event.get_uri())
event.set_data_attr('page', 'https://edx.org/')
self.assertEqual('https://edx.org/', event.get_uri())
event = events.Event({})
event.set_data_attr(
'module',
ModuleURI(
'/courses/MITx/1.111x/2010_Spring/modx/i4x://MITx/1.111x/problem/a/problem_get'
))
self.assertEqual('https://unknown/problem/a/', event.get_uri())
event.set_data_attr('page', 'https://edx.org/')
self.assertEqual('https://edx.org/problem/a/', event.get_uri())
def convert_json_to_event(event_json):
data = event_json['log_data']
timestamp = datetime.fromtimestamp(data['timestampMillis'] / 1000)
if event_json['log_type'] == 'event':
return events.Event(event_type=events.EventType.PSEUDO,
timestamp=timestamp)
elif event_json['log_type'] == 'foreground_app':
return events.AppActivityUsageEvent(
timestamp=timestamp,
app_id=data['packageName'],
source_class=data['sourceClassName'])
elif event_json['log_type'] == 'system_snapshot':
return events.SystemMemorySnapshot(timestamp=timestamp)
def test_set_data_attr(self):
'''Simple coverage test to check the field setter method works correctly.
The setter function should ignore any false types.
'''
event = events.Event({})
event.set_data_attr('key', 'value')
self.assertEqual('value', event['key'])
event.set_data_attr('key', False)
self.assertEqual('value', event['key'])
event.set_data_attr('key', '')
self.assertEqual('value', event['key'])
event.set_data_attr('key', None)
self.assertEqual('value', event['key'])
def test_event_no_data(self):
calls = []
def handler(data):
calls.append(data)
event = events.Event()
event += handler
event.notify()
event()
self.assertEqual(calls, [None, None])
def testUDP(a, b):
"""testUDP(a, b) -> Validates the path of a UDP message between a and b."""
msg_params = {
"proto":
UDP, # Additional param for NETWORK_SEND event.
# Typical network event parameters:
"src":
"LIGHT-1",
"dest":
"LIGHT-2",
"payload":
events.Event(events.UPDATE_DEFAULT_BRIGHTNESS_EVENT,
None,
"LIGHT-1",
"LIGHT-2",
params={"new-brightness": .2})
}
net_event = events.Event(events.NETWORK_SEND, 0, "LIGHT-1", "NET-1",
msg_params)
# Light 1 tells Net 1 to send info
after_net_send = a.onEvent(net_event)[0]
assert after_net_send.type == events.UDP_SEND
# Net 1 tells Net 2 that its sending info
after_udp_send = a.onEvent(after_net_send)[0]
assert after_udp_send.type == events.UDP_RECEIVE
# Net 2 gets the event
after_udp_receive = b.onEvent(after_udp_send)[0]
assert after_udp_receive.type == events.NETWORK_RECEIVE
# Net 2 tells Light 2 that it should adjust brightness
after_net_receive = b.onEvent(after_udp_receive)[0]
assert after_net_receive.type == events.UPDATE_DEFAULT_BRIGHTNESS_EVENT
def WorldClick(self, worldPos, button):
if button == 1:
for objId in self.objs:
obj = self.objs[objId]
if obj.playerId != self.playerId: continue
obj.MoveTo(worldPos)
moveOrder = events.Event("moveorder")
moveOrder.objId = obj.objId
moveOrder.pos = worldPos
self.mediator.Send(moveOrder)
if button == 3:
bestUuid, bestDist = self.ObjNearPos(worldPos, 1)
clickTolerance = 5.
if bestUuid is not None and bestDist < clickTolerance:
for objId in self.objs:
obj = self.objs[objId]
if obj.playerId != self.playerId: continue
obj.Attack(bestUuid)
if bestUuid is not None:
attackOrder = events.Event("attackorder")
attackOrder.attackerId = obj.objId
attackOrder.targetId = bestUuid
self.mediator.Send(attackOrder)
if bestUuid is None or bestDist >= clickTolerance:
for objId in self.objs:
obj = self.objs[objId]
if obj.playerId != self.playerId: continue
#Stop attack
obj.Attack(None)
stopOrder = events.Event("stoporder")
stopOrder.objId = obj.objId
self.mediator.Send(stopOrder)
def parse_cal(link):
"""Returns a list of all events in someone's calendar"""
lst = []
with open(link, "rb") as c:
all_text = c.read()
cal = Calendar.from_ical(all_text)
for component in cal.walk("vevent"):
name = component.get('summary')
start = component.decoded('dtstart') #aware datetime
end = component.decoded('dtend') #aware datetime
temp = events.Event(name, start, end)
lst.append(temp)
return lst
def homepage_create_user():
if request.method == "POST":
if EMAIL_REGEX.match(request.form['email_address']) is None:
error = "Invalid e-mail address."
return render_template("create_user.jinja2", error_msg=error)
if len(request.form['passwd']) < 8:
error = "Passwords must consist of at least 8 characters."
return render_template("create_user.jinja2", error_msg=error)
if request.form["passwd"] == request.form["passwd_repeat"]:
ip_addr = request.access_route[-1]
user_passwd = request.form["passwd"]
full_name = request.form["full_name"]
db = Database()
result = db.create_user(full_name,
request.form['email_address'],
user_passwd,
ip_addr)
if result:
if result[0] == -1:
error = "User with this e-mail address already exists."
return render_template("create_user.jinja2", error_msg=error)
session_id = result[1]
# log event
create_user_event = events.Event("Users Create User",
db,
logger=current_app.logger)
metadata = {"ip_addr": ip_addr, "created_by": "self"}
create_user_event.log_event(result[0], json.dumps(metadata))
user_ctx = users.UserContext(result[0], db=db, logger=current_app.logger)
# default permissions
user_ctx.add_permission("onboard-users")
user_ctx.add_permission("launch-ico")
user_ctx.add_permission("ethereum-network")
db.update_user_permissions(result[0], user_ctx.acl())
config_stream = open("config.json", "r")
config_data = json.load(config_stream)
config_stream.close()
if config_data["new_user_tokens"] > 0:
cr = Credits(result[0], db, current_app.logger)
cr.issue_credits(config_data["new_user_tokens"],
{"ip_addr": ip_addr, "reason": "New User Bonus"})
return redirect(url_for("admin.admin_main", session_token=session_id))
else:
error = "Passwords did not match."
return render_template("create_user.jinja2", error_msg=error)
return render_template("create_user.jinja2")
def _networkSend(self, event):
proto = event.params["proto"]
send_event = events.Event(proto,
event.fire_time + TO_NET_DELAY,
event.source,
self.id,
params={
"src": event.params["src"],
"dest": event.params["dest"],
"payload": event.params["payload"]
})
return [send_event]
def dispatch_directed_command(api_key):
db = database.Database(current_app.logger)
ip_addr = request.access_route[-1]
node_id = db.validate_api_key(api_key)
if node_id:
next_command = db.get_next_directed_command(node_id)
if next_command:
command_id = next_command[0]
command_data = json.loads(next_command[1])
new_event = events.Event("Ethereum Node Command Dispatch", db,
current_app.logger)
event_data = {
"ip_address": ip_addr,
"node_id": node_id,
"command": json.dumps(command_data),
"command_id": command_id
}
new_event_id = new_event.log_event(node_id, json.dumps(event_data))
command_data["command_id"] = command_id
command_data["event_id"] = new_event_id
command_data["directed"] = True
if db.dispatch_directed_command(command_id, new_event_id):
return Response(
json.dumps({
"result": "OK",
"command_data": command_data
}))
else:
return Response(
json.dumps({
"result":
"Error",
"error_message":
"Could not dispatch command {0}".format(command_id)
}))
else:
return Response(
json.dumps({
"result":
"Error",
"error_message":
"Could not fetch next directed command"
}))
else:
return Response(
json.dumps({
"result": "Error",
"error_message": "Invalid API key"
}))
def test_do_no_stringify_nonetype(self):
'''Ensure that when a field is not set, an event __getitem__ call returns None.
In the translation project there is code resembling the following:
if event['unset_field']:
<conditional body>
However, old implementations of the base Event class would stringify
any __getitem__ calls which resulted in behavior where an unset field
would return the string "None", which consequently led to conditional
code like the aforementioned snippet always executing.
'''
event = events.Event({})
self.assertEqual(None, event['unset_field'])
def ingest(event, database):
'''
Insert/update event into the databse
'''
# Check if the customer is new
#customer_id = event.get('key')
if event.get('customer_id'):
customer_id = event.get('customer_id')
else:
customer_id = event.get('key')
try:
customer = database.customers.get(customer_id)
except:
customer = None
# Insert new customer to database with customer_id
if not customer:
customer = events.Customer(event)
database.insertCustomer(customer)
# Add/update event in database
if event['type'] == event_type['order']:
order = events.Order(event)
# Update existing order amount
customer.updateOrderAmount(order, database.orders)
database.insertOrder(order)
elif event['type'] == event_type['image']:
image = events.Image(event)
database.insertImage(image)
elif event['type'] == event_type['site_visit']:
site_visit = events.SiteVisit(event)
customer.increaseSiteVisit()
# Update site visit count for existing customer
database.insertSiteVisit(site_visit)
elif event['type'] == event_type['customer']:
# Update existing customer attributes
customer.updateCustomerAttr(event)
database.insertCustomer(customer)
else:
e = events.Event(event)
database.insertEvent(e)
# Update the latest customer interaction in database
database.getMax(event)
return database
def __init__(self, pos, size, state_images, do_resize=False):
super(Button, self).__init__()
# states: 0=normal, 1=hover, 2=pressed, 3=disabled
self._images = state_images
self.rect = pygame.Rect(pos, size)
self.rect.center = pos
self.state = self.NORMAL
# resize images to fit button size
if do_resize:
for idx, img in enumerate(self._images):
self._images[idx] = pygame.transform.smoothscale(
img, self.rect.size)
self.image = self._images[0]
self.event_clicked = events.Event()
def test_get_resource_display_name(self):
'''Simple coverage test to check the get_resource_name method works under
the following scenarios:
- No resource_display_name field set but module (ModuleURI) is set
- resource_display_name field set and module (ModuleURI) is set
'''
event = events.Event({})
event.set_data_attr(
'module',
ModuleURI(
'/courses/MITx/2.111x/2010_Spring/modx/i4x://MITx/2.111x/problem/a/problem_get'
))
self.assertEqual('a', event.get_resource_display_name())
event.set_data_attr('resource_display_name', 'display_name')
self.assertEqual('display_name', event.get_resource_display_name())
def update_fov(self):
player = self.world.player
pos = self.world.player.pos
level = self.world.levels[player.dlevel]
new_fov = set(fov.calculate_fov(pos, FOV_RADIUS, level))
for pos in player.tiles_in_sight.difference(new_fov):
tile_info = world.TileInfo(pos, level[pos.x, pos.y])
events.events.handle_event(
events.Event(events.EventType.TILE_HIDDEN, tile_info))
for pos in new_fov.difference(player.tiles_in_sight):
world.reveal_tile(level, pos)
player.tiles_in_sight = new_fov
def onEvent(self, *args):
"""
Will be called when receiving an event from the broadcaster.
See onConnect which subscribes to the targets.
"""
try:
# Wamp v1: onEvent is callbacked with topic and event
target, event_data = args
except ValueError:
# Wamp v2: onEvent is callbacked with event
event_data, = args
target = None
event = events.Event(target, event_data)
if event.is_a_vote:
voting_fsm = self.states.get(event.tracking_id)
if not voting_fsm:
log.msg('Ignoring vote %r because I have already lost' %
event.vote)
return
own_vote = voting_fsm.vote
is_a_fold = (own_vote < event.vote)
if is_a_fold:
log.msg(
'Folding due to vote %r being higher than own vote %r' %
(event.vote, own_vote))
voting_fsm.fold()
else:
log.msg('Calling due to vote %r being lower than own vote %r' %
(event.vote, own_vote))
voting_fsm.call()
elif event.is_a_request:
try:
self.handle_request(event)
except Exception as e:
log.err(e.message)
for line in traceback.format_exc().splitlines():
log.err(line)
self.publish_failed(event, e.message)
else:
log.msg(str(event))
def test_clear_handlers(self):
calls = set()
def handler_one(data):
calls.add("one")
def handler_two(data):
calls.add("two")
event = events.Event()
event += handler_one
event += handler_two
event.clear_handlers()
self.assertEqual(calls, set())
