start = pd.Timestamp('20180101', tz='Europe/Berlin')
end = pd.Timestamp('20210320', tz='Europe/Berlin')
country_code = 'DE' # Germany
# Create a "data_base" folder, where the csv files will be saved
if os.path.isdir('data_base') is False:
os.mkdir('data_base')
# =============================================================================
# Get Data from Entso-E
# API Wrapper: https://github.com/EnergieID/entsoe-py
# =============================================================================
#"""
key = str(np.genfromtxt('entsoe.txt', dtype='str'))
client = EntsoePandasClient(api_key=key)
# Time Series
# NoMatchingDataError
# ts_day_ahead = client.query_day_ahead_prices(country_code, start=start,end=end)
ts_load = client.query_load(country_code, start=start, end=end)
ts_load.to_csv('data_base/ts_load.csv')
ts_load_forecast = client.query_load_forecast(country_code,
start=start,
end=end)
ts_load_forecast.to_csv('data_base/ts_load_forecast.csv')
ts_generation_forecast = client.query_generation_forecast(country_code,
from entsoe import EntsoePandasClient
import pandas as pd
from plotly.offline import iplot, init_notebook_mode
init_notebook_mode()
import plotly.graph_objs as go
import plotly.figure_factory as ff
# Belgum solar data
# In[29]:
client = EntsoePandasClient(api_key='#######################')
start = pd.Timestamp('20171201', tz='Europe/Brussels')
end = pd.Timestamp('20180701', tz='Europe/Brussels')
country_code = 'BE' # Belgium
# total energy generation
belgium=client.query_generation(country_code, start=start,end=end, psr_type=None)
# In[30]:
belgium.tail(10)
from entsoe import EntsoePandasClient
import pandas as pd
import mysql.connector
client = EntsoePandasClient(api_key='c4d117a2-f140-492b-bc2b-d615ec5774f4')
start = pd.Timestamp('20171201', tz='Europe/Brussels')
end = pd.Timestamp('20180101', tz='Europe/Brussels')
country_code = 'BE' # Belgium
# methods that return Pandas Series
client.query_day_ahead_prices(country_code, start=start, end=end)
client.query_load(country_code, start=start, end=end)
client.query_load_forecast(country_code, start=start, end=end)
client.query_generation_forecast(country_code, start=start, end=end)
# methods that return Pandas DataFrames
client.query_wind_and_solar_forecast(country_code,
start=start,
end=end,
psr_type=None)
client.query_generation(country_code, start=start, end=end, psr_type=None)
client.query_installed_generation_capacity(country_code,
start=start,
end=end,
psr_type=None)
client.query_crossborder_flows('DE', 'DK', start=start, end=end)
client.query_imbalance_prices(country_code,
start=start,
end=end,
psr_type=None)
from entsoe import EntsoePandasClient
import sqlite3
import pandas as pd
from datetime import date, timedelta
import time
end_date = date.today() + timedelta(days=1)
current_date = end_date.strftime("%Y%m%d")
client = EntsoePandasClient(api_key='444fc771-5d0f-499f-9328-90c05c459219')
start = pd.Timestamp('20201109', tz='Europe/Brussels')
end = pd.Timestamp(current_date, tz='Europe/Brussels')
country_code = 'DE'
generation = client.query_load(country_code, start=start, end=end)
generation1.to_csv('outfile1.csv')
print(generation1)
start = pd.Timestamp('20201109', tz='Europe/Brussels')
end_date = date.today() + timedelta(days=2)
current_date = end_date.strftime("%Y%m%d")
end = pd.Timestamp(current_date, tz='Europe/Brussels')
country_code = 'DE'
generation2 = client.query_load_forecast(country_code, start=start, end=end)
generation2.to_csv('outfile2.csv')
print(generation2)
from entsoe import EntsoePandasClient
import pandas as pd
import matplotlib.pyplot as plt
#download load and generation data from the entso-e platform
#enter your own api_key
client = EntsoePandasClient(api_key="")
ts = pd.DataFrame()
ts2 = pd.DataFrame()
start, end = pd.Timestamp('20190101', tz='Europe/Brussels'), pd.Timestamp(
'20190501', tz='Europe/Brussels')
start2, end2 = pd.Timestamp('20200101', tz='Europe/Brussels'), pd.Timestamp(
'20200501', tz='Europe/Brussels')
for country_code in [
'DE-LU', 'BE', 'DK', 'AT', 'BG', 'CH', 'CZ', 'EE', 'ES', 'FI', 'FR',
'GB', 'GR', 'HR', 'HU', 'IE', 'IT', 'NL', 'NO', 'PL', 'PT', 'RO', 'SE'
]:
try:
#download load data
pd.concat([
client.query_load(country_code, start=start, end=end),
client.query_load(country_code, start=start2, end=end2)
]).to_csv('./data/load_' + country_code + '.csv')
#download generation data
pd.concat([
# import libraries
from entsoe import EntsoePandasClient
from entsoe.mappings import DOMAIN_MAPPINGS, BIDDING_ZONES
import pandas as pd
import os, errno
# import security token saved in a separate file (login.py)
from login import token
#%%
# combine domain and bidding zone keys and values into the DOMAIN_MAPPINGS dictionary
DOMAIN_MAPPINGS.update(BIDDING_ZONES)
#%%
# use security token to access the api through the entsoe pandas client
client = EntsoePandasClient(api_key=token)
#%%
# define attributes for the data to be extracted
# timestamps for the first half of 2019
start = pd.Timestamp('20190101', tz='Europe/Brussels')
end = pd.Timestamp('20190601', tz='Europe/Brussels')
#%%
# list of bidding zones in the North Sea region
bz_ns = [
'BE',
'DE-LU',
'DK-1',
'DK-2', # Belgium, Germany + Luxembourg, Denmark
'FR',
import pandas as pd
from settings import api_key
from entsoe import EntsoePandasClient as Entsoe
e = Entsoe(api_key=api_key, retry_count=20, retry_delay=30)
start = pd.Timestamp('20170601', tz='Europe/Brussels')
end = pd.Timestamp('20171201', tz='Europe/Brussels')
#s = e.query_imbalance_prices(country_code='BE', start=start, end=end, as_dataframe=True)
"""domains = [["10YIT-GRTN-----B", "Italy, IT CA / MBA"],
["10Y1001A1001A885", "Italy_Saco_AC"],
["10Y1001A1001A893", "Italy_Saco_DC"],
["10Y1001A1001A699", "IT-Brindisi BZ"],
["10Y1001A1001A70O", "IT-Centre-North BZ"],
["10Y1001A1001A71M", "IT-Centre-South BZ"],
["10Y1001A1001A72K", "IT-Foggia BZ"],
["10Y1001A1001A66F", "IT-GR BZ"],
["10Y1001A1001A84D", "IT-MACROZONE NORTH MBA"],
["10Y1001A1001A85B", "IT-MACROZONE SOUTH MBA"],
["10Y1001A1001A877", "IT-Malta BZ"],
["10Y1001A1001A73I", "IT-North BZ"],
["10Y1001A1001A80L", "IT-North-AT BZ"],
["10Y1001A1001A68B", "IT-North-CH BZ"],
["10Y1001A1001A81J", "IT-North-FR BZ"],
["10Y1001A1001A67D", "IT-North-SI BZ"],
["10Y1001A1001A76C", "IT-Priolo BZ"],
["10Y1001A1001A77A", "IT-Rossano BZ"],
["10Y1001A1001A74G", "IT-Sardinia BZ"],
["10Y1001A1001A75E", "IT-Sicily BZ"],
["10Y1001A1001A788", "IT-South BZ"]]
from entsoe import EntsoePandasClient, EntsoeRawClient
import pandas as pd
import matplotlib.pyplot as plt
from datetime import datetime
from dateutil.relativedelta import *
localtime = datetime.today() + relativedelta(days=-30)
startTime = '{:04d}'.format(localtime.year) + '{:02d}'.format(
localtime.month) + '{:02d}'.format(localtime.day)
localtime = datetime.today()
endTime = '{:04d}'.format(localtime.year) + '{:02d}'.format(
localtime.month) + '{:02d}'.format(localtime.day)
start = pd.Timestamp(startTime, tz='Europe/Vienna')
end = pd.Timestamp(endTime, tz='Europe/Vienna')
country_code = 'AT'
client = EntsoePandasClient(api_key='---')
data = client.query_load(country_code=country_code, start=start, end=end)
#data.plot()
#plt.show()
clientRaw = EntsoeRawClient(api_key='---')
data2 = clientRaw.query_imbalance_prices(country_code=country_code,
start=start,
end=end)
# Using ENTSOE built in python package get data from France - load, generation and DA prices
from entsoe import EntsoePandasClient
import pandas as pd
client = EntsoePandasClient(api_key="cc9c9fbb-2142-405b-88e8-8ab410f35694")
start = pd.Timestamp("20160101", tz="UTC")
end = pd.Timestamp("20190102", tz="UTC")
country_code = "FR"
if __name__ == "__main__":
DA_prices = client.query_day_ahead_prices(country_code,
start=start,
end=end)
DA_prices.to_csv("france_DA_prices.csv")
load_france = client.query_load_forecast(country_code,
start=start,
end=end)
load_france.to_csv("france_load_forecast.csv")
gen_france = client.query_generation_forecast(country_code,
start=start,
end=end)
gen_france.to_csv("france_generation_forecast.csv")
from entsoe import EntsoePandasClient
import pandas as pd
import time
import xmltodict
import pprint
import json
client = EntsoePandasClient(api_key='37c416e5-19fb-47a6-8852-d7721dc930db')
hoy = time.strftime('%Y%m%d')
mañana = str(int(hoy) + 1)
print('Fecha incio extracción = ' + hoy)
print('Fecha fin extracción = ' + mañana)
start = pd.Timestamp(hoy, tz='Europe/Brussels')
end = pd.Timestamp(mañana, tz='Europe/Brussels')
PSRTYPE_MAPPINGS = {
'A03': 'Mixed',
'A04': 'Generation',
'A05': 'Load',
'B01': 'Biomass',
'B02': 'Fossil Brown coal/Lignite',
'B03': 'Fossil Coal-derived gas',
'B04': 'Fossil Gas',
'B05': 'Fossil Hard coal',
'B06': 'Fossil Oil',
'B07': 'Fossil Oil shale',
'B08': 'Fossil Peat',
'B09': 'Geothermal',
'B10': 'Hydro Pumped Storage',
class Pricing_data:
def __init__(self):
self.__db_name = 'Pricing_data.db'
self.schema_path = "pricing_schema.sql"
self.__cursor = None
self.__connection = None
self.__client = EntsoePandasClient(
api_key='db59dcca-7ec4-4484-956e-86152f39e8be')
self.__country_code = 'BE' # Belgium
self.__timezone = 'Europe/Brussels'
self.today_start = None
self.today_end = None
self.tomorrow_start = None
self.tomorrow_end = None
self.updated = False
self.create_db()
def check_db_existence(self):
db_exists = os.path.exists(self.__db_name)
return db_exists
def create_db_schema(self):
with sqlite3.connect(self.__db_name) as conn:
with open(self.schema_path, 'rt') as file:
schema = file.read()
conn.executescript(schema)
self.update_last_update_time_today_price(True)
self.update_last_update_time_tomorrow_price(True)
def create_db(self):
if (not self.check_db_existence()):
self.create_db_schema()
self.__connection = sqlite3.connect(self.__db_name)
self.__cursor = self.__connection.cursor()
#create empty tables
#self.__cursor.execute('CREATE TABLE today(hour INTEGER PRIMARY KEY, price FLOAT)')
#self.__cursor.execute('CREATE TABLE tomorrow(hour INTEGER PRIMARY KEY, price FLOAT)')
def get_today_data(self):
#get today time
today = datetime.now().date()
self.today_start = today.strftime('%Y%m%d')
self.today_end = (today + timedelta(days=1)).strftime('%Y%m%d')
#set today time
self.today_start = pd.Timestamp(self.today_start, tz=self.__timezone)
self.today_end = pd.Timestamp(self.today_end, tz=self.__timezone)
#get today data
today_data = self.__client.query_day_ahead_prices(
self.__country_code, start=self.today_start, end=self.today_end)
return today_data
def upload_today_data(self):
today_data = self.get_today_data()
#delete the yesterday table
self.__cursor.execute('DROP TABLE today')
self.__cursor.execute(
'CREATE TABLE today(hour INTEGER PRIMARY KEY, price FLOAT)')
for i in range(0, 24):
self.__cursor.execute('INSERT INTO today VALUES(?,?)',
(i, today_data[i]))
self.__connection.commit()
self.update_last_update_time_today_price()
# No need
def check_time(self):
#check if correct date for updating tomorrow data
#should have changed the tomorrow data, first need to check datetime, if in range, continuously update til latest one,
#otherwise use the today data
update = False
now = datetime.now()
update_start = now.replace(hour=10, minute=30, second=0, microsecond=0)
#update_end = now.replace(hour=13, minute=30, second=0, microsecond=0)
if (update_start < now):
update = True
return update
def get_tomorrow_data(self):
#loop = True
#get today time
tomorrow = datetime.now().date() + timedelta(days=1)
self.tomorrow_start = tomorrow.strftime('%Y%m%d')
self.tomorrow_end = (tomorrow + timedelta(days=1)).strftime('%Y%m%d')
#set tomorrow time
self.tomorrow_start = pd.Timestamp(self.tomorrow_start,
tz=self.__timezone)
self.tomorrow_end = pd.Timestamp(self.tomorrow_end, tz=self.__timezone)
#while(self.check_time() & loop):
#get tomorrow data
# try:
# tomorrow_data = self.__client.query_day_ahead_prices(self.__country_code,start = self.tomorrow_start,end = self.tomorrow_end)
# loop = False
# self.updated = True
# except:
# loop = True
is_latest = False
try:
tomorrow_data = self.__client.query_day_ahead_prices(
self.__country_code,
start=self.tomorrow_start,
end=self.tomorrow_end)
is_latest = True
except Exception as e:
# in case the value is not yet available
tomorrow_data = self.get_today_data()
is_latest = False
return {"data": tomorrow_data, "is_latest": is_latest}
def is_data_latest_for_today_price(self):
current_date = datetime.now().date
last_update_time = self.get_last_update_time()
if (not last_update_time is None):
last_update_date = datetime.strptime(last_update_time["today"],
'%b %d, %Y %H:%M:%S').date
if (current_date == last_update_date):
return True
return False
return False
def is_data_latest_for_tomorrow_price(self):
current_date = datetime.now().date
last_update_time = self.get_last_update_time()
if (not last_update_time is None):
last_update_date = datetime.strptime(last_update_time["tomorrow"],
'%b %d, %Y %H:%M:%S').date
if (current_date == last_update_date):
return True
return False
return False
def upload_tomorrow_data(self):
#if(self.updated == False):
# tomorrow_data = self.get_today_data()
#else:
# tomorrow_data = self.get_tomorrow_data()
#delete the today table
raw_data = self.get_tomorrow_data()
self.__cursor.execute('DROP TABLE tomorrow')
self.__cursor.execute(
'CREATE TABLE tomorrow(hour INTEGER PRIMARY KEY, price FLOAT)')
for i in range(0, 24):
self.__cursor.execute('INSERT INTO tomorrow VALUES(?,?)',
(i, raw_data["data"][i]))
self.__connection.commit()
if (raw_data["is_latest"]):
self.update_last_update_time_tomorrow_price()
def get_forecast_pricing(self):
print(self.is_data_latest_for_tomorrow_price())
if (not self.is_data_latest_for_tomorrow_price()):
self.upload_tomorrow_data()
current_hour = datetime.now().hour
con = None
cur = None
data = None
SELECT_QUERY = "SELECT price FROM today WHERE hour>=" + str(
current_hour
) + " UNION ALL SELECT price from tomorrow WHERE hour<=" + str(
current_hour - 1)
try:
con = sqlite3.connect(self.__db_name)
cur = con.cursor()
result = cur.execute(SELECT_QUERY)
forecast_pricing = []
for row in result:
forecast_pricing.append(row[0])
except sqlite3.Error as e:
print("Exception Logged: Get " + str(e))
return None
finally:
if con:
con.close()
return forecast_pricing
def get_current_pricing(self):
print(self.is_data_latest_for_today_price())
if (not self.is_data_latest_for_today_price()):
self.upload_today_data()
current_hour = datetime.now().hour
con = None
cur = None
data = None
SELECT_QUERY = "SELECT price FROM today WHERE hour = " + str(
current_hour)
try:
con = sqlite3.connect(self.__db_name)
cur = con.cursor()
result = cur.execute(SELECT_QUERY)
for row in result:
return row[0]
except sqlite3.Error as e:
print("Exception Logged: Get " + str(e))
return None
finally:
if con:
con.close()
def can_update(self):
current_hour = datetime.now().hour
if (current_hour >= 10 and current_hour <= 13):
return True
return False
def get_last_update_time(self):
con = None
cur = None
data = None
SELECT_QUERY = "SELECT LastUpdateTodayPrice, LastUpdateTomorrowPrice FROM LastUpdate LIMIT 1"
try:
con = sqlite3.connect(self.__db_name)
cur = con.cursor()
result = cur.execute(SELECT_QUERY)
for row in result:
print(row[0])
return {"today": row[0], "tomorrow": row[1]}
except sqlite3.Error as e:
print("Exception Logged: Get " + str(e))
return None
finally:
if con:
con.close()
def update_last_update_time_today_price(self, initial=False):
cur = None
con = None
data = None
try:
if (initial):
yesterday = datetime.now() - timedelta(days=1)
current_time = datetime.strftime(yesterday, '%b %d, %Y %X')
else:
current_time = datetime.strftime(datetime.now(),
'%b %d, %Y %X')
con = sqlite3.connect(self.__db_name)
cur = con.cursor()
INSERT_QUERY = "INSERT INTO LastUpdate (Id,LastUpdateTodayPrice) VALUES (1,'" + current_time + "')"
UPDATE_QUERY = "UPDATE LastUpdate SET LastUpdateTodayPrice='" + current_time + "' WHERE Id=1"
if (self.get_last_update_time()["Today"] is None):
print("None")
result = cur.execute(INSERT_QUERY)
con.commit()
data = 100
else:
print("Time" + self.get_last_update_time()["Today"])
result = cur.execute(UPDATE_QUERY)
con.commit()
data = 101
except sqlite3.Error as e:
print("Exception Logged: Update" + str(e))
data = 112
finally:
if con:
con.close()
return data
def update_last_update_time_tomorrow_price(self, initial=False):
cur = None
con = None
data = None
try:
if (initial):
yesterday = datetime.now() - timedelta(days=1)
current_time = datetime.strftime(yesterday, '%b %d, %Y %X')
else:
current_time = datetime.strftime(datetime.now(),
'%b %d, %Y %X')
con = sqlite3.connect(self.__db_name)
cur = con.cursor()
INSERT_QUERY = "INSERT INTO LastUpdate (Id,LastUpdateTomorrowPrice) VALUES (1,'" + current_time + "')"
UPDATE_QUERY = "UPDATE LastUpdate SET LastUpdateTomorrowPrice='" + current_time + "' WHERE Id=1"
if (self.get_last_update_time()["Tomorrow"] is None):
print("None")
result = cur.execute(INSERT_QUERY)
con.commit()
data = 100
else:
print("Time" + self.get_last_update_time())
result = cur.execute(UPDATE_QUERY)
con.commit()
data = 101
except sqlite3.Error as e:
print("Exception Logged: Update" + str(e))
data = 112
finally:
if con:
con.close()
return data
def setUpClass(cls):
cls.client = EntsoePandasClient(api_key=api_key)
cls.start = pd.Timestamp('20180101', tz='Europe/Brussels')
cls.end = pd.Timestamp('20180107', tz='Europe/Brussels')
cls.country_code = 'BE'
import pandas as pd
from entsoe import EntsoePandasClient
import matplotlib.pyplot as plt
## Entsoe Transparancy platform login:
key = "285a3e21-c574-453b-9690-e327c7bd73fd" ## don't publish
client = EntsoePandasClient(api_key=key)
## Time window:
start_time = pd.Timestamp('20160101', tz='Europe/Brussels')
end_time = pd.Timestamp('20161231', tz='Europe/Brussels')
country_code = "CH" # Switzerland
neighbour_countries = ["AT", "DE", "FR", "IT"]
# it is resampled to an hour with mean because the values coming out of the database are acutally given in MW and not in MWh
domestic_production = client.query_generation(country_code, start=start_time, end=end_time, psr_type=None).resample("H").mean()
neighbour_production = []
for country in neighbour_countries:
neighbour_production.append(client.query_generation(country, start=start_time, end=end_time, psr_type=None).resample("H").mean())
emission_production_matrix_filepath = r"C:\Users\walkerl\Documents\code\proof_of_concept\data\emissions_technology_matrix.xlsx"
emission_production_matrix = pd.read_excel(emission_production_matrix_filepath, index_col=0)
return dataframe
def data_base_connection(table_name, dataframe):
conn = sqlite3.connect('db.sqlite3')
c = conn.cursor()
dataframe.to_sql(table_name, conn, if_exists='replace', index=False)
sql = "SELECT * FROM " + table_name + ";"
c.execute(sql)
print("Database data:")
for row in c.fetchall():
print(row)
#ENTSOE API connecntion
client = EntsoePandasClient(api_key='444fc771-5d0f-499f-9328-90c05c459219')
#start and end date format
start_date_raw = date.today() + timedelta(days=1)
start_date = start_date_raw.strftime("%Y%m%d")
end_date_raw = date.today() + timedelta(days=2)
end_date = end_date_raw.strftime("%Y%m%d")
#quering load and renewable generation forecasts
start = pd.Timestamp(start_date, tz='Europe/Brussels')
end = pd.Timestamp(end_date, tz='Europe/Brussels')
country_code = 'DE'
load_raw = client.query_load_forecast(country_code, start=start, end=end)
renewable = client.query_wind_and_solar_forecast(country_code,
start=start,
def __init__(self, token):
self.client = EntsoePandasClient(api_key=token)
"""
today = datetime.datetime.now()
today = str(today.strftime("%Y%m%d"))
tomorrow = datetime.datetime.now() + datetime.timedelta(days=1)
tomorrow = str(tomorrow.strftime("%Y%m%d"))
df = pd.read_csv(
"https://data.norges-bank.no/api/data/EXR/M.EUR.NOK.SP?lastNObservations=1&format=csv",
sep=';')
df = df.filter(items=["BASE_CUR", "QUOTE_CUR", "TIME_PERIOD", "OBS_VALUE"])
eur = df["OBS_VALUE"]
date = df["TIME_PERIOD"]
client = EntsoePandasClient(api_key="YOUR_ENTSOE_API-CODE")
# Fordelen ved å velge timezone er at den automatisk justerer CET til sommertidsudo
start = pd.Timestamp(today, tz="Europe/Brussels")
end = pd.Timestamp(tomorrow, tz="Europe/Brussels")
country_code = "NO_3" # MidtNorge
ts = client.query_day_ahead_prices(country_code, start=start,
end=end).to_frame()
price = ts.multiply(eur)
price = round(price.div(10),
2) # Deler egentlig på 1000, da ender man opp i NOK.
# Men det var mer natulig å dele på 10 for å få det i Øre.
"""
Nettleie er 44,54 øre/kWh = 0,4454 kr/kWh.
"""
from entsoe import EntsoePandasClient
import sqlite3
import pandas as pd
from datetime import date, timedelta
import time
end_date = date.today() + timedelta(days=1)
current_date = end_date.strftime("%Y%m%d")
client = EntsoePandasClient(api_key='444fc771-5d0f-499f-9328-90c05c459219')
start = pd.Timestamp('20201109', tz='Europe/Brussels')
end = pd.Timestamp(current_date, tz='Europe/Brussels')
country_code = 'DE'
generation1 = client.query_generation(country_code,
start=start,
end=end,
psr_type=None)
generation = generation1.iloc[:,
generation1.columns.get_level_values(1) ==
'Actual Aggregated']
generation.columns = generation.columns.droplevel(level=1)
print(generation)
generation['Date'] = generation.index
generation.insert(0, 'id', range(0, len(generation)))
generation['Total_Non_Renewables'] = generation[
'Fossil Brown coal/Lignite'] + generation['Fossil Gas'] + generation[
'Hydro Run-of-river and poundage': 24.,
'Hydro Water Reservoir': 24.,
'Marine':
17., # used 'ocean' in 'pre-commercial technologies' for marine, not sure!
'Nuclear': 12.,
'Other': 820., # used coal for other (conservative), to be refined!
'Other renewable': np.nan,
'Solar': 41., # used PV for solar
'Waste':
922.22, # for waste, note sure but used the first row of table 1 in https://www.mdpi.com/2071-1050/8/11/1181
'Wind Offshore': 12.,
'Wind Onshore': 11.
}
# client parameters
client = EntsoePandasClient(api_key='${{ secrets.TOKEN_API }}')
for year in range(2015, 2021):
#for month in range(1,13):
# Paramétrage de la période de l'historique demandé
# if yearly
start = pd.Timestamp(year=year, month=1, day=1, tz='Europe/Brussels')
end = pd.Timestamp(year=year, month=12, day=31, tz='Europe/Brussels')
# if monthly
#start = pd.Timestamp(year=year, month=month, day=1, tz='Europe/Brussels')
#end = pd.Timestamp(year=year, month=month, day=start.daysinmonth, tz='Europe/Brussels')
country_code = ['DE', 'FR']
# call query
df, timespan = query_entsoe(start, end, country_code)
