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

mrio_toolbox/extractors/gtap11/extraction/__init__.py

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

mrio_toolbox/extractors/gtap11/extraction/extractor.py

@@ -0,0 +1,129 @@
+"""
+Extracts the data from the .har file and saves it as .npy files.
+"""
+
+import os
+from mrio_toolbox.extractors.gtap11.extraction.harpy_files.har_file import HarFileObj
+
+import xarray as xr
+import logging
+import mrio_toolbox.extractors.gtap11.gtap_mrio.mrio_builder as mrio_builder
+
+log = logging.getLogger(__name__)
+
+def extract_gtap11(
+        year = 2017,
+        source = "",
+        files = "all",
+        name = "gtap",
+        build_io = True,
+        save_raw = True
+):
+    """
+    Extract GTAP data from .har files and save it as .nc file.
+
+    Parameters
+    ----------
+    source : str, optional
+        Location of the source files, by default the current directory
+    save_raw : str, optional
+        Where to save the raw files, by default the current directory
+    files : list, optional
+        List of files to extract, by default, all files in the source directory
+    name : str, optional
+        Name under which the files are saved, by default "gtap"
+    build_io : bool, optional
+        Whether to build the input-output table, by default False
+
+    Raises
+    ------
+    NotADirectoryError
+        Exception raised when the source directory does not exist
+    FileNotFoundError
+        Exception raised when the destination directory does not contain any .har files
+        If only some files are missing, a warning is issued but the extraction continues
+    """
+    #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.")
+
+    log.info(f"Extracting GTAP data from {os.path.abspath(source)}")
+    
+    #List available har files
+    har_files = [f for f in os.listdir(source) if f.endswith(".har")]
+    if len(har_files) == 0:
+        log.error(f"No .har files found in {os.path.abspath(source)}")
+        raise FileNotFoundError(f"No .har files found in {os.path.abspath(source)}")
+    log.info(f"Found {len(har_files)} .har files in {os.path.abspath(source)}")
+
+    if isinstance(files, str) and files == "all":
+        files = har_files
+    
+    ds = xr.Dataset()
+    for file in files:
+        if file not in har_files:
+            log.warning(f"{file} not found in {os.path.abspath(source)}")
+            continue
+        log.info(f" Extracting {file}")
+        filename = os.path.join(source, file)
+        data = HarFileObj(filename = filename)
+        variables = data.getHeaderArrayNames()
+        for variable in variables:
+            log.info(f"     Extracting {variable}")
+            ds = convert_variable(data, variable, ds)
+
+    if save_raw:
+        log.info(f"Saving {name}_raw.nc")
+        if save_raw is True:
+            #By default, save in the source folder
+            save_raw = source
+        ds.to_netcdf(os.path.join(save_raw, f"{name}_raw.nc"))
+    if build_io:
+        log.info("Building input-output table")
+        mrio = mrio_builder.build_io(ds)
+        mrio.name = f"{name}_{year}"
+        return mrio
+
+def convert_variable(file, variable, ds):
+    """
+    Convert a variable from a .har file to a xarray DataArray.
+
+    Data descriptor variables are stored as attributes of the dataset.
+
+    Parameters
+    ----------
+    file : harpy.HarFileObj
+        Representation of the .har file
+    variable : str
+        Name of the variable to extract
+    ds : xarray.Dataset
+        Dataset to which the variable is added
+
+    Returns
+    -------
+    ds : xarray.Dataset
+        Updated dataset
+    """
+    data = file[variable]
+    coords = dict()
+    dims = []
+    for dim in data.sets.dims:
+        if dim.name is None:
+            #Intercepts descriptive variables
+            log.info(f"     {variable} is a descriptive variable")
+            ds.attrs[variable] = str(data.array)
+            return ds
+        dims.append(dim.name)
+        coords[dim.name] = dim.dim_desc
+    ds[variable] = xr.DataArray(
+        data.array,
+        coords = coords,
+        dims = dims,
+        attrs = {
+            "long_name": data.long_name,
+            "name" : variable
+        }
+    )
+    return ds 
+    

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

@@ -0,0 +1,6 @@
+"""
+The code in this module is copied from the HARPY package, which you can visit on github:
+https://github.com/GEMPACKsoftware/HARPY/tree/master
+
+Both the HARPY library and the MRIO toolbox library are licenced under the GPL 3 license.
+"""

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

