def test_Stats(self): from stats import Stats statistics = Stats(1, 2, 2, 3, 4, 7, 9) self.assertAlmostEqual(statistics.mean(), 4.0) self.assertEqual(statistics.median(), 3) self.assertEqual(statistics.modes(), [2]) statistics = Stats(1, 2, 2, 3, 4, 7, 9, 7) self.assertAlmostEqual(statistics.mean(), 4.375) self.assertAlmostEqual(statistics.median(), 3.5) self.assertEqual(statistics.modes(), [2, 7])
def make_post(event, context): posts = [] paginator = client("dynamodb").get_paginator("scan") for page in paginator.paginate( TableName="WordpostBotPosts", FilterExpression="reactions = :t", ExpressionAttributeValues={":t": { "BOOL": False }}): for item in page["Items"]: posts.append(item["id"]["S"]) info_table = resource("dynamodb").Table("WordpostBotInfo") credentials = info_table.get_item(Key={"resource": "credentials"})["Item"] access_token = credentials["access_token"] stats_item = info_table.get_item(Key={"resource": "stats"})["Item"] stats = Stats(access_token, posts, stats_item["top_reactors"], stats_item["top_posts"], stats_item["total_posts"], stats_item["total_reactions"]) session = Session() session.params = {"access_token": credentials["access_token"]} api_url = "https://graph.facebook.com/v2.10/" r = session.post(api_url + credentials["page_id"] + "/feed", data={"message": stats.get_top_reactor_message()}) r.raise_for_status() post_id = r.json()["id"] session.post(api_url + post_id + "/comments", data={ "message": stats.get_top_post_message() }).raise_for_status()
def __init__(self): with open("properties.json") as fp: config = json.load(fp) # self.q = Queue.Queue() # # current completion time of a queue policy = config["server"]["allocationPolicy"] self.allocation_policy = AllocationPolicy.get_policy(policy) self.stat = Stats() # TODO : Use this code if we want to use multiple queues self.write_server = config["server"]["writeServer"] self.read_server = config["server"]["readServer"] self.no_of_read_response_required = config["server"][ "noOfReadResponse"] self.no_of_write_response_required = config["server"][ "noOfWriteResponse"] self.server_queues = [] self.completion_time = [] for i in range(0, config["server"]["numberOfServers"]): self.server_queues.append(Queue.PriorityQueue()) self.completion_time.append(0) self.dist = Distribution.get_distribution( config["request"]["distribution"], rate=1)
def reset(self, seed=None): self.feq = FutureEventsQueue() self.clock = Clock() self.stats = Stats() if seed is not None: random.seed(seed) self.initialize()
def run_game(): # initialize game and create screen object pygame.init() settings = Settings() screen = pygame.display.set_mode(settings.screen_res) pygame.display.set_caption("Alien Invasion") stats = Stats() ship = Ship(screen) bullets = Group() aliens = Group() play_button = Button(settings, screen, 'Play') scoreboard = Scoreboard(settings, screen, stats) fun.create_fleet(settings, screen, aliens, ship.rect.height, stats) # start the main loop for the game while True: fun.check_events(settings, screen, ship, bullets, stats, aliens, play_button, scoreboard) if stats.game_active: ship.update() bullets.update() aliens.update() fun.drop_aliens(aliens) fun.collide(ship, aliens, bullets, settings, stats) fun.delete_bullets(bullets) fun.update_screen(screen, settings, ship, bullets, aliens, stats, play_button, scoreboard)
def year_stats(self): teams = self.all_info().json()['teams'] team_to_stats = dict() for t in teams: stats = Stats(t['valuesByStat']) team_to_stats[t['id']] = stats return team_to_stats
def send_command(self, command): """ Send a command to the Tello and wait for a response. :param command: Command to send. :return (str): Response from Tello. """ self.log.append(Stats(command, len(self.log))) print(">> send cmd: {}".format(command)) #self.abort_flag = False #timer = threading.Timer(self.command_timeout, self.set_abort_flag) self.socket.sendto(command.encode('utf-8'), self.tello_address) start = time.time() while not self.log[-1].got_response(): now = time.time() diff = now - start if diff > self.MAX_TIME_OUT: print("Max timeout exceeded... command %s" % command) break time.sleep(0.01) # TODO: is timeout considered failure or next command still get executed # now, next one got executed print("Command completed: %s to %s" % (command, self.tello_ip)) return self.log[-1].got_response()
def run_game(): # Initialize pygame, settings, and screen object. pygame.init() screen = pygame.display.set_mode((630, 800)) pygame.display.set_caption("PACMAN") # Draw maze mazefile = 'maze.txt' maze = Maze(screen, mazefile) # Pacman pm = PM(screen, maze) # Stats stats = Stats() # Ghosts red = Red(screen, maze) blue = Blue(screen, maze) pink = Pink(screen, maze) orange = Orange(screen, maze) cherry = Cherry(screen) display = Display(screen, pm) while True: if stats.game_active: gf.check_events(screen, pm, maze, red, blue, pink, orange, stats, display) gf.update_screen(screen, pm, maze, red, blue, pink, orange, cherry, stats, display) pygame.display.flip()
def anvill_decomp_main(args, source_path, dest_path): sources_decompile = list(source_path.rglob("*.json")) if sources_decompile: workdir_decompile = str(dest_path.joinpath("work")) log.debug(f"Making work dir [{workdir_decompile}]") os.makedirs(workdir_decompile, exist_ok=True) log.info(f"Found {len(sources_decompile)} JSON specs") num_cpus = os.cpu_count() anvill_stats = Stats() if args.test_options: with open(args.test_options, "r") as rf: anvill_stats.load_rules(rf) anvill_stats.set_stat("start_time", str(datetime.now())) max_items_decompile = len(sources_decompile) apply_anvill_decomp = partial(run_anvill_decompile, args.anvill_decompile, dest_path, args.only_fails, source_path_decompile, anvill_stats) with ThreadPool(num_cpus) as p: with tqdm(total=max_items_decompile) as pbar: for _ in p.imap_unordered(apply_anvill_decomp, enumerate(sources_decompile)): pbar.update() anvill_stats.set_stat("end_time", str(datetime.now())) if args.dump_stats: outpath = dest_path.joinpath("stats.json") anvill_stats.save_json(outpath) if args.slack_notify: dump_via_slack(args, anvill_stats)
def anvill_python_main(args, source_path, dest_path): num_cpus = os.cpu_count() anvill_stats = Stats() if args.test_options: with open(args.test_options, "r") as rf: anvill_stats.load_rules(rf) # get all the bitcode log.info(f"Listing files in {str(source_path)}") sources = list(source_path.rglob("*.elf")) log.info(f"Found {len(sources)} ELF files") # load test to ignore anvill_stats.set_stat("start_time", str(datetime.now())) max_items_python = len(sources) # workspace for anvill-python apply_anvill_python = partial(run_anvill_python, args.anvill_python, dest_path, args.only_fails, source_path, anvill_stats) with ThreadPool(num_cpus) as p: with tqdm(total=max_items_python) as pbar: for _ in p.imap_unordered(apply_anvill_python, enumerate(sources)): pbar.update() anvill_stats.set_stat("end_time", str(datetime.now())) if args.dump_stats: outpath = dest_path.joinpath("stats.json") anvill_stats.save_json(outpath) if args.slack_notify: dump_via_slack(args, anvill_stats)
def run(self): self.distances = self.__build_distance_matrix(self.points) self.heur_values = self.__density() self.stats = Stats(np.sum(self.distances)) self.__build_pheromone_vector() sol_dist = np.empty(self.num_ants) sol_medians = np.empty((self.num_ants, self.num_medians), dtype=int) for i in range(self.iterations): for j in range(self.num_ants): solution_matrix, medians = self.build_solution() sol_dist[j] = self.eval(solution_matrix) sol_medians[j] = medians self.stats.add_solution(sol_dist, sol_medians) local_best = self.stats.get_local_best() local_worst = self.stats.get_local_worst() global_best = self.stats.get_global_best() self.update_pheromone(local_best, local_worst, global_best) print('Iteration ' + str(i + 1)) self.stats.print_stats() self.stats.record_data() if self.outfile: self.stats.dump_to_file(self.outfile) return global_best[0]
def get_stats(self, itr=0): self.stats = Stats() # Clean stats self.set_iteration(itr) self.read_meminfo() self.read_slabinfo() self.read_cpuinfo() return self.stats
def __init__(self): # initializes game session and builds game resourses pygame.init() self.settings = Settings() # storing game statistics self.stats = Stats(self) self.screen = pygame.display.set_mode((0, 0), pygame.FULLSCREEN) self.screen_rect = self.screen.get_rect() self.settings.screen_width = self.screen.get_rect().width self.settings.screen_height = self.screen.get_rect().height pygame.display.set_caption("Warplanes") self.bg_color = self.settings.bg_colour self.hp = self.settings.enemy_hp self.junkers = Junkers(self) self.shots = pygame.sprite.Group() self.enemy_shots = pygame.sprite.Group() self.enemies = pygame.sprite.Group() # game scoreboard self.sb = Scoreboard(self) self.play_button = Button(self, "START", (0, -100)) self.info_button = Button(self, "INFO", (0, 100)) self.pause_button = Button(self, "Continue") self._create_sky() self.info = Info(self) pygame.mixer.music.load('music.wav') self.shot_sound = pygame.mixer.Sound('shot.ogg') self.explosion_sound = pygame.mixer.Sound('explosion.ogg')
class Race(metaclass=utilities.StrMeta): starting_stats = Stats(0, 0, 0, 0) def __init__(self, str, agi, int, con): if not self.starting_stats.validStart(): raise InvalidStartingStats("Unbalanced starting stats: %d" % self.starting_stats.sum())
def bundle_func(self, dir_list): ''' Function called in parallel_bundler() which gives it an array containing src_path and dest_path Generates json object and captures stats of each process Arguments: dir_list -- Array containing src_path and dest_path Returns: bundled_file_data -- Json object of archive file stat -- Stat object of the process ''' stat = Stats() start = time.time() proc_name = multiprocessing.current_process().name cmd, elapsed_proc_time, tar_path = Bundler.bundle_file_set(dir_list[0], dir_list[1]) end = time.time() elapsed = end - start tar_size = Bundler.get_bundle_size(tar_path) bundled_file_data = {} stat.capture_stats(elapsed_proc_time, tar_size, 0, tar_path, proc_name, cmd, "", end) return bundled_file_data, stat, tar_path
def __init__(self, config): """Initializes the primary kcauto instance with the passed in Config instance; creates the Stats instance and resets scheduled sleep timers. Args: config (Config): kcauto Config instance """ self.kc_region = None self.config = config self.stats = Stats(self.config) self.scheduler = Scheduler(self.config, self.stats) self.modules = { 'resupply': None, 'pvp': None, 'combat': None, 'repair': None, 'ship_switcher': None, 'fleet_switcher': None, 'expedition': None, 'quest': None } self.print_stats_check = True self.paused = False self.regions = {} self.active_fleets = {} self.combat_fleets = {} self.expedition_fleets = {} self.combat_cycle = False
def start_game(): pygame.init() settings = Settings() screen = pygame.display.set_mode( (settings.screen_width, settings.screen_height)) pygame.display.set_caption("Alien Attack") play_button = Button(settings, screen, "Play") stats = Stats(settings) sb = ScoreBoard(settings, screen, stats) ship = Ship(settings, screen) bullets = Group() aliens = Group() gf.create_fleet(settings, screen, ship, aliens) while True: gf.check_events(settings, screen, stats, sb, play_button, ship, aliens, bullets) if stats.game_active: update_elements(settings, screen, stats, sb, ship, aliens, bullets) gf.update_screen(settings, screen, stats, sb, ship, aliens, bullets, play_button)
def get_stats(self): """Retrieves statistics about the queue""" href = proc_template(self._conn.stats_href, queue_name=self._name) hdrs, body = self._conn._perform_http(href=href, method='GET') return Stats(body)
def _cumulative_stats(self, lineup: Lineup): """ Calculates an approximation of the final statistics of this lineup, assuming ideal management (setting lineups daily, etc.) :param Lineup lineup: the lineup to examine and use to calculate stats :return Stats: the accumulated, year-end total stats """ total_stats = Stats({}, BaseballStat) for p in lineup.starters(): total_stats += self._get_projection(p.name) or Stats({}, BaseballStat) for p in lineup.benched(): total_stats += self._get_projection(p.name) or Stats( {}, BaseballStat) * self.likelihood(p, lineup) return total_stats