def climacell( city: str, api_key: Optional[str] = None, first_attempt: bool = True ) -> None: logging.info(f"Sending request for '{city}' to ClimaCell API.") if api_key is None: try: api_key = keys.climacell_api_key except Exception as err: logging.error("Unable to get API key for ClimaCell.") logging.error(err) return coords = get_coordinates(city) try: forecast = cc.get_climacell_data( lat=coords.lat, long=coords.long, api_key=api_key ) fp = save_data("climacell", city, forecast) logging.info(f"Saved results to '{fp.as_posix()}'") except HTTPError as http_err: logging.error(f"ClimaCell API request error ({http_err.response.status_code}).") logging.error(http_err.response.json()["message"]) if first_attempt: logging.info("Retrying request to ClimaCell.") climacell(city=city, api_key=api_key, first_attempt=False) except Exception as err: logging.error(err)
def accuweather( city: str, api_key: Optional[str] = None, first_attempt: bool = True ) -> None: logging.info(f"Sending request for '{city}' to AccuWeather API.") if api_key is None: try: api_key = keys.accuweather_api_key except Exception as err: logging.error("Unable to get API key for AccuWeather.") logging.error(err) return coords = get_coordinates(city) try: forecast = accu.get_accuweather_forecast( lat=coords.lat, long=coords.long, api_key=api_key ) fp = save_data(source="accuweather", city=city, data=forecast) logging.info(f"Saved results to '{fp.as_posix()}'") except HTTPError as http_err: logging.error( f"AccuWeather API request error ({http_err.response.status_code})." ) logging.error(http_err.response.json()["Message"]) if first_attempt and http_err.response.status_code != 503: logging.info("Retrying request to AccuWeather.") accuweather(city=city, api_key=api_key, first_attempt=False) except Exception as err: logging.error(err)
def open_weather_map( city: str, api_key: Optional[str] = None, first_attempt: bool = True ) -> None: logging.info(f"Sending request for '{city}' to OpenWeatherMap API.") if api_key is None: try: api_key = keys.openweathermap_api_key except Exception as err: logging.error("Unable to get API key for OpenWeatherMap.") logging.error(err) return coords = get_coordinates(city) try: forecast = owm.get_openweathermap_data( lat=coords.lat, long=coords.long, api_key=api_key ) fp = save_data("open-weather-map", city, forecast) logging.info(f"Saved results to '{fp.as_posix()}'") except HTTPError as http_err: logging.error( f"OpenWeatherMap API request error ({http_err.response.status_code})." ) logging.error(http_err.response.json()["detail"]) if first_attempt: logging.info("Retrying request to OpenWeatherMap.") open_weather_map(city=city, api_key=api_key, first_attempt=False) except Exception as err: logging.error(err)
def get_weather(): #if coordinates.get_coordinates() in coordinates: lat, lng = (coordinates.get_coordinates()) api_key = "e0a60102f41a97b05ea6fe58b5b5fbd0" host = "https://api.darksky.net/forecast/" url = host + api_key + "/" + str(lat) + "," + str(lng) response = requests.get(url) utc_time = (response.json()["currently"]["time"]) current_time = datetime.datetime.fromtimestamp(utc_time) print("Current Time: ", current_time) weather_summary = response.json()["currently"]["summary"] print("Current Weather: ", weather_summary) current_temp = response.json()["currently"]["temperature"] print("Current Temperature: ", current_temp) future_hourly = response.json()["hourly"]["data"] print("Hourly future updates") for i in future_hourly: time = datetime.datetime.fromtimestamp(i['time']) summary = i['summary'] print("{0} : {1}".format(str(time), summary))
def providers_map(): if ('session_id' not in session): abort(400) center, provider_array = get_coordinates(plan_id=request.args.get("plan_id"), zipcode=session['zipcode'], state=session['state']) response= dict(center=center, provider_array = provider_array) return render_template('providers_map.html', response=response)
def national_weather_service(city: str, n_attempt: int = 1) -> None: logging.info(f"Sending request for '{city}' to NWS API.") coords = get_coordinates(city) try: forecast = nws.get_nws_forecast(lat=coords.lat, long=coords.long) fp = save_data(source="national-weather-service", city=city, data=forecast) logging.info(f"Saved results to '{fp.as_posix()}'") except HTTPError as http_err: logging.error(f"NWS API request error ({http_err.response.status_code}).") logging.error(http_err) if n_attempt <= 5 and http_err.response.status_code != 404: logging.info("Trying NWS API again.") national_weather_service(city=city, n_attempt=n_attempt + 1) except Exception as err: logging.error(err)
def find_nearest(home_location): home_coordinates = get_coordinates(home_location) for center in full_centers_json: distance = distanceLatLong.distance_calc( home_coordinates, center['physical_address'][0]['Coordinates']) if len(center['regular_schedule']) > 0: distance_array.append([ distance, center['alternate_name'], center['physical_address'][0]['address_1'], center['phones'][0]['number'], center['regular_schedule'] ]) else: distance_array.append([ distance, center['alternate_name'], center['physical_address'][0]['address_1'], center['phones'][0]['number'] ]) distance_array.sort() print(print_center(distance_array.pop(0)))
def train(opt: Options): real_label = 1 fake_label = 0 netG = Generator(opt) netD = Discriminator(opt) print(netG) print(netD) netG.apply(weights_init_g) netD.apply(weights_init_d) # summary(netD, (opt.c_dim, opt.x_dim, opt.y_dim)) dataloader = load_data(opt.data_root, opt.x_dim, opt.y_dim, opt.batch_size, opt.workers) x, y, r = get_coordinates(x_dim=opt.x_dim, y_dim=opt.y_dim, scale=opt.scale, batch_size=opt.batch_size) optimizerD = optim.Adam(netD.parameters(), lr=opt.lr, betas=(opt.beta1, opt.beta2)) optimizerG = optim.Adam(netG.parameters(), lr=opt.lr, betas=(opt.beta1, opt.beta2)) criterion = nn.BCELoss() # criterion = nn.L1Loss() noise = torch.FloatTensor(opt.batch_size, opt.z_dim) ones = torch.ones(opt.batch_size, opt.x_dim * opt.y_dim, 1) input_ = torch.FloatTensor(opt.batch_size, opt.c_dim, opt.x_dim, opt.y_dim) label = torch.FloatTensor(opt.batch_size, 1) input_ = Variable(input_) label = Variable(label) noise = Variable(noise) if opt.use_cuda: netG = netG.cuda() netD = netD.cuda() x = x.cuda() y = y.cuda() r = r.cuda() ones = ones.cuda() criterion = criterion.cuda() input_ = input_.cuda() label = label.cuda() noise = noise.cuda() noise.data.normal_() fixed_seed = torch.bmm(ones, noise.unsqueeze(1)) def _update_discriminator(data): # for p in netD.parameters(): # p.requires_grad = True # to avoid computation netD.zero_grad() real_cpu, _ = data input_.data.copy_(real_cpu) label.data.fill_(real_label-0.1) # use smooth label for discriminator output = netD(input_) errD_real = criterion(output, label) errD_real.backward() D_x = output.data.mean() # train with fake noise.data.normal_() seed = torch.bmm(ones, noise.unsqueeze(1)) fake = netG(x, y, r, seed) label.data.fill_(fake_label) output = netD(fake.detach()) # add ".detach()" to avoid backprop through G errD_fake = criterion(output, label) errD_fake.backward() # gradients for fake/real will be accumulated D_G_z1 = output.data.mean() errD = errD_real + errD_fake optimizerD.step() # .step() can be called once the gradients are computed return fake, D_G_z1, errD, D_x def _update_generator(fake): # for p in netD.parameters(): # p.requires_grad = False # to avoid computation netG.zero_grad() label.data.fill_(real_label) # fake labels are real for generator cost output = netD(fake) errG = criterion(output, label) errG.backward() # True if backward through the graph for the second time D_G_z2 = output.data.mean() optimizerG.step() return D_G_z2, errG def _save_model(epoch): os.makedirs(opt.models_root, exist_ok=True) if epoch % 1 == 0: torch.save(netG.state_dict(), os.path.join(opt.models_root, "G-cppn-wgan-anime_{}.pth".format(epoch))) torch.save(netD.state_dict(), os.path.join(opt.models_root, "D-cppn-wgan-anime_{}.pth".format(epoch))) def _log(i, epoch, errD, errG, D_x, D_G_z1, D_G_z2, delta_time): print('[%d/%d][%d/%d] Loss_D: %.4f Loss_G: %.4f D(x): %.4f D(G(z)): %.4f / %.4f Elapsed %.2f s' % (epoch, opt.iterations, i, len(dataloader), errD.data.item(), errG.data.item(), D_x, D_G_z1, D_G_z2, delta_time)) def _save_images(i, epoch): os.makedirs(opt.images_root, exist_ok=True) if i % 100 == 0: fake = netG(x, y, r, fixed_seed) fname = os.path.join(opt.images_root, "fake_samples_{:02}-{:04}.png".format(epoch, i)) vutils.save_image(fake.data[0:64, :, :, :], fname, nrow=8) def _start(): print("Start training") for epoch in range(opt.iterations): for i, data in enumerate(dataloader, 0): start_iter = time.time() fake, D_G_z1, errD, D_x = _update_discriminator(data) D_G_z2, errG = _update_generator(fake) end_iter = time.time() _log(i, epoch, errD, errG, D_x, D_G_z1, D_G_z2, end_iter - start_iter) _save_images(i, epoch) _save_model(epoch) _start()
#!/usr/bin/env python from __future__ import print_function from coordinates import get_coordinates from coordinates import calculate_distances import numpy as np np.set_printoptions(linewidth=100) if __name__ == '__main__': with open('data.txt', 'r') as f: coordinates = get_coordinates(f) part_2_max = 10000 debug = False if debug: from coordinates import test_data coordinates = get_coordinates(test_data) part_2_max = 32 # coordinates.shape = (#coords, 2) distance = calculate_distances(coordinates) # distance.shape == (#coords, x_max, y_min) if debug: # This should yield the answer from the example on AoC.
def __init__(self, opt: Options) -> None: self.opt = opt self.x, self.y, self.r = get_coordinates(opt.x_dim, opt.y_dim, scale=opt.scale, batch_size=opt.batch_size)
from coordinates import get_coordinates from connections import get_connections from estimators import estimate from renderers import draw if __name__ == '__main__': heatmaps_path = './resources/heatmaps.npy' paf_path = './resources/pafs.npy' example_img_path = 'resources/ski.jpg' output_img_path = 'output.jpg' example_image = cv2.imread(example_img_path) heatmaps = np.load(heatmaps_path) paf = np.load(paf_path) cfg = get_default_configuration() coordinates = get_coordinates(cfg, heatmaps) connections = get_connections(cfg, coordinates, paf) skeletons = estimate(cfg, connections) output = draw(cfg, example_image, coordinates, skeletons) cv2.imwrite(output_img_path, output) print(f"Output image: {output_img_path}")
from coordinates import get_coordinates import pyautogui import time import cv2 import matplotlib.pyplot as plt if __name__ == "__main__": target_test_coordinates = (1500, 1500) scanned_image = Image.open("ObjectToBeSegemented/object6.jpg") if scanned_image.size[0] > 1024 or scanned_image.size[1] > 1024: scanned_image.thumbnail((1024, 1024)) size = scanned_image.size res = run(np.array(scanned_image), size) mask = res.convert("L") empty = Image.new("RGBA", size, 0) scanned_image = Image.composite(scanned_image, empty, mask) scanned_image.show() print("scanning ends here") time.sleep(4) img1 = cv2.imread("Screenshots/photo.jpg") img2 = pyautogui.screenshot() img2 = cv2.cvtColor(np.array(img2), cv2.COLOR_RGB2BGR) x, y = get_coordinates(img1, img2, target_test_coordinates) print(x, y) print("mapping complete") cv2.rectangle(img2, (x, y), (x + 5, y + 5), (0, 0, 255), 25) cv2.rectangle( img1, (target_test_coordinates[0], target_test_coordinates[1]), (target_test_coordinates[0] + 5, target_test_coordinates[1] + 5), (0, 0, 255), 25)
def __init__(self, opt: Options) -> None: self.opt = opt self.x, self.y, self.r = get_coordinates(opt.x_dim, opt.y_dim, scale=opt.scale, batch_size=opt.batch_size)