@@ -0,0 +1,279 @@
+"""
+Created on Jun 29 14:46:48 2018
+
+"""
+
+import numpy as np
+from typing import List, Union
+
+class _HeaderSet:
+    """
+    This class is used to represent sets associated with header arrays.
+    """
+
+#    Status is unknown elements but set, element index, known set elements, no set just numeric
+    _valid_status = ["u", "e", "k", "n"]
+    _genSetID     = 0
+
+    def __init__(self, name: 'Union[str,None]',
+                 status: str,
+                 dim_desc: 'Union[List[str],str,None]',
+                 dim_size: int):
+
+        self.name = name
+        self.status = status
+        self.dim_desc = dim_desc
+        if not dim_desc is None:
+            if any([len(el) > 12 for el in dim_desc]):
+                raise ValueError("Set Element too long (maximum 12 Characters for set Elements)")
+        self.elemPosDict={} if self.dim_desc is None else dict(zip( [elem.strip().lower() for elem in dim_desc], range(0,len(self.dim_desc))))
+        self.dim_size = dim_size
+
+    def transform_index(self,index):
+        if isinstance(index,(str,int)):
+            return self.name_to_ind(index), None
+
+        elif isinstance(index,slice):
+            newslice=self.convertSlice(index)
+            npIndList=list(range(self.dim_size))[newslice]
+            SetName=self._newname() if not all(p is None for p in [newslice.start,newslice.stop,newslice.step]) else self.name
+            if self.dim_desc:
+                return npIndList, _HeaderSet(SetName, self.status, self.dim_desc[newslice], len(npIndList))
+            else:
+                return npIndList, _HeaderSet(SetName, self.status, dim_desc=None, dim_size=len(npIndList))
+
+
+        elif isinstance(index,list):
+            useElem=self.status in ["e","k"]
+            setElList=[] if useElem else None
+            npIndList=[]
+            for ind in index:
+                if isinstance(ind, (str,int) ):
+                    idx=self.name_to_ind(ind)
+                    npIndList.append(idx)
+                    if useElem: setElList.append(self.dim_desc[idx])
+                elif isinstance(ind,slice):
+                    newslice = self.convertSlice(ind)
+                    npIndList.append(list(range(self.dim_size))[newslice])
+                    if useElem: setElList.extend(self.dim_desc[newslice])
+                else:
+                    raise TypeError("Only slice, str, int allowed in list indexing")
+            if useElem:
+                if len(set(setElList)) != len(setElList):
+                    raise ValueError("Indexing leads to duplicate set elements which is not permitted")
+                if setElList != self.dim_desc:
+                    return npIndList, _HeaderSet(self._newname(), self.status, setElList, len(npIndList))
+                else:
+                    return npIndList, self
+            else:
+                return npIndList, _HeaderSet(self._newname(), self.status, None, len(npIndList))
+
+
+    def convertSlice(self,index):
+        if not isinstance(index.step, int) and not index.step is None:
+            raise ValueError("step in slice has to be integer")
+        start=self.name_to_ind(index.start)
+        start= None if start==0 else start
+        stop = self.name_to_ind(index.stop)
+        stop =  None if stop==self.dim_size else stop
+        step= None if index.step == 1 else index.step
+        return slice(start, stop, step)
+
+    def name_to_ind(self,idx):
+        if idx is None:
+            return None
+        elif isinstance(idx,str):
+            if idx.strip().lower() in self.elemPosDict:
+                return self.elemPosDict[idx.strip().lower()]
+            else:
+                raise ValueError("Element not in set")
+        elif isinstance(idx,int):
+            if idx >= self.dim_size:
+                raise ValueError("Index Out Of bounds")
+            return idx
+
+    def _newname(self):
+        _HeaderSet._genSetID+=1
+        return "S@"+str(_HeaderSet._genSetID)
+
+
+class _HeaderDims:
+
+    def __init__(self, setList):
+        self._dims=setList
+
+    @staticmethod
+    def fromShape(shape):
+        setList=[_HeaderSet(None, 'n', None, dim) for dim in shape]
+        return _HeaderDims(setList)
+
+    @staticmethod
+    def fromSetShape(sets, setElDict, shape):
+        setObjList=[]
+        lowerDict=dict(zip([key.strip().lower() for key in setElDict.keys()], setElDict.keys() ))
+        for idim, setName in enumerate(sets):
+            lowSet=setName.strip().lower()
+            if lowSet in lowerDict:
+                setObjList.append(_HeaderSet(setName,'k',setElDict[lowerDict[lowSet]],shape[idim]))
+            else:
+                setObjList.append(_HeaderSet(setName, 'u', None, shape[idim]))
+        return _HeaderDims(setObjList)
+
+
+    @property
+    def dims(self) -> List[_HeaderSet]:
+        return self._dims
+
+    @dims.setter
+    def dims(self, obj) -> None:
+        self._dims = obj
+
+    def ndim(self):
+        """
+        Number of dimensions
+        """
+        return len(self._dims)
+
+    def defined(self):
+        """
+        Tells whether dimensensions have sets defined or are just array like
+        """
+        return not all([dim.name is None for dim in self._dims])
+
+    @property
+    def setNames(self):
+        return [dim.name for dim in self.dims]
+    
+    @setNames.setter
+    def setNames(self, sNames):
+        if not isinstance(sNames,list): raise TypeError("set Names needs to be given as a list of strings")
+        if len(sNames) != len(self.dims) : raise ValueError("wrong length of set List. Header is rank "+str(len(self.dims))+ "but received list size "+ len(sNames))
+        for name in sNames:
+            if not isinstance(name,str): raise TypeError("set Names contains a non string object: "+str(name))
+            if len(name.strip()) > 12 : raise ValueError("Set names are limited to 12 characters. received '"+name+"'")
+        for newName, dim in zip(sNames,self.dims):
+            dim.name=newName.strip()
+
+    @property
+    def setElements(self):
+        return [dim.dim_desc for dim in self.dims]
+
+    @property
+    def shape(self):
+        return tuple([sets.dim_size for sets in self._dims])
+
+    def __str__(self):
+        outputstr=""
+        for setDim in self._dims:
+            if setDim.status in "keu":
+                outputstr+="   " + setDim.name.ljust(12) + ": \n"
+            else:
+                outputstr+="   "+"Not Specified"
+            if setDim.status in "ke":
+                outputstr+="      " +", ".join(setDim.dim_desc) + "\n"
+        return outputstr
+
+
+
+    def compatible_shape(self,other):
+        return self.shape == other
+
+    def matchSets(self,sets=None, shape:tuple=None):
+        if sets is None and shape is None : raise KeyError("Only one argument allowed")
+        newSets = []
+        if not sets is None:
+            # Try to match the shape of the dimensions
+            iset=len(self.dims)-1; jset=len(sets.dims)-1
+            while iset >=0 and jset >=0:
+                if jset < 0 :
+                    newSets.append(self.dims[iset])
+                    iset -=1
+                elif iset < 0 :
+                    newSets.append(sets.dims[jset])
+                    jset -=1
+                if self.dims[iset].dim_size == sets.dims[jset].dim_size or self.dims[iset].dim_size == 1 or sets.dims[jset].dim_size == 1:
+                    if self.dims[iset].status != 'n':
+                        newSets.append(self.dims[iset])
+                    else:
+                        newSets.append(sets.dims[jset])
+                    iset-= 1 ; jset -=1
+            newSets.reverse()
+        elif not shape is None:
+            iset = len(self.dims) - 1; jset=len(shape)-1
+            while iset >=0 and jset >=0:
+                if jset < 0 :
+                    newSets.append(self.dims[iset])
+                    iset -=1
+                elif iset < 0 :
+                    newSets.append(_HeaderSet(None , 'n' , None, shape[jset]))
+                    jset -=1
+                if self.dims[iset].dim_size == shape[jset] or self.dims[iset].dim_size == 1 or shape[jset] == 1:
+                    newSets.append(self.dims[iset])
+                    iset-= 1 ; jset -=1
+            newSets.reverse()
+        else:
+            return KeyError("Either sets o shape have to be defined")
+
+        return _HeaderDims(newSets)
+
+
+    def transform_index(self,index_tuple):
+        if not isinstance(index_tuple,tuple):
+            index_tuple=(index_tuple,)
+
+        trueLen=len([x for x in index_tuple if x is not None])
+        if trueLen != self.ndim() and not Ellipsis in index_tuple:
+            raise ValueError("Rank mismatch in indexing")
+        if index_tuple.count(Ellipsis)>1:
+            raise ValueError("Only single Ellipsis (...) allowed in indexing")
+
+        thisIndex=[]
+        for ind in index_tuple:
+            if ind == Ellipsis:
+                for i in range(0,self.ndim()-trueLen+1):
+                    thisIndex.append(slice(None,None,None))
+            elif isinstance(ind,(list,str,int,slice)) or ind is None:
+                thisIndex.append(ind)
+            else:
+                raise TypeError("Only ...,list,str,int,slice and None allowed as indices")
+
+        npIndex=[]
+        newSets=[]
+
+        iset=0
+        for index in thisIndex:
+            if index is None:
+                npInd=np.newaxis
+                newSet=_HeaderSet(None , 'n' , None, 1)
+            else:
+                setDim=self._dims[iset]
+                npInd, newSet = setDim.transform_index(index)
+                iset+=1
+            npIndex.append(npInd)
+            newSets.append(newSet)
+
+        rankIndex=tuple([slice(None) if isinstance(ind,list) or ind is None else 0 for ind in npIndex])
+        newSets = [setDim for ri, setDim in zip(rankIndex,newSets) if ri != 0]
+        return self._makeNPIndex(npIndex), rankIndex, _HeaderDims(newSets)
+
+
+    @staticmethod
+    def _makeNPIndex(indexList):
+        newinds = []
+        for i, item in enumerate(indexList):
+            if isinstance(item, list):
+                newinds.append(item)
+            elif isinstance(item,int):
+                newinds.append([item])
+
+        numpyInd = list(np.ix_(*newinds))
+        newinds=[]
+        for item in indexList:
+            if not item is None:
+                newinds.append(numpyInd.pop(0))
+            else:
+                newinds.append(None)
+
+        return tuple(newinds)
+
+

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

