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

mrio_toolbox/_parts/__init__.py

@@ -1,7 +0,0 @@
-"""
-This module provides the Part and Axe classes.
-"""
-
-from ._Part import Part,load_part
-
-__all__ = ['Part','load_part']

mrio_toolbox/_parts/part_operations.py

@@ -1,57 +0,0 @@
-"""Basic operations on Parts
-
-Because of my inexperience in software development,
-I only created this file lately.
-
-I will move the relevant methods from the _Part class to this file
-at a later point.
-"""
-
-def reformat(part,new_dimensions):
-    """
-    Reshape a Part to match a new dimensions combination.
-
-    Equivalent to a combination of the develop and combine_axes methods.
-
-    This only works for contiguous dimensions in the current Part,
-    without overlapping dimensions.
-
-    Parameters
-    ----------
-    new_dimensions : list of list of str
-        Target dimensions to reshape into.
-
-    Returns
-    -------
-    data : numpy.ndarray
-        Reshaped data.
-    axes : list of Axe
-        Reshaped axes.
-
-    Examples
-    --------
-    If the Part has dimensions::
-
-        [["countries"], ["sectors"], ["sectors"]]
-
-    The following is allowed::
-
-        [["countries", "sectors"], ["sectors"]]
-
-    The following is not allowed::
-
-        [["countries"], ["sectors", "sectors"]]
-        [["sectors"], ["countries", "sectors"]]
-        [["sectors", "countries"], ["sectors"]]
-    """
-    def formatting_iteration(part,new_dimensions):
-        if part.get_dimensions() == new_dimensions:
-            return part
-        for i,dim in enumerate(part.get_dimensions()):
-            if dim != new_dimensions[i]:
-                part = part.combine_axes(i,i+len(new_dimensions[i])-1)
-                return formatting_iteration(part,new_dimensions)
-    developed = part.develop(squeeze = False)
-    return formatting_iteration(developed,new_dimensions)
-
-

mrio_toolbox/extractors/__init__.py

@@ -1,20 +0,0 @@
-"""
-This module provides functions to extract raw MRIO data from various providers. 
-Given the raw data files, it allows to build an MRIO object to be used with this library.
-"""
-from .extractors import *
-from .downloaders import *
-
-__all__ = [
-    "extract_MRIO",
-    "extract_eora",
-    "extract_gloria",
-    "extract_wiod",
-    "extract_exiobase",
-    "extract_figaro",
-    "extract_emerging",
-    "extract_gtap",
-    "extract_icio",
-    "download_MRIO",
-    "download_figaro"
-]

mrio_toolbox/extractors/downloaders.py

@@ -1,36 +0,0 @@
-"""
-Module for extracting and converting data from various sources.
-"""
-
-import logging as log
-log = log.getLogger(__name__)
-
-
-def download_MRIO(table,year,destination,**kwargs):
-    """
-    Downloads the MRIO from the internet and saves it to the specified destination. 
-   
-    Specific downloaders are called based on the table name.
-    Refer to the individual downloader functions for more details.
-    
-    Parameters
-    ----------
-    table : str
-        Name of the MRIO table to extract. Currently supported:
-        
-        - 'figaro': Downloading FIGARO data.
-    
-    year : str
-        Year of the data to extract.
-    destination : path-like
-        Path to the destination directory where the NetCDF file will be saved.
-    **kwargs : dict
-        Additional keyword arguments specific to the extractor function.
-        For example, `extended` for WIOD extraction to specify if extended data should be included.
-    """
-    log.info(f"Download MRIO data for table '{table}' for year {year} to the folder {destination}")
-    if table == 'figaro':
-        from mrio_toolbox.extractors.figaro.figaro_downloader import download_figaro
-        download_figaro(year, destination, **kwargs)
-    else:
-        raise ValueError(f"Downloader for table '{table}' is not implemented yet. Currently supported: 'figaro'.")

mrio_toolbox/extractors/emerging/__init__.py

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

mrio_toolbox/extractors/emerging/emerging_extractor.py

@@ -1,117 +0,0 @@
-"""
-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

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

mrio_toolbox/extractors/eora/eora_extractor.py

@@ -1,132 +0,0 @@
-"""
-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

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

mrio_toolbox/extractors/exiobase/exiobase_extractor.py

@@ -1,270 +0,0 @@
-"""
-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
-