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
