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)
