def __init__(self, buffer_size=65535, threads_count=os.cpu_count() * 2, verbose=False, show_logs=True): self.server_sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) self.buffer_size = buffer_size self.threads_count = threads_count self.stats = Statistics() self.stats_lock = threading.RLock() self.show_logs = show_logs self.verbose = verbose self.executor = ThreadPoolExecutor(max_workers=self.threads_count - 1)
def __init__(self): # other super().__init__() self.oneUse = True # _modules self.iConfigParser = ConfigParser() self.config = self.iConfigParser.parser() self.iGlobalTimer = GlobalTimer() self.iCommands = Commands(self) # modules self.iAntiSpam = AntiSpam(self) self.iServerStatus = ServerStatus(self) self.iGiveRoles = GiveRoles(self) self.iAdmMSG = AdmMSG(self) self.iChecks = Checks(self) self.iTimeVoice = TimeVoice(self) self.iDuels = Duels(self) self.iNullCheck = NullCheck(self) self.iLevels = Levels(self) self.iStatistics = Statistics(self) self.iEconomy = Economy(self) self.iBuyRole = BuyRole(self) self.iPVC = PersonalVoiceChannels(self) self.iTimeRoles = TimeRoles(self) self.iLaV = LevelsAndVoiceRewards(self) self.iMusic = Music(self)
def test_saving_the_winner_of_a_game(save_path): """Test the saving and retrieval of game rankings.""" # First, create a completely new statistics object stats = Statistics(save_path=save_path) # Save the results of two consecutive games stats.save(ranking=["gold1", "bronze1", "silver1", "loser1"]) stats.save(ranking=["gold2", "bronze2", "silver2", "loser2"]) # Check if the results are immediatly retrievable expected_rankings = [ ["gold1", "bronze1", "silver1", "loser1"], ["gold2", "bronze2", "silver2", "loser2"], ] assert stats.data.all_rankings == expected_rankings # And then check if the same data can be retrieved after a "restart" del stats new_stats = Statistics(save_path=save_path) assert new_stats.data.all_rankings == expected_rankings
def test_creation_of_save_file(save_path): """Statistics object should automatically create save file.""" stats = Statistics(save_path=save_path) save_path = stats.save_path assert save_path.exists()
def stats(save_path): """Return a statistics object which will be recycled after the test.""" return Statistics(save_path=save_path)
def __init__(self, generator_code, prev_screen): self.generator = self.GENERATOR_MAPPER[generator_code] self.result = dict() self.prev_screen = prev_screen self.statistics = Statistics()
class Manager: GENERATOR_MAPPER = { "1": SumGenerator(), "2": SubGenerator(), "3": MultGenerator() } def __init__(self, generator_code, prev_screen): self.generator = self.GENERATOR_MAPPER[generator_code] self.result = dict() self.prev_screen = prev_screen self.statistics = Statistics() def requestInput(self): c = input("") if c.lower() == "sair": self.prev_screen["reference"].print() else: self.execute() self.statistics.saveRecords(self.result["correct"], self.result["incorrect"], self.result["duration"]) time.sleep(5) self.prev_screen["reference"].print() def execute(self): questions = self.generator.generate_question(5) self.init_result() start_time = time.time() for question in questions: question.print() self.check_answer(question) time.sleep(1) self.result["duration"] = time.time() - start_time os.system("clear") self.print_result() def init_result(self): self.result = {"correct": 0, "incorrect": 0, "duration": 0} def check_answer(self, question): print("") ans = int(input("Resultado a operação: ")) if question.alternatives["ans"] == ans: self.result["correct"] += 1 print("\nResposta CORRETA") else: self.result["incorrect"] += 1 print("\nResposta incorreta") def print_result(self): print("Parabéns! Você completou a partida. \n") print("Acertos: {}".format(self.result["correct"])) print("Erros: {}".format(self.result["incorrect"])) print("Duração: {:.1f} segundos".format(self.result["duration"])) def print(self): os.system("clear") print("Preparado para iniciar uma nova partida? \n") print("- Digite sempre o valor do resultado da questão.") print("- Pressione qualquer tecla para INICIAR.") print("- Digite SAIR para voltar a tela anterior.") self.requestInput()
def __init__(self) -> None: """Initialize the game with all the components.""" pg.init() pg.font.init() self.screen: graphics.Screen = graphics.Screen() # Statistics self.statistics = Statistics() # Sliders self.slides: List[graphics.Slider] = [ graphics.Slider(Slider("Drag coefficient", 50, 0, 100, 1150, 820)), graphics.Slider(Slider("Friction", 10000, 0, 30000, 1150, 880)), graphics.Slider(Slider('Player 1 mass', 1, 0.01, 2, 1300, 820)), graphics.Slider(Slider('Player 2 mass', 1, 0.01, 2, 1300, 880)), ] # Players self.players: List[player.Player] = [ player.Player(200, 200, ps.Player1Settings, mass=self.slides[2], phone=ConnectPhone()), player.Player(300, 300, ps.Player2Settings, mass=self.slides[3]), ] # Plots self.graphs: List[graphics.Graph] = [ graphics.Graph(self.players, "v"), graphics.Graph(self.players, "a", position=(1100, 400)) ] # Buttons self.buttons: List[graphics.Button] = [ graphics.Button( Button("Start!", 700, 600, 100, 50, Colors.GREEN.value, Colors.BLUE.value)) ] # End screen buttons self.end_btn: List[graphics.Button] = [ graphics.Button( Button("Retry", 600, 600, 100, 50, Colors.GREEN.value, Colors.BLUE.value)), graphics.Button( Button("Quit", 800, 600, 100, 50, Colors.RED.value, Colors.BLUE.value)), ] # Layers self.layers: List[arena.ArenaLayer] = [ arena.FrictionLayer(np.ones((ArenaSettings.x, ArenaSettings.y)), self.slides[1].get_value), arena.AirResistanceLayer(self.slides[0].get_value), ] # Arena self.arena: arena.Arena = arena.Arena(ArenaSettings.x, ArenaSettings.y, layers=self.layers) # Physic engine self.physics: Physics = Physics(self) # Input boxes self.input_boxes = [ graphics.InputBox(500, 400, 200, 32, text='player 1 name'), graphics.InputBox(800, 400, 200, 32, text='player 2 name') ] # Score self.score_table = [ graphics.Text( Texts("Win and draw probabilities", ScreenSettings.width / 2, 200, 115)), graphics.Text(Texts('', ScreenSettings.width / 2, 260, 80)), graphics.Text(Texts('', ScreenSettings.width / 2, 320, 80)), graphics.Text(Texts('', ScreenSettings.width / 2, 380, 80)), ]
class Game: """This class represents the whole game.""" def __init__(self) -> None: """Initialize the game with all the components.""" pg.init() pg.font.init() self.screen: graphics.Screen = graphics.Screen() # Statistics self.statistics = Statistics() # Sliders self.slides: List[graphics.Slider] = [ graphics.Slider(Slider("Drag coefficient", 50, 0, 100, 1150, 820)), graphics.Slider(Slider("Friction", 10000, 0, 30000, 1150, 880)), graphics.Slider(Slider('Player 1 mass', 1, 0.01, 2, 1300, 820)), graphics.Slider(Slider('Player 2 mass', 1, 0.01, 2, 1300, 880)), ] # Players self.players: List[player.Player] = [ player.Player(200, 200, ps.Player1Settings, mass=self.slides[2], phone=ConnectPhone()), player.Player(300, 300, ps.Player2Settings, mass=self.slides[3]), ] # Plots self.graphs: List[graphics.Graph] = [ graphics.Graph(self.players, "v"), graphics.Graph(self.players, "a", position=(1100, 400)) ] # Buttons self.buttons: List[graphics.Button] = [ graphics.Button( Button("Start!", 700, 600, 100, 50, Colors.GREEN.value, Colors.BLUE.value)) ] # End screen buttons self.end_btn: List[graphics.Button] = [ graphics.Button( Button("Retry", 600, 600, 100, 50, Colors.GREEN.value, Colors.BLUE.value)), graphics.Button( Button("Quit", 800, 600, 100, 50, Colors.RED.value, Colors.BLUE.value)), ] # Layers self.layers: List[arena.ArenaLayer] = [ arena.FrictionLayer(np.ones((ArenaSettings.x, ArenaSettings.y)), self.slides[1].get_value), arena.AirResistanceLayer(self.slides[0].get_value), ] # Arena self.arena: arena.Arena = arena.Arena(ArenaSettings.x, ArenaSettings.y, layers=self.layers) # Physic engine self.physics: Physics = Physics(self) # Input boxes self.input_boxes = [ graphics.InputBox(500, 400, 200, 32, text='player 1 name'), graphics.InputBox(800, 400, 200, 32, text='player 2 name') ] # Score self.score_table = [ graphics.Text( Texts("Win and draw probabilities", ScreenSettings.width / 2, 200, 115)), graphics.Text(Texts('', ScreenSettings.width / 2, 260, 80)), graphics.Text(Texts('', ScreenSettings.width / 2, 320, 80)), graphics.Text(Texts('', ScreenSettings.width / 2, 380, 80)), ] def run(self) -> None: """Run the whole game loop.""" clock: pg.time.Clock = pg.time.Clock() while 1: if self.run_intro(): break # Set player name self.players[0].name = self.input_boxes[0].text self.players[1].name = self.input_boxes[1].text self.cont_game: bool = True while self.cont_game: if not self.run_game(clock): # Give the winner points if self.players[0].health_bar.health > self.players[ 1].health_bar.health: self.players[0].score += 1 else: self.players[1].score += 1 stats = [ player.name for player in sorted(self.players, key=lambda x: x.health_bar.health, reverse=True) ] self.statistics.save(stats) stats = self.statistics.win_probability( [self.players[0].name, self.players[1].name]) # Add highscore self.score_table[ 1].msg = f"{self.players[0].name}: {stats['player_1']:.2f}" self.score_table[ 2].msg = f"{self.players[1].name}: {stats['player_2']:.2f}" self.score_table[3].msg = f"Draw: {stats['draw']:.2f}" while 1: if self.run_end(): self.end_btn[0].clicked = False break self.reset_game() pg.quit() def run_intro(self) -> bool: """Run the game introduction.""" for event in pg.event.get(): if event.type == pg.QUIT: pg.quit() quit() for box in self.input_boxes: box.handle_event(event) for box in self.input_boxes: box.update() # Fill the screen with white self.screen.screen.fill(Colors.WHITE.value) # Draw text onto the screen graphics.Text( Texts( "EiT gruppe rød", ScreenSettings.width / 2, 300, 115, )).draw(self.screen.screen) # Draw the buttions list(map(lambda x: x.draw(self.screen.screen), self.buttons)) # Input boxes for box in self.input_boxes: box.draw(self.screen.screen) pg.display.update() return self.buttons[0].clicked def run_game(self, clock: pg.time.Clock) -> bool: """Run the game.""" run: bool = True # Check for events for event in pg.event.get(): if event.type == pg.QUIT: run = False # Code for slides elif event.type == pg.MOUSEBUTTONDOWN: pos = pg.mouse.get_pos() for s in self.slides: if s.button_rect.collidepoint(pos): s.hit = True elif event.type == pg.MOUSEBUTTONUP: for s in self.slides: s.hit = False # Fill the screen with black to remove old drawings self.screen.screen.fill(Colors.BLACK.value) # Draw arena self.arena.draw(self.screen.screen) # Move players self.physics.move_players() # Draw players for p in self.players: p.update_health() p.draw(self.screen.screen) # Draw plots for graph in self.graphs: graph.draw(self.screen.screen) # Move sliders for s in self.slides: if s.hit: pass s.move() # Draw sliders for s in self.slides: s.draw(self.screen.screen) pg.display.flip() clock.tick(60) if True in [p.health_bar.health <= 0 for p in self.players]: return False return run def run_end(self) -> bool: """Run when one player dies.""" for event in pg.event.get(): if event.type == pg.QUIT: pg.quit() quit() # Fill the screen with white self.screen.screen.fill(Colors.WHITE.value) # Draw text onto the screen list(map(lambda x: x.draw(self.screen.screen), self.score_table)) # Draw the buttions list(map(lambda x: x.draw(self.screen.screen), self.end_btn)) if self.end_btn[1].clicked: self.cont_game = False pg.display.update() return self.end_btn[0].clicked or self.end_btn[1].clicked def get_players(self) -> List[player.Player]: """Return all player in game.""" return self.players def get_arena(self) -> arena.Arena: """Return game arena.""" return self.arena def reset_game(self): list(map(lambda x: x.reset_position(), self.players)) list(map(lambda x: x.health_bar.reset(), self.players))
class ProxyServer: def __init__(self, buffer_size=65535, threads_count=os.cpu_count() * 2, verbose=False, show_logs=True): self.server_sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) self.buffer_size = buffer_size self.threads_count = threads_count self.stats = Statistics() self.stats_lock = threading.RLock() self.show_logs = show_logs self.verbose = verbose self.executor = ThreadPoolExecutor(max_workers=self.threads_count - 1) def start(self, host='0.0.0.0', port=0): self.server_sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) self.server_sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEPORT, 1) self.server_sock.bind((host, port)) self.server_sock.listen() host, port = self.get_server_addr() print('Прокси работает на ', '{}:{}'.format(host, port)) while self.executor: client_sock, addr = self.server_sock.accept() self.executor.submit(self.__handle_client, client_sock, addr) def stop(self): self.server_sock.settimeout(0) self.server_sock.close() self.executor.shutdown() self.executor = None def show_final_stats(self): print('Получено байт: ', self.stats.received_bytes) print('Байт отправлено: ', self.stats.sent_bytes) def get_server_addr(self): curr_ip = socket.gethostbyname(socket.gethostname()) curr_port = self.server_sock.getsockname()[1] return curr_ip, curr_port def __handle_client(self, client_sock, addr): conn_ip = addr[0] package = self.__receive_data(client_sock, 1.5) host, port, is_https = self.get_conn_info(package) conn = Connection(client_sock, conn_ip, host, port) if not package: return None if is_https: self.__handle_https(conn) else: self.__handle_http(conn, package) def __handle_http(self, conn, package): remote_sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) if self.show_logs: log = self.get_log_info(conn, package.decode()) if log: print(log) try: remote_sock.connect((conn.remote_host, conn.remote_port)) remote_sock.sendall(package) self.update_stats(0, len(package)) self.transfer_http_data(remote_sock.makefile('rb'), conn.socket) finally: conn.socket.close() remote_sock.close() def __handle_https(self, conn): remote_sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) remote_sock.connect((conn.remote_host, conn.remote_port)) conn.socket.sendall(RESPONSE_MESSAGE) try: self.__communicate(conn, remote_sock) except: pass def __communicate(self, conn, remote_sock): #conn.socket.setblocking(0) #remote_sock.setblocking(0) with conn.socket: with remote_sock: while True: readers, _, _ = select.select([conn.socket, remote_sock], [], []) has_data = False for i, reader in enumerate(readers): data = reader.recv(self.buffer_size) if data: has_data = True if reader is conn.socket: remote_sock.sendall(data) else: conn.socket.sendall(data) if not has_data: break def get_header_info(self, src): content_len = 0 resp_header = b'' is_chunked = False while True: line = src.readline() resp_header += line if line == TRANSFER_ENCODING_HEADER: is_chunked = True if line[:15] == CONTENT_LEN_HEADER: content_len = int(line[15:-2].decode()) if line == b'\r\n' or not line: break return resp_header, is_chunked, content_len def transfer_http_data(self, remote_sock_file, client_sock): response, is_chunked, content_len = self.get_header_info(remote_sock_file) if is_chunked: client_sock.sendall(response) self.update_stats(len(response), 0) response = b'' while True: line = remote_sock_file.readline() response += line if line == b'0\r\n': response += b'\r\n' break if not line: break num = int(line[:-2].decode(), 16) chunk = remote_sock_file.read(num + 2) response += chunk client_sock.sendall(response) self.update_stats(len(response), 0) response = b'' if content_len != 0: body = remote_sock_file.read(content_len) response += body client_sock.sendall(response) self.update_stats(len(response), 0) def get_log_info(self, conn, package): if self.verbose: return package request_row = package.split('\n')[0] components = request_row.split() protocol = 'https:/' if conn.secure_sock else '' method = components[0] url = conn.remote_host + components[1] \ if conn.secure_sock else components[1] formatted_request = '{} {}{}'.format(method, protocol, url) return '{} {}'.format(conn.ip, formatted_request) def update_stats(self, recv, sent): with self.stats_lock: self.stats.update(recv, sent) def __receive_data(self, sock, timeout=None): result = b'' if timeout: sock.settimeout(timeout) while True: try: data = sock.recv(self.buffer_size) except socket.error: return result if not data: result += data break result += data return result @staticmethod def get_conn_info(package): package = package.decode() package_lines = package.split('\n') is_https = package_lines[0].find('http') == -1 host_line = next((line for line in package_lines if line.find('Host') >= 0), None) full_url = host_line.split()[1] port = 80 host = full_url if ':' in full_url: host, port = full_url.split(':') return host, int(port), is_https