def test_geo_metadata_CANADA(self): responses.add( responses.GET, self.geo_js_url, json=GEO_METADATA_CANADA, status=200 ) geo = GeoMetadata.from_geo_js(self.geo_js_url) self.assertEqual("CAN", geo.country_iso_code) self.assertEqual("Canada", geo.country_name)
def _get_geo_metadata(self) -> GeoMetadata: return GeoMetadata( country_iso_code=self._country_iso_code, country_name=self._country_name, region=self._region, country_2letter_iso_code=self._country_2letter_iso_code, )
def get_regional_emissions_choropleth_data( self, net_energy_consumed: float, country_iso_code: str) -> List[Dict]: # add country codes here to render for different countries if country_iso_code.upper() not in ["USA"]: return [{"region_code": "", "region_name": "", "emissions": ""}] region_emissions = self._data_source.get_country_emissions_data( country_iso_code.lower()) choropleth_data = [] for region_name in region_emissions.keys(): region_code = region_emissions[region_name]["regionCode"] if region_name not in ["_unit"]: from codecarbon.core.units import Energy energy_consumed = Energy.from_energy(kwh=net_energy_consumed) from codecarbon.external.geography import GeoMetadata emissions = self._emissions.get_region_emissions( energy_consumed, GeoMetadata(country_iso_code=country_iso_code, region=region_name), ) choropleth_data.append({ "region_code": region_code, "region_name": region_name.upper(), "emissions": emissions, }) return choropleth_data
def get_global_emissions_choropleth_data( self, net_energy_consumed: float) -> List[Dict]: def formatted_energy_percentage(energy_type: float, total: float) -> float: return float("{:.1f}".format((energy_type / total) * 100)) global_energy_mix = self._data_source.get_global_energy_mix_data() choropleth_data = [] for country_iso_code in global_energy_mix.keys(): country_name = global_energy_mix[country_iso_code]["country_name"] if country_iso_code not in ["_define", "ATA"]: from codecarbon.core.units import Energy energy_consumed = Energy.from_energy(kWh=net_energy_consumed) from codecarbon.external.geography import GeoMetadata country_emissions = self._emissions.get_country_emissions( energy_consumed, GeoMetadata(country_name=country_name, country_iso_code=country_iso_code), ) total = global_energy_mix[country_iso_code]["total_TWh"] choropleth_data.append({ "iso_code": country_iso_code, "emissions": country_emissions, "country": country_name, "fossil": formatted_energy_percentage( global_energy_mix[country_iso_code]["fossil_TWh"], total), "geothermal": formatted_energy_percentage( global_energy_mix[country_iso_code]["geothermal_TWh"], total), "hydroelectricity": formatted_energy_percentage( global_energy_mix[country_iso_code] ["hydroelectricity_TWh"], total, ), "nuclear": formatted_energy_percentage( global_energy_mix[country_iso_code]["nuclear_TWh"], total), "solar": formatted_energy_percentage( global_energy_mix[country_iso_code]["solar_TWh"], total), "wind": formatted_energy_percentage( global_energy_mix[country_iso_code]["wind_TWh"], total), }) return choropleth_data
def test_get_emissions_PRIVATE_INFRA_USA_WITHOUT_COUNTRYNAME(self): # WHEN emissions = self._emissions.get_private_infra_emissions( Energy.from_energy(kwh=0.3), GeoMetadata(country_iso_code="USA")) # THEN assert isinstance(emissions, float) self.assertAlmostEqual(emissions, 0.20, places=2)
def setUp(self) -> None: # GIVEN self._energy = Energy.from_energy(kwh=10) self._geo = GeoMetadata( country_iso_code="FRA", country_name="France", region=None, country_2letter_iso_code="FR", )
def test_geo_metadata_USA(self): responses.add(responses.GET, self.geo_js_url, json=GEO_METADATA_USA, status=200) geo = GeoMetadata.from_geo_js(self.geo_js_url) self.assertEqual("USA", geo.country_iso_code) self.assertEqual("United States", geo.country_name) self.assertEqual("illinois", geo.region)
def test_get_emissions_PRIVATE_INFRA_unknown_country(self): """ If we do not know the country we fallback to a default value. """ emissions = self._emissions.get_private_infra_emissions( Energy.from_energy(kWh=1), GeoMetadata(country_iso_code="AAA", country_name="unknown"), ) assert isinstance(emissions, float) self.assertAlmostEqual(emissions, 0.475, places=2)
def test_get_emissions_PRIVATE_INFRA_USA_WITHOUT_REGION(self): # WHEN emissions = self._emissions.get_private_infra_emissions( Energy.from_energy(kWh=0.3), GeoMetadata(country_iso_code="USA", country_name="United States"), ) # THEN assert isinstance(emissions, float) self.assertAlmostEqual(emissions, 0.115, places=2)
def test_get_emissions_PRIVATE_INFRA_CANADA_WITHOUT_REGION(self): # WHEN emissions = self._emissions.get_private_infra_emissions( Energy.from_energy(kwh=3), GeoMetadata(country_iso_code="CAN", country_name="Canada"), ) # THEN assert isinstance(emissions, float) self.assertAlmostEqual(emissions, 1.6, places=2)
def test_get_emissions_PRIVATE_INFRA_NOR(self): """ Norway utilises hydropower more than any other country around the globe """ # WHEN emissions = self._emissions.get_private_infra_emissions( Energy.from_energy(kWh=1), GeoMetadata(country_iso_code="NOR", country_name="Norway"), ) # THEN assert isinstance(emissions, float) self.assertAlmostEqual(emissions, 33.4 / 1_000, places=2)
def test_get_emissions_PRIVATE_INFRA_FRA(self): """ European country is a specific case as we have there carbon intensity to without computation. """ # WHEN emissions = self._emissions.get_private_infra_emissions( Energy.from_energy(kWh=1), GeoMetadata(country_iso_code="FRA", country_name="France"), ) # THEN assert isinstance(emissions, float) self.assertAlmostEqual(emissions, 0.055, places=2)
def get_global_emissions_choropleth_data( self, net_energy_consumed: float) -> List[Dict]: def formatted_energy_percentage(energy_type: float, total: float) -> float: return float("{:.1f}".format((energy_type / total) * 100)) global_energy_mix = self._data_source.get_global_energy_mix_data() choropleth_data = [] for country_iso_code in global_energy_mix.keys(): country_name = global_energy_mix[country_iso_code]["countryName"] if country_iso_code not in ["_define", "ATA"]: from codecarbon.core.units import Energy energy_consumed = Energy.from_energy(kwh=net_energy_consumed) from codecarbon.external.geography import GeoMetadata country_emissions = self._emissions.get_country_emissions( energy_consumed, GeoMetadata(country_name=country_name, country_iso_code=country_iso_code), ) total = global_energy_mix[country_iso_code]["total"] choropleth_data.append({ "iso_code": country_iso_code, "emissions": country_emissions, "country": country_name, "coal": formatted_energy_percentage( global_energy_mix[country_iso_code]["coal"], total), "petroleum": formatted_energy_percentage( global_energy_mix[country_iso_code]["petroleum"], total), "natural_gas": formatted_energy_percentage( global_energy_mix[country_iso_code]["naturalGas"], total), "low_carbon": formatted_energy_percentage( global_energy_mix[country_iso_code]["lowCarbon"], total), }) return choropleth_data
def get_regional_emissions_choropleth_data( self, net_energy_consumed: float, country_iso_code: str) -> List[Dict]: # add country codes here to render for different countries if country_iso_code.upper() not in ["USA", "CAN"]: return [{"region_code": "", "region_name": "", "emissions": ""}] try: region_emissions = self._data_source.get_country_emissions_data( country_iso_code.lower()) except DataSourceException: # This country has regional data at the energy mix level, not the emissions level country_energy_mix = self._data_source.get_country_energy_mix_data( country_iso_code.lower()) region_emissions = { region: { "regionCode": region } for region, energy_mix in country_energy_mix.items() } choropleth_data = [] for region_name in region_emissions.keys(): region_code = region_emissions[region_name]["regionCode"] if region_name not in ["_unit"]: from codecarbon.core.units import Energy energy_consumed = Energy.from_energy(kWh=net_energy_consumed) from codecarbon.external.geography import GeoMetadata emissions = self._emissions.get_region_emissions( energy_consumed, GeoMetadata(country_iso_code=country_iso_code, region=region_name), ) choropleth_data.append({ "region_code": region_code, "region_name": region_name.upper(), "emissions": emissions, }) return choropleth_data
def test_get_emissions_PRIVATE_INFRA_JOR(self): """ Jordania use fossil energy """ # WHEN emissions = self._emissions.get_private_infra_emissions( Energy.from_energy(kWh=1_000), GeoMetadata(country_iso_code="JOR", country_name="Jordan"), ) # THEN jor_carbon_intensity = 17.19636 / 19.380129999999998 * 635 # fossil jor_carbon_intensity += 0.02277 / 19.380129999999998 * 26 # hydroelectricity jor_carbon_intensity += 1.441 / 19.380129999999998 * 48 # solar jor_carbon_intensity += 0.72 / 19.380129999999998 * 26 # wind jor_carbon_intensity /= 1000 # convert from g_per_kWh to kgs_per_kWh jor_emissions = (jor_carbon_intensity * 1_000 ) # Emissions in Kgs of CO2 For 1 000 kWh of energy assert isinstance(emissions, float) self.assertAlmostEqual(emissions, jor_emissions, places=2)
def _get_geo_metadata(self) -> GeoMetadata: return GeoMetadata.from_geo_js(self._data_source.geo_js_url)