def test_can_set_upevent_if_same_downevent_fetched(self):
mngr = events.EventManager()
mngr.set_event("CTRL_DOWN", 2)
mngr.get_event("CTRL_DOWN")
res = mngr.set_event("CTRL_UP", 2)
self.assertEqual(res, True)
self.assertEqual(mngr._events["CTRL_DOWN"], None)
self.assertEqual(mngr._events["CTRL_UP"], 2)
self.assertEqual(mngr._last_events["CTRL_DOWN"], 2)
mngr = events.EventManager()
mngr.set_event("CTRL_DOWN", 2)
res = mngr.set_event("CTRL_UP", 2)
self.assertEqual(res, False)
self.assertEqual(mngr._events["CTRL_DOWN"], 2)
self.assertEqual(mngr._events["CTRL_UP"], None)
mngr = events.EventManager()
mngr.set_event("CTRL_DOWN", 2)
mngr.get_event("CTRL_DOWN")
res = mngr.set_event("CTRL_UP", 4)
self.assertEqual(res, False)
self.assertEqual(mngr._events["CTRL_DOWN"], None)
self.assertEqual(mngr._events["CTRL_UP"], None)
self.assertEqual(mngr._last_events["CTRL_DOWN"], 2)
self.assertEqual(mngr._last_events["CTRL_UP"], None)
def test_event_stored_after_fetched(self):
mngr = events.EventManager()
mngr.set_event("CTRL_DOWN", 2)
mngr.get_event("CTRL_DOWN")
self.assertEqual(mngr._last_events["CTRL_DOWN"], 2)
mngr.set_event("CTRL_DOWN", 4)
self.assertEqual(mngr._last_events["CTRL_DOWN"], 2)
def start(environment_dimensions):
print("environment dimensions: " + str(environment_dimensions))
screen = rendering.Screen((1280, 700))
side_bar_width = 400
task_bar_height = 40
environment_canvas_dimensions = (screen.dimensions[0] - side_bar_width,
screen.dimensions[1] - task_bar_height)
width_ratio = environment_canvas_dimensions[0] / environment_dimensions[0]
environment_camera = rendering.RelativeCamera((0, 0),
(width_ratio, width_ratio))
highlight_dimension = (side_bar_width, screen.dimensions[1])
creature_highlight = gen.CreatureHighlight(highlight_dimension)
screen.add_canvas(creature_highlight,
(environment_canvas_dimensions[0], 0))
event_manager = events.EventManager(screen)
renderer = rendering.PyGameRenderer(screen)
manager = render_management.Manager(event_manager, render=renderer.render)
create_environment_f = functools.partial(
create_environment, screen, environment_camera, environment_dimensions,
creature_highlight, task_bar_height, renderer, manager)
create_environment_f()
task_bar = create_task_bar(
(environment_canvas_dimensions[0], task_bar_height), manager, renderer,
create_environment_f)
screen.add_canvas(task_bar)
manager.start()
def __init__(self, port=None):
self.verbose = console.Option(False)
self.strict = console.Option(False)
self.autoTrace = console.Option(False)
self.stretch = console.Option(100)
self.console = console.Command()
self.console.finishFunction = self.finish
if port is None:
self.nextPort = randomPort()
else:
self.nextPort = port
self.eventManager = events.EventManager()
self.fileManager = files.FileManager(printer=self.console)
self.fileManager.purgeResponseFiles()
self.requestManager = agents.RequestGenerator(self.eventManager,
self.fileManager,
self.console,
strict=self.strict,
verbose=self.verbose)
self.servers = {}
self.proxyProcess = None
self.console.addOption(
"strict", self.strict,
"Apply strict testing of HTTP requests and responses")
self.console.addOption("verbose", self.verbose, "Show details")
self.console.addOption(
"stretch", self.stretch,
"Multiply all delays by factor = stretch / 100")
self.console.addOption("autotrace", self.autoTrace,
"Trace every request for which check fails")
self.console.addCommand("serve", self.doServe, "SID+",
"Set up servers")
self.console.addCommand(
"request", self.doRequest, "ID FILE SID",
"Initiate request named ID for FILE from server SID")
self.console.addCommand(
"fetch", self.doFetch, "ID FILE SID",
"Fetch FILE from server SID using request named ID")
self.console.addCommand(
"respond", self.doRespond, "ID+",
"Allow servers to return reponses to requests")
self.console.addCommand("delay", self.doDelay, "MS",
"Delay for MS milliseconds")
self.console.addCommand(
"check", self.doCheck, "ID [CODE]",
"Make sure request ID handled properly and generated expected CODE"
)
self.console.addCommand(
"generate", self.doGenerate, "FILE BYTES",
"Generate file (extension '.txt' or '.bin') with specified number of bytes"
)
self.console.addCommand("delete", self.doDelete, "FILE+",
"Delete specified files")
self.console.addCommand(
"proxy", self.doProxy, "[PATH] ARG*",
"(Re)start proxy server (pass arguments to proxy)")
self.console.addCommand("trace", self.doTrace, "ID+",
"Trace histories of requests")
def main():
"""
Main function of the application.
"""
# Initialize the event manager.
event_manager = events.EventManager()
AppState.get_state().set_event_manager(event_manager)
# Initialize and register the application heartbeat.
heart_beat = HeartBeat()
event_manager.register_listener(heart_beat)
# Initialize and register the world.
basic_experiment = experiment.basic.BasicExperiment()
world = basic_experiment.get_world()
event_manager.register_listener(world)
AppState.get_state().set_world(world)
# Initialize pygame.
surface = init()
# Initialize and register the view.
main_view = view.View(surface)
event_manager.register_listener(main_view)
# Initialize and register the controller.
main_controller = controller.Controller()
event_manager.register_listener(main_controller)
# Start the heartbeat.
heart_beat.run()
def __init__(self, *args, **kwargs):
"""Initialize a new client for the Ceilometer v2 API."""
if not kwargs.get('auth_plugin') and not kwargs.get('session'):
kwargs['auth_plugin'] = monitoringclient.get_auth_plugin(*args,
**kwargs)
self.auth_plugin = kwargs.get('auth_plugin')
self.http_client = monitoringclient._construct_http_client(**kwargs)
self.alarm_client = self._get_alarm_client(**kwargs)
aodh_enabled = self.alarm_client is not None
if not aodh_enabled:
self.alarm_client = self.http_client
self.meters = meters.MeterManager(self.http_client)
self.old_samples = samples.OldSampleManager(self.http_client)
self.samples = samples.SampleManager(self.http_client)
self.statistics = statistics.StatisticsManager(self.http_client)
self.resources = resources.ResourceManager(self.http_client)
self.alarms = alarms.AlarmManager(self.alarm_client, aodh_enabled)
self.events = events.EventManager(self.http_client)
self.event_types = event_types.EventTypeManager(self.http_client)
self.traits = traits.TraitManager(self.http_client)
self.trait_descriptions = trait_descriptions.\
TraitDescriptionManager(self.http_client)
self.query_samples = query.QuerySamplesManager(
self.http_client)
self.query_alarms = query.QueryAlarmsManager(self.alarm_client)
self.query_alarm_history = query.QueryAlarmHistoryManager(
self.alarm_client)
self.capabilities = capabilities.CapabilitiesManager(self.http_client)
def __init__(self):
pygame.init()
self.running = True
self.size = App.WINDOW_SIZE
self.surface = pygame.display.set_mode(self.size, pygame.RESIZABLE)
self.event_manager = events.EventManager(is_debug=True)
self.imp = imp.IMP().init(None, self.event_manager, True)
self.register_objs()
self.wire_events()
def __init__(self):
pg.init()
pg.display.set_caption("THRUSTER")
self.evm = events.EventManager() # communication between objects
self.evm.add_listener(self)
self.gm = game.Game(self) # game model
self.vw = view.Viewer(self.SIZE, self.gm, self.evm) # visuals
self.kb = controls.KeyboardController(self.evm) # handle keyboard
def main():
pygame.init()
evManager = e.EventManager()
keyb = c.KeyboardController(evManager)
tick = c.TickController(evManager)
init(evManager)
pygameView = v.PygameView(evManager)
tick.run()
pygame.quit()
sys.exit()
def __init__(self,
nickname,
username,
realname="IRCBot",
server=("localhost", 6667),
channels=["#bots"]):
self.nickname = nickname
self.username = username
self.realname = realname
self.server = server
self.channels = channels
self.event_manager = events.EventManager()
def __init__(self):
self.verbose = console.Option(False)
self.strict = console.Option(0)
self.autoTrace = console.Option(False)
self.stretch = console.Option(100)
self.timeout = console.Option(5000)
self.checkTiming = console.Option(False)
self.checkUnsafe = console.Option(False)
self.checkLocking = console.Option(False)
self.checkSemaphore = console.Option(False)
self.linefeedPercent = console.Option(5)
self.console = console.Command()
self.console.finishFunction = self.finish
self.host = socket.gethostname()
self.eventManager = events.EventManager()
self.fileManager = files.FileManager(printer = self.console, fileGenerator = findFileGenerator())
self.fileManager.purgeResponseFiles()
self.requestManager = agents.RequestGenerator(self.eventManager, self.fileManager, self.console, strict = self.strict, verbose = self.verbose)
self.portManager = agents.PortFinder(self.console)
self.servers = {}
self.monitors = []
self.haveProxy = False
self.proxyProcess = None
self.activeEvents = {}
self.getId = 0
self.console.addOption("strict", self.strict, "Set level of strictness on HTTP message formatting (0-4)")
self.console.addOption("timing", self.checkTiming, "Insert random delays into synchronization operations")
self.console.addOption("unsafe", self.checkLocking, "Check for thread-unsafe functions")
self.console.addOption("locking", self.checkLocking, "Check proper use of locks")
self.console.addOption("semaphore", self.checkSemaphore, "Disallow use of semaphores")
self.console.addOption("verbose", self.verbose, "Show details")
self.console.addOption("stretch", self.stretch, "Multiply all delays by factor = stretch / 100")
self.console.addOption("timeout", self.timeout, "Set default timeout for wait (in milliseconds)")
self.console.addOption("autotrace", self.autoTrace, "Trace every request for which check fails")
self.console.addOption("linefeed", self.linefeedPercent, "Frequency of line feeds in binary files (percent)")
self.console.addCommand("serve", self.doServe, "SID+", "Set up servers. (Server with SID starting with '-' is disabled.)")
self.console.addCommand("request", self.doRequest, "ID FILE SID", "Initiate request named ID for FILE from server SID")
self.console.addCommand("post-request", self.doPostRequest, "ID FILE SID", "Initiate request named ID for FILE from server SID")
self.console.addCommand("fetch", self.doFetch, "ID FILE SID", "Fetch FILE from server SID using request named ID")
self.console.addCommand("respond", self.doRespond, "ID+", "Allow servers to return reponses to requests")
self.console.addCommand("get", self.doGet, "URL", "Retrieve web object with and without proxy and compare the two")
self.console.addCommand("delay", self.doDelay, "MS", "Delay for MS milliseconds")
self.console.addCommand("check", self.doCheck, "ID [CODE]", "Make sure request ID handled properly and generated expected CODE")
self.console.addCommand("generate", self.doGenerate, "FILE BYTES", "Generate file (extension '.txt' or '.bin') with specified number of bytes")
self.console.addCommand("delete", self.doDelete, "FILE+", "Delete specified files")
self.console.addCommand("proxy", self.doProxy, "[PATH] ARG*", "(Re)start proxy server (pass arguments to proxy)")
self.console.addCommand("external", self.doExternalProxy, "HOST:PORT", "Use external proxy")
self.console.addCommand("trace", self.doTrace, "ID+", "Trace histories of requests")
self.console.addCommand("signal", self.doSignal, "[SIGNO]", "Send signal number SIGNO to process. Default = 13 (SIGPIPE)")
self.console.addCommand("disrupt", self.doDisrupt, "(request|response) [SID]", "Schedule disruption of request or response by client [or server SID]")
self.console.addCommand("wait", self.doWait, "* | ID+", "Wait until all or listed pending requests, fetches, and responses have completed")
def test_success(self):
mngr = events.EventManager()
mngr.set_event("CTRL_DOWN", 2)
evt1 = mngr.get_event("CTRL_DOWN")
mngr.set_event("CTRL_UP", 2)
evt2 = mngr.get_event("CTRL_UP")
self.assertEqual(evt1, 2)
self.assertEqual(evt2, 2)
self.assertEqual(mngr._events["CTRL_DOWN"], None)
self.assertEqual(mngr._events["CTRL_UP"], None)
self.assertEqual(mngr._last_events["CTRL_DOWN"], None)
self.assertEqual(mngr._last_events["CTRL_UP"], 2)
def test_fail(self):
mngr = events.EventManager()
mngr.set_event("CTRL_DOWN", 2)
evt = mngr.get_event("CTRL_DOWN")
self.assertEqual(evt, 2)
mngr.set_event("CTRL_DOWN", 3)
evt = mngr.get_event("CTRL_DOWN")
self.assertEqual(evt, None)
mngr.set_event("CTRL_DOWN", 4)
evt = mngr.get_event("CTRL_DOWN")
self.assertEqual(evt, None)
mngr.set_event("CTRL_DOWN", 5)
evt = mngr.get_event("CTRL_DOWN")
self.assertEqual(evt, None)
def main():
"""
Main function of the application.
"""
# Initialize the event manager.
event_manager = events.EventManager()
AppState.get_state().set_event_manager(event_manager)
# Initialize and register the application heartbeat.
heart_beat = HeartBeat()
event_manager.register_listener(heart_beat)
# Initialize and register the world.
#experiment_ = experiment.experiment.Experiment.load_experiment("20161126T003019.p")
experiment_ = experiment.basic.BasicVisionExperiment()
AppState.get_state().set_experiment(experiment_)
world = experiment_.get_world()
event_manager.register_listener(world)
AppState.get_state().set_world(world)
# Initialize pygame.
surface = init()
# Initialize and register the view.
main_view = view.View(surface)
event_manager.register_listener(main_view)
# Initialize the website trace history view.
trace_view = agentevents.AgentEvents()
event_manager.register_listener(trace_view)
# Initialize and register the controller.
main_controller = controller.Controller()
event_manager.register_listener(main_controller)
# Add the experiment controller to the controller
main_controller.set_experiment_controller(
lambda e, coords: experiment_.controller(
e, main_view.window_coords_to_world_coords(coords)))
# Start the webserver.
webserver.trace_view = trace_view
webserver.start()
# Start the heartbeat.
heart_beat.run()
def mainLoop():
print("Init pygame mainloop")
pygame.init()
running = True
clock = pygame.time.Clock()
window_manager = interface.WindowManager()
window_manager.initMainMenu()
event_manager = events.EventManager(window_manager)
while running:
clock.tick(30)
for event in pygame.event.get():
if event.type == pygame.QUIT:
running = False
else:
event_manager.manageEvent(event)
print("Fin")
def __init__(self):
print("world.__init__()")
World.singleton = self
self.entity_list = []
self.player = entities.Player()
self.ai_manager = AI_Manager()
self.cell_manager = cell.CellManager()
self.entity_manager = entity.EntityManager()
self.event_manager = events.EventManager()
self.dialogue_manager = dialogue.DialogueManager()
### Time and date
self.world_time = 0.0
self.world_time_scale = 0.05
self.date = datetime.date(2050, 1, 1) # Y, M, D
### Weather:
self.current_weather = None
self.last_weather = None
### Light
self.light_sources = None
self.outside_lighting_ctrl = 'outdoor_sun_shadow'
self.sky_dome = 'sky_dome'
self.atmosphere_ctrl = 'skybox' #'atmosphere_time'
###
self.gravity = Vector([0, 0, -15.0])
bge.logic.setGravity([0, 0, 0])
self.world_effects = {
'mist color': [0.0, 0.0, 0.0],
'tint': [0.0, 0.0, 0.0]
}
self.gamestate = 'loading'
self.suspended = False
self.KX_player = False
import events import game_map import view event_manager = events.EventManager() the_view = view.View(event_manager) the_map = game_map.GameMap(event_manager)
def test_can_fetch_unknown_event(self):
mngr = events.EventManager()
evt = mngr.get_event("FOO")
self.assertEqual(evt, None)
import canvas, events, gui, vectors, constants
import pygame
import torch
import network
pygame.display.set_caption('Shoe generator')
clock = pygame.time.Clock()
pygame.init()
gameDisplay = pygame.display.set_mode((1250, 600),
pygame.DOUBLEBUF) # Create display
controller = events.EventManager()
cGAN = network.CGAN().cuda()
# Load cGAN parameters
checkpoint = torch.load(constants.NETWORK_FILE_NAME)
cGAN.generator.load_state_dict(checkpoint['g_state_dict'])
cGAN.discriminator.load_state_dict(checkpoint['d_state_dict'])
draw_canvas = canvas.Canvas(512, 20, 44, gameDisplay, evManager=controller)
render_canvas = canvas.Preview(512,
1250 - 20 - 512,
44,
gameDisplay,
draw_canvas,
cGAN,
evManager=controller)
# Define input box here so python doesnt immediatly put it in garbage after creating it
'install ctypes from http://sourceforge.net/projects/ctypes/files/ctypes'
)
raise
user32 = ctypes.windll.user32
# disable the screen stretching
user32.SetProcessDPIAware()
RESOLUTION = (800, 600)
#Initialize PyGame and create an game window
pygame.init()
pygame.font.init()
pygame.display.set_caption('Chaos Projectile')
pygame.mouse.set_visible(True)
#screen = pygame.display.set_mode(RESOLUTION, pygame.RESIZABLE)
screen = pygame.display.set_mode(
RESOLUTION, pygame.NOFRAME | pygame.FULLSCREEN) # | pygame.HWSURFACE)
#Create event manager
evManager = events.EventManager()
#Create game world
game = gameworld.GameWorld(screen, evManager)
systemMngr = systemmanager.SystemManager(evManager, game)
#Create input controller
input_control = controller.InputController(screen, evManager)
#CPU Tick Event
spinner = CPUSpinner(evManager)
spinner.run()
def __init__(self, port=None):
self.verbose = console.Option(False)
self.strict = console.Option(0)
self.autoTrace = console.Option(False)
self.stretch = console.Option(100)
self.timeout = console.Option(3000)
self.console = console.Command()
self.console.finishFunction = self.finish
if port is None:
self.nextPort = randomPort()
else:
self.nextPort = port
self.host = socket.gethostname()
self.eventManager = events.EventManager()
self.fileManager = files.FileManager(printer=self.console)
self.fileManager.purgeResponseFiles()
self.requestManager = agents.RequestGenerator(self.eventManager,
self.fileManager,
self.console,
strict=self.strict,
verbose=self.verbose)
self.servers = {}
self.haveProxy = False
self.proxyProcess = None
self.activeEvents = {}
self.console.addOption(
"strict", self.strict,
"Set level of strictness on HTTP message formatting (0-4)")
self.console.addOption("verbose", self.verbose, "Show details")
self.console.addOption(
"stretch", self.stretch,
"Multiply all delays by factor = stretch / 100")
self.console.addOption(
"timeout", self.timeout,
"Set default timeout for wait (in milliseconds)")
self.console.addOption("autotrace", self.autoTrace,
"Trace every request for which check fails")
self.console.addCommand(
"serve", self.doServe, "SID+",
"Set up servers. (Server with SID starting with '-' is disabled.)"
)
self.console.addCommand(
"request", self.doRequest, "ID FILE SID",
"Initiate request named ID for FILE from server SID")
self.console.addCommand(
"fetch", self.doFetch, "ID FILE SID",
"Fetch FILE from server SID using request named ID")
self.console.addCommand(
"respond", self.doRespond, "ID+",
"Allow servers to return reponses to requests")
self.console.addCommand("delay", self.doDelay, "MS",
"Delay for MS milliseconds")
self.console.addCommand(
"check", self.doCheck, "ID [CODE]",
"Make sure request ID handled properly and generated expected CODE"
)
self.console.addCommand(
"generate", self.doGenerate, "FILE BYTES",
"Generate file (extension '.txt' or '.bin') with specified number of bytes"
)
self.console.addCommand("delete", self.doDelete, "FILE+",
"Delete specified files")
self.console.addCommand(
"proxy", self.doProxy, "[PATH] ARG*",
"(Re)start proxy server (pass arguments to proxy)")
self.console.addCommand("external", self.doExternalProxy, "HOST:PORT",
"Use external proxy")
self.console.addCommand("trace", self.doTrace, "ID+",
"Trace histories of requests")
self.console.addCommand(
"signal", self.doSignal, "[SIGNO]",
"Send signal number SIGNO to process. Default = 13 (SIGPIPE)")
self.console.addCommand(
"disrupt", self.doDisrupt, "(request|response) [SID]",
"Schedule disruption of request or response by client [or server SID]"
)
self.console.addCommand(
"wait", self.doWait, "* | ID+",
"Wait until all or listed pending requests, fetches, and responses have completed"
)
def evt_man(endpoint):
return events.EventManager(1, endpoint.ip, endpoint.port)
def run_experiment(experiment_, render = True, interactive = True, console_output = True, save_logs = True):
"""
Run an experiment until it halts. Simulates the world defined
by the experiment and handles control events.
:param experiment_: An object of type Experiment.
:param render: A boolean indicating whether the simulation is
to be rendered to the screen.
:param interactive: A boolean indicating whether interactive
is to be enabled. If interactive mode is
on, rendering should be on as well.
:param console_output: A boolean indicating whether simulation
output is to be displayed in the console.
:param save_logs: A boolean indicating whether simulation output
is to be saved in a log file.
"""
if interactive:
assert render, "render must be true if interactive mode is set"
# Reset the app state
AppState.get_state().reset()
# Initialize the event manager.
event_manager = events.EventManager()
AppState.get_state().set_event_manager(event_manager)
# Initialize and register the application heartbeat.
heart_beat = HeartBeat()
event_manager.register_listener(heart_beat)
# Initialize and register the world.
AppState.get_state().set_experiment(experiment_)
world = experiment_.get_world()
event_manager.register_listener(world)
AppState.get_state().set_world(world)
# Initialize pygame.
surface = init()
if render:
# Initialize and register the view.
main_view = view.View(surface)
event_manager.register_listener(main_view)
# Initialize the website trace history view.
trace_view = agentevents.AgentEvents()
event_manager.register_listener(trace_view)
# Initialize and register the controller.
main_controller = controller.Controller()
event_manager.register_listener(main_controller)
if interactive:
# Add the experiment controller to the controller
main_controller.set_experiment_controller(lambda e, coords: experiment_.controller(e, main_view.window_coords_to_world_coords(coords)))
if console_output:
# Enable console logger
AppState.get_state().enable_console_logger()
if save_logs:
# Store experiment logs
if not os.path.isdir(settings.RESULTS_DIR):
os.makedirs(settings.RESULTS_DIR)
file_path = os.path.join(settings.RESULTS_DIR, "%s - %s.log" % (strftime("%Y%m%dT%H%M%S"), experiment_.__class__.__name__))
AppState.get_state().enable_file_logger(file_path)
# Start the webserver.
webserver.register({'traces': trace_view})
webserver.start()
# Start the heartbeat.
heart_beat.run(slow = render, halt_fun = experiment_.halt, metrics_fun = experiment_.calculate_metrics)
if len(heart_beat.metrics) > 0:
# Store experiment results
if not os.path.isdir(settings.RESULTS_DIR):
os.makedirs(settings.RESULTS_DIR)
file_path = os.path.join(settings.RESULTS_DIR, "%s - %s.json" % (strftime("%Y%m%dT%H%M%S"), experiment_.__class__.__name__))
with open(file_path, 'w') as f:
json.dump(heart_beat.metrics, f, indent=4, sort_keys=True)
def test_cannot_override_nonfetch_event(self):
mngr = events.EventManager()
mngr.set_event("CTRL_DOWN", 2)
res = mngr.set_event("CTRL_DOWN", 4)
self.assertEqual(res, False)
self.assertEqual(mngr._events["CTRL_DOWN"], 2)
def test_cannot_created_event(self):
mngr = events.EventManager()
res = mngr.set_event("FOO", 42)
self.assertEqual(res, False)
self.assertEqual("FOO" in mngr._events, False)
def test_cannot_fetch_same_event_twice(self):
mngr = events.EventManager()
mngr.set_event("CTRL_DOWN", 2)
mngr.get_event("CTRL_DOWN")
evt = mngr.get_event("CTRL_DOWN")
self.assertEqual(evt, None)
def test_can_set_event(self):
mngr = events.EventManager()
res = mngr.set_event("CTRL_DOWN", 2)
self.assertEqual(res, True)
self.assertEqual(mngr._events["CTRL_DOWN"], 2)
