def get_country_details(self, country): """Returns country code(alpha_3) and continent""" try: country_obj = pycountry.countries.get(name=country) if country_obj is None: c = pycountry.countries.search_fuzzy(country) country_obj = c[0] continent_code = pc.country_alpha2_to_continent_code( country_obj.alpha_2) continent = pc.convert_continent_code_to_continent_name( continent_code) return country_obj.alpha_3, continent except: if 'Congo' in country: country = 'Congo' if country == 'Mainland China': country = 'China' elif country == 'Diamond Princess' or country == 'Laos' or country == 'MS Zaandam' or country == 'Holy See' or country == 'Timor-Leste': return country, country elif country == 'Korea, South' or country == 'South Korea': country = 'Korea, Republic of' elif country == 'Taiwan*': country = 'Taiwan' elif country == 'Burma': country = 'Myanmar' elif country == 'West Bank and Gaza': country = 'Gaza' else: return country, country country_obj = pycountry.countries.search_fuzzy(country) continent_code = pc.country_alpha2_to_continent_code( country_obj[0].alpha_2) continent = pc.convert_continent_code_to_continent_name( continent_code) return country_obj[0].alpha_3, continent
def all_countries(self): resp = requests.get(self.all) json = resp.json() first = json[0]['CountryCode'] last10daysAll = [] last10daysSpecific = [] for i in json: if i['CountryCode'] == first: try: code = pc.country_alpha2_to_continent_code(i['CountryCode']) last10daysSpecific.append((code,i['Confirmed'])) except: pass else: last10daysSpecific = last10daysSpecific[-10:] if (len(last10daysSpecific) != 0): last10daysAll.append(last10daysSpecific) last10daysSpecific.clear() first = i['CountryCode'] try: code = pc.country_alpha2_to_continent_code(i['CountryCode']) last10daysSpecific.append((code,i['Confirmed'])) except: pass print(json)
def get_continent(country): """ DESCRIPTION: return continent code given country name. INPUT: country - (str) country name OUTPUT: continent_code - (str) continent code for country """ try: #get country code country_code = pc.country_name_to_country_alpha2( country, cn_name_format="default") # get continent code continent_code = pc.country_alpha2_to_continent_code(country_code) except: # given that there are only two countries that cause an exception # it's easy to deal with them manually if country == 'The Bahamas': return 'NA' elif country == 'Myanmar (Burma)': return 'AS' # Redundant case else: print('Something Went Wrong') return -1 return continent_code
def execute_dtw(df_period_group, compare_group): dtw_results = [] for country in df_period_group: try: country_code = pc.country_name_to_country_alpha2( country[0], cn_name_format="default") except Exception as e: print(country[0], "has error", e) continue try: continent_name = pc.country_alpha2_to_continent_code(country_code) except Exception as e: print(country[0], "has error", e) continue try: result = dtw.dtw(compare_group["StringencyIndex"], country[1]["StringencyIndex"]) except Exception as e: print(country[0], "has error", e) continue dtw_results.append([ country[0], continent_name, result.distance, result.normalizedDistance ]) dtw_df = pd.DataFrame( data=dtw_results, columns=["Country", "Continent", "Distance", "Normalized_distance"], ) return dtw_df
def get_continent_name(code): # Input: # -- code: iso alpha 3 country code # Output: # -- continent: name of the continent # Create continent variable continent = np.nan # Convert iso alpha 3 code to iso alpha 2 code country_code = alpha3_to_alpha2(code) if country_code == 'VA': country_code = 'IT' elif country_code == 'SX': country_code = 'NL' # Convert is alpha 2 code to continent code continent_code = pc.country_alpha2_to_continent_code(country_code) # Convert continent code to continent name if continent_code == 'NA': continent = 'North America' elif continent_code == 'SA': continent = 'South America' elif continent_code == 'AF': continent = 'Africa' elif continent_code == 'AS': continent = 'Asia' elif continent_code == 'EU': continent = 'Europe' # Return continent name return continent
def classify_Ark_probes_per_continent(List_probes): ## Classifies Ark probes per continent and stores them into corresponding files Dict_cont_probe = {} continents = { 'NA': 'North_America', 'SA': 'South_America', 'AS': 'Asia', 'OC': 'Oceania_Australia', 'AF': 'Africa', 'EU': 'Europe' } i = 0 for probe in List_probes: tab = probe.split('-') cont = '' try: cont = pc.country_alpha2_to_continent_code(str(tab[1]).upper()) #i+=1 except: if str(tab[1]).upper() == 'UK': cont = 'EU' #i+=1 pass print ("The probe " + probe + " is in " + cont) ## store in a dictionary if continents[cont] in Dict_cont_probe: Dict_cont_probe[continents[cont]].append(probe)
def get_continents(self, country_name): continents_table = { "AS": "Asia", "EU": "Europe", "NA": "North-America", "SA": "South-America", "AF": "Africa", "OC": "Oceania" } countries_not_found_table = { "England": "Europe", "Wales": "Europe", "Scotland": "Europe", "Northern Ireland": "Europe", "Kosovo": "Europe", "Chinese Taipei": "Asia", "Palestinian territories": "Asia", "East Timor": "Asia", "Netherlands Antilles": "South-America", "Saint Helena": "Africa" } try: iso2_cname = pycc.country_name_to_country_alpha2(country_name) continent_code = pycc.country_alpha2_to_continent_code(iso2_cname) return continents_table.get(continent_code) except KeyError: return countries_not_found_table.get(country_name)
def get_continent(row): """ retrieve the continent data for a given row """ if row['Country Name'] in [ 'Bahamas, The', 'Curacao', 'Sint Maarten (Dutch part)', 'St. Kitts and Nevis', 'St. Lucia', 'St. Martin (French part)', 'St. Vincent and the Grenadines', 'Virgin Islands (U.S.)' ]: return 'NA' elif row['Country Name'] in [ 'Channel Islands', 'Czech Republic', 'Faeroe Islands', 'Kosovo', 'Macedonia, FYR', 'Moldova', 'Slovak Republic' ]: return 'EU' elif row['Country Name'] in [ 'Hong Kong SAR, China', 'Iran, Islamic Rep.', 'Korea, Dem. Rep.', 'Korea, Rep.', 'Kyrgyz Republic', 'Lao PDR', 'Macao SAR, China', 'Micronesia, Fed. Sts.', 'Timor-Leste', 'Vietnam', 'West Bank and Gaza', 'Yemen, Rep.' ]: return 'AS' elif row['Country Name'] in [ 'Congo, Dem. Rep.', 'Congo, Rep.', "Cote d'Ivoire", 'Egypt, Arab Rep.', 'Tanzania', 'Gambia, The' ]: return 'AF' elif row['Country Name'] in ['Bolivia', 'Venezuela, RB']: return 'SA' else: return pycountry_convert.country_alpha2_to_continent_code( pycountry.countries.get(name=row['Country Name']).alpha_2)
def addContinent(self, df): df['Continent'] = df.apply( lambda row: pc.convert_continent_code_to_continent_name( pc.country_alpha2_to_continent_code( pc.country_name_to_country_alpha2( row.country, cn_name_format="default"))), axis=1)
def add_continent_name(self) -> None: """ Adds a continent name to this tweet. """ if self.has_continent_name(): # already has a continent name return if self.country_code is None or len(self.country_code) != 2: # incorrect country code self.continent: None = None return if self.country_code == 'AQ': # special case self.continent: str = 'Antarctica' return try: # return continent name from country code self.continent: str = convert_continent_code_to_continent_name( country_alpha2_to_continent_code(self.country_code)) return except: # return None if this fails self.continent: None = None return
def continents(elem): if elem == 'Mainland China': return 'China' if elem == 'US': return 'Nordamerika' if elem == 'UK': return 'Europa' if elem == 'Others': return 'Andere' try: country_code = pc.country_name_to_country_alpha2( elem, cn_name_format="default") continent_name = pc.country_alpha2_to_continent_code(country_code) if continent_name == "NA": return 'Nordamerika' if continent_name == 'EU': return "Europa" if continent_name == 'AS': return "Asien" if continent_name == 'AF': return "Afrika" if continent_name == 'OC': return "Ozeanien" return continent_name except: return elem
def main(): data = read_file('internet.csv') incomeperperson = pd.Series(get_variable(data, "incomeperperson")) internetuserate = pd.Series(get_variable(data, "internetuserate")) urbanrate = pd.Series(get_variable(data, "urbanrate")) incomeperperson_vs_internetuserate = internetuserate.corr(incomeperperson) urbanrate_vs_internetuserate = internetuserate.corr(urbanrate) urbanrate_vs_incomeperperson = incomeperperson.corr(urbanrate) print(incomeperperson_vs_internetuserate) print(urbanrate_vs_internetuserate) print(urbanrate_vs_incomeperperson) continents = { 'NA': 'North America', 'SA': 'South America', 'AS': 'Asia', 'OC': 'Australia', 'AF': 'Africa', 'EU': 'Europe' } for point in data: country_code = pc.country_name_to_country_alpha2(point['country'], cn_name_format="default") continent_code = pc.country_alpha2_to_continent_code(country_code) point['continent'] = continents[continent_code] write_file(data)
def get_continent(country): try: country_code = pc.country_name_to_country_alpha2( country, cn_name_format='default') return pc.country_alpha2_to_continent_code(country_code) except (KeyError, TypeError): return country
def geolocator_process(loc_string): """ user location will be determent by the geo-locator library. it receives the users location as written in the web converts it to latitude and longitude then it will be called again to convert the latitude and longitude to a global unique name of country and continent. """ country, continent = None, None # initiate the returned variables loc = geolocator.geocode(loc_string) if loc: lat, lon = loc.latitude, loc.longitude time.sleep(config.SLEEP_TIME_FOR_LOCATIONS_API) try: new_loc = geolocator.reverse([lat, lon], language='en') country = new_loc.raw["address"]["country"] continent = config.continents_dict[ country_alpha2_to_continent_code( country_name_to_country_alpha2(country))] except TypeError: logger.warning( config.USER_PROBLEMATIC_COUNTRY.format(loc_string)) except KeyError: if country in config.KNOWN_COUNTRIES: country, continent = config.KNOWN_COUNTRIES[country] finally: time.sleep(config.SLEEP_TIME_FOR_LOCATIONS_API) return country, continent
def test_country_alpha2_to_continent(self): cn_continent = country_alpha2_to_continent_code('US') assert (cn_continent) assert (cn_continent == 'NA') cn_continent = country_alpha2_to_continent_code('AU') assert (cn_continent) assert (cn_continent == 'OC') cn_continent = country_alpha2_to_continent_code('NZ') assert (cn_continent) assert (cn_continent == 'OC') cn_continent = country_alpha2_to_continent_code('JP') assert (cn_continent) assert (cn_continent == 'AS')
def get_country_continent_from_address(address_dict): """ Takes address dictionary (from 'get_address_by_location'), returns country """ # dictionary of continent names: continent_name_dict = { "AF": "Africa", "AS": "Asia", "NA": "North America", "SA": "South America", "OC": "Oceania", "EU": "Europe" } # get info from address dict address = address_dict["address"] country = address["country"] # get continent country_code = pc.country_name_to_country_alpha2(country, cn_name_format="default") continent_abbreviation = pc.country_alpha2_to_continent_code(country_code) continent_name = continent_name_dict[continent_abbreviation] return [country, continent_name]
def reverse_geocode(lat, lng): reverse_data = geocoder.osm_reverse.OsmReverse((lat, lng)).geojson country = None city = None continent = None try: feature_properties = reverse_data['features'][0]['properties'] cc = feature_properties['country_code'].upper() city = None if "city" in feature_properties: city = feature_properties['city'] elif "town" in feature_properties: city = feature_properties["town"] elif "state" in feature_properties: city = feature_properties['state'] elif "county" in feature_properties: city = feature_properties['county'] country = pycountry.countries.get(alpha_2=cc).name continent_code = country_alpha2_to_continent_code(cc) continent = convert_continent_code_to_continent_name(continent_code) except: return None, None, None else: return continent, country, city
def country_to_continent(country_name): country_alpha2 = pc.country_name_to_country_alpha2(country_name) country_continent_code = pc.country_alpha2_to_continent_code( country_alpha2) country_continent_name = pc.convert_continent_code_to_continent_name( country_continent_code) return country_continent_name
def gather(self, data_name): """Importing and cleaning OECD. returns istat as pandas.dataframe""" # Import, Rename, adjust values in million oecd = pd.read_csv(f'data/OECD_{data_name}.csv') oecd.rename(columns={ 'LOCATION': 'Country', 'TIME': 'Year', 'Value': data_name }, inplace=True) oecd['Country'] = oecd['Country'].apply(lambda x: x.split(' ')[ 0] if re.match(r'[France|Germany].*', x) else x) oecd[data_name] = oecd[data_name].apply( lambda value: float(value * 1000000)) # Kick out every country with the wrong code len (they're not in europe anyways) & not in europe oecd = oecd[oecd['Country'].apply(lambda x: len(x) == 3)] oecd = oecd[oecd['Country'].apply( lambda x: pc.country_alpha2_to_continent_code( country_2_code=pc.country_alpha3_to_country_alpha2(x )) == 'EU')] # Turn country codes to full country names oecd['Country'] = oecd['Country'].apply( lambda x: pc.map_country_alpha3_to_country_name()[x]) oecd.set_index(['Country', 'Year'], inplace=True) oecd.sort_index(inplace=True) oecd = pd.DataFrame(oecd[data_name]) self.data.append(oecd)
def country_to_continent(): country_name = input("country name = ") country_alpha2 = pc.country_name_to_country_alpha2(country_name) country_continent_code = pc.country_alpha2_to_continent_code( country_alpha2) country_continent_name = pc.convert_continent_code_to_continent_name( country_continent_code) print(country_continent_name)
def country_code_to_continent(self, country_code_iso2: str) -> str: """ Convert country code iso2 to country code iso2 continent """ try: continent = pc.country_alpha2_to_continent_code(country_code_iso2) except: continent = 'Other' return continent
def country_to_continent(country_name): "Convert country name string to continent" country_alpha2 = pcc.country_name_to_country_alpha2(country_name) country_continent_code = pcc.country_alpha2_to_continent_code( country_alpha2) country_continent_name = pcc.convert_continent_code_to_continent_name( country_continent_code) return country_continent_name
def get_regions_by_markets(markets: list): regions: list = [] try: regions = list(set([ pc.country_alpha2_to_continent_code(country_code) for country_code in markets])) except Exception as e: logger.error(e) return regions
def get_continent(country_code): if country_code =='VA': return 'Europe' if country_code =='TL': return 'Asia' else: continent_name = pc.country_alpha2_to_continent_code(country_code) country_continent_name = pc.convert_continent_code_to_continent_name(continent_name) return country_continent_name
def load_master_data(): """ Continent details for each city from weatherbit metadata is pulled using pycountry_convert API and stored in city_country_mdata table. :return void: """ db_name = "postgres" db_password = "******" db_user = "******" db_host = "localhost" root_dir = os.path.dirname(os.path.dirname(os.path.realpath(__file__))) filepath = os.path.join(root_dir, "data") data = pd.read_csv(os.path.join(filepath, "cities_all.csv")) data["city_country"] = data["city_name"].str.cat(data["country_full"], sep=", ") data = data.dropna() try: conn = psycopg2.connect(dbname=db_name, password=db_password, user=db_user, host=db_host) cur = conn.cursor() for item in data.itertuples(): continent_flag = 0 continent_name = "" if re.sub("[^a-zA-Z0-9, ]+", "", item[8]): try: country_code = pc.country_name_to_country_alpha2( item[5], cn_name_format="default") continent_name = pc.country_alpha2_to_continent_code( country_code) except: continent_flag = 1 if continent_flag == 0: # query = """ INSERT INTO city_country_mdata (lat, lon, citycountry, continent) VALUES (%s,%s,%s,%s) """ record = (item[6], item[7], re.sub("[^a-zA-Z0-9, ]+", "", item[8]), continent_name) cur.execute(query, record) conn.commit() conn.close() except Exception as e: print("Exiting load_master_data due to exception: ", e.__class__) finally: if conn: cur.close() conn.close()
def country_alpha2_to_continent(country_alpha2): """Map country name to continent""" try: continent_code = country_alpha2_to_continent_code(country_alpha2) except: continent_code = "N/A" return (continent_code)
def readLocation(): memoizedDict = {} # index = 0 for fileName in alignScores: tempdf = pd.read_csv(fileName) outfileName = "relativeDistAll" + fileName # initialize geoLocation = [] relativeDistance = [] ascensionNumL = [] countryCodeL = [] continentCodeL = [] # get relative distance # for index in range(1000): for index in range(len(tempdf["Location"])): print(index) location = tempdf["Location"][index] ascensionNumL.append(tempdf["AscensionNum"][index]) # check memo dictionary to see if we've already done this loc # note that if geolocation is none we just ignore it if not location in memoizedDict.keys(): currentGeo = findGeocode(location) # save relative distance if currentGeo != None: latitudeLongitude = (currentGeo.latitude, currentGeo.longitude) geolocator = Nominatim(user_agent="your_app_name") longlat = geolocator.reverse( [currentGeo.latitude, currentGeo.longitude]) countryCode = longlat.raw['address']['country_code'] continentCode = country_alpha2_to_continent_code( countryCode.upper()) if continentCode == "NA": continentCode = "NorthA" if type(currentGeo) != float: memoizedDict[location] = (distance( originPoint, latitudeLongitude), currentGeo, countryCode, continentCode) else: memoizedDict[location] = (0, currentGeo, countryCode, continentCode) relativeDistance.append(memoizedDict[location][0]) geoLocation.append(memoizedDict[location][1]) countryCodeL.append(memoizedDict[location][2]) continentCodeL.append(memoizedDict[location][3]) # Now add the column to dataframe currentOutputDF = pd.DataFrame({ "geoLocation": geoLocation, "relativeDistance": relativeDistance, "AscensionNum": ascensionNumL, "countryCode": countryCodeL, "continentCode": continentCodeL }) # And output the df to a new csv file. currentOutputDF.to_csv(outfileName)
def country_alpha2_to_continent_code(a2): if a2 == 'AQ': return 'AN' elif a2 == 'TF': return 'AF' elif a2 == 'EH': return 'AF' elif a2 == 'PN': return 'OC' elif a2 == 'SX': return 'NA' elif a2 == 'TL': return 'AS' elif a2 == 'UM': return 'NA' elif a2 == 'VA': return 'EU' else: return pc.country_alpha2_to_continent_code(a2)
def country_to_continent(country_name): country_continent_name = "" try: country_alpha2 = pc.country_name_to_country_alpha2(country_name) country_continent_code = pc.country_alpha2_to_continent_code(country_alpha2) country_continent_name = pc.convert_continent_code_to_continent_name(country_continent_code) except: pass return country_continent_name
def get_continent(col): try: cn_a2_code = country_name_to_country_alpha2(col) except: cn_a2_code = 'Unknown' try: cn_continent = country_alpha2_to_continent_code(cn_a2_code) except: cn_continent = 'Unknown' return (cn_a2_code, cn_continent)