def __init__(self): Scene.__init__(self) self.callback = self._default_cb self.wait_img = Screen.get_instance().create_image(self.get_name() + "_wait") if not self.wait_img.is_cached(): img = Screen.create_button(ResourceManager.get("empty.png"), Strings.get("Please wait..."), Config.get("text_color"), ResourceManager.get(Config.get("font")), 100) self.wait_img.load_surface(img) self.wait_img.save() self.nb_imgs = len(Config.get("photomaton")["placeholders"]) self.one_more_imgs = [] for i in xrange(self.nb_imgs): self.one_more_imgs.append( Screen.get_instance().create_image(self.get_name() + "_one_more%d" % i)) if not self.one_more_imgs[i].is_cached(): img = Screen.create_button( ResourceManager.get("empty.png"), Strings.get( "Encore une... (%d / %d)" % (i + 1, self.nb_imgs)), Config.get("text_color"), ResourceManager.get(Config.get("font")), 100) self.one_more_imgs[i].load_surface(img) self.one_more_imgs[i].save()
def __init__(self, arduino, camera): Scene.__init__(self) self.arduino = arduino self.camera = camera self.timer = None self.current_step = 0 self.callback = self._default_cb self.cheese_img = Screen.get_instance().create_image(self.get_name() + "_cheese") if not self.cheese_img.is_cached(): base_img = Screen.get_instance().create_empty_image(True) self.cheese_img.load_surface(base_img.img) surf_text = Screen.create_text( Strings.get("Cheese"), ResourceManager.get(Config.get("font")), 100, Config.get("text_color")) tw, th = surf_text.get_size() bw, bh = self.cheese_img.img.get_size() self.cheese_img.img.blit(surf_text, ((bw - tw) / 2, (bh - th) / 2)) self.cheese_img.save() self.wait_img = Screen.get_instance().create_image(self.get_name() + "_wait") if not self.wait_img.is_cached(): img = Screen.create_button(ResourceManager.get("empty.png"), Strings.get("Please wait..."), Config.get("text_color"), ResourceManager.get(Config.get("font")), 100) self.wait_img.load_surface(img) self.wait_img.save() self.imgs = [] wait_before = Config.get("wait_before_snap") for i in xrange(wait_before, 0, -1): cache_img = Screen.get_instance().create_image( "%s_%d" % (self.get_name(), i), True) if not cache_img.is_cached(): base_img = Screen.get_instance().create_empty_image(True) cache_img.load_surface(base_img.img) img = Screen.create_text(str(i), None, 200, (255, 0, 0)) iw, ih = img.get_size() w, h = base_img.size cache_img.img.blit(img, (10, 10)) cache_img.img.blit(img, (w - iw - 10, 10)) cache_img.img.blit(img, (10, h - ih - 10)) cache_img.img.blit(img, (w - iw - 10, h - ih - 10)) cache_img.save() self.imgs.append(cache_img) Screen.get_instance().register_callback("on_preview_starts", self._on_preview_starts)
def __init__(self): # Initilized Pygame Library if pg.get_sdl_version()[0] == 2: pg.mixer.pre_init(44100, 32, 2, 1024) pg.init() if pg.mixer and not pg.mixer.get_init(): print("Warning, no sound") pg.mixer = None # Sets up Window/Screen Display self.winstyle = FULLSCREEN self.bestdepth = pg.display.mode_ok(SCREENRECT.size, self.winstyle, 32) self.screen = pg.display.set_mode(SCREENRECT.size, self.winstyle, self.bestdepth) pg.display.set_caption("Depth") # Stateful variables about mouse movement & IO events self.mouse_rel = pg.mouse.get_rel() self.events = [] self.resources = ResourceManager() # Initialize Containers/Components/UI self.main_menu = Component(SCREENRECT.x, SCREENRECT.y, SCREENRECT.w, SCREENRECT.h) mm = self.main_menu mm.image = self.resources.get_image("mm_back.png") mm.set_font("broadway") mm.text = "Depth" mm_exit_btn = Component(0, 0, 0, 0, parent=mm) mm_exit_btn.resize_width_ratio(1 / 6) mm_exit_btn.resize_height_ratio(1 / 10) mm_exit_btn.center_x_percent(1 / 3) mm_exit_btn.center_y_percent(3 / 4) mm_exit_btn.set_font("calibri") mm_exit_btn.text = "Quit" mm_exit_btn.register_event(Actions.on_left_click, lambda c, gctxt: self.close()) mm_start_btn = Component(0, 0, 0, 0, parent=mm) mm_start_btn.resize_width_ratio(1 / 6) mm_start_btn.resize_height_ratio(1 / 10) mm_start_btn.center_x_percent(2 / 3) mm_start_btn.center_y_percent(3 / 4) mm_start_btn.set_font("calibri") mm_start_btn.text = "Play" mm_start_btn.register_event( Actions.on_left_click, lambda c, gctxt: print("Call code to go to next menu")) self.current_component = self.main_menu
def __init__(self, city, dst_dir, log_path, time_slot): self.res = ResourceManager("./resource", city) self.city = city self.try_times = 3 self.base_url = "http://restapi.amap.com/v3/traffic/status/rectangle" self.params = { 'key': None, 'rectangle': None, 'extensions': 'all', 'level': 6 } self.dst_dir = dst_dir self.time_slot = time_slot self.data = None Logging.init_log(log_path)
def __init__(self, name, action=None, param=None): self.name = name self.action = action self.param = param img_file = ResourceManager.get("%s.png" % name) img_file_sel = ResourceManager.get("%s_sel.png" % name) if img_file and os.path.isfile(img_file): w, h = Screen.get_instance().get_size() screen_ratio = Config.get( "form_buttons")["normal"]["screen_height_ratio"] self.img = pygame.image.load(img_file) iw, ih = self.img.get_rect().size new_ih = h / screen_ratio self.img = pygame.transform.scale(self.img, ((new_ih * iw) / ih, new_ih)) if img_file_sel and os.path.isfile(img_file_sel): self.img_sel = pygame.image.load(img_file_sel) iw, ih = self.img_sel.get_rect().size new_ih = h / screen_ratio self.img_sel = pygame.transform.scale( self.img_sel, ((new_ih * iw) / ih, new_ih)) else: self.img_sel = self.img else: # Generate img button_font = Config.get("form_buttons")["normal"]["font"] button_font_size = Config.get( "form_buttons")["normal"]["font_size"] button_text_color = Config.get( "form_buttons")["normal"]["text_color"] self.img = Screen.create_text(name, ResourceManager.get(button_font), button_font_size, button_text_color) button_font = Config.get("form_buttons")["selected"]["font"] button_font_size = Config.get( "form_buttons")["selected"]["font_size"] button_text_color = Config.get( "form_buttons")["selected"]["text_color"] self.img_sel = Screen.create_text(name, ResourceManager.get(button_font), button_font_size, button_text_color) self.is_selected = False self.need_rendering = False
class StockGateway: 'Class to fetch stock data from CSV or APIs' resource_manager = ResourceManager() def fetch_from_csv(self, path=''): return self.resource_manager.read_from_csv(path)
def show(self, callback=None): Scene.show(self) if callback: self.callback = callback self.img = PIL.Image.open( ResourceManager.get(Config.get("photomaton")["template"])) self.img_counter = 0 SceneManager.get_instance().show_scene("snap", self._process_img)
def create_action_button(button_id, text, img): button_font = Config.get("buttons")["font"] button_font_size = Config.get("buttons")["font_size"] button_img = Config.get("buttons")["img"] button_margin = Config.get("button_margin") button_text_color = Config.get("buttons")["text_color"] button = Screen.create_button(ResourceManager.get(button_img), text, button_text_color, ResourceManager.get(button_font), button_font_size) w, h = img.get_size() bw, bh = button.get_size() if button_id == Arduino.BUTTON_1: img.blit(button, (w - (bw + button_margin), h - (bh + button_margin))) elif button_id == Arduino.BUTTON_2: img.blit(button, (button_margin, h - (bh + button_margin)))
def _recover_power_off(self, cluster_name, fail_node_name): cluster = ResourceManager.get_cluster(cluster_name) if not cluster: logging.error("RecoverManager : cluster not found") return fail_node = cluster.get_node_by_name(fail_node_name) print "fail node is %s, power fail" % fail_node.name print "start recovery vm" self._recover_vm(cluster, fail_node) print "end recovery vm" return self._recover_node_by_start(fail_node)
def _recover_hardware_fault(self, cluster_name, fail_node_name): cluster = ResourceManager.get_cluster(cluster_name) if not cluster: logging.error("RecoverManager : cluster not found") return fail_node = cluster.get_node_by_name(fail_node_name) logging.info( "RecoverManager : start to recover the hardware fault of node %s" % (fail_node)) self._recover_vm(cluster, fail_node) return self._recover_node_by_reboot(fail_node)
def _recover_network_isolation(self, cluster_name, fail_node_name): cluster = ResourceManager.get_cluster(cluster_name) if not cluster: logging.error("RecoverManager : cluster not found") return fail_node = cluster.get_node_by_name(fail_node_name) logging.info( "RecoverManager : start to recover the network isolation of node %s" % (fail_node)) self._recover_vm(cluster, fail_node) return self._recover_node_by_reboot(fail_node)
def _recover_os_hanged(self, cluster_name, fail_node_name): cluster = ResourceManager.get_cluster(cluster_name) if not cluster: logging.error("RecoverManager : cluster not found") return fail_node = cluster.get_node_by_name(fail_node_name) print "fail node is %s, OS fail" % fail_node.name logging.info("fail node is %s, OS fail", fail_node.name) print "start recovery vm" self._recover_vm(cluster, fail_node) print "end recovery vm" return self._recover_node_by_reboot(fail_node)
class QueryHandler: def __init__(self): self.__web_generator = WebGenerator() self.__resource_manager = ResourceManager() self.__encoding = "UTF-8" def handle_get_request(self, request: str) -> Tuple[str, bytes]: if request == "/style.css": return 'text/css', read_file_bytes("/" + "style/style.css") if request.startswith("/images"): return '', read_file_bytes(request) if request == "/all": return 'text/html', self.__handle_resources_request() if request == "/add": return 'text/html', read_file_bytes("/add.html") else: return 'text/html', read_file_bytes("/index.html") def __handle_index_request(self) -> bytes: return bytes(self.__web_generator.generate_index(), self.__encoding) def __handle_resources_request(self) -> bytes: return bytes(self.__web_generator.generate_resources_page(self.__resource_manager.get_all_resources()), self.__encoding) def handle_post_request(self, request: str, post_data: str) -> Tuple[str, bytes]: if post_data.startswith("subject"): search_query = post_data.split("=")[1].split("&")[0] return 'text/html', self.__handle_search_request(search_query) else: vars = post_data.split("&") resource_data = {} for var in vars: var_data = var.split("=") resource_data[var_data[0]] = var_data[1].replace("+", " ") self.__resource_manager.add_resource(resource_data) return 'text/html', read_file_bytes("/add.html") def __handle_search_request(self, search_query: str) -> bytes: return bytes(self.__web_generator.generate_resources_page(self.__resource_manager.search(search_query)), self.__encoding)
def __init__(self, arduino): Scene.__init__(self) self.arduino = arduino self.img = Screen.get_instance().create_image(self.get_name()) if not self.img.is_cached(): self.img.load(ResourceManager.get("welcome.png")) create_action_button(Arduino.BUTTON_1, Strings.get("Go"), self.img.get_surface()) create_action_button(Arduino.BUTTON_2, Strings.get("Settings"), self.img.get_surface()) self.img.save() self.arduino.register_callback(Arduino.BUTTON_1, self.on_button1) self.arduino.register_callback(Arduino.BUTTON_2, self.on_button2)
def __init__(self, arduino): Scene.__init__(self) self.arduino = arduino self.img = Screen.get_instance().create_image(self.get_name()) if not self.img.is_cached(): self.img.load(ResourceManager.get("empty.png")) create_action_button(Arduino.BUTTON_1, Strings.get("Ok"), self.img.get_surface()) create_action_button(Arduino.BUTTON_2, Strings.get("Next"), self.img.get_surface()) self.img.save() arduino.register_callback(Arduino.BUTTON_1, self.on_button1) arduino.register_callback(Arduino.BUTTON_2, self.on_button2) self.menu = Form(self.img.get_surface().get_size()) self.menu.add_item(FormButton("mode_simple", self._snap_simple)) self.menu.add_item(FormButton("mode_photomaton", self._snap_photomaton)) self.menu.add_item(FormButton("mode_special", self._snap_special)) self.menu.cache(self.get_name(), self.img)
def __init__(self, arduino): Scene.__init__(self) self.arduino = arduino self.img = Screen.get_instance().create_image(self.get_name()) if not self.img.is_cached(): self.img.load(ResourceManager.get("empty.png")) create_action_button(Arduino.BUTTON_1, Strings.get("Ok"), self.img.get_surface()) create_action_button(Arduino.BUTTON_2, Strings.get("Next"), self.img.get_surface()) self.img.save() arduino.register_callback(Arduino.BUTTON_1, self.on_button1) arduino.register_callback(Arduino.BUTTON_2, self.on_button2) self.menu = Form(self.img.get_surface().get_size()) for item in Config.get("special_effects"): self.menu.add_item(FormButton(Strings.get(item["string"]), self._effect, item["id"])) self.menu.cache(self.get_name(), self.img)
def _recover_instance_crash(self, cluster_name, failed_instance_name): cluster = ResourceManager.get_cluster(cluster_name) if not cluster: logging.warning( "RecoverManager, _recover_instance_crash: cluster not found") return failed_instance = cluster.get_protected_instance_by_instance_name( failed_instance_name) if failed_instance == None: logging.warning( "RecoverManager, _recover_instance_crash: failed instance not found" ) return logging.info( "RecoverManager : start to recover the instance crash of instance %s" % (failed_instance_name)) result = failed_instance.recover_instance_crash() return result
def __init__(self, arduino): Scene.__init__(self) self.arduino = arduino self.img = Screen.get_instance().create_image(self.get_name()) if not self.img.is_cached(): self.img.load(ResourceManager.get("empty.png")) create_action_button(Arduino.BUTTON_1, Strings.get("Ok"), self.img.get_surface()) create_action_button(Arduino.BUTTON_2, Strings.get("Next"), self.img.get_surface()) self.img.save() arduino.register_callback(Arduino.BUTTON_1, self.on_button1) arduino.register_callback(Arduino.BUTTON_2, self.on_button2) w, h = Screen.get_instance().get_size() self.menu = Form((w, h)) self.menu.add_item(FormButton(Strings.get("Clean Cache"), self._action_clean_cache)) self.menu.add_item(FormButton(Strings.get("Shutdown"), self._action_shutdown)) self.menu.add_item(FormButton(Strings.get("Back"), self._action_back)) self.menu.cache(self.get_name(), self.img)
def __init__(self, arduino, camera): SnapScene.__init__(self, arduino, camera) self.selected_overlay = None overlays = [] for item in Config.get("special_effects"): overlays.append(item["id"]) self.overlay_imgs = {} for overlay in overlays: self.overlay_imgs[overlay] = [] for i in xrange(len(self.imgs)): base_img = self.imgs[i] cache_img = Screen.get_instance().create_image("%s_%s_%d" % (self.get_name(), overlay, i), True) if not cache_img.is_cached(): cache_img.load(os.path.join(ResourceManager.get_instance().get_folder(), overlay)) cache_img.adapt_to_screen() cache_img.img.blit(base_img.img, (0, 0)) cache_img.save() self.overlay_imgs[overlay].append(cache_img)
def init_once(self): print "Starting " + ENV_VARS.package + " v" + ENV_VARS.version JabberConnection.__init__(self) gnome.init(ENV_VARS.package, ENV_VARS.version) self.pman = PluginManager() self.resources = ResourceManager() self.__load_resources() ld = LoginDlg(1) ld.evtDoConnect = self.startup ld.evtCancel = self.quit ld.show() ## Show us more info if we are debugging if __debug__: self.session.evtTransmitXML.connect(self.__on_transmit_xml) self.session.evtRecvXML.connect(self.__on_recv_xml) self.session.evtPresenceRequest.connect(self.__on_presence_request)
def show(self): Scene.show(self, self.img) qr_path = os.path.join("cache/last_qrcode.png") if os.path.exists(qr_path): qr = pygame.image.load(qr_path) iw, ih = qr.get_size() w, h = self.img.size l = (w - iw) / 2 t = h - ih - (h / 6) Screen.get_instance().get_window().blit(qr, (l, t)) txt = Screen.create_text(Strings.get("Last picture :"), ResourceManager.get(Config.get("font")), Config.get("qrcode")["text_size"], Config.get("text_color")) iw, ih = txt.get_size() l = (w - iw) / 2 t -= ih + 5 Screen.get_instance().get_window().blit(txt, (l, t)) Screen.get_instance().update() Logger.get_instance().show_msg()
def _default_cb(self, path, img): now = time.strftime("%Y-%m-%d_%H.%M.%S") #get the current date and time for the start of the filename filename = "special_%s.jpg" % now new_path = os.path.join(SnapScene.get_folder(), filename) img = PIL.Image.open(path) pic = PIL.Image.open(ResourceManager.get(self.selected_overlay)) img.paste(pic, (0, 0), pic) img.save(new_path) if not os.path.isfile(path): Logger.log_error("File '%s' was not created" % path) else: img = Screen.get_instance().create_image("tmp") img.load(new_path) img.adapt_to_screen() Scene.show(self, img) SnapScene.create_qrcode(filename, "cache/last_qrcode.png") to_wait = Config.get("picture_show_delay") if to_wait > 0: time.sleep(to_wait) SceneManager.get_instance().show_main_scene()
def _default_cb(self, img): now = time.strftime( "%Y-%m-%d_%H.%M.%S" ) #get the current date and time for the start of the filename filename = "photomaton_%s.jpg" % now path = os.path.join(SnapScene.get_folder(), filename) self.img.save(path) if not os.path.isfile(path): Logger.log_error("File '%s' was not created" % path) else: img = Screen.get_instance().create_image("tmp") img.load(path) img.adapt_to_screen() Scene.show(self, img) SnapScene.create_qrcode( filename, os.path.join(ResourceManager.get_instance().get_folder(), "last_qrcode.png")) to_wait = Config.get("picture_show_delay") if to_wait > 0: time.sleep(to_wait) SceneManager.get_instance().show_main_scene()
from Renderer import Renderer from Animation import Animation from TransformationGraph import Transform from ResourceManager import ResourceManager #-------------------------------------------------------# window = pyglet.window.Window(800, 600) winDimensions = [800, 600] rendMan = Renderer(winSize=winDimensions) Renderer.activeRenderer = rendMan sg = rendMan.getSceneGraph() rm = ResourceManager("Tests\\data") ResourceManager.activeManager = rm rm.registerExtension(".jpg", "img", ["img"], pyglet.image.load) rm.registerExtension(".bmp", "img", ["img"], pyglet.image.load) rm.registerExtension(".png", "img", ["img"], pyglet.image.load) rm.registerExtension(".anim", "anim", ["anim"], Animation) anim1 = rm.request("CharizardEvolve.anim") anim2 = rm.request("PShip.anim") s1 = Sprite(anim1, t=sg.newTransform()) s2 = Sprite(anim2, t=sg.newTransform(t=vec(-200, 100))) s1.setAnimation("Alternating") s2.setAnimation("Looping")
from scenes.SelectModeScene import SelectModeScene from scenes.SettingsScene import SettingsScene from scenes.SnapScene import SnapScene from scenes.SnapPhotomatonScene import SnapPhotomatonScene from scenes.SnapSpecialScene import SnapSpecialScene from scenes.SelectEffectScene import SelectEffectScene def quit(): Logger.log_info("Quit") SceneManager().get_instance().stop() return True if __name__ == "__main__": Strings.get_instance().load(ResourceManager.get( Config.get("strings_file"))) camera = Camera() arduino = Arduino() Screen.get_instance().init(camera) try: camera.start() arduino.start() try: arduino.register_callback(Arduino.BUTTON_3, quit, Config.get("halt_delay")) sm = SceneManager().get_instance() sm.add_scene(WelcomeScene(arduino)) sm.add_scene(SettingsScene(arduino)) sm.add_scene(SelectModeScene(arduino)) sm.add_scene(SnapScene(arduino, camera))
def _readImage(self, line): rm = ResourceManager.getRM() image = rm.request(resId=line) return image
metavar='-m', type=int, default=536870912, help='Max file size (in bytes) to allow users to upload.') parser.add_argument('--port', metavar='-p', type=int, default=5000, help='Port number to listen on.') parser.add_argument('--deploy', action='store_true', help='Deploy to accept incoming connections.') args = parser.parse_args() resource_manager = ResourceManager(num_processes=args.num_workers, resource_lifespan=args.resource_expiration, job_lifespan=args.job_expiration) def sigint_handler(sig, frame): print('Shutting down...') resource_manager.shutdown() sys.exit(0) # register sigint handler signal.signal(signal.SIGINT, sigint_handler) resource_manager.start() application = Flask(__name__)
from ResourceManager import ResourceManager from Animation import Animation from Sprite import Sprite #-------------------------------------------------------# window = pyglet.window.Window(800, 600) winDimensions = [800, 600] rendMan = Renderer(winSize=winDimensions) Renderer.activeRenderer = rendMan sg = rendMan.getSceneGraph() rm = ResourceManager("Tests\\data") ResourceManager.activeManager = rm rm.registerExtension(".jpg", "img", ["img"], pyglet.image.load) rm.registerExtension(".bmp", "img", ["img"], pyglet.image.load) rm.registerExtension(".png", "img", ["img"], pyglet.image.load) rm.registerExtension(".anim", "anim", ["anim"], Animation) im = rm.request("C:/Users/John/Pictures/Lake.jpg") sp = pyglet.sprite.Sprite(im) sp2 = Sprite(im, t=sg.newTransform()) pyglet.gl.glClearColor(1,0,1,0); def update(dt): pass
from Renderer import Renderer from Animation import Animation from TransformationGraph import Transform from ResourceManager import ResourceManager #-------------------------------------------------------# window = pyglet.window.Window(800, 600) winDimensions = [800, 600] rendMan = Renderer(winSize=winDimensions) Renderer.activeRenderer = rendMan sg = rendMan.getSceneGraph() rm = ResourceManager("Tests\\data") ResourceManager.activeManager = rm rm.registerExtension(".jpg", "img", ["img"], pyglet.image.load) rm.registerExtension(".bmp", "img", ["img"], pyglet.image.load) rm.registerExtension(".png", "img", ["img"], pyglet.image.load) rm.registerExtension(".anim", "anim", ["anim"], Animation) anim1 = rm.request("CharizardEvolve.anim") anim2 = rm.request("PShip.anim") s1 = Sprite(anim1, t=sg.newTransform()) s2 = Sprite(anim2, t=sg.newTransform(t=vec(-200,100))) s1.setAnimation("Alternating") s2.setAnimation("Looping")
def _readImage(self, line): rm = ResourceManager.getRM() image = rm.request(resId = line) return image
def __init__(self): self.__web_generator = WebGenerator() self.__resource_manager = ResourceManager() self.__encoding = "UTF-8"
class Crawler: def __init__(self, city, dst_dir, log_path, time_slot): self.res = ResourceManager("./resource", city) self.city = city self.try_times = 3 self.base_url = "http://restapi.amap.com/v3/traffic/status/rectangle" self.params = { 'key': None, 'rectangle': None, 'extensions': 'all', 'level': 6 } self.dst_dir = dst_dir self.time_slot = time_slot self.data = None Logging.init_log(log_path) def get_request_url(self, boxID): box = self.res.get_city_box(boxID) box = "%s,%s;%s,%s" % tuple(box) self.params['rectangle'] = box self.params['key'] = self.res.get_key() str_params = urlencode(self.params) url = '%s?%s' % (self.base_url, str_params) return url @classmethod def __request__(cls, url): try: f = urlopen(url, timeout=30) except: return None try: data = f.read() data = data.decode("utf-8") data = json.loads(data) except: return None return data def request(self, boxID): url = self.get_request_url(boxID) data = None res = 0 for i in range(self.try_times): data = self.__request__(url) if data is not None and data['info'] == "OK": break else: logging.warning( "fail to get %s data in region %s_%s, try again..." % (self.city, boxID[0], boxID[1])) if data is None or data['info'] != "OK": res = 1 logging.error( "fail to get %s data in region %s_%s after trying %s times..." % (self.city, boxID[0], boxID[1], self.try_times)) return data, res def save(self, t): data_path = os.path.join(self.dst_dir, self.city) if not os.path.isdir(data_path): os.mkdir(data_path) data_path = os.path.join(data_path, "%s.json" % t) with open(data_path, 'w', encoding='utf-8') as f: try: json.dump(self.data, f, ensure_ascii=False, indent=4) logging.info("save %s data success" % self.city) except: logging.warning("save %s data fail" % self.city) def run(self): lngNum, latNum = self.res.get_lat_lng_num() self.data = {} miss = 0 start_time = time.time() for i in range(lngNum): for j in range(latNum): boxID = [i, j] self.data["%s_%s" % tuple(boxID)], tmp = self.request(boxID) miss += tmp self.save(start_time) elapse_time = time.time() - start_time return elapse_time, miss