@@ -0,0 +1,262 @@
+"""
+.. autoclass: HarFileObj
+    :members:
+
+Created on Mar 12 09:53:27 2018
+"""
+
+from .har_file_io import HarFileIO, HarFileInfoObj
+from .header_array import HeaderArrayObj
+from collections import OrderedDict
+from typing import TypeVar, List, Union
+from os import path
+import warnings
+TypeHarFileObj = TypeVar('TypeHarFileObj', bound='HarFileObj')
+
+class HarFileObj(object):
+    """
+    HAR file object - essentially a memory representation of a HAR file.
+
+    ``HarFileObj`` stores a `list` of ``harpy.HeaderArrayObj`` in ``self``.
+    Each ``harpy.HeaderArrayObj`` corresponds to a header-array.
+    If ``HarFileObj`` is provided with ``filename``, then the header-arrays in that file will be loaded - i.e., each ``harpy.HeaderArrayObj`` in ``self`` will correspond to a header-array in that file.
+
+    Access to the ``HarFileObj`` is provided in a dict-like style: `__getitem__`, `__setitem__`, `__delitem__`, and `__contains__` are implemented. Each can take list arguments and returns results as a list.
+    Note that all methods are case insensitive with respect to header names.
+
+    Example: given file ex.har with Headers HD1 and HD2::
+
+        >>> from harpy import HarFileObj
+        >>> thisHar = HarFileObj("ex.har")
+        >>> headersOnFile = thisHar.getHeaderArrayNames()  # ["HD1","HD2"]
+        >>> hd1Head = thisHar["HD1"]  # obtain the HeaderArrayObj for HD1
+        >>> del thisHar["HD1"]  # remove HD1 from HarFile
+        >>> print("HD1" in thisHar)
+        False
+        >>> thisHar.writeToDisk()  # overwrites ex.har, now only contains HD2
+
+    Attributes
+    ----------
+    head_arrs : OrderedDict
+        Returned/provided as a `list` of ``HeaderArrayObj`` defining all ``HeaderArrayObj`` associated with a file.
+
+    _hfi : HarFileInfoObj
+        Basic info of the HAR file content. This is used in conjunction with `head_arrs` to permit on-the-fly reading of ``HeaderArrayObj`` and thus reduce the memory footprint.
+    """
+
+
+    def __init__(self, filename: str=None):
+        self._head_arrs = OrderedDict()
+        self.filename=filename
+        if isinstance(filename, str):
+            if path.isfile(filename):
+                self._hfi = HarFileIO.readHarFileInfo(filename)
+            else:
+                self._hfi = HarFileInfoObj(file=filename)
+
+    def __getitem__(self, item : 'Union[str, List[str]]' ):
+        if isinstance(item,str):
+            return self._getHeaderArrayObj(item)
+        elif isinstance(item,list):
+            if not all([isinstance(myitem,str) for myitem in item]):
+                raise TypeError("All items in item must be of type 'str'")
+            return self._getHeaderArrayObjs(item)
+        else:
+            raise TypeError("item must be string or list of strings")
+
+
+    def __setitem__(self, key: 'Union[str, List[str]]', value: 'Union[HeaderArrayObj, List[HeaderArrayObj]]'):
+        if isinstance(key, str) and isinstance(value,HeaderArrayObj):
+            self._addHeaderArrayObj(key, value)
+        elif isinstance(key, list) and isinstance(value,list):
+            if not all([isinstance(mykey,str) for mykey in key]):
+                raise TypeError("All items in key must be of type 'str'")
+            if not all([isinstance(myval,HeaderArrayObj) for myval in value]):
+                raise TypeError("All items in value must be of type 'HeaderArrayObj'")
+            self._addHeaderArrayObjs(key, value)
+        else:
+            raise TypeError("Only combination str-HeaderArrayObj or list(str)-list(HeaderArrayObj) permitted in __getitem__'")
+
+        return None
+
+    def __delitem__(self, key):
+        if isinstance(key,str):
+            if key.strip().upper() in self._head_arrs:
+                del self._head_arrs[key.strip().upper()]
+        elif isinstance(key,list):
+            for mykey in key:
+                if mykey in self._head_arrs:
+                    del self[mykey]
+        else:
+            raise TypeError("key must be string or list of strings")
+
+        return None
+
+    def __contains__(self, key):
+        if isinstance(key,str):
+            return key.strip().upper() in self._head_arrs
+        return False
+
+
+
+
+    def getHeaderArrayNames(self):
+        """
+        :return: Returns the name of all ``harpy.HeaderArrayObj()`` stored with ``self``.
+        """
+
+        if not self._hfi.is_valid(fatal=False):
+            warnings.warn("Har file "+self._hfi.filename+" has changed since last access, rereading information")
+            self._hfi=HarFileObj(self._hfi.file)._hfi
+            self._head_arrs=OrderedDict()
+
+        return self._hfi.getHeaderArrayNames()
+
+    def getRealHeaderArrayNames(self):
+        """
+        :return: Returns only the names of arrays of type 2D or 7D - i.e. multi-dimensional header arrays of floating point numbers.
+        """
+
+        if not self._hfi.is_valid():
+            warnings.warn("Har file "+self._hfi.filename+" has changed since last access, rereading information")
+            self._hfi = HarFileObj(self._hfi.file)._hfi
+            self._head_arrs = OrderedDict()
+        return [key for key,val in self._hfi.items() if val.data_type in ["RE","RL","2R"]]
+
+
+    def _getHeaderArrayObj(self, ha_name: str):
+        """
+        Retrieve a single ``harpy.HeaderArrayObj``.
+
+        :param ha_name: The ``"name"`` of the ``harpy.HeaderArrayObj``.
+        :return: A ``harpy.HeaderArrayObj``.
+        """
+
+        if not self._hfi.is_valid(fatal=False):
+            warnings.warn("Har file "+self._hfi.filename+" has changed since last access, rereading information")
+            self._hfi = HarFileObj(self._hfi.file)._hfi
+            self._head_arrs = OrderedDict()
+
+        if not isinstance(ha_name, str):
+            raise TypeError("'ha_name' must be a string.")
+
+        upname=ha_name.strip().upper()
+        if not upname in self._hfi:
+            raise KeyError("HeaderArrayObj '%s' does not exist in HarFileObj." % ha_name)
+        if not upname in self._head_arrs:
+            hnames, haos=  HarFileIO.readHeaderArraysFromFile(self._hfi, ha_names=upname)
+            self._head_arrs[upname]=haos[0]
+
+        return self._head_arrs[upname]
+
+    def _getHeaderArrayObjs(self, ha_names=None):
+        """
+        Retrieve a `list` of `harpy.HeaderArrayObj`.
+
+        :param 'Union[None,str,List[str]]' ha_names: The name or `list` of names of ``harpy.HeaderArrayObj``. If `None` is provided (the default) then all ``harpy.HeaderArrayObj`` are returned.
+        :return: `list` of ``harpy.HeaderArrayObj``.
+        """
+
+        if isinstance(ha_names, str):
+            ha_names = [ha_names]
+        elif ha_names is None:
+            ha_names = self.getHeaderArrayNames()
+
+        ha_objs = []
+        for ha_name in ha_names:
+            ha_objs.append(self._getHeaderArrayObj(ha_name))
+        return ha_objs
+
+    def _readHeaderArrayObjs(self, ha_names = None):
+        """
+         Reads the header array objects with names ``ha_names`` from ``filename``. If `None` (the default), read all header array objects. `harpy.HeaderArrayObj` are stored in ``self`` and can be retrieved with the ``self.getHeaderArrayObjs()`` method.
+
+        :param 'Union[None,str,List[str]]' ha_names:
+        """
+        hnames, haos = HarFileIO.readHeaderArraysFromFile(self._hfi, ha_names=ha_names)
+        self._head_arrs=OrderedDict(zip(hnames, haos))
+
+
+    def writeToDisk(self, filename: str=None, ha_names=None):
+        """
+        :param str filename: Writes `harpy.HeaderArrayObj` with ``ha_names`` to ``filename``. If ``ha_names`` is None, write all the `harpy.HeaderArrayObj` stored in ``self``.
+        :param 'Union[None,str,List[str]]' ha_names: The names of the header arrays to write to ``filename``.
+        """
+        if filename is None and self.filename is None:
+            raise ValueError("No filename specified in write or upon creation, use writeToDisk(filename=YOURFILENAME)")
+        if filename is None:
+            filename=self.filename
+        if ha_names is None:
+            ha_names = self.getHeaderArrayNames()
+        elif isinstance(ha_names, str):
+            ha_names = [ha_names]
+
+        ha_to_write = self._getHeaderArrayObjs(ha_names)
+
+        HarFileIO.writeHeaders(filename, ha_names, ha_to_write)
+        self._hfi.updateMtime()
+
+    def _removeHeaderArrayObjs(self, ha_names):
+        """
+        TODO: its more of a pop, not a remove, maybe rename
+        :param 'Union[str,List[str]]' ha_names: Remove one or more `harpy.HeaderArrayObj` from ``self``.
+        """
+
+        if isinstance(ha_names, str):
+            ha_names = [ha_names]
+
+        outlist=self._getHeaderArrayObjs(ha_names)
+
+        for ha_name in ha_names:
+            if ha_name.strip().upper() in self._hfi:
+                del self._hfi._ha_infos[ha_name.strip().upper()]
+            if ha_name.strip().upper() in self._head_arrs:
+                del self._head_arrs[ha_name.strip().upper()]
+        return outlist
+
+    def _addHeaderArrayObjs(self, hnames, ha_objs) -> None:
+        """
+        :param 'Union[HeaderArrayObj,List[HeaderArrayObj]]' ha_objs: Add one or more `harpy.HeaderArrayObj` to ``self``.
+        """
+
+        if isinstance(ha_objs, HeaderArrayObj):
+            ha_objs = [ha_objs]
+        if isinstance(hnames, str):
+            hnames = [hnames]
+
+        for hname, ha_obj in zip(hnames,ha_objs):
+            if ha_obj.is_valid():
+                self._addHeaderArrayObj(hname, ha_obj)
+
+        return None
+
+    def _addHeaderArrayObj(self, hname : str, ha_obj: HeaderArrayObj):
+        """
+        :param ha_obj: A `harpy.HeaderArrayObj` object.
+        """
+
+        if len(hname.strip()) > 4:
+            raise HarFileObj.InvalidHeaderArrayName("Name of Header too long")
+
+        self._hfi.addHAInfo(hname.strip().upper(),0,0)
+        self._head_arrs[hname.strip().upper()]= ha_obj
+
+
+    @staticmethod
+    def _loadFromDisk(filename: str, ha_names: list = None) -> TypeHarFileObj:
+        """Loads a HAR file into memory, returning a HarFileObj.
+
+        :param filename: The name of the file to load.
+        :param ha_names: If provided, only reads headers with the names matching the strings contained in this list. By default, all header arrays are read.
+        :return "HarFileObj": Returns ``HarFileObj`` with
+        """
+
+        hfo = HarFileObj(filename=filename)
+        hfo._readHeaderArrayObjs(ha_names=ha_names)
+
+        return hfo
+
+
+    class InvalidHeaderArrayName(ValueError):
+        """Raised if header array name is not exactly four (alphanumeric) characters long."""
+        pass