def main(): battlesimulator = Master() battlesimulator.introMessage() setupPlayers = SetupPlayers() setupPlayers.askPlayer() battlesimulator.displayStats(Warrior(1, 2, 3), Warrior(4, 5, 6)) warriorSet = WarriorSet(Warrior(1, 2, 3), Warrior(4, 5, 6)) warriorSet.printWarriors() simulation = Simulation() simulation.setWarriors(Warrior(1, 2, 3), Warrior(4, 5, 6)) simulation.run()
class Painter(Frame): total = 1 mas = Master.Master() scaling = 10.0 intersection_Size = 4 ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ##### # ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### INITIALIZATION ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ##### # ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ##### # def __init__(self, master=None): self.initializeFrame(master) self.initializeMap() self.after(10, self.update) def initializeFrame(self, master): Frame.__init__(self, master) Pack.config(self) self.createWidgets() def initializeMap(self): self.mas.printState() # Draw the intersections and streets for inter in self.mas.m.intersections: self.drawIntersection(inter, self.scaling * self.mas.m.intersections[inter][0], self.scaling * self.mas.m.intersections[inter][1]) for street in self.mas.m.streets: self.drawStreet(street) for car in self.mas.cars: self.drawCar(car) ############################################## ### stepping function ### ############################################## def update(self, *args): # Let the Master class do a time step self.mas.run(self.total) self.total += 1 self.mas.printCars() for car in self.mas.cars: if car.needsUpdate: self.updateCar(car) car.needsUpdate = False self.after(70, self.update) def updateCar(self, car): dx = self.getDX(car) dy = self.getDY(car) self.draw.move(car.name, dx, dy) def drawIntersection(self, label, x, y): self.draw.create_rectangle(x-self.intersection_Size, y-self.intersection_Size, x+self.intersection_Size ,y+self.intersection_Size ,tags=label, fill="blue") def drawStreet(self, street): x0 = self.mas.m.intersections[street[0]][0] * self.scaling y0 = self.mas.m.intersections[street[0]][1] * self.scaling x1 = self.mas.m.intersections[street[1]][0] * self.scaling y1 = self.mas.m.intersections[street[1]][1] * self.scaling #self.draw.create_rectangle(x0-1, y0-1, x1+1, y1) self.draw.create_line(x0, y0, x1, y1, fill="red",) def drawCar(self, car): x = self.getXY(car.curPos)[0] y = self.getXY(car.curPos)[1] self.draw.create_rectangle(x - 3, y - 3, x + 3, y + 3, tags=car.name, fill="green") def getXY(self, carPos): streetID = carPos[0] street = self.mas.m.streets[streetID] length = float(street[2]) x0 = self.mas.m.intersections[street[0]][0] * self.scaling y0 = self.mas.m.intersections[street[0]][1] * self.scaling x1 = self.mas.m.intersections[street[1]][0] * self.scaling y1 = self.mas.m.intersections[street[1]][1] * self.scaling direction = [x1 - x0, y1 - y0] progress = float(carPos[1]) return [x0 + progress/length * direction[0], y0 + progress/length * direction[1]] def getDX(self, car): return self.getXY(car.curPos)[0] - self.getXY(car.oldPos)[0] def getDY(self, car): return self.getXY(car.curPos)[1] - self.getXY(car.oldPos)[1] def createWidgets(self): self.QUIT = Button(self, text='QUIT', foreground='red', command=self.quit) self.QUIT.pack(side=BOTTOM, fill=BOTH) self.draw = Canvas(self, width="10i", height="10i") #self.speed = Scale(self, orient=HORIZONTAL, from_=-100, to=100) #self.speed.pack(side=BOTTOM, fill=X) # all of these work.. #self.draw.create_rectangle(0, 0, 10, 10, tags="thing", fill="blue") self.draw.pack(side=LEFT)
from Master import * from Worker import * import random import sys import time """ Main of the implementation execute the Implementation. """ # create a Transaction with parameter if __name__ == '__main__': master = Master(name="Master") master.start() # start the Master Thread senders_receivers = [ "Marc", "Luc", "Antoine", "Mathieu", "Jean", "Patrick", "Stephane", "Junior" ] # list of Person to execute Transactions request maxAmount = sys.maxsize # initial Amount to the biggest interger in the system workers = [] # workers initialisations failedWorkers = [] # failed or malicious Workers workerNumber = 5 # numbers of Workers for i in range(1, workerNumber + 1): workers.append(StartWorker(name=f"Worker {i}")) master.addWorker(workers[i - 1]) # Present Workers to the Master for i in range(100): indexSender = random.randint(0, len(senders_receivers) -
from mpi4py import MPI import time from Worker import * from Master import * from IO import * from graph import * comm = MPI.COMM_WORLD rank = comm.Get_rank() size = comm.Get_size() if rank == size - 1: # master process master = Master(rank, size - 1, comm) master.Run() else: worker = Worker("../graph/large.graph", rank, size - 1, comm) worker.Local_Graph() worker.Local_Step()
#!/usr/bin/env python from Master import * master = Master() master.createTable([{ 'key1': 'varchar(256)' }, { 'key2': 'int' }, { 'key3': 'varchar(1)' }, { 'key4': 'int' }, { 'res': 'int' }]) params = [['a', 'b', 'c', 'd'], [1, 2, 3, 4], ['x', 'y', 'z'], [10, 20, 30, 40]] master.setInputParams(params) master.start()
import Master import Gameplay master = Master.Master() gameplay = Gameplay.Gameplay() master.setGameplay(gameplay) master.onStart() print("This line will be printed.")
class Controller: """ The Controller is the connection which is made between a View and a Model, as expected in MVC-modeled software. The View is specified globally within the controller, as is the Master """ view = None master = Master() def __init__(self): """ The __init__ method initialises a View, as the controller must be given as argument to deal with user input. """ self.view = GuiView(self) return def main(self, command): # Todo: Split """ The main method is a method originally used as basis for a TUI, but is still used by the GUI for historic reasons. This method arranges Model changes accordingly based on user input in the View. Relatively new changes are not dealt with through this method, but separate smaller methods. This method should be splitted up in the future. E.g. > Controller.main('sweep 0 0 10 1') > None :param command: This is the command (as string) that is given to the method and describes the user input in a way that the Controller can forward it to the Model. :return: None """ command = command.split(" ") if command[0] == 'openFile': print('hello2') if self.master.open_file(command[1]): print('File %s opened' % command[1]) else: print('Filename unknown, failed opening...') elif command[0] == 'parameters': parameters = self.master.get_parameters() interactive = self.master.get_interactive() bs = self.master.get_bs() # print(str(parameters) + '\n\n') # print(str(interactive) + '\n\n') # print(bs) return parameters, interactive, bs elif command[0] == 'sweep': self.master.add_sweep(int(command[1]), int(command[2]), int(command[3]), int(command[4])) # sweeps.append([command[1], command[2], command[3], command[4]]) elif command[0] == 'execute': return self.master.execute() elif command[0] == 'show': self.master.close_file() elif command[0] == 'exit': self.master.close_file() def get_sweeps(self): """ Returns all sweeps that are stored in the model. :return: List of all currently stored sweeps. E.g. > Controller.get_sweeps() > [[0, 0, 10, 1], [1, 0, 20, 2]] """ return self.master.get_sweeps() def quit(self): # Todo: Work out. """ Called when the program is exited (both forced and unforced). Exits python. :return: quit(0) E.g. > Controller.quit() > quit() """ print('Graceful exit!') quit(0) def simulate(self, query): """ Used for simulating an amount of runs, considering parameter query. :param amount: The amount of runs that should be carried out over the UPPAAL-model stored in the Model. :param query: The UPPAAL-parameter that should be considered. :return: A list of traces of every run taken. E.g. > simulate(2, 'cost') > [ [ (0,0), (1,1), (2,2) ], [ (0,0), (1,2), (2,2) ] ] """ return self.master.simulate(query)
######################################################################### RPipeMstr is the core master process of RenderPipe. Copyright (C) 2011 Hadi Saraf RPipeMstr is part of RenderPipe. RenderPipe is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program. If not, see <http://www.gnu.org/licenses/>. ######################################################################### """ """""" """""" """""" """""" """""" """""" """""" """""" """""" """""" """""" """""" __version__ = 1.1 import Master if "__main__" == __name__: print( "RenderPipe 1.1, master application, built May 08 2011.\nCopyright (C) 2011 Hadi Saraf.\n\n" ) Master.Master() # runs RPipeMstr
import socket import sys from Master import * # prompt user to enter secret key file keyfile = input("Input secret key file: ") #"fakeSecretKey.txt" # create server socket serv = socket.socket(socket.AF_INET, socket.SOCK_STREAM) # create master (usernumber 1) mast = Master(keyfile, 1) print("") # bind server to localhost and port 8080, and listen for 1 connection serv.bind(('0.0.0.0', 8080)) serv.listen(1) while True: # accept connections from outside (conn, addr) = serv.accept() print("") print("Sending a session key status request to outstation...") messageOut = str(mast.sendStatusRequest()) while True: # send message to client conn.send(messageOut.encode()) # read data sent from client