mrio-toolbox 1.0.0__py3-none-any.whl → 1.1.1__py3-none-any.whl

mrio_toolbox/extractors/emerging/emerging_extractor.py

@@ -0,0 +1,117 @@
+"""
+Extractor for Emerging MRIO
+
+This extractor loads tables and labels from the Emerging MRIO .mat files files, 
+builds an mrio object from the data and saves it as NetCDF for further use with
+the mrio_toolbox library.
+  
+Supports Emerging v.1
+https://zenodo.org/records/10956623 
+
+Created on 18.03.2025
+@author: wirth
+"""
+
+import os
+import logging
+import numpy as np
+import h5py
+
+from mrio_toolbox import MRIO
+from mrio_toolbox.utils.savers._to_nc import save_to_nc
+
+log = logging.getLogger(__name__) 
+
+
+def extract_emerging(year, source, precision=32):
+    """
+    Extract EMERGING data. 
+
+    Loads EMERGING tables and labels and store them as NetCDF for further use with 
+    the mrio_toolbox library. 
+
+    Parameters
+    ----------
+    year : str
+        Data year to load.
+    source : path-like
+        Path to folder where raw data is stored
+    destination : path-like
+        path to folder where NetCDF file will be saved
+    precision : int
+        Precision of the data in bits. Default is 32.
+    """
+    
+    log.info(f"Opening EMERGING data for year {year}...")
+    file_path = os.path.join(source, f"global_mrio_{year}.mat")
+    
+    #Check source path
+    if not os.path.isfile(file_path):
+        log.error(f"{os.path.abspath(file_path)} does not exist.")
+        raise FileNotFoundError(f"{os.path.abspath(file_path)} does not exist.")
+        
+    f = h5py.File(file_path, "r")
+
+    log.info("Extracting labels...")
+    countries = []
+    sectors = []
+    y_labs = []
+    va_labs = ["Value added"]
+    
+    for ref in f['country_list']:
+        ref_key = ref.item()  # Convert NumPy array to scalar with the item function
+        country_data = f['#refs#'][ref_key][:]
+        country_name = ''.join(chr(c[0]) for c in country_data) # Convert ASCII codes to string
+        countries.append(country_name)
+    
+    for ref_key in f["sector_list"][0]:
+        sector_data = f['#refs#'][ref_key][:]
+        sector_data = ''.join(chr(c[0]) for c in sector_data)
+        sectors.append(sector_data)
+
+    for ref_key in f['final_list'][0]:
+        fd_data = f['#refs#'][ref_key][:]
+        fd_data = ''.join(chr(c[0]) for c in fd_data)
+        y_labs.append(fd_data)
+        
+    labels = {
+    "countries": countries,
+    "sectors": sectors,
+    "y_labs": y_labs,
+    "va_labs": va_labs
+    }
+    
+    if precision == 32:
+        log.info("Data precision is 32 bits")
+        dt = np.float32
+    elif precision == 64:
+        log.info("Data precision is 64 bits")
+        dt = np.float64
+    
+    log.info("Extracting data, this can take a while...")
+    tables = {}
+    tables["T"] = np.array(f["z"],dtype=dt)
+    tables["Y"] = np.array(f["f"], dtype=dt).transpose() # y is provided transposed
+    tables["VA"] = np.array(f["va"], dtype=dt) # No vay part provided
+    
+    # Assemble mrio object
+    log.info("Building MRIO object...")
+    m = MRIO()
+    m.add_dimensions(labels)
+    log.info("Building MRIO objects from parts containing labels and tables...")
+    m.parts["T"] = m.new_part(name="T",
+        data= tables["T"],
+        dimensions = [["countries","sectors"],["countries", "sectors"]])
+    log.info("T part added")
+    m.parts["Y"] = m.new_part(name="Y",
+        data= tables["Y"],
+        dimensions = [["countries","sectors"],["countries", "y_labs"]])
+    log.info("Y part added")
+    m.parts["VA"] = m.new_part(name="VA",
+        data= tables["VA"],
+        dimensions = ["va_labs",["countries", "sectors"]])
+    log.info("VA part added")
+    log.info("MRIO object built")
+
+    m.name = f"emerging_{year}_{precision}bits_resolution"
+    return m

