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

mrio_toolbox/extractors/gtap11/extraction/harpy_files/header_array.py

@@ -1,300 +0,0 @@
-"""
-Created on Mar 02 11:39:45 2018
-
-"""
-import numpy as np
-from ._header_sets import  _HeaderDims
-from typing import Union,List,Dict
-
-
-class HeaderArrayObj(object):
-
-    __array_priority__ = 2 #make this precede the np __add__ operations, etc
-
-    def __init__(self):
-        self._coeff_name=""
-        self._array=None
-        self._sets=None
-        self._long_name=""
-
-    @property
-    def array(self) -> np.ndarray:
-        return self._array
-
-    @array.setter
-    def array(self, obj):
-        self._array = obj
-
-    @property
-    def coeff_name(self):
-        return self._coeff_name
-
-    @coeff_name.setter
-    def coeff_name(self, obj):
-        if not issubclass(type(obj), str):
-            msg = "'obj' must be of 'str' type."
-            raise TypeError(msg)
-        if len(obj) < 12:
-            obj.ljust(12)
-        self._coeff_name = obj
-
-    @property
-    def long_name(self):
-        return self._long_name
-
-    @long_name.setter
-    def long_name(self, obj):
-        self._long_name = obj
-
-    @property
-    def sets(self):
-        return self._sets
-
-    @sets.setter
-    def sets(self, obj):
-        self._sets = obj
-
-    @property
-    def setNames(self):
-        return self._sets.setNames
-
-    @setNames.setter
-    def setNames(self,sNames):
-        self._sets.setNames=sNames
-    
-    @property
-    def setElements(self):
-        return self._sets.setElements
-
-    @property
-    def rank(self):
-        return len(self.array.shape)
-
-    def __getitem__(self, item) -> 'HeaderArrayObj':
-        npInd, rankInd, newDim = self._sets.transform_index(item)
-        return HeaderArrayObj.HeaderArrayFromCompiledData(array=np.array(self.array[npInd][rankInd]), SetDims=newDim)
-
-    def __setitem__(self, key, value):
-        npInd, rankInd, newDim = self._sets.transform_index(key)
-        if isinstance(value,HeaderArrayObj):
-            self.array[npInd] = value.array
-        elif isinstance(value,(np.ndarray,int,float)):
-            self.array[npInd]=value
-        else:
-            raise TypeError("Only HeaderArrayObj, np.ndarray, int, float  allowed in __setitem__")
-
-
-
-    def is_valid(self, raise_exception=True) -> bool:
-        """
-        Checks if ``self`` is a valid ``HeaderArrayObj``.
-
-        :param bool raise_exception: If `False`, `True`/`False` will be returned on check success/failure. Otherwise an exception is raised (the default).
-        :return bool:
-        """
-
-        if not isinstance(self._array, (np.ndarray, np.float32, np.int32,np.float64)):
-            if raise_exception:
-                raise TypeError("HeaderArrayObj 'array' must be of type 'numpy.ndarray'.")
-            else:
-                return False
-
-        if not isinstance(self._sets, _HeaderDims):
-            raise TypeError("'sets' must be of type _HeaderDims")
-
-        if not isinstance(self.long_name, str):
-            raise TypeError("'long_name' must be of str type.")
-
-        if not isinstance(self.coeff_name, str):
-            raise TypeError("'coeff_name' must be of str type.")
-
-        if self._sets.shape != self.array.shape:
-            if not ( len(self._sets.shape) == 0 and self.array.size == 1):
-                raise ValueError("shape of set and array do not match")
-        return True
-
-    @staticmethod
-    def SetHeaderFromData(setName: str, setElements:'Union[List[str], np.array]',  long_name: str=None):
-        if not isinstance(setName,str):
-            raise TypeError("setName must be of type str")
-        if len(setName.strip()) > 12 :
-            raise ValueError("setName is restricted to 12 Characters")
-        if long_name is None: long_name=""
-        if isinstance(long_name, str):
-            long_name="Set "+setName.strip()+" "+long_name.strip()
-        else:
-            raise TypeError("LongName must be string")
-
-        if isinstance(setElements,(list,np.ndarray)):
-            if not all([isinstance(el,str) for el in setElements]):
-                raise TypeError("All Set Elements must be of type str")
-            if not all([len(el)<=12 for el in setElements]):
-                raise ValueError("Set Elelement strings must be 12 characters at most")
-
-        if isinstance(setElements,list):
-            array=np.array(setElements)
-            setElDict={setName:setElements}
-        elif isinstance(setElements,np.ndarray):
-            array=setElements
-            setElDict = {setName: setElements.tolist()}
-        else:
-            raise TypeError("SetElemenets must be list of str or np array of strings")
-
-
-        return HeaderArrayObj.HeaderArrayFromData(array=array, long_name=long_name, sets=[setName], setElDict=setElDict)
-
-    @staticmethod
-    def HeaderArrayFromData(array: np.ndarray, coeff_name: str = None, long_name: str = None,
-                            sets: 'List[str]' = None, setElDict: 'Dict[str:List[str]]' = None) -> 'HeaderArrayObj':
-        """
-        Creates a new HeaderArrayObj from basic data. I.e. sets and set elements are given as basic list and dict[str:list[str]]
-        """
-
-        hao = HeaderArrayObj()
-
-        HeaderArrayObj._setHeaderBaseData(array, coeff_name, hao, long_name)
-        if sets is None:
-            hao.sets = _HeaderDims.fromShape(array.shape)
-        else:
-            if not isinstance(sets,list):
-                raise TypeError("sets must be of type list")
-            if not all(isinstance(setName,str) for setName in sets):
-                raise TypeError("all setNames in sets must be strings")
-            if not all(len(setName) <= 12 for setName in sets):
-                raise TypeError("all setNames in sets must be shorter than 13 Characters")
-
-            if setElDict is None: setElDict={}
-            if not isinstance(setElDict,dict):
-                raise TypeError("setElDict must be of type dict[str:list[str]]")
-
-            hao.sets = _HeaderDims.fromSetShape(sets, setElDict, array.shape)
-
-        if hao.is_valid():
-            return hao
-
-    @staticmethod
-    def HeaderArrayFromCompiledData(array: np.ndarray, coeff_name: str=None, long_name: str=None,
-                            SetDims: _HeaderDims=None) -> 'HeaderArrayObj':
-        """
-        Creates a new HeaderArrayObj from precompiled data. I.e. sets are already in _HeaderDim structure
-        """
-
-        hao = HeaderArrayObj()
-
-        HeaderArrayObj._setHeaderBaseData(array, coeff_name, hao, long_name)
-        if not isinstance(SetDims,_HeaderDims):
-            raise TypeError("sets must be of type _HeaderDims")
-        if SetDims is None:
-            hao.sets = _HeaderDims.fromShape(array.shape)
-        else:
-            hao.sets = SetDims
-
-        if hao.is_valid():
-            return hao
-
-    @staticmethod
-    def _setHeaderBaseData(array, coeff_name, hao, long_name) -> None:
-        if not isinstance(array, (np.ndarray, np.float32, np.int32,np.float64)):
-            print(type(array))
-            raise HeaderArrayObj.UnsupportedArrayType("'array' must be of numpy.ndarray type.")
-
-        # Defaults handling
-        if coeff_name is None:
-            coeff_name = " " * 12
-        if long_name is None:
-            long_name = coeff_name
-        if len(coeff_name) < 12:
-            coeff_name = coeff_name.ljust(12)
-        if len(long_name) < 70:
-            long_name = long_name.ljust(70)
-        hao.array = array
-        hao.coeff_name = coeff_name
-        hao.long_name = long_name
-
-    def array_operation(self,
-                        other: "Union[np.ndarray, HeaderArrayObj]",
-                        operation: str,
-                        **kwargs) -> 'HeaderArrayObj':
-        """
-        This method is implemented to allow for operations on the arrays of HeaderArrayObjs. Most Tablo-like
-        functionality is replicated with this method.
-        :param "HeaderArrayObj" other: The second ``HeaderArrayObj`` involved in the operation.
-        :param str operation: A ``str`` specifying the ``numpy.ndarray`` operation attribute - e.g. ``"__add__"``.
-        :param dict kwargs: Any additional kwargs are passed to the new ``HeaderArrayObj``.
-        :return: A new ``HeaderArrayObj`` that results from the operation. Will have a default header name of ``"NEW1"``.
-        """
-
-
-        if issubclass(type(other), HeaderArrayObj):
-            new_array = getattr(self.array, operation)(other.array)
-            new_sets=self._sets.matchSets(sets=other._sets)
-        elif issubclass(type(other), np.ndarray):
-            new_array = getattr(self.array, operation)(other)
-            new_sets=self._sets.matchSets(shape=other.shape)
-        elif issubclass(type(other), (float, int)):
-            new_array = getattr(self.array, operation)(other)
-            new_sets=self._sets
-        else:
-            msg = "Operation is not permitted for objects that are not of 'numpy.ndarray' type, or 'HeaderArrayObj' type."
-            raise TypeError(msg)
-
-        return HeaderArrayObj.HeaderArrayFromCompiledData( array=new_array, SetDims=new_sets, **kwargs)
-
-    def __neg__(self):
-        self.array=-self.array
-        return self
-
-    def __add__(self, other):
-        return self.array_operation(other, "__add__")
-
-    def __mul__(self, other):
-        return self.array_operation(other, "__mul__")
-
-    def __truediv__(self, other):
-        return self.array_operation(other, "__truediv__")
-
-    def __floordiv__(self, other):
-        return self.array_operation(other, "__floordiv__")
-
-    def __pow__(self, other):
-        return self.array_operation(other, "__pow__")
-
-    def __mod__(self, other):
-        return self.array_operation(other, "__mod__")
-
-    def __sub__(self, other):
-        return self.array_operation(other, "__sub__")
-
-    def __radd__(self, other):
-        return self.array_operation(other, "__radd__")
-
-    def __rmul__(self, other):
-        return self.array_operation(other, "__rmul__")
-
-    def __rtruediv__(self, other):
-        return self.array_operation(other, "__rtruediv__")
-
-    def __rfloordiv__(self, other):
-        return self.array_operation(other, "__rfloordiv__")
-
-    def __rpow__(self, other):
-        return self.array_operation(other, "__rpow__")
-
-    def __rmod__(self, other):
-        return self.array_operation(other, "__rmod__")
-
-    def __rsub__(self, other):
-        return self.array_operation(other, "__rsub__")
-
-    def __str__(self) -> str:
-        outputstr="\n"
-        outputstr+="CoeffName".ljust(24)+": "+self.coeff_name+"\n"
-        outputstr+="Rank".ljust(24)+": "+str(len(self.array.shape))+"\n"
-        if self.sets:
-            outputstr += self.sets.__str__()
-
-        return outputstr
-
-    class UnsupportedArrayType(TypeError):
-        """Raised if invalid array type passed."""
-        pass

