def __init__(self, initial_position, scale, num_stacks, scenario_boundaries, stack_desp): self.DIRECTORIO = "images/gameplay/arm/" self.estado = "IDLE" self.stack_desp = stack_desp self.scenario_boundaries = scenario_boundaries self.scale = scale self.moving = False self.direction = None self.scenario = None self.function_set = None self.velocity = 255 self.function_id = 0 self.instruction_id = 0 self.ticksResuelto = 0 self.termino_instruction = True self.currentPos = initial_position self.initial_pos = initial_position self.catching = False self.catching2 = False self.movingUp = False self.movingDown = False self.resuelto = False self.ERROR = False self.returnPoints = [] self.attachedBox = None rscale_x = 145/283.0*self.scale rscale_y = 125/313.0*self.scale x0 = (160 + 110*(initial_position + self.stack_desp - 1) - 15)*self.scale + self.scenario_boundaries[0] y0 = self.scenario_boundaries[1] + 1 self.cable = Application.createSfSprite(self.DIRECTORIO+"cable.png", x0 + (145*self.scale - rscale_x*44)/2.0, y0 - 4, 44*rscale_x, 65*rscale_y + 4) self.base_cable_size = (44*rscale_x, 65*rscale_y + 4) self.cable_height = self.base_cable_size[1] self.holder = Application.createSfSprite(self.DIRECTORIO+"holder.png", x0 + 26*rscale_x, y0 + 65*rscale_y, 230*rscale_x, 72*rscale_y) self.base_holder_size = (230*rscale_x, 72*rscale_y) self.left_pin = Application.createSfSprite(self.DIRECTORIO+"left_pin.png", x0, y0 + 65*rscale_y + 72*rscale_y, 53*rscale_x, 176*rscale_y) self.base_left_pin_pos = (x0, y0 + 65*rscale_y + 72*rscale_y) self.base_left_pin_size = (53*rscale_x, 176*rscale_y) self.ddx = 26*rscale_x self.right_pin = Application.createSfSprite(self.DIRECTORIO+"right_pin.png", x0 + 145*self.scale - 53*rscale_x, y0 + 65*rscale_y + 72*rscale_y, 53*rscale_x, 176*rscale_y) self.base_right_pin_pos = (x0 + 145*self.scale - 53*rscale_x, y0 + 65*rscale_y + 72*rscale_y) self.base_right_pin_size = (53*rscale_x, 176*rscale_y)
def __init__(self, prevScreen, puzzle_number): self.puzzle_number = puzzle_number self.width = 1200 self.heigth = 700 self.blanco = sf.Color(250, 250, 250) self.negro = sf.Color(0, 0, 0) name = Application.username self.window = sf.RenderWindow( sf.VideoMode(self.width, self.heigth), "DRAG BOX - LETS PLAY " + name, sf.Style.Close ) self.window.SetIcon(16, 16, Icon.window_icon()) self.Evento = sf.Event() self.window.SetFramerateLimit(60) self.backScreen = prevScreen self.sonidos = None self.temp = None self.dragging_instruction = False self.playing = False self.playingStepByStep = False self.instruction_name = None self.function_set = Drawable_FunctionSet() self.slider = Drawable_Slider(249, 98, 505, 143, 50) self.toolbox = Drawable_Toolbox() self.goal = Drawable_Scenario(77, 461, 511, 700, prevScreen, str(puzzle_number), True) self.working_area = Drawable_Scenario(529, 87, 1200, 700, prevScreen, str(puzzle_number), False) self.working_area.goal = self.goal self.bg_over = Application.createSfSprite(self.DIRECTORIO + "bgs/gameplay/scenario_bg2.png", 0, 0, 2000, 1000) self.message = None Application.setActiveWindow(self)
def __init__(self, xi, yi, xf, yf, level_name, puzzle_number, final): self.puzzle_number = puzzle_number self.level_name = level_name self.DIRECTORIO = "images/gameplay/" self.there_is_arm = False self.goal = None self.final = final self.num_stacks = Application.getNumberStacksLevel(level_name, puzzle_number) stack_desp = (8 - self.num_stacks)/2 self.scale_x = (xf - xi)/1200.0 self.scale_y = (yf - yi)/700.0 self.stack_desp = stack_desp self.stacks = [] for i in range(self.num_stacks): self.stacks.append(Drawable_Stack(i, level_name, puzzle_number,self.scale_x, [xi, yi, xf, yf], final, stack_desp)) #imagenes self.filter = Application.createSfSprite(self.DIRECTORIO+"scenario_filter.png", xi, yi, xf - xi, yf - yi) self.bg = Application.createSfSprite(self.DIRECTORIO+"scenario_bg2.png", xi, yi, xf - xi, yf - yi) #self.bg_bot = Application.createSfSprite(self.DIRECTORIO+"scenario_bg_bottom.png", xi, 650, xf - xi, yf - 650) #self.poleL = Application.createSfSprite(self.DIRECTORIO+"pole.png", xi, yi, 30, yf - yi) #self.poleR = Application.createSfSprite(self.DIRECTORIO+"pole.png", xf - 30, yi, 30, yf - yi) if not final: self.BuildArm([xi, yi, xf, yf])
def main(): """ Tests the game over state. """ app = Application() config = app.game_config config.home_pile_size = 1 app.goto_prepare() app.main()
def DefinirTops(self): self.tops = [] self.tops2 = [] positions = [(292,190), (666,190), (1037,190), (292,438), (666,438), (1037,438)] for i in range(6): self.tops.append(Application.createSfSprite(self.DIRECTORIO+"buttons/top.png", positions[i][0], positions[i][1], 110, 64)) self.tops2.append(Application.createSfSprite(self.DIRECTORIO+"buttons/top_2.png", positions[i][0], positions[i][1], 110, 64))
def __init__(self): # Change these to set the window resolution and title as you desire myResolution = (1024, 640) myTitle = "MyGame" # Don't change this Application.__init__(self, myResolution, myTitle) self.Initialize()
def deleteStack(self,cual): Application.putOnDeleteList(self.stacks[cual]) del self.stacks[cual] self.i-= 1 x=cual while( x< len(self.stacks)): self.stacks[x].Reposition(x) x+=1
def main(): '''Turn on the DBus Mainloop and start the program''' #turn on the dbus mainloop DBusGMainLoop(set_as_default=True) #constructor for your class instances options = parse_options() app = Application(options.gui) app.start_app()
def DefinirSprites(self): self.bgwidth = 65 self.bgheight = 700 - 167 posX_btns = 11 self.btnwidth = 44 width_btns = self.btnwidth height_btns = self.btnwidth self.bg = Application.createSfSprite(self.DIRECTORIO+"bg_toolbox.png", 0, 167, self.bgwidth, self.bgheight) self.botonDown = Application.createSfSprite(self.DIRECTORIO+"img_INS_DOWN.png", posX_btns, 184, width_btns, height_btns) self.botonRight = Application.createSfSprite(self.DIRECTORIO+"img_INS_RIGHT.png", posX_btns, 249, width_btns, height_btns) self.botonLeft = Application.createSfSprite(self.DIRECTORIO+"img_INS_LEFT.png", posX_btns, 313, width_btns, height_btns) self.botonProg1 = Application.createSfSprite(self.DIRECTORIO+"img_PROG_1.png", posX_btns, 376, width_btns, height_btns) self.botonProg2 = Application.createSfSprite(self.DIRECTORIO+"img_PROG_2.png", posX_btns, 442, width_btns, height_btns) self.botonProg3 = Application.createSfSprite(self.DIRECTORIO+"img_PROG_3.png", posX_btns, 506, width_btns, height_btns) self.botonProg4 = Application.createSfSprite(self.DIRECTORIO+"img_PROG_4.png", posX_btns, 569, width_btns, height_btns) self.botonClear = Application.createSfSprite(self.DIRECTORIO+"img_INS_CLEAR_2.png", posX_btns, 634, width_btns, height_btns)
def __init__(self, xi, yi, xf, yf, default_value): self.current = default_value self.clicked = False self.DIRECTORIO = "images/gameplay/slider/" r_width = 768 r_height = 133 scale_x = 356.0/768.0 scale_y = 45.0/143.0 self.piece = Application.createSfSprite(self.DIRECTORIO+"piece.png", xi, yi - 10, (xf - xi)*(2.03/13.0), yf - yi + 9) self.fixed = Application.createSfSprite(self.DIRECTORIO+"fixed.png", xi, yi + (1.02/2.27)*(yf - yi), xf - xi, (yf - yi)*(1.25/2.27))
def _configure(self): Application._configure(self) import os self.home = os.path.abspath( os.path.expanduser(self.inventory.home)) # should the following be in _init? import os if not os.path.exists(self.home): os.makedirs(self.home) return
def setInitialState(self, stack_id,scale, scenario_boundaries, final, stack_desp): if final: boxes = Application.getColorBoxFromStackSolution(level_name, puzzle_number, stack_id+1) else: boxes = Application.getColorBoxFromStack(level_name, puzzle_number, stack_id+1) self.stack_boundaries = [(120 + 110*(stack_id+stack_desp) + 15)*scale + scenario_boundaries[0], 650, (120 + 110*(stack_id+stack_desp) + 15)*scale + scenario_boundaries[0] + 90*scale, 650 + 30*scale] for box in boxes: self.stack.append(Drawable_Box(stack_id, box, stack_boundaries, scale, len(boxes))) self.scale = scale self.stack_boundaries = stack_boundaries
def DefinirBotones(self): #boton create self.boton1 = Application.createSfSprite(self.DIRECTORIO+"buttons/button_create_1.png", 434, 504, 367, 140) self.boton2 = Application.createSfSprite(self.DIRECTORIO+"buttons/button_create_2.png", 434, 504, 367, 140) #boton home self.botonHome1 = Application.createSfSprite(self.DIRECTORIO+"buttons/button_home_1.png", 1200-157, 0, 157, 80) self.botonHome2 = Application.createSfSprite(self.DIRECTORIO+"buttons/button_home_2.png", 1200-157, 0, 157, 80) image = sf.Image() image.LoadFromFile(self.DIRECTORIO+"buttons/CREATE.png") self.create = sf.Sprite(image) self.create.Resize(1013-829,661-500) self.create.SetCenter(0, 0) self.create.SetPosition(688,348)
def DefinirFondo(self): self.Fondo = Application.createSfSprite(self.DIRECTORIO+"bgs/TBG.png", 0, 0, 1200, 700) font = sf.Font() font = sf.Font.GetDefaultFont() #font.LoadFromFile('my_downloaded_font.ttf', 50) self.tittle = sf.String("LEVEL: " + self.backScreen + ", PUZZLE " + str(self.puzzle_number) + "(" + Application.username + ")", font) color = sf.Color(0, 0, 0) rect = self.tittle.GetRect() self.tittle.SetColor(color) self.tittle.SetCenter(0,0) self.tittle.SetSize(35) self.tittle.SetPosition((1200 - rect.GetWidth())/2, 15) self.delimiter = Application.createSfSprite(self.DIRECTORIO+"gameplay/delimiter.png", 0, rect.GetHeight() + 47, 1200, 10)
def EndPuzzle(self): c = self.function_set.GetCount() #actualizar archivos #primero a ver si entra a los top 5! made_it = Application.updateTopFile("levels/" + self.backScreen + "/", str(self.puzzle_number) + "_top", Application.username, c) #ahora a ver si mejoro su marca personal. pers = Application.saveScore(Application.username, self.backScreen, self.puzzle_number, c) #levantar ventana final! from Game_Over import Game_Over nuevaVentana = Game_Over(c, made_it, pers) nuevaVentana.sonidos = self.sonidos self.window.Close() nuevaVentana.Update()
def post(self): try: app_id, command = self.validate_arguments() except tornado.web.MissingArgumentError: return app = Application(app_id, command, self.agent) app.start() agent.add_running_application(app_id, app) self.write(dict( app_id=app_id, command=command, result="started" ))
def __init__(self, style=STYLE_DEFAULT, fixed_size=None): View.__init__(self) self._window = self self._first_responder = None self._title = None self._style = style self._resizable = fixed_size is None self._application = Application.shared_application() self._min_size = None self._max_size = None self._zoomed = False self._key_window = False self._main_window = False if fixed_size is None: # normal window self._pyglet = PygletWindow(self, style=style, resizable=True) else: # fixed size window self._pyglet = PygletWindow(self, style=style, resizable=False, width=fixed_size.width, height=fixed_size.height) x, y = self._pyglet.get_location() width, height = self._pyglet.get_size() View.set_frame(self, Rect(x, y, width, height)) self._application._add_window(self)
def BotonPlayStop(self): self.playingStepByStep = False image = sf.Image() if self.playing: self.working_area.DetenerEjecucion() self.working_area.ResetConfigs() self.function_set.ResetConfigs() Application.putOnDeleteList(self.message) self.message = None image.LoadFromFile(self.DIRECTORIO + "gameplay/play_1.png") self.botonPlayStop.SetImage(image) else: self.working_area.Ejecutar(self.function_set) image.LoadFromFile(self.DIRECTORIO + "gameplay/stop_1.png") self.botonPlayStop.SetImage(image) self.playing = not self.playing
def __init__(self, tipo, mensaje): self.errorCount = 4 self.DIRECTORIO = "images/errors/" self.fade = Application.createSfSprite(self.DIRECTORIO + "fade.png", 0, 0, 0, 0) if tipo in ["ERROR_1", "ERROR_2"]: self.DefinirMensaje(tipo, 0, 0, 350, 200) else: self.DefinirMensaje(tipo) self.DefinirSprites()
def DefinirBotones(self): self.boton1 = Application.createSfSprite(self.DIRECTORIO+"buttons/button_choose_1.png", 434, 564, 367, 120) self.boton2 = Application.createSfSprite(self.DIRECTORIO+"buttons/button_choose_2.png", 434, 564, 367, 120) self.botonHome1 = Application.createSfSprite(self.DIRECTORIO+"buttons/button_home_1.png", 1200-157, 0, 157, 80) self.botonHome2 = Application.createSfSprite(self.DIRECTORIO+"buttons/button_home_2.png", 1200-157, 0, 157, 80) self.botonPrev1 = Application.createSfSprite(self.DIRECTORIO+"buttons/scroll_prev_1.png", 0, 0, 130, 700) self.botonPrev2 = Application.createSfSprite(self.DIRECTORIO+"buttons/scroll_prev_2.png", 0, 0, 130, 700) self.botonNext1 = Application.createSfSprite(self.DIRECTORIO+"buttons/scroll_next_1.png", 1070, 0, 130, 700) self.botonNext2 = Application.createSfSprite(self.DIRECTORIO+"buttons/scroll_next_2.png", 1070, 0, 130, 700)
def __init__(self): self.width = 1200 self.heigth = 700 self.blanco = sf.Color(250, 250, 250) self.negro = sf.Color(0, 0, 0) self.window = sf.RenderWindow(sf.VideoMode(self.width, self.heigth), "DRAG BOX - PUZZLES (EASY)", sf.Style.Close) self.Evento = sf.Event() self.window.SetFramerateLimit(60) self.scores = Application.getScores(Application.username, "EASY")
def __init__(self): self.width = 1200 self.heigth = 700 self.blanco = sf.Color(250, 250, 250) self.negro = sf.Color(0, 0, 0) self.window = sf.RenderWindow(sf.VideoMode(self.width, self.heigth), "CARGO BOT - PUZZLES (TUTORIAL)", sf.Style.Close) self.Evento = sf.Event() self.window.SetFramerateLimit(60) self.sonidos = None self.scores = Application.getScores(Application.username, "TUTORIAL")
def __init__(self): self.width = 1200 self.heigth = 700 self.blanco = sf.Color(250, 250, 250) self.negro = sf.Color(0, 0, 0) self.window = sf.RenderWindow(sf.VideoMode(self.width, self.heigth), "DRAG BOX - CHANGE PROFILE", sf.Style.Close) self.Evento = sf.Event() self.window.SetFramerateLimit(60) self.usernames = Application.getFiles("profiles/") self.isSelected = False self.xSelected = 0 self.ySelected = 0 self.name_selected = None
def DefinirFondo(self): self.Fondo0 = Application.createSfSprite(self.DIRECTORIO+"bgs/TBG3.png", 0, 0, 1200, 700) self.Fondo = Application.createSfSprite(self.DIRECTORIO+"bgs/GBG.png", 0, 0, 1200, 700) self.credits = Application.createSfSprite(self.DIRECTORIO+"scores/credits.png", 0, 700 - 43, 113, 43) self.mmenu = Application.createSfSprite(self.DIRECTORIO+"scores/main_menu.png", 1200 - 197, 700 - 43, 197, 43) self.credits_2 = Application.createSfSprite(self.DIRECTORIO+"scores/credits_2.png", 0, 700 - 43, 113, 43) self.mmenu_2 = Application.createSfSprite(self.DIRECTORIO+"scores/main_menu_2.png", 1200 - 197, 700 - 43, 197, 43)
def __init__(self, stack_id, level_name, puzzle_number, scale, scenario_boundaries, final, stack_desp): self.DIRECTORIO = "images/gameplay/" self.stack_id = stack_id self.level_name = level_name self.puzzle_number = puzzle_number self.scenario_boundaries = scenario_boundaries self.final = final self.stack_desp = stack_desp self.stack = [] self.base = Application.createSfSprite(self.DIRECTORIO+"base.png", (160 + 110*(stack_id+stack_desp) + 15)*scale + scenario_boundaries[0],650, 90*scale, 30*scale) self.setInitialState(stack_id, level_name, puzzle_number, scale, scenario_boundaries, final, stack_desp)
def main_thread(): #thread gesture recognition t1 = threading.Thread(target=main_predict_on_thread) t1.start() #thread main run application app = QtWidgets.QApplication(sys.argv) player = Application() player.show() player.resize(640, 480) sys.exit(app.exec_())
def __init__(self, level, puzzle_number): self.backScreen = level self.width = 1200 self.heigth = 700 self.window = sf.RenderWindow(sf.VideoMode(self.width, self.heigth), "CARGO BOT - TOP 5: "+ level + " PUZZLE " + str(puzzle_number), sf.Style.Close) self.Evento = sf.Event() self.sonidos = None self.data = Application.getTopScores(level, puzzle_number) self.posiciones = [(909, 190), (702, 289), (494, 386), (290, 485), (79, 582)] self.star_posiciones = [(1088, 222),(877, 319),(671, 412),(465, 509),(257, 609)] self.userSize = (289 - 79, 638 - 574) self.starSize = (324 - 257, 674 - 609) self.FillInTops(self.data, self.posiciones, self.userSize)
def DefinirBotones(self): self.botonHome1 = Application.createSfSprite(self.DIRECTORIO+"buttons/button_home_1.png", 1200-157, 0, 157, 80) self.botonHome2 = Application.createSfSprite(self.DIRECTORIO+"buttons/button_home_2.png", 1200-157, 0, 157, 80) self.botonBack1 = Application.createSfSprite(self.DIRECTORIO+"buttons/button_back_1.png", 0, 0, 80, 80) self.botonBack2 = Application.createSfSprite(self.DIRECTORIO+"buttons/button_back_2.png", 0, 0, 80, 80) self.botonPlayStop = Application.createSfSprite(self.DIRECTORIO+"gameplay/play_1.png", 10, 91, 100, 70) self.botonStep = Application.createSfSprite(self.DIRECTORIO+"gameplay/stepbystep.png", 125, 100, 70, 50)
def FillInTops(self, data, posiciones, size): self.tops = [] self.stars = [] for i in range(len(data)): if data[i][0] == "__EMPTY__": t = sf.String("----------") else: t = sf.String(data[i][0]) print "valor: " + str(data[i][1]) self.stars.append(Application.createSfSprite("images/buttons/stars/" + str(data[i][1]) + ".png", self.star_posiciones[i][0], self.star_posiciones[i][1], self.starSize[0], self.starSize[1])) color = sf.Color(0, 0, 0) rect = t.GetRect() t.SetColor(color) t.SetCenter(0,0) t.SetSize(25) t.SetPosition(posiciones[i][0] + (size[0] - rect.GetWidth())/2 + 5, posiciones[i][1] + (size[1] - rect.GetHeight())/2) self.tops.append(t)
def __init__(self, score, made_it, personal_mark): self.width = 1200 self.heigth = 700 self.window = sf.RenderWindow(sf.VideoMode(self.width, self.heigth), "DRAG BOX - CONGRATULATIONS!", sf.Style.Close) self.Evento = sf.Event() self.sonidos = None if not (personal_mark in ["BETTER", "NOT_BETTER", "FIRST_TIME", "EQUAL"] or made_it): self.img_score = Application.createSfSprite(self.DIRECTORIO+"scores/"+str(score)+".png", 181, 350, 1022-181, 336 - 251) else: self.img_score = Application.createSfSprite(self.DIRECTORIO+"scores/"+str(score)+".png", 181, 251, 1022-181, 336 - 251) if made_it: self.img_gratz = Application.createSfSprite(self.DIRECTORIO+"scores/gratz.png", 181, 330, 1022 - 181, 250) elif personal_mark == "BETTER": self.img_gratz = Application.createSfSprite(self.DIRECTORIO+"scores/better.png", 181, 330, 1022 - 181, 250) elif personal_mark == "NOT_BETTER": self.img_gratz = Application.createSfSprite(self.DIRECTORIO+"scores/worse.png", 181, 330, 1022 - 181, 250) elif personal_mark == "FIRST_TIME": self.img_gratz = Application.createSfSprite(self.DIRECTORIO+"scores/first.png", 181, 330, 1022 - 181, 250) elif personal_mark == "EQUAL": self.img_gratz = Application.createSfSprite(self.DIRECTORIO+"scores/equal.png", 181, 330, 1022 - 181, 250)
def setUp(self): self.eventStore = EventStore.get() self.appStore = ApplicationStore.get() self.fileFactory = FileFactory.get() self.userConf = UserConfigLoader.get("user.ini") self.engine = PolicyEngine() self.ar1 = Application("ristretto.desktop", pid=21, tstart=1, tend=2000) self.ar2 = Application("ristretto.desktop", pid=22, tstart=2600, tend=2900) self.ag1 = Application("gimp.desktop", pid=23, tstart=1, tend=4000) self.ag2 = Application("gimp.desktop", pid=24, tstart=4500, tend=4590) self.appStore.insert(self.ar1) self.appStore.insert(self.ar2) self.appStore.insert(self.ag1) self.appStore.insert(self.ag2)
from kicker.agents.neural_net_agent import NeuralNetAgent from Application import Application, read_config config = read_config() randomness = 0.5 if 'randomness' in config: randomness = config['randomness'] agent = NeuralNetAgent(randomness=randomness) app = Application(agent) app.run()
def app(browser): all_instances = Application(browser) return all_instances
from Application import Application if __name__ == '__main__': app = Application() app.run()
from Application import Application if __name__ == '__main__': app = Application() app.display()
def __init__(self, name=None): Application.__init__(self, name) Stager.__init__(self) return
from Application import Application if __name__ == '__main__': application = Application()
def loadDb(self, store: ApplicationStore = None, checkInitialised: bool = False): """Load the PreloadLogger database. Go through the directory and create all the relevant app instances and events. Can be made to insert all found apps into an ApplicationStore, or to exit if some Application instances are not properly initialised. """ count = 0 # Counter of fetched files, for stats actors = set() # Apps that logged anything at all empties = 0 # Matching files without content (logger crash) invalids = 0 # Files with corrupted content (logger crash) nosyscalls = [] # Logs with zero syscalls logged (not a bug) nosyscallactors = set() # Apps that logged zero syscalls instanceCount = 0 # Count of distinct app instances in the dataset hasErrors = False # Whether some uninitialised apps were found invalidApps = set() # List of desktop IDs that could not be init'd eventCount = 0 # List all log files that match the PreloadLogger syntax for file in os.listdir(self.path): # Ignore files that don't match if not PreloadLoggerLoader.pattern.match(file): continue count += 1 # Process log files that match the PreloadLogger name pattern try: f = open(self.path + "/" + file, 'rb') except (IOError) as e: print("Error: could not open file %s: %s" % (file, str(e)), file=sys.stderr) else: with f: if os.fstat(f.fileno()).st_size == 0: print("Info: file '%s' is empty. Skipping." % file) continue # Parse the first line to get the identity of the app, # but sometimes the header ends up on the second line # in some logs... So, parse until we find a match, and # remember the line index of the header idx = 0 headerLocation = 0 result = None for binary in f: try: line = binary.decode('utf-8') except (UnicodeDecodeError) as e: print("Error: %s has a non utf-8 line: %s " % (file, str(e)), file=sys.stderr) idx += 1 continue result = PreloadLoggerLoader.header.match(line) if result: headerLocation = idx break idx += 1 # Files with a missing or corrupted header are invalid if result is None: print("%s is missing a header" % file, file=sys.stderr) invalids += 1 continue # Parse the header line, make sure it has the right length. g = result.groups() if (len(g) != 3): print("%s has wrong group count: " % file, result.group(), file=sys.stderr) invalids += 1 continue # Filter interpreters, and rewrite them to get the identity # of the app they launched instead. items = space.split(g[2]) interpreterid = None # Python if (pyre.match(g[0])): interpreterid = g[0] g = self.parsePython(g, items) # print("PYTHON APP: %s" % g[2]) # Bash if (bashre.match(g[0])): interpreterid = g[0] g = self.parseBash(g, items) # print("BASH APP: %s" % g[2]) # Java if (javare.match(g[0])): interpreterid = g[0] g = self.parseJava(g, items) # print("JAVA APP: %s" % g[2]) # Perl if (perlre.match(g[0])): interpreterid = g[0] g = self.parsePerl(g, items) # print("PERL APP: %s" % g[2]) # Mono if (monore.match(g[0])): interpreterid = g[0] g = self.parseMono(g, items) # print("MONO APP: %s" % g[2]) # PHP if (phpre.match(g[0])): interpreterid = g[0] g = self.parsePHP(g, items) # print("PHP APP: %s" % g[2]) # Get first and last event to calculate the timestamps. tstart = float("inf") tend = 0 skipCache = None lineIdx = 0 f.seek(0, 0) for binary in f: # Ignore the header. if lineIdx == headerLocation: lineIdx += 1 skipCache = None continue # Decode line. try: line = binary.decode('utf-8') except (UnicodeDecodeError) as e: print("Error: %s has a non utf-8 line: %s " % (file, str(e)), file=sys.stderr) lineIdx += 1 skipCache = None continue # Previous line did not end and was skipped, merge it. if skipCache: line = skipCache + line skipCache = None # Line continues... if line.endswith('\\\n'): skipCache = line lineIdx += 1 continue line = line.rstrip("\n").lstrip(" ") # Line is a parameter to the last system call logged if line.startswith(' '): lineIdx += 1 continue # Check that line is a syntactically valid system call result = PreloadLoggerLoader.syscall.match(line) if result is None: if debugEnabled(): print("%s has a corrupted line (match): %s" % (file, line), file=sys.stderr) lineIdx += 1 continue # Update the timestamp (convert to ZG millisec format) h = result.groups() tstart = int(h[0]) * 1000 break # TODO, first non-header line + tail code. lastLine = tail(f) result = None if lastLine: result = PreloadLoggerLoader.syscall.match(lastLine) if result is None: if debugEnabled(): print("%s's last line is corrupted: %s" % (file, lastLine), file=sys.stderr) else: # Update the timestamp (convert to ZG millisec format) h = result.groups() tend = int(h[0]) * 1000 # Check if the timestamps have been set if tend == 0: nosyscalls.append(g) nosyscallactors.add(g[0]) continue # Sometimes, short logs have event ordering problems... We # can try to ignore these problems as all events are indi- # vidually timestamped anyway. if tstart > tend: tend, start = tstart, tend # TODO: process deletions and remove corresponding files # Make the application try: app = Application(desktopid=g[0], pid=int(g[1]), tstart=tstart, tend=tend, interpreterid=interpreterid) app.setCommandLine(g[2]) except (ValueError) as e: print("MISSING: %s" % g[0], file=sys.stderr) hasErrors = True invalidApps.add(g[0]) continue # Ignore study artefacts! if app.isStudyApp(): continue # Add command-line event event = Event(actor=app, time=tstart, cmdlineStr=g[2]) app.addEvent(event) # Add system call events skipCache = None lineIdx = 0 currentCall = None prevTimestamp = 0 timeDelta = 0 f.seek(0, 0) for binary in f: # Ignore the header. if lineIdx == headerLocation: lineIdx += 1 skipCache = None continue # Decode line. try: line = binary.decode('utf-8') except (UnicodeDecodeError) as e: print("Error: %s has a non utf-8 line: %s " % (file, str(e)), file=sys.stderr) lineIdx += 1 skipCache = None continue # Previous line did not end and was skipped, merge it. if skipCache: line = skipCache + line skipCache = None # Line continues... if line.endswith('\\\n'): skipCache = line lineIdx += 1 continue line = line[:-1] # Remove ending "\n" # Line is a parameter to the last system call logged if line.startswith(' '): if currentCall: currentCall = (currentCall[0], currentCall[1] + '\n' + line) elif debugEnabled(): print("%s has a corrupted line (no call): %s" % (file, line), file=sys.stderr) lineIdx += 1 continue # Check that line is a syntactically valid system call result = PreloadLoggerLoader.syscall.match(line) if result is None: if debugEnabled(): print("%s has a corrupted line (match): %s" % (file, line), file=sys.stderr) lineIdx += 1 continue # Update the timestamp (convert to ZG millisec format) h = result.groups() timestamp = int(h[0]) * 1000 # Append the system call to our syscall list. Note that # we do something odd with the timestamp: because PL # only logs at second precision, a lot of system calls # have the same timestamp, which causes the EventStore # to sort them in the wrong order. So, every time we # have a timestamp identical to the previous one, we # increase a counter that sorts them. This works under # the assumption that there are at most 1000 events per # second. if timestamp == prevTimestamp: timeDelta += 1 else: timeDelta = 0 # Process the last system call into an Event, and clear # up the syscalls list to keep RAM free! if currentCall: event = Event(actor=app, time=currentCall[0], syscallStr=currentCall[1]) app.addEvent(event) eventCount += 1 # Create the new syscalls list. currentCall = (timestamp + timeDelta, h[1]) prevTimestamp = timestamp lineIdx += 1 # Add the found process id to our list of actors, using the # app identity that was resolved by the Application ctor actors.add(app.desktopid) if checkInitialised and not app.isInitialised(): print("MISSING: %s" % g[0], file=sys.stderr) hasErrors = True # Insert into the ApplicationStore if one is available if store is not None: store.insert(app) instanceCount += 1 if checkInitialised and hasErrors: if invalidApps: print("Invalid apps:", file=sys.stderr) for a in sorted(invalidApps): print("\t%s" % a, file=sys.stderr) sys.exit(-1) # print("Apps that logged valid files:") # for act in sorted(actors): # print(act) # print("\nApps that logged files without a single system call:") # for act in sorted(nosyscallactors): # print(act) self.appCount = len(actors) self.instCount = count - empties - invalids - len(nosyscalls) self.eventCount = eventCount self.validEventRatio = 100 - 100 * (invalids + empties + len(nosyscalls)) / (count) print("Finished loading DB.\n%d files seen, %d valid from %d apps, " "%d empty files, " "%d logs with 0 syscalls from %d apps, " "%d invalid.\nIn " "total, %.02f%% files processed." % (count, self.instCount, self.appCount, empties, len(nosyscalls), len(nosyscallactors), invalids, self.validEventRatio)) print("Instance count: %d" % instanceCount)
from Application import Application application = Application([]) application.start()
import tkinter as tk from Application import Application from lib import * if __name__ == '__main__': root = tk.Tk() root.title('paint') center_window(root) Application(master=root) root.mainloop() print('terminated')
def createApplication(self): return Application(server=self, useSessionSweeper=False)
import os import ctypes import pygame from Application import Application screen_size = ctypes.windll.user32.GetSystemMetrics( 0), ctypes.windll.user32.GetSystemMetrics(1) os.environ['SDL_VIDEO_WINDOW_POS'] = "%d,%d" % (screen_size[0] / 2 - 569, screen_size[1] / 2 - 320) pygame.init() if __name__ == "__main__": app = Application() app.Run()
class TestBoard(TestCase): def setUp(self): self.app = Application() self.app.load_deck() def test_algerian_create(self): fields = algerian(self.app._double_deck) # check numbers of fields self.assertTrue(17, len(fields)) # check types of fields for field in fields[:8]: self.assertTrue(isinstance(field, Stack)) for field in fields[8:16]: self.assertTrue(isinstance(field, Pile)) self.assertTrue(isinstance(fields[16], LongDeck)) def test_algerian_shuffle(self): fields = algerian(self.app._double_deck) fields = algerian_shuffle(fields, self.app._double_deck) for field in fields[:8]: self.assertFalse(field.show_cards()) for field in fields[8:12]: self.assertTrue(len(field.show_cards()) == 2) for field in fields[12:16]: self.assertTrue(len(field.show_cards()) == 1) self.assertTrue(len(fields[16].show_cards()) == 68) for field in fields[16].show_subfields(): self.assertTrue(len(field.show_cards()) == 4) def test_canfield_create(self): fields = canfield(self.app._deck) # check number of fields self.assertEqual(10, len(fields)) # check types of fields for field in fields[:4]: self.assertTrue(isinstance(field, Stack)) self.assertTrue(isinstance(fields[4], Deck)) for field in fields[5:9]: self.assertTrue(isinstance(field, Pile)) self.assertTrue(isinstance(fields[9], UnputtablePile)) def test_canfield_shuffle(self): fields = canfield(self.app._deck) fields = canfield_shuffle(fields, self.app._deck) for field in fields[:4]: self.assertFalse(field.show_cards()) self.assertEqual(34, len(fields[4].show_cards())) for field in fields[5:9]: self.assertEqual(1, len(field.show_cards())) self.assertEqual(14, len(fields[9].show_cards())) def test_fifteen_puzzle_create(self): fields = fifteen_puzzle(self.app._deck) # check number of fields self.assertEqual(15, len(fields)) # chcek type of fields for field in fields: self.assertTrue(isinstance(field, Fours)) def test_fifteen_puzzle_shuffle(self): fields = fifteen_puzzle(self.app._deck) fields = fifteen_puzzle_shuffle(fields, self.app._deck) for field in fields[:13]: self.assertEqual(4, len(field.show_cards())) self.assertEqual(0, len(fields[13].show_cards())) self.assertEqual(0, len(fields[14].show_cards())) def test_klondike_create(self): fields = klondike(self.app._deck) self.assertEqual(12, len(fields)) self.assertTrue(isinstance(fields[0], Deck)) for field in fields[1:8]: self.assertTrue(isinstance(field, Pile)) for field in fields[8:]: self.assertTrue(isinstance(field, Stack)) def test_klondike_shuffle(self): fields = klondike(self.app._deck) fields = klondike_shuffle(fields, self.app._deck) self.assertEqual(24, len(fields[0].show_cards())) for i, field in enumerate(fields[1:8]): self.assertEqual(i + 1, len(field.show_cards())) def test_natali_create(self): fields = natali(self.app._double_deck) self.assertEqual(17, len(fields)) for field in fields[:8]: self.assertTrue(isinstance(field, Stack)) for field in fields[8:16]: self.assertTrue(isinstance(field, Pile)) self.assertTrue(isinstance(fields[16], Deck)) def test_natali_shuffle(self): fields = natali(self.app._double_deck) fields = natali_shuffle(fields, self.app._double_deck) for field in fields[:8]: self.assertFalse(field.show_cards()) for i, field in enumerate(fields[8:16:-1]): self.assertEqual(i + 1, len(field.show_cards())) self.assertEqual(68, len(fields[16].show_cards())) def test_osmosis_create(self): fields = osmosis(self.app._deck) self.assertEqual(9, len(fields)) for field in fields[:4]: self.assertTrue(isinstance(field, Fours)) for field in fields[4:8]: self.assertTrue(isinstance(field, Cascade)) self.assertTrue(isinstance(fields[8], Deck)) def test_osmosis_shuffle(self): fields = osmosis(self.app._deck) fields = osmosis_shuffle(fields, self.app._deck) for field in fields[:4]: self.assertEqual(4, len(field.show_cards())) self.assertEqual(1, len(fields[4].show_cards())) for field in fields[5:8]: self.assertEqual(0, len(field.show_cards())) self.assertEqual(35, len(fields[8].show_cards()))
def main(): # Data centre sizes MY_RESOURCE_TYPES = { "L":{ "CPU": {'CAPACITY':100.0, 'EXECOST': LinearCostFunc(1.0,0.0),'OVERLOADCOST': NoCostFunc(),'MU':1}, "NET_UP": {'CAPACITY':100.0, 'EXECOST': NoCostFunc(),'OVERLOADCOST': NoCostFunc(),'MU':1}, "NET_DOWN": {'CAPACITY':100.0, 'EXECOST': NoCostFunc(),'OVERLOADCOST': NoCostFunc(),'MU':1} }, "M":{ "CPU": {'CAPACITY':50.0, 'EXECOST': LinearCostFunc(1.0,0.0),'OVERLOADCOST': NoCostFunc(),'MU':1}, "NET_UP": {'CAPACITY':50.0, 'EXECOST': NoCostFunc(),'OVERLOADCOST':NoCostFunc(),'MU':1}, "NET_DOWN": {'CAPACITY':50.0, 'EXECOST': NoCostFunc(),'OVERLOADCOST': NoCostFunc(),'MU':1} }, "S":{ "CPU": {'CAPACITY':10.0, 'EXECOST': LinearCostFunc(1.0,0.0),'OVERLOADCOST': NoCostFunc(),'MU':1}, "NET_UP": {'CAPACITY':10.0, 'EXECOST': NoCostFunc(),'OVERLOADCOST': NoCostFunc(),'MU':1}, "NET_DOWN": {'CAPACITY':10.0, 'EXECOST': NoCostFunc(),'OVERLOADCOST': NoCostFunc(),'MU':1} } } #workloadName = "workload_v1_6_a5mini_1may" workloadName = "workfile_tripple_production" nbrApps = 5 depth = 4 mode = "_continuous" testCase = "_cost_ver" logging.basicConfig(filename='activities.log', level=logging.DEBUG, filemode='w') logging.info("---- %s ----" % time.strftime("%d/%m/%Y - %H:%M:%S")) applications = {} applicationTypes = Application.TYPES.keys() for i in range(0, nbrApps): #applications.update({'A%i'%i : Application('A%i'%i, Application.TYPES[random.choice(applicationTypes)])}) applications.update({'A%i'%i : Application('A%i'%i, Application.TYPES['SYMMETRIC'])}) env = simpy.Environment() topologyMaker = TopologyMaker(env, None, applications) datacentres, links, leafnodes = topologyMaker.GenerateTreeFromParameters( childStruct = [2, 2, 1], sizeStruct = [ MY_RESOURCE_TYPES['L'], MY_RESOURCE_TYPES['M'], MY_RESOURCE_TYPES['S'] ], uplinkStruct = [10000,1000,1000], downlinkStruct = [10000,1000,1000], latencyStruct = [1,1,1] ) logging.info('Topology generated, with %i datacentres' % len(datacentres)) topology = Topology(env, datacentres, links, leafnodes) scheduler = optScheduler(env, topology, applications) logging.info('%s scheduler created' % type(scheduler).__name__) coordinator = Coordinator(env, topology, scheduler, depth) workload = Workload(env,'workloads/'+workloadName+'.json', coordinator) monitor = SystemMonitor(env, 1, 0.2, workloadName+mode+testCase, topology, coordinator, applications, scheduler, [ ("TOTAL_OVERLOAD", SystemMonitor.measureSystemOverloaFactor), ("COMPONENT_OVERLOAD", SystemMonitor.measureComponentOverloadFactor), ("RESOURCE_UTILISATION", SystemMonitor.measureComponentResourceUtilisation), ("APP_RESOURCE_UTILISATION", SystemMonitor.measureUtilisationPerApp), ("APP_RTT", SystemMonitor.measureAppLatency), ], [ ("TOTAL_OVERLOAD", SystemMonitor.fileCSVOutput, None), ("COMPONENT_OVERLOAD", SystemMonitor.fileCSVOutput, SystemMonitor.composeDCLinkHeader), ("RESOURCE_UTILISATION", SystemMonitor.fileCSVOutput, SystemMonitor.composeDCLinkHeader), ("APP_RESOURCE_UTILISATION", SystemMonitor.fileCSVOutput, None), ("APP_RTT", SystemMonitor.fileCSVOutput, SystemMonitor.composeLatencyHeader) ], []) #workload.produceWorkload() env.process(workload.produceWorkload()) env.process(monitor.measure()) logging.info("Controller started") controller = PeriodicController(env, coordinator, 1, 0.1) logging.info("Simulation started") env.run(until=workload.getWorkloadTimeSpan()) logging.info("Simulation Done") monitor.compose() logging.info("Composing results") monitor.produceOutput() scheduler.output(workloadName+mode+testCase) print "DONE"
def __init__(self): Application.__init__(self, (800, 600)) self.player = Player()
def __init__(self, name): Application.__init__(self, name) self._pid = None return
def createApplication(self): """Create and return an application object. Invoked by __init__.""" return Application(server=self)
from Application import Application if __name__ == '__main__': gameApp = Application() gameApp.run()
from Application import Application from unittest.mock import MagicMock from ratelimit import RateLimitException from time import sleep instance = Application() ################################################################################ def testThrottlePollFail(): mock = MagicMock() # test the function try: while True: instance.throttledPoll(mock) except RateLimitException: assert(mock.call_count == 1) def testThrottlePoll(): mock = MagicMock() # test the function try: instance.throttledPoll(mock) sleep(5) instance.throttledPoll(mock) except RateLimitException:
def setUp(self): self.console_input = PromptFake() self.console_output = ConsoleSpy() self.app = Application(self.console_input, self.console_output)
from Application import Application """ Main: Run this file to start Application """ if __name__ == '__main__': application = Application() application.setup_environment()
def setUp(self): self.app = Application() self.app.load_deck()
#!/usr/bin/python3 import sys from Application import Application, Window app = Application(sys.argv) win = Window() sys.exit(app.exec_())
from Application import Application application = Application() application.run()
def main(started_at=None): """ main entry point for the program :param started_at: optional point in time where the application has been started :return: """ # ### SETUP APPLICATION locale.setlocale(locale.LC_ALL, '') app_started_at = started_at or datetime.utcnow().replace(tzinfo=tz.tzutc()) application = Application(appname=six.u(os.path.basename(__file__).split('.')[0]), appauthor=__author__) _ = application.ugettext # ### SETUP CONFIGURATION default_configuration = OrderedDict() default_configuration['Privacy'] = OrderedDict() default_configuration['Privacy']['Participate in anonymous system analytics'] = 'Yes' default_configuration['Logging'] = OrderedDict() default_configuration['Logging']['Logging to'] = 'Stream, File' default_configuration['Logging']['Disable syslog on'] = 'uberspace.de' configuration = application.configuration( filename=os.path.join(application.user_config_dir, application.appname.lower() + '.conf'), default=default_configuration) # get list of hosts on which syslog will be disabled (e.g. on servers like uberspace.de) disable_syslog_on_hosts = configuration.get('Logging', 'Disable syslog on').split(',') disable_syslog_on_hosts = [hostname.strip() for hostname in disable_syslog_on_hosts] # ### SETUP COMMAND LINE OPTIONS # command line options in CSV format in a formatted string for easier translation cli_options_csvdata = """\ Argument Flags\tAction\tGroup\tHelp\tOther Options --reset\tstore_true\t{reset_opts}\t{reset}\tdefault=False --delete\tstore\t{reset_opts}\t{deletes}\tdefault=0 -h, --help\tstore_true\t{other_opts}\t{help}\tdefault=False -v\tcount\t{other_opts}\t{verbose}\tdefault=0 -V, --version\tversion\t{other_opts}\t{version}\t -q, --quiet\tstore_true\t{other_opts}\t{quiet}\tdefault=False --logging\tstore\t{other_opts}\t{logging}\tdefault=stream,file --nosyslog\tstore_true\t{other_opts}\t{nosyslog}\tdefault={enable_syslog}""" cli_options = textwrap.dedent(cli_options_csvdata.format( # Translate: Command line option group verbose_opts=_('Options for verbosity'), # Translate: Command line option group other_opts=_('Other Options'), # Translate: Command line option group reset_opts=_('Application Resetting'), # Translate: Command line option to show help help=_('Show help and exit'), # Translate: Command line option to show version version=_('Show version and exit'), # Translate: Command line option to show verbose messages verbose=_('Show additional information; stackable with -vv or -vvv'), # Translate: Command line option to supress all output, overwriting the command line open '-v' quiet=_('Suppress all output; overwrites -v, -vv and -vvv'), # Translate: Command line option to reset the application reset=_('Deletes all reclaimable configuration files'), # Translate: Command line option to delete specific configuration files deletes=_('Delete specific configuration files and tries to regenerate them at the next start'), # Translate: Command line option to configure logging messages (choices: stream, file, stream+file, off) logging=textwrap.dedent(_('''\ Toggles logging; possible values: stream, file, syslog, nteventlog, off or any comma separated list \ (e.g. stream,file; stream,sys; file,nt ...)''')), # Translate: Command line option to disable logging to syslog nosyslog=_('disable automatically logging to syslog'), # enable syslog by default on all machines except the ones with platform.node() occurring in server_hostnames enable_syslog=any(name in platform.node().lower() for name in disable_syslog_on_hosts))) # create a temporary argument parser to get initial options to setup logging # this parser will be overwritten later to enable localisation of parser messages (like the command line help) parser = application.parser(cli_options, copyright=_(__copyright__), contact=_(__contact__), license=_(__license__), author=_(__author__) doc=_(__doc__)) args = parser.parse_args() # ### SETUP LOGGER logger = logging.getLogger(application.appname.lower()) logger.setLevel(logging.DEBUG) syslog = logging.getLogger(application.appname.lower() + "_syslog") syslog.setLevel(100) logging_handlers = args.logging.split(',') if args.nosyslog else '{},system'.format(args.logging).split(',') try: logging_handlers.extend([handler.strip() for handler in configuration.get('Logging', 'Handlers').split(',')]) except (configparser.NoSectionError, configparser.NoOptionError): pass logger, syslog = application.setup_logging_handlers(logging_handlers, verbose=args.v, logger=logger, syslog=syslog) # ### SETUP FINAL PARSER # this second initialisation enables localisation of the command line interface if preferred parser = application.parser(cli_options, copyright=_(__copyright__), contact=_(__contact__), license=_(__license__)) parser.epilog = '\n{copy}\n{license}\n\n{contact}\n'.format(copy=_(__copyright__), license=_(__license__), contact=__contact__) args = parser.parse_args() # ### HANDLE COMMAND LINE ARGUMENTS if args.help: # handle command line help manually to enable localisation parser.print_help() sys.exit(0) if args.reset: application.reset(['language', 'configuration', 'cache', 'log', 'data']) for handler in logger.handlers and not args.quiet: handler.setLevel(logging.INFO) logger.info('Application has been reset. Please restart.') sys.exit(0) if args.delete: to_delete = [] to_delete.extend([x.lower().strip() for x in args.delete.split(',')]) application.reset(to_delete) # ### SETUP FINISHED # ### START APPLICATION # Translate: Everything between curled brackets are placeholder; # Please replace the %X to set proper date formatting for your language. # See http://strftime.org for details. logger.info('{application} started at {time}'.format(application=application.appname.lower(), time=app_started_at)) record = Sniffer.record(detailed=True, format='json', cache=application.user_cache_dir) if record.startswith('"'): record = record[1:] if record.endswith('"'): record = record[:-1] # record = json.loads(record, encoding='utf8') url = 'http://localhost:5000' endpoint = '/alpha/log/systeminformation' # todo: use Module "request" for Http POST requests for Python 3 Support request = urllib2.Request(url + endpoint, record) project_url = 'https://github.com/piaballerstadt/Sniffer' request.add_header('User-Agent', 'Sniffer/{version} by {author} ({url})'.format(version='0.1', author='Pia Ballerstadt', url=project_url)) try: f = urllib2.urlopen(request) print(f.read()) except urllib2.HTTPError as e: print('HTTP Error {code}: {message}'.format(code=e.code, message=e.read()))
parser = argparse.ArgumentParser() parser.add_argument("-v", "--verbose", help="increase output verbosity", action="store_true") parser.add_argument("-c", "--charachter", type=str, help="charachter name to fetch details") parser.add_argument("-l", "--list_of_characters", help="get list of characters", action="store_true") args = parser.parse_args() app = Application() # app begins chars = CharachterPage() if args.list_of_characters: list_of_characters = [str(x['*']) for x in chars.getCharachtersList()] pprint(list_of_characters) sys.exit(0) if args.charachter: char_name = urllib.quote(args.charachter) file_name_text = '/'.join( [app.settings['storage_folder']['Charachters_text'], char_name]) file_name_info = '/'.join( [app.settings['storage_folder']['Charachters_info'], char_name])
import os import argparse import urllib from pprint import pprint from Houses import HousesPage from Application import Application # Command line options parser = argparse.ArgumentParser() parser.add_argument("-v", "--verbose", help="increase output verbosity", action="store_true") parser.add_argument("-s", "--house", type=str, help="house name to fetch details") parser.add_argument("-l", "--list_of_houses", help="get list of houses", action="store_true") args = parser.parse_args() app = Application() list_of_houses = [] # app begins houses = HousesPage(dict()) if args.list_of_houses: list_of_houses = houses.getListOfHouses() pprint (list_of_houses) if args.house: house_name = urllib.quote(args.house) # setup persistent storage locations file_name_text = '/'.join([app.settings['storage_folder']['Houses_text'],house_name]) file_name_info = '/'.join([app.settings['storage_folder']['Houses_info'],house_name]) file_name_nlp = '/'.join([app.settings['storage_folder']['Houses_nlp'],house_name])
def test_app_types(self): ff = Application("firefox.desktop", pid=1, tstart=0, tend=2) cf = Application("catfish.desktop", pid=2, tstart=21, tend=32) th = Application("thunar.desktop", pid=3, tstart=5, tend=8) gd = Application("gnome-disks.desktop", pid=4, tstart=2, tend=4) self.assertTrue(ff.isUserlandApp()) self.assertTrue(cf.isDesktopApp()) self.assertTrue(th.isDesktopApp()) self.assertTrue(gd.isDesktopApp())
import Tkinter as tk from Application import Application from Style import Style transferedArtStyles = [ Style("Starry night", "chainer_fast_neuralstyle/models/thumbnails/starry-night.jpg", "chainer_fast_neuralstyle/models/starry.model"), Style("Kanagawa", "chainer_fast_neuralstyle/models/thumbnails/kanagawa-style.jpg", "chainer_fast_neuralstyle/models/kanagawa.model"), Style("Kandinsky", "chainer_fast_neuralstyle/models/thumbnails/kandinsky.jpg", "chainer_fast_neuralstyle/models/kandinsky_e2_full512.model"), Style("Candy", "chainer_fast_neuralstyle/models/thumbnails/candy-style.jpg", "chainer_fast_neuralstyle/models/candy_512_2_49000.model"), Style("Cubist", "chainer_fast_neuralstyle/models/thumbnails/cubist-style.jpg", "chainer_fast_neuralstyle/models/cubist.model") ] root = tk.Tk() root.attributes("-fullscreen", True) app = Application(root, transferedArtStyles) root.mainloop()
def setUp(self): self.userConf = UserConfigLoader.get("user.ini") self.appStore = ApplicationStore.get() self.eventStore = EventStore.get() self.fileStore = FileStore.get() self.fileFactory = FileFactory.get() self.sim = AttackSimulator() self.a1 = Application("ristretto.desktop", pid=1, tstart=1, tend=2000) self.a2 = Application("firefox.desktop", pid=2, tstart=1, tend=2000) self.a3 = Application("ristretto.desktop", pid=3, tstart=3000, tend=6000) self.ac = Application("catfish.desktop", pid=100, tstart=1, tend=2900) self.appStore.insert(self.a1) self.appStore.insert(self.a2) self.appStore.insert(self.a3) self.appStore.insert(self.ac) self.p001 = "/home/user/.cache/firefox/file" s001 = "open64|%s|fd 10: with flag 524288, e0|" % self.p001 e001 = Event(actor=self.a1, time=10, syscallStr=s001) e001.evflags &= ~EventFileFlags.designation # not by designation self.eventStore.append(e001) e001b = Event(actor=self.a2, time=11, syscallStr=s001) e001b.evflags &= ~EventFileFlags.designation # not by designation self.eventStore.append(e001b) self.p002 = "/home/user/Images/picture.jpg" s002 = "open64|%s|fd 10: with flag 524288, e0|" % self.p002 e002 = Event(actor=self.a1, time=12, syscallStr=s002) e002.evflags &= ~EventFileFlags.designation # not by designation self.eventStore.append(e002) e002b = Event(actor=self.ac, time=30, syscallStr=s002) e002b.evflags &= ~EventFileFlags.designation # not by designation self.eventStore.append(e002b) self.p003 = "/home/user/Downloads/logo.jpg" s003 = "open64|%s|fd 10: with flag 524288, e0|" % self.p003 e003 = Event(actor=self.a1, time=13, syscallStr=s003) e003.evflags |= EventFileFlags.designation # this event by designation self.eventStore.append(e003) e003b = Event(actor=self.a3, time=3003, syscallStr=s003) e003b.evflags &= ~EventFileFlags.designation # not by designation self.eventStore.append(e003b) self.p004 = "/home/user/Downloads/logo.png" s004 = "open64|%s|fd 10: with flag 64, e0|" % self.p004 e004 = Event(actor=self.a1, time=14, syscallStr=s004) e004.evflags &= ~EventFileFlags.designation # not by designation self.eventStore.append(e004) self.p005 = "/home/user/Dropbox/Photos/holidays.jpg" s005 = "open64|%s|fd 10: with flag 524288, e0|" % self.p005 e005 = Event(actor=self.a1, time=15, syscallStr=s005) e005.evflags &= ~EventFileFlags.designation # not by designation self.eventStore.append(e005) e005b = Event(actor=self.a1, time=1005, syscallStr=s005) e005b.evflags &= ~EventFileFlags.designation # not by designation self.eventStore.append(e005b) self.p006 = "/home/user/Images/random.txt" s006 = "open64|%s|fd 10: with flag 524288, e0|" % self.p006 e006 = Event(actor=self.a1, time=16, syscallStr=s006) e006.evflags &= ~EventFileFlags.designation # not by designation self.eventStore.append(e006) self.p007 = "/home/user/Images/file.jpg" s007 = "open64|%s|fd 10: with flag 524288, e0|" % self.p007 e007 = Event(actor=self.a1, time=17, syscallStr=s007) e007.evflags |= EventFileFlags.designation # this event by designation self.eventStore.append(e007) self.p008 = "/home/user/Images/other.foo" s008 = "open64|%s|fd 10: with flag 64, e0|" % self.p008 e008 = Event(actor=self.a1, time=18, syscallStr=s008) e008.evflags &= ~EventFileFlags.designation # not by designation self.eventStore.append(e008) self.p009 = "/home/user/Downloads/unknown.data" s009 = "open64|%s|fd 10: with flag 64, e0|" % self.p009 # e009 = Event(actor=self.a1, time=18, syscallStr=s009) # e009.evflags |= EventFileFlags.designation # this event by designation # self.eventStore.append(e009) e009b = Event(actor=self.a3, time=3009, syscallStr=s009) e009b.evflags &= ~EventFileFlags.designation # not by designation self.eventStore.append(e009b) self.p010 = "/home/user/Dropbox/Photos/holidays.metadata" s010 = "open64|%s|fd 10: with flag 524288, e0|" % self.p010 e010 = Event(actor=self.a1, time=20, syscallStr=s010) e010.evflags &= ~EventFileFlags.designation # not by designation self.eventStore.append(e010) self.p011 = "/home/user/Dropbox/Photos/holidays.evenmoremetadata" s011 = "open64|%s|fd 11: with flag 524288, e0|" % self.p011 e011 = Event(actor=self.a3, time=3020, syscallStr=s011) e011.evflags &= ~EventFileFlags.designation # not by designation self.eventStore.append(e011) self.eventStore.simulateAllEvents() self.acCache = AccessListCache.get() self.lookUps = dict() self.allowedCache = dict()