mrio_toolbox/extractors/eora/__init__.py

@@ -0,0 +1,3 @@
+"""
+This module contains the EORA extractor.
+"""

mrio_toolbox/extractors/eora/eora_extractor.py

@@ -0,0 +1,132 @@
+"""
+Extractor for Eora26 data.
+
+This extractor loads Eora26 raw data files and converts them to NetCDF
+files.
+  
+Supports Eora26 v199.82
+https://worldmrio.com/eora26/
+
+Created on Fr Nov 29, 2024
+@author: wirth, based on code of beaufils
+
+"""
+
+import os
+import logging
+import numpy as np
+from mrio_toolbox import MRIO
+from mrio_toolbox.utils.savers._to_nc import save_to_nc
+
+log = logging.getLogger(__name__)
+
+def extract_eora26(
+    year, 
+    source,
+    parts = 'all'):
+    """
+    Extract EORA26 data. 
+
+    Loads EORA26 tables and labels and store them as NetCDF for further use with 
+    the mrio_toolbox library. 
+
+    Parameters
+    ----------
+    year : str
+        Data year to load.
+    parts : str
+        Data blocks to load:
+            basic : T, FD
+            all : T, FD, VA, QT, QY
+    source : path-like
+        Path to folder where raw data is stored
+    """
+
+    #Check source path
+    if not os.path.exists(source):
+        log.error(f"{os.path.abspath(source)} does not exist.")
+        raise NotADirectoryError(f"{os.path.abspath(source)} does not exist.")
+
+    # EORA26 comes with 189 countries and 26 sectors
+    c,s = 189,26
+
+    # Usually, we want to extract all tables 
+    if parts == "all":
+        parts = ["T","FD","VA","Q","QY"]
+    else:
+        parts = ["T","FD"]
+    
+    # First, we create a dictionary of part objects
+    tables = dict()
+    
+    
+    for part in parts:
+        tables[part] = np.loadtxt(
+            os.path.join(source,f'Eora26_{year}_bp_{part}.txt'),
+            delimiter = '\t')
+        
+        # Then, we have to exclude statistical discrepancies 
+        # (RoW) row and column, so our data aligns with the number
+        # of countries and sectors
+        if part == "T":
+            tables[part] = tables[part][:c*s,:c*s]
+        elif part == "FD": 
+            tables[part] = tables[part][:c*s,:c*6]
+        elif part == "QY": 
+            tables[part] = tables[part][:,:c*6]
+        else: #Q, VA
+            tables[part] = tables[part][:,:c*s]
+    
+    # Next, we load the labels
+    labels = {} 
+    # Split country and sector labels for multi-indexing
+    labs = np.loadtxt(os.path.join(source, "labels_T.txt"),
+                    dtype=str, delimiter ='\t')
+    sectors = labs[:s,3].tolist()
+    countries = []
+    for i in range(c):
+        countries.append(labs[i*s,1][:])
+
+    # Omit countries and sectors from y_labs, they are already included
+    # in sectors and countries labels. 
+    y_labs = np.loadtxt(os.path.join(source, "labels_FD.txt"), 
+                    dtype=str, delimiter ='\t')
+    y_labs = y_labs[:6, 3].tolist()
+    
+    # q and y labels need to be reformatted into a single list
+    q_labs = np.loadtxt(os.path.join(source, "labels_Q.txt"),
+                    dtype=str,delimiter="\t")
+    q_labs = [" - ".join(sub_array[:-1]) for sub_array in q_labs]
+
+    va_labs = np.loadtxt(os.path.join(source, "labels_VA.txt"),
+                    dtype=str,delimiter="\t")
+    va_labs = [" - ".join(sub_array[:-1]) for sub_array in va_labs]     
+
+    labels["countries"] = countries
+    labels["sectors"] = sectors
+    labels["y_labs"] = y_labs
+    labels["q_labs"] = q_labs
+    labels["va_labs"] = va_labs
+
+    
+    # build an MRIO object from labels and tables
+    m = MRIO()
+    m.add_dimensions(labels)
+    m.parts["t"] = m.new_part(name="t",
+        data= tables["T"],
+        dimensions = [["countries","sectors"],["countries", "sectors"]])
+    m.parts["y"] = m.new_part(name="y",
+        data= tables["FD"],
+        dimensions = [["countries","sectors"],["countries", "y_labs"]])
+    m.parts["va"] = m.new_part(name="va",
+        data= tables["VA"],
+        dimensions = ["va_labs",["countries","sectors"]])
+    m.parts["q"] = m.new_part(name="q",
+        data= tables["Q"],
+        dimensions = ["q_labs",["countries","sectors"]])
+    m.parts["qy"] = m.new_part(name="qy",
+        data= tables["QY"],
+        dimensions = ["q_labs",["countries","y_labs"]])
+
+    m.name = f"eora26_{year}"
+    return m