mrio_toolbox/extractors/gtap11/extraction/harpy_files/sl4.py

@@ -1,229 +0,0 @@
-"""
-Class for decoding SL4 files.
-"""
-from __future__ import print_function, absolute_import
-from .har_file import HarFileObj
-from .header_array import HeaderArrayObj
-import numpy as np
-
-
-class SL4(object):
-
-    def __init__(self, fname, extractList=None):
-        """
-        Decodes an SL4 file and returns variable Header (1 dim add containing cumulative solution + subtotals if present)
-        In addtion Set information is available via the getSet functions
-        :param fname: str filename of the SL4 file
-        :param extractList: list(varNames) only required if a subset of variables should be extracted
-        """
-        self._sets=[]
-        self._variables=[]
-        self.setHeaders={}
-        self.variableDict={}
-        self.varTypeDict={}
-        self.solFile=HarFileObj("fname"+".sol")
-        self.decode_SL4(fname, extractList)
-
-
-    @property
-    def variableNames(self):
-        return self._variables
-    @variableNames.setter
-    def variableNames(self, val):
-        raise Exception ("Variables in SL4 class cannot be assigned")
-
-    @property
-    def setNames(self):
-        return self._sets
-    @setNames.setter
-    def setNames(self,val):
-        raise Exception ("Sets in SL4 class cannot be assigned")
-
-    def varType(self,name):
-        if not name.strip().lower() in self.varTypeDict:
-            raise Exception("Could not find variable '" + name + "' in the SL4 file. Please check the variable list")
-        return self.varTypeDict[name.strip().lower()]
-
-    def getSet(self,name):
-        if not name.strip().lower() in self.setHeaders:
-            raise Exception ("Could not find set '"+name+"' in the SL4 file. Please check the set list")
-        return self.setHeaders[name.strip().lower()]
-
-    def getVariable(self,name:str) -> HeaderArrayObj:
-        if not name.strip().lower() in self.variableDict:
-            raise Exception("Could not find variable '" + name + "' in the SL4 file. Please check the variable list")
-        return self.variableDict[name.strip().lower()]
-
-    def decode_SL4(self, fname, extractList):
-        HarObj=HarFileObj(fname)
-
-        #collect the set information. Not sure whether intertemporals work yet
-        setNames =   HarObj["STNM"]
-        self.generateSetHeaders(HarObj, setNames)
-        resultsSet=["Cumulative"]
-        resultsDataHeaders=["CUMS"]
-        resultsShockComponents = ["SHCK"]
-        resultsShockList = ["SHCL"]
-        # check for subtotals
-        if "STLS" in HarObj.getHeaderArrayNames():
-            self.appendSubtotals(HarObj, resultsDataHeaders, resultsSet, resultsShockComponents, resultsShockList)
-
-
-        # Get the common header needed to extract the variable
-        varNames=   HarObj["VARS"]
-        varDims =   HarObj["VCNA"]
-        varSetPtr = HarObj["VCAR"]
-        varLabel  = HarObj["VCLB"]
-        varSizeEnd = HarObj["ORND"]
-        varSizeExo = HarObj["OREX"]
-        varExoList = HarObj["OREL"]
-        cumResCom = HarObj["CMND"]
-        cumResPtr = HarObj["PCUM"]
-        shockPtr  = HarObj["PSHK"]
-        shockVal  = HarObj["SHOC"]
-
-
-        varLower=[name.strip().lower() for name in varNames.array]
-        if not extractList: extractList=varLower
-        useVars=[item.lower() for item in extractList]
-        useDict=dict(zip(useVars,useVars))
-
-        self.varTypeDict=dict(zip(varLower,HarObj["VCTP"].array))
-        #prepare the different results. By default add cumulative. If subtatoals are present append them to the lists
-
-        self._variables=[name.strip() for name in varNames.array.tolist()]
-        varSetDict={}
-        nvar=len(self._variables)
-
-        nexoListUsed=0
-        nShkListUsed=0
-        setPos=0
-
-        self.variableDict={}
-
-        #extract the variables. The resulting headers do not distinguish between endo and exo
-        for i in range(0,nvar):
-            useIt=varLower[i] in useDict
-            setPos=self.generateSetDictEntry(i, resultsSet, setNames, setPos, varDims, varSetDict, varSetPtr)
-
-            outDataList = self.assembleVariableData(HarObj, cumResCom, cumResPtr, i, nexoListUsed,
-                                                                 resultsDataHeaders, resultsShockComponents,
-                                                                 resultsShockList, shockPtr, shockVal, varExoList,
-                                                                 varSizeEnd, varSizeExo, generateData=useIt)
-
-            if useIt: self.reshapeAndAdd(i, outDataList, varLabel, varSetDict)
-            nexo = varSizeExo.array[i, 0]
-            nendo = varSizeEnd.array[i, 0]
-            if nexo != 0 and nendo != 0: nexoListUsed += nexo
-
-
-        # adjust available information to extracted data
-        self._variables = [name.strip() for name in varNames.array.tolist() if name.strip().lower() in useDict]
-
-        self.varTypeDict = { key:val for key,val in  self.varTypeDict.items() if key.lower() in useDict}
-
-    def generateSetHeaders(self, HarObj, setNames):
-        setSizes = HarObj["SSZ"]
-        setLabels = HarObj["STLB"]
-        setElStat = HarObj["ELST"]
-        setEls = HarObj["STEL"]
-        setElPtr = HarObj["ELAD"]
-        self._sets = [name.strip().lower() for name in setNames.array.tolist()]
-        nsets = len(self._sets)
-        self.setHeaders = {}
-        for i in range(0, nsets):
-            if setElStat.array[i] == 'k':
-                start = (setElPtr.array[i, 0] - 1)
-                end = start + setSizes.array[i, 0]
-                self.setHeaders[self._sets[i].strip().lower()] = HeaderArrayObj.SetHeaderFromData(self._sets[i],
-                                                                                                  setEls.array[
-                                                                                                  start:end],
-                                                                                                  setLabels.array[i])
-
-    def reshapeAndAdd(self, i, outDataList, varLabel, varSetDict):
-        flatData = np.concatenate(outDataList)
-        varSets = [thisSet.strip() for thisSet in varSetDict[self._variables[i].strip().lower()]]
-        simSizes = tuple(
-            [self.getSet(thisSet).array.shape[0] for thisSet in varSetDict[self._variables[i].strip().lower()]])
-        setElDict = {}
-        for myset in varSets:
-            setElDict[myset.strip().lower()] = self.getSet(myset).array.tolist()
-        finalData = flatData.reshape(simSizes,order="F").astype(np.float32)
-        # create headers for all variables
-        self.variableDict[self._variables[i].strip().lower()] = \
-            HeaderArrayObj.HeaderArrayFromData(finalData,self._variables[i].strip()[0:12],varLabel.array[i][0:70], varSets, setElDict)
-
-    def assembleVariableData(self, HarObj, cumResCom, cumResPtr, iVar, nexoListUsed, resultsDataHeaders,
-                             resultsShockComponents, resultsShockList, shockPtr, shockVal, varExoList, varSizeEnd,
-                             varSizeExo, generateData=True):
-        nexo = varSizeExo.array[iVar, 0]
-        nendo = varSizeEnd.array[iVar, 0]
-        # Assemble the data into a vector (subtotals are appended to the list as they are in the results* Lists)
-        outDataList = []
-        if not generateData: return outDataList
-
-        for DataHead, ShockComHead, ShockListHead in zip(resultsDataHeaders, resultsShockComponents, resultsShockList):
-            cumRes = HarObj[DataHead]
-            shockCom = HarObj[ShockComHead]
-            shockList = HarObj[ShockListHead]
-            start = cumResPtr.array[iVar, 0] - 1
-            end = start + cumResCom.array[iVar, 0]
-            Data = np.asfortranarray(cumRes.array[start:end, 0])
-            nshk = shockCom.array[iVar, 0]
-            nShkListUsed=0
-            for prevVar in range(0,iVar):
-                prevNEndo=varSizeEnd.array[prevVar, 0]
-                prevNExo=varSizeExo.array[prevVar, 0]
-                prevNShocked=shockCom.array[prevVar, 0]
-                if prevNShocked != prevNExo or prevNEndo != 0: nShkListUsed+=prevNShocked
-
-            if nexo != 0 and nendo != 0:# partially exo
-                insertMask = []
-                for j in range(nexoListUsed, nexoListUsed + nexo):
-                    insertMask.append(varExoList.array[j, 0] - (j - nexoListUsed + 1))
-
-                flatData = np.insert(Data, insertMask, 0)
-
-                self.insertShocks(flatData, iVar, nshk, nexo, shockList, shockPtr, shockVal, nShkListUsed)
-            elif nendo != 0: #fully endo
-                flatData = Data
-            else:  # fully exo
-                flatData = np.zeros(nexo)
-                self.insertShocks(flatData, iVar, nshk, nexo, shockList, shockPtr, shockVal, nShkListUsed)
-            outDataList.append(flatData)
-        return outDataList
-
-    def generateSetDictEntry(self, i, resultsSet, setNames, setPos, varDims, varSetDict, varSetPtr):
-        ndim = varDims.array[i, 0]
-        if ndim > 0:
-            varSetDict[self._variables[i].strip().lower()] = setNames.array[[j - 1 for j in varSetPtr.array[setPos:setPos + ndim, 0]]].tolist()
-            varSetDict[self._variables[i].strip().lower()] = [name.strip() for name in varSetDict[self._variables[i].strip().lower()]]
-            setPos += ndim
-        else:
-            varSetDict[self._variables[i].strip().lower()] = []
-        if len(resultsSet) > 1: varSetDict[self._variables[i].strip().lower()].append("#RESULTS")
-        return setPos
-
-    def appendSubtotals(self, HarObj, resultsDataHeaders, resultsSet, resultsShockComponents, resultsShockList):
-        nresults = HarObj["STLS"].array.flatten()[0]
-        for i in range(1, nresults + 1):
-            resultsDataHeaders.append("%03iS" % i)
-            resultsShockComponents.append("%03iC" % i)
-            resultsShockList.append("%03iL" % i)
-            #resultsSet.append("Subtotal%03i" % i)
-        description = ["Cumulative Results"]
-        description.extend(HarObj["STDS"].array.tolist())
-        for name in HarObj["STDS"].array:
-            resultsSet.append(str(name) if len(name) <= 12 else str(name)[0:12])
-        self._sets.append("#results")
-        self.setHeaders["#results"] = HeaderArrayObj.SetHeaderFromData("#RESULTS", np.array(resultsSet), "Cumlative and Subtotal elements")
-
-    @staticmethod
-    def insertShocks(flatData, i, nshk, nexo, shockList, shockPtr, shockVal,nShkListUsed):
-        if nshk > 0:
-            start = shockPtr.array[i, 0] - 1
-            if nshk == nexo:
-                flatData[0:nexo]=shockVal.array[start:start+nshk,0]
-            else:
-                flatData[shockList.array[nShkListUsed:nShkListUsed+nshk,0]-1]=shockVal.array[start:start+nshk, 0]
-