mrio_toolbox/extractors/exiobase/__init__.py

@@ -0,0 +1,3 @@
+"""
+This module contains the exiobase 3 extractor
+"""

mrio_toolbox/extractors/exiobase/exiobase_extractor.py

@@ -0,0 +1,270 @@
+"""
+Created on Wed Mar 29 10:43:49 2023
+
+Load and convert Exiobase Industries MRIO files.
+
+Supports Exiobase 3.9.5 in csv https://zenodo.org/records/14869924 
+
+This is the supporting information excel sheet:
+https://onlinelibrary.wiley.com/action/downloadSupplement?doi=10.1111%2Fjiec.12715&file=jiec12715-sup-0009-SuppMat-9.xlsx
+
+@author: wirth
+"""
+
+import os
+import pandas as pd
+import logging
+from mrio_toolbox import MRIO
+from mrio_toolbox.utils.savers._to_nc import save_to_nc
+
+s,c = 163,49
+log = logging.getLogger(__name__)
+
+def extract_exiobase3(
+    year, 
+    source,
+    mode="ixi",
+    satellites = 'basic'):
+    
+    """
+    Load and preformat an EXIOBASE 3 table.
+
+    Parameters
+    ----------
+    year : str
+        Data year to load.
+    source : path-like
+        Path to folder where raw data is stored
+    satellites : str
+        Satellite accounts to load:
+            basic : air emissions
+            all : air_emissions, employment, energy, land, material, nutrients, water
+    path : path-like
+        Path to raw data.
+
+    Returns
+    -------
+    tables : dict of {str : 2D numpy array}
+        Keys correspond to matrix parts.
+        Values are the numerical tables stored as numpy arrays.
+    labels : dict of {str : list of str}
+        Dictionnary of countries and sectors labels.
+
+    """
+    source = os.path.join(source, f"IOT_{year}_[{mode}]")
+    #Check source path
+    if not os.path.exists(source):
+        log.error(f"{os.path.abspath(source)} does not exist.")
+        raise NotADirectoryError(f"{os.path.abspath(source)} does not exist.")
+        
+    # EXIOBASE 3 comes with: 
+    # - 43 countries + 5 ROW regions 
+    # - 163 industries
+    # - 9 final demand categories
+    # - 9 value added categories including taxes
+    # - various satellite accounts
+     #c,s,y,va = 48,163, 5, 9,
+
+    parts = ["t", "y", "va", "vay", "q_air", "qy_air"]
+    
+    # Load labels
+    log.info("Loading labels...")
+    countries = pd.read_csv(os.path.join(source,"unit.txt"), delimiter="\t")
+    countries = countries["region"].tolist()
+    seen = set()  # Remove duplicates while preserving order
+    countries = [x for x in countries if not (x in seen or seen.add(x))]
+    sectors = pd.read_csv(os.path.join(source,"unit.txt"), delimiter="\t")
+    sectors = sectors[sectors["region"] == "AT"]["sector"].tolist()
+    y_labs = pd.read_csv(os.path.join(source,"Y.txt"), header=1, dtype= "str", delimiter="\t")
+    y_labs = y_labs.columns[2:9]
+    va_labs = pd.read_csv(os.path.join(source, "factor_inputs", "unit.txt"), dtype= "str", delimiter="\t")
+    va_labs = va_labs.iloc[:,0].tolist()
+    q_labs_air_emissions = pd.read_csv(os.path.join(source, "air_emissions", "unit.txt"), dtype= "str", delimiter="\t")
+    q_labs_air_emissions = q_labs_air_emissions.apply(lambda row: f"{row.iloc[0]} - {row.iloc[1]}", axis=1).tolist()
+    
+    labels = {
+            "countries" : countries,
+            "sectors" : sectors, 
+            "y_labs" : y_labs,
+            "va_labs" : va_labs,
+            "q_labs_air_emissions" : q_labs_air_emissions,
+            }
+    
+    if satellites == 'all':
+        
+        parts.extend(["q_employment", "qy_employment", "q_energy", "qy_energy", "q_land", "qy_land", "q_material", "qy_material", "q_nutrients", "qy_nutrients", "q_water", "qy_water"])
+        
+        q_labs_employment  = pd.read_csv(os.path.join(source, "employment", "unit.txt"), dtype= "str", delimiter="\t")
+        labels["q_labs_employment"] = q_labs_employment.apply(lambda row: f"{row.iloc[0]} - {row.iloc[1]}", axis=1).tolist()
+        q_labs_energy  = pd.read_csv(os.path.join(source, "energy", "unit.txt"), dtype= "str", delimiter="\t")
+        labels["q_labs_energy"] = q_labs_energy.apply(lambda row: f"{row.iloc[0]} - {row.iloc[1]}", axis=1).tolist()
+        q_labs_land  = pd.read_csv(os.path.join(source, "land", "unit.txt"), dtype= "str", delimiter="\t")
+        labels["q_labs_land"] = q_labs_land.apply(lambda row: f"{row.iloc[0]} - {row.iloc[1]}", axis=1).tolist()
+        q_labs_material  = pd.read_csv(os.path.join(source, "material", "unit.txt"), dtype= "str", delimiter="\t")
+        labels["q_labs_material"] = q_labs_material.apply(lambda row: f"{row.iloc[0]} - {row.iloc[1]}", axis=1).tolist()
+        q_labs_nutrient  = pd.read_csv(os.path.join(source, "nutrients", "unit.txt"), dtype= "str", delimiter="\t")
+        labels["q_labs_nutrient"] = q_labs_nutrient.apply(lambda row: f"{row.iloc[0]} - {row.iloc[1]}", axis=1).tolist()
+        q_labs_water  = pd.read_csv(os.path.join(source, "water", "unit.txt"), dtype= "str", delimiter="\t")
+        labels["q_labs_water"] = q_labs_water.apply(lambda row: f"{row.iloc[0]} - {row.iloc[1]}", axis=1).tolist()
+    
+    log.info("Labels loaded")
+        
+    # Load tables
+
+    tables = {}
+    log.info("Loading IO tables, this can take a while...")
+    for part in parts: 
+        
+        
+        if part == "t": 
+             tables[part] = pd.read_csv(os.path.join(source, "Z.txt"), delimiter = "\t", dtype = "str", header = None).iloc[3:, 2:].to_numpy().astype(float)
+             log.info(f"Loaded {part}")
+        elif part == "y":
+            tables[part] = pd.read_csv(os.path.join(source, "Y.txt"), delimiter = "\t", dtype = "str", header = None).iloc[3:, 2:].to_numpy().astype(float)
+            log.info(f"Loaded {part}")
+        elif part == "va":
+            tables[part] = pd.read_csv(os.path.join(source, "factor_inputs", "F.txt"), delimiter = "\t", dtype = "str", header = None).iloc[3:, 1:].to_numpy().astype(float)
+            log.info(f"Loaded {part}")
+        elif part == "vay":
+            tables[part] = pd.read_csv(os.path.join(source, "factor_inputs", "F_Y.txt"), delimiter = "\t", dtype = "str", header = None).iloc[3:, 1:].to_numpy().astype(float)
+            log.info(f"Loaded {part}")
+        elif part == "q_air":
+            tables[part] = pd.read_csv(os.path.join(source, "air_emissions", "F.txt"), delimiter = "\t", dtype = "str", header = None).iloc[3:, 1:].to_numpy().astype(float)
+            log.info(f"Loaded {part}")
+        elif part == "qy_air":
+            tables[part] = pd.read_csv(os.path.join(source, "air_emissions", "F_Y.txt"), delimiter = "\t", dtype = "str", header = None).iloc[3:, 1:].to_numpy().astype(float)
+            log.info(f"Loaded {part}")
+        elif part == "q_employment":
+            tables[part] = pd.read_csv(os.path.join(source, "employment", "F.txt"), delimiter = "\t", dtype = "str", header = None).iloc[3:, 1:].to_numpy().astype(float)
+            log.info(f"Loaded {part}")
+        elif part == "qy_employment":
+            tables[part] = pd.read_csv(os.path.join(source, "employment", "F_Y.txt"), delimiter = "\t", dtype = "str", header = None).iloc[3:, 1:].to_numpy().astype(float)
+            log.info(f"Loaded {part}")
+        elif part == "q_energy":
+            tables[part] = pd.read_csv(os.path.join(source, "energy", "F.txt"), delimiter = "\t", dtype = "str", header = None).iloc[3:, 1:].to_numpy().astype(float)
+            log.info(f"Loaded {part}")
+        elif part == "qy_energy":
+            tables[part] = pd.read_csv(os.path.join(source, "energy", "F_Y.txt"), delimiter = "\t", dtype = "str", header = None).iloc[3:, 1:].to_numpy().astype(float)
+            log.info(f"Loaded {part}")
+        elif part == "q_land":
+            tables[part] = pd.read_csv(os.path.join(source, "land", "F.txt"), delimiter = "\t", dtype = "str", header = None).iloc[3:, 1:].to_numpy().astype(float)
+            log.info(f"Loaded {part}")
+        elif part == "qy_land":
+            tables[part] = pd.read_csv(os.path.join(source, "land", "F_Y.txt"), delimiter = "\t", dtype = "str", header = None).iloc[3:, 1:].to_numpy().astype(float)
+            log.info(f"Loaded {part}")
+        elif part == "q_material":
+            tables[part] = pd.read_csv(os.path.join(source, "material", "F.txt"), delimiter = "\t", dtype = "str", header = None).iloc[3:, 1:].to_numpy().astype(float)
+            log.info(f"Loaded {part}")
+        elif part == "qy_material":
+            tables[part] = pd.read_csv(os.path.join(source, "material", "F_Y.txt"), delimiter = "\t", dtype = "str", header = None).iloc[3:, 1:].to_numpy().astype(float)
+            log.info(f"Loaded {part}")
+        elif part == "q_nutrients":
+            tables[part] = pd.read_csv(os.path.join(source, "nutrients", "F.txt"), delimiter = "\t", dtype = "str", header = None).iloc[3:, 1:].to_numpy().astype(float)
+            log.info(f"Loaded {part}")
+        elif part == "qy_nutrients":
+            tables[part] = pd.read_csv(os.path.join(source, "nutrients", "F_Y.txt"), delimiter = "\t", dtype = "str", header = None).iloc[3:, 1:].to_numpy().astype(float)
+            log.info(f"Loaded {part}")
+        elif part == "q_water":
+            tables[part] = pd.read_csv(os.path.join(source, "water", "F.txt"), delimiter = "\t", dtype = "str", header = None).iloc[3:, 1:].to_numpy().astype(float)
+            log.info(f"Loaded {part}")
+        elif part == "qy_water":
+            tables[part] = pd.read_csv(os.path.join(source, "water", "F_Y.txt"), delimiter = "\t", dtype = "str", header = None).iloc[3:, 1:].to_numpy().astype(float)
+            log.info(f"Loaded {part}")
+        else:
+            tables[part] = None
+            log.info(f"Didn't load {part}")
+        
+    log.info("Tables loaded")
+    m = MRIO()
+    m.add_dimensions(labels)
+    
+    log.info("Building MRIO objects from parts containing labels and tables...")
+    m.parts["t"] = m.new_part(name="t",
+        data= tables["t"],
+        dimensions = [["countries","sectors"],["countries", "sectors"]])
+    log.info("t part added")
+    m.parts["y"] = m.new_part(name="y",
+        data= tables["y"],
+        dimensions = [["countries","sectors"],["countries", "y_labs"]])
+    log.info("y part added")
+    m.parts["va"] = m.new_part(name="va",
+        data= tables["va"],
+        dimensions = ["va_labs",["countries","sectors"]])
+    log.info("va part added")
+    m.parts["vay"] = m.new_part(name="vay",
+        data= tables["vay"],
+        dimensions = ["va_labs",["countries","y_labs"]])
+    log.info("vay part added")
+    m.parts["q_air"] = m.new_part(name="q_air",
+        data = tables["q_air"],
+        dimensions = ["q_labs_air_emissions",["countries","sectors"]])
+    log.info("q_air part added")
+    m.parts["qy_air"] = m.new_part(name="qy_air",
+        data = tables["qy_air"],
+        dimensions = ["q_labs_air_emissions",["countries","y_labs"]])
+    log.info("qy_air part added")
+    
+    if(satellites == 'all'): 
+        m.parts["q_employment"] = m.new_part(name="q_employment",
+        data = tables["q_employment"],
+        dimensions = ["q_labs_employment",["countries","sectors"]])
+        log.info("q_employment part added")
+        
+        m.parts["qy_employment"] = m.new_part(name="qy_employment",
+            data = tables["qy_employment"],
+            dimensions = ["q_labs_employment",["countries","y_labs"]])
+        log.info("qy_employment part added")
+        
+        m.parts["q_energy"] = m.new_part(name="q_energy",
+        data = tables["q_energy"],
+        dimensions = ["q_labs_energy",["countries","sectors"]])
+        log.info("q_energy part added")
+        
+        m.parts["qy_energy"] = m.new_part(name="qy_energy",
+            data = tables["qy_energy"],
+            dimensions = ["q_labs_energy",["countries","y_labs"]])
+        log.info("qy_energy part added")
+        
+        m.parts["q_land"] = m.new_part(name="q_land",
+        data = tables["q_land"],
+        dimensions = ["q_labs_land",["countries","sectors"]])
+        log.info("q_land part added")
+        
+        m.parts["qy_land"] = m.new_part(name="qy_land",
+            data = tables["qy_land"],
+            dimensions = ["q_labs_land",["countries","y_labs"]])
+        log.info("qy_land part added")
+        
+        m.parts["q_material"] = m.new_part(name="q_material",
+        data = tables["q_material"],
+        dimensions = ["q_labs_material",["countries","sectors"]])
+        log.info("q_material part added")
+        
+        m.parts["qy_material"] = m.new_part(name="qy_material",
+            data = tables["qy_material"],
+            dimensions = ["q_labs_material",["countries","y_labs"]])
+        log.info("qy_material part added")
+        
+        m.parts["q_nutrients"] = m.new_part(name="q_nutrients",
+        data = tables["q_nutrients"],
+        dimensions = ["q_labs_nutrient",["countries","sectors"]])
+        log.info("q_nutrients part added")
+        
+        m.parts["qy_nutrients"] = m.new_part(name="qy_nutrients",
+            data = tables["qy_nutrients"],
+            dimensions = ["q_labs_nutrient",["countries","y_labs"]])
+        log.info("qy_nutrients part added")
+        
+        m.parts["q_water"] = m.new_part(name="q_water",
+        data = tables["q_water"],
+        dimensions = ["q_labs_water",["countries","sectors"]])
+        log.info("q_water part added")
+        
+        m.parts["qy_water"] = m.new_part(name="qy_water",
+            data = tables["qy_water"],
+            dimensions = ["q_labs_water",["countries","y_labs"]])
+        log.info("qy_water part added")
+
+    m.name = f"exiobase3_{year}_{mode}_{satellites}_satellites"
+    return m
+

mrio_toolbox/extractors/extractors.py

@@ -0,0 +1,79 @@
+"""
+Module for extracting and converting data from various sources.
+"""
+
+import logging as log
+import os
+log = log.getLogger(__name__)
+
+def extract_MRIO(table,year,source,destination,
+                 preprocessing = False,
+                 saving_kwargs = dict(),
+                 extraction_kwargs = dict()):
+    """
+    Extract MRIO data and save it to a NetCDF file.
+
+    Specific extractors are called based on the table name.
+    Refer to the individual extractor functions for more details.
+    
+    Parameters
+    ----------
+    table : str
+        Name of the MRIO table to extract. Currently supported:
+        
+        - 'eora26': Extracts Eora26 data.
+        - 'gloria': Extracts GLORIA data.
+        - 'wiod': Extracts WIOD data.
+        - 'icio': Extracts ICIO data.
+        - 'exiobase3': Extracts EXIOBASE3 data.
+        - 'figaro': Extracts FIGARO data.
+        - 'emerging': Extracts EMERGING data.
+        - 'gtap11': Extracts GTAP 11 data.
+    
+    year : str
+        Year of the data to extract.
+    source : path-like
+        Path to the source directory containing the raw data files.
+    destination : path-like
+        Path to the destination directory where the NetCDF file will be saved.
+    preprocessing : dict
+        Parameters for preprocessing the table
+        If left empty, no preprocessing is done
+    extraction_kwargs : dict
+        Additional keyword arguments specific to the extractor function.
+    saving_kwargs : dict
+        Additional keyword arguments for saving the MRIO data
+    """
+    log.info(f"Extracting MRIO data for table '{table}' for year {year} from {source} to {destination}")
+    if table == 'eora26':
+        from mrio_toolbox.extractors.eora.eora_extractor import extract_eora26
+        mrio = extract_eora26(year, source, **extraction_kwargs)
+    elif table == 'gloria':
+        from mrio_toolbox.extractors.gloria.gloria_extractor import extract_gloria
+        mrio =extract_gloria(year, source, **extraction_kwargs)
+    elif table == 'wiod16':
+        from mrio_toolbox.extractors.wiod.wiod_extractor import extract_wiod
+        mrio = extract_wiod(year, source, **extraction_kwargs)
+    elif table == 'icio':
+        from mrio_toolbox.extractors.icio.icio_extractor import extract_icio
+        mrio =extract_icio(year, source, **extraction_kwargs)
+    elif table == 'exiobase3':
+        from mrio_toolbox.extractors.exiobase.exiobase_extractor import extract_exiobase3
+        mrio = extract_exiobase3(year, source, **extraction_kwargs)
+    elif table == 'figaro':
+        from mrio_toolbox.extractors.figaro.figaro_extractor import extract_figaro
+        mrio = extract_figaro(year, source, **extraction_kwargs)
+    elif table == 'emerging':
+        from mrio_toolbox.extractors.emerging.emerging_extractor import extract_emerging
+        mrio = extract_emerging(year, source, **extraction_kwargs)
+    elif table == 'gtap11':
+        from mrio_toolbox.extractors.gtap11 import extract_gtap11
+        mrio = extract_gtap11(year, source, destination, **extraction_kwargs)
+    else:
+        raise ValueError(f"Unsupported MRIO table: {table}")
+    if preprocessing:
+        mrio.preprocess(**preprocessing)
+    if not saving_kwargs and not destination:
+        return mrio
+    filepath = os.path.join(destination, f"{table}_year{year}.nc")
+    mrio.save(file = filepath, **saving_kwargs)

mrio_toolbox/extractors/figaro/__init__.py

@@ -0,0 +1,3 @@
+"""
+This module contains the figaro extractor and the figaro downloader.
+"""