mrio_toolbox/extractors/gtap11/gtap_mrio/__init__.py

@@ -1,6 +0,0 @@
-"""
-This module contains the IO builder for the GTAP 11 extractor.
-"""
-from .mrio_builder import build_io
-
-__all__ = ["build_io"]

mrio_toolbox/extractors/gtap11/gtap_mrio/mrio_builder.py

@@ -1,158 +0,0 @@
-"""
-Functions to build an MRIO object from GTAP data.
-"""
-
-import mrio_toolbox as mrio
-import logging
-
-log = logging.getLogger(__name__)
-
-def transform_gtap(gtap):
-    """
-    Convert the gtap data into an MRIO object.
-
-    Parameters
-    ----------
-    gtap : xarray Dataset
-        Extracted gtap data
-    """
-    return mrio.MRIO(data=gtap)
-
-def build_io(gtap):
-    """
-    Create the input-output table from the GTAP data
-
-    This function treats GTAP data as is.
-    It does not solve any imbalance and stays as close as possible
-    to the raw dataset.
-
-    The international trade block allocation follows 
-    from the proportionality assumptions.
-    Given the disagreement between import and export data,
-    we average the two to get the bilateral trade shares.
-    
-    Parameters
-    ----------
-    gtap_data : MRIO object
-        Direct extraction from the gtap data
-    """
-    if not isinstance(gtap,mrio.MRIO):
-        gtap = transform_gtap(gtap)
-
-    #We solve the disagreement between import and export data
-    #by averaging the two
-    log.info("Compute the trade shares")
-    trade = (gtap.VXSB + gtap.VMSB)/2
-    
-    #There are some non-null elements in the diagonal of the trade matrix
-    #These are statistical artefact from GTAP. We set them to zero.
-    for country in gtap.REG:
-        trade["all",country,country] = 0
-    
-    #Then, we normalize the trade shares
-    imports = trade.sum(axis=1)
-    imports.data[imports.data == 0] = 1
-    shares = trade/imports.expand_dims(axis=1)
-    #Shares is of shape (sectors,country of origin, country of destination)
-    #Shares some to 1 for each sector and country of destination
-
-    #Now, we create the inter-industry matrix
-    log.info("Create the inter-industry matrix")
-    log.info("Fill the diagonal blocks")
-    T = gtap.new_part(name="t",dimensions=(("REG","COMM"),("REG","COMM")))
-
-    log.info("Fill the off-diagonal blocks")
-    for current in gtap.REG:
-        #We create the inter-industry matrix within each country
-        #We only need to fit VDFB into the diagonal blocks of the matrix
-        T[(current,"all"),(current,"all")] = gtap.VDFB["all","all",current]
-        for partner in gtap.REG:
-            #We create the international trade block for each trade partner
-            if partner != current:
-                #We use the trade shares to split the sectoral imports 
-                #by trade partner
-                #This is known as the proportionality assumption
-                #It means that the trade shares of a country in a given market
-                #Does not depend on the sector buying it
-                T[(partner,"all"),(current,"all")] = gtap.VMFB[
-                    "all","all",current
-                    ]*shares[
-                    "all",partner,current
-                    ]
-    
-    log.info("Create the final demand matrix")
-    #We turn to the final demand matrix
-    #First, we create the labels for the final demand categories
-    gtap.labels["y_labs"] = ["Households","Government","Investment"]
-
-    #Now, we create the final demand matrix
-    Y = gtap.new_part(name="y",dimensions=(("REG","COMM"),("REG","y_labs")))
-
-    #The process is similar to the inter-industry matrix,
-    #but we have to loop over the final demand categories
-    categories = {
-        "Households":"P",
-        "Government":"G",
-        "Investment":"I"
-    }
-    for country in gtap.REG:
-        for category in categories:
-            #Fill the domestic use of domestic products
-            Y[(country,"all"),(country,category)] = gtap.parts[
-                f"VD{categories[category]}B"]["all",country]
-            for partner in gtap.REG:
-                if partner != country:
-                    #Fill the imports from each trade partner
-                    Y[(partner,"all"),(country,category)] = gtap.parts[
-                        f"VM{categories[category]}B"
-                        ]["all",country].data[:,None,:]*shares[
-                        "all",partner,country
-                    ].data
-
-    #Finally, we create the value added matrix.
-    #Our value added in basic prices encompasses the primary endowments,
-    #margins and net taxes and subsidies.
-    #Margins also include export taxes and subsidies,
-    #as these do not abund the value added of the importing country.
-
-    #Prepare the primary inputs / value added labels
-    log.info("Create the value added matrix")
-    va_labs = []
-    for endowment in gtap.ENDW:
-        va_labs.append(endowment)
-    va_labs.append("margins")
-    va_labs.append("net taxes and subsidies")
-    gtap.labels["va_labs"] = va_labs
-
-    #Create the value added matrix
-    VA = gtap.new_part(name="va",dimensions=(("va_labs"),("REG","COMM")))
-
-    #Reformat the va_labs
-    log.info("Cast the va_labs")
-    endowments = gtap.EVFB.reformat([["ENDW"],["ACTS","REG"]])
-    endowments = endowments.swap_ax_levels(1,"ACTS","REG")
-    VA[gtap.ENDW] = endowments
-
-    #Aggregate the margins and export taxes and subsidies
-    log.info("Aggregate margins and export taxes and subsidies")
-    margins = gtap.VTWR.sum(-1).sum(0) + gtap.XTRV.sum(2)
-    margins = margins.flatten()
-    margins = margins.swap_ax_levels(0,"COMM","REG")
-    VA[["margins"]] = margins
-
-    #Get the net taxes and subsidies as the residual
-    log.info("Derive net taxes and subsidies")
-    output = T.sum(1) + Y.sum(1)
-    VA[["net taxes and subsidies"]] = output - T.sum(0) - VA.sum(0)
-
-    gtap_mrio = mrio.MRIO()
-    gtap_mrio.metadata = gtap.metadata
-    for part in [T,Y,VA]:
-        gtap_mrio.add_part(part)
-
-    gtap_mrio.rename_dimensions(
-        ["REG","COMM"],
-        ["countries","sectors"]
-    )
-
-    return gtap_mrio