foxes 0.5.0.2__py3-none-any.whl → 0.5.2__py3-none-any.whl

foxes/utils/__init__.py

@@ -2,14 +2,16 @@
 General utilities.
 """
 from .wind_dir import wd2uv, wd2wdvec, wdvec2wd, uv2wd, delta_wd
-from .pandas_helpers import PandasFileHelper
+from .pandas_utils import PandasFileHelper
+from .xarray_utils import write_nc
 from .subclasses import all_subclasses
 from .dict import Dict
 from .data_book import DataBook
-from .plotly_helpers import show_plotly_fig
+from .plotly_utils import show_plotly_fig
 from .cubic_roots import cubic_roots
-from .geopandas_helpers import read_shp, shp2csv, read_shp_polygons, shp2geom2d
+from .geopandas_utils import read_shp, shp2csv, read_shp_polygons, shp2geom2d
 from .load import import_module
+from .exec_python import exec_python
 
 from . import two_circles
 from . import abl

foxes/utils/exec_python.py

@@ -0,0 +1,56 @@
+import numpy as np
+import pandas as pd
+import xarray as xr
+import matplotlib.pyplot as plt
+
+def exec_python(s, indicator="%", newline=";", globals=globals(), locals={}):
+    """
+    Executes strings that start with the
+    indicator as python commands, returns one value
+
+    Example: 
+    s = "%p%N=10;p=np.zeros((N,3));p[:,0]=50;p[:,1]=np.linspace(0,7000,N);p[:,2]=119"
+    
+    Parameters
+    ----------
+    s: list, dict or object
+        The source to by analyzed
+    indicator: str
+        The indicator that trigger python evaluation
+    newline: str
+        The new line indicator
+    globals: dict
+        The global namespace
+    locals: dict
+        The local namespace
+        
+    Returns
+    -------
+    out: list, dict or object
+        The same structure, but all python
+        strings evaluated
+    
+    :group: utils
+
+    """
+    if isinstance(s, str):
+        L = len(indicator)
+        if len(s) > L and s[:L] == indicator:
+            a = s[L:]
+            if not indicator in a:
+                exec(a, globals, locals)
+            else:
+                ilist = a.split(indicator)
+                if len(ilist) != 2:
+                    raise ValueError(f"Expecting at most 2 occurences of '{indicator}', found {len(ilist)}: {s}")
+                v, b = ilist
+                for c in b.split(newline):
+                    exec(c, globals, locals)
+                return locals[v]
+    elif isinstance(s, list):
+        return [exec_python(a, indicator) for a in s]
+    elif isinstance(s, tuple):
+        return tuple(exec_python(list(s), indicator))
+    elif isinstance(s, dict):
+        return {k: exec_python(a, indicator) for k, a in s.items()}
+    return s

foxes/utils/geopandas_utils.py

@@ -0,0 +1,294 @@
+import numpy as np
+import argparse
+
+import foxes.constants as FC
+from .dict import Dict
+from .geom2d import AreaUnion, ClosedPolygon
+
+try:
+    import geopandas as gpd
+
+    IMPORT_GPD_OK = True
+except ImportError:
+    gpd = None
+    IMPORT_GPD_OK = False
+
+try:
+    import utm
+
+    IMPORT_UTM_OK = True
+except ImportError:
+    utm = None
+    IMPORT_UTM_OK = False
+
+
+def check_import_gpd():
+    """
+    Checks if library import worked,
+    raises error otherwise.
+    """
+    if not IMPORT_GPD_OK:
+        print("\n\nFailed to import geopandas. Please install, either via pip:\n")
+        print("  pip install geopandas\n")
+        print("or via conda:\n")
+        print("  conda install -c conda-forge geopandas\n")
+        raise ImportError("Failed to import geopandas")
+
+
+def check_import_utm():
+    """
+    Checks if library import worked,
+    raises error otherwise.
+    """
+    if not IMPORT_UTM_OK:
+        print("\n\nFailed to import utm. Please install, either via pip:\n")
+        print("  pip install utm\n")
+        print("or via conda:\n")
+        print("  conda install -c conda-forge utm\n")
+        raise ImportError("Failed to import utm")
+
+
+def read_shp(fname, **kwargs):
+    """
+    Read a shape file
+
+    Parameters
+    ----------
+    fname: str
+        Path to the .shp file
+    kwargs: dict, optional
+        Additional parameters for geopandas.read_file()
+
+    Returns
+    -------
+    data: geopandas.GeoDataFrame
+        The data frame in WSG84
+
+    :group: utils
+
+    """
+    check_import_gpd()
+    gpdf = gpd.read_file(fname, **kwargs)
+    return gpdf.to_crs("EPSG:4326")  # Convert to WGS84
+
+
+def shp2csv(ifile, ofile, in_kwargs={}, out_kwargs={}, verbosity=1):
+    """
+    Read shape file, write csv file
+
+    Parameters
+    ----------
+    iname: str
+        Path to the input .shp file
+    oname: str
+        Path to the output .csv file
+    in_kwargs: dict
+        Additional parameters for geopandas.read_file()
+    out_kwargs: dict
+        Additional parameters for geopandas to_csv()
+    verbosity: int
+        The verbosity level, 0 = silent
+
+    :group: utils
+
+    """
+    if verbosity > 0:
+        print("Reading file", ifile)
+
+    gpdf = read_shp(ifile, **in_kwargs)
+
+    if verbosity > 0:
+        print("Writing file", ofile)
+
+    gpdf.to_csv(ofile, **out_kwargs)
+
+    return gpdf
+
+
+def _extract_poly_coords(geom):
+    """
+    Helper function for shapefile reading
+    """
+    if geom.geom_type == "Polygon":
+        exterior_coords = geom.exterior.coords[:]
+        interior_coords = []
+        for interior in geom.interiors:
+            interior_coords.append(interior.coords[:])
+    elif geom.geom_type == "MultiPolygon":
+        exterior_coords = []
+        interior_coords = []
+        for part in geom.geoms:
+            epe, epi = _extract_poly_coords(part)  # Recursive call
+            exterior_coords.append(epe)
+            interior_coords.append(epi)
+    else:
+        raise ValueError("Unhandled geometry type: " + repr(geom.type))
+    return exterior_coords, interior_coords
+
+
+def read_shp_polygons(
+    fname,
+    names=None,
+    name_col="Name",
+    geom_col="geometry",
+    to_utm=True,
+    ret_utm_zone=False,
+    **kwargs,
+):
+    """
+    Reads the polygon points from a shp file.
+
+    Parameters
+    ----------
+    fname: str
+        Path to the .shp file
+    names: list: of str, optinal
+        The names of the polygons to be extracted. All by
+        default
+    name_col: int
+        Column that contains the area names
+    geom_col: str
+        The geometry column
+    to_utm: bool or str, optional
+        Convert to UTM coordinates. If str, then UTM zone
+        plus letter, e.g. "32U"
+    ret_utm_zone: bool
+        Return UTM zone plus letter as str
+    kwargs: dict, optional
+        Additional parameters for geopandas.read_shp()
+
+    Returns
+    -------
+    point_dict_exterior: dict
+        Dict with list of array of points. Key: area name,
+        Value: list:np.ndarray, shape of latter: (n_points, 2)
+    point_dict_interior: dict
+        Dict with list of array of points. Key: area name,
+        Value: list:np.ndarray, shape of latter: (n_points, 2)
+    utm_zone_str: str, optional
+        The utem zone plus letter as str, e.g. "32U"
+
+    :group: utils
+
+    """
+
+    pdf = read_shp(fname, **kwargs)
+    pnames = list(pdf[name_col])
+
+    utmz = None
+    utml = None
+    apply_utm = False
+    if isinstance(to_utm, str) or to_utm == True:
+        apply_utm = True
+        check_import_utm()
+        utmz = int(to_utm[:-1]) if isinstance(to_utm, str) else None
+        utml = to_utm[-1] if isinstance(to_utm, str) else None
+
+    exterior = Dict()
+    interior = Dict()
+    names = pnames if names is None else names
+    for name in names:
+        if name == name:  # exclude nan values
+            if not name in pnames:
+                raise KeyError(
+                    f"Name '{name}' not found in file '{fname}'. Names: {pnames}"
+                )
+
+            a = pdf.loc[pnames.index(name), geom_col]
+            epe, epi = _extract_poly_coords(a)
+
+            def _to_utm(poly):
+                nonlocal utmz, utml
+                utm_poly = np.zeros_like(poly)
+                utm_poly[:, 0], utm_poly[:, 1], utmz, utml = utm.from_latlon(
+                    poly[:, 1],
+                    poly[:, 0],
+                    force_zone_number=utmz,
+                    force_zone_letter=utml,
+                )
+                return utm_poly
+
+            def _to_numpy(data):
+                if not len(data):
+                    return []
+                if isinstance(data[0], tuple):
+                    out = np.array(data, dtype=FC.DTYPE)
+                    return _to_utm(out) if apply_utm else out
+                return [_to_numpy(d) for d in data]
+
+            exterior[name] = _to_numpy(epe)
+            interior[name] = _to_numpy(epi)
+
+    if ret_utm_zone:
+        return exterior, interior, f"{utmz}{utml}"
+    else:
+        return exterior, interior
+
+
+def shp2geom2d(*args, ret_utm_zone=False, **kwargs):
+    """
+    Read shapefile into geom2d geometry
+
+    Parameters
+    ----------
+    args: tuple, optional
+        Arguments for read_shp_polygons()
+    ret_utm_zone: bool
+        Return UTM zone plus letter as str
+    kwargs: dict, optional
+        Keyword arguments for read_shp_polygons()
+
+    Returns
+    -------
+    geom: foxes.tools.geom2D.AreaGeometry
+        The geometry object
+    utm_zone_str: str, optional
+        The utem zone plus letter as str, e.g. "32U"
+
+    :group: utils
+
+    """
+
+    exint = read_shp_polygons(*args, ret_utm_zone=ret_utm_zone, **kwargs)
+
+    def _create_geom(data):
+        if not len(data):
+            return None
+        if isinstance(data, dict):
+            gs = [_create_geom(g) for g in data.values()]
+            gs = [g for g in gs if g is not None]
+            return AreaUnion(gs) if len(gs) else None
+        if isinstance(data, np.ndarray) and len(data.shape) == 2:
+            return ClosedPolygon(data)
+        gs = [_create_geom(g) for g in data]
+        gs = [g for g in gs if g is not None]
+        return AreaUnion(gs) if len(gs) else None
+
+    gext = _create_geom(exint[0])
+    gint = _create_geom(exint[1])
+    geom = gext - gint if gint is not None else gext
+
+    if ret_utm_zone:
+        return geom, exint[2]
+    else:
+        return geom
+
+
+if __name__ == "__main__":
+    # define arguments and options:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("shp_file", help="The input .shp file")
+    parser.add_argument("-n", "--names", help="Area names", default=None, nargs="+")
+    parser.add_argument(
+        "--no_utm", help="switch off conversion to UTM", action="store_true"
+    )
+    args = parser.parse_args()
+
+    g = shp2geom2d(args.shp_file, to_utm=not args.no_utm, names=args.names)
+
+    import matplotlib.pyplot as plt
+
+    fig, ax = plt.subplots()
+    g.add_to_figure(ax)
+    plt.show()
+    plt.close(fig)

foxes/utils/pandas_utils.py

@@ -0,0 +1,175 @@
+import pandas as pd
+from pathlib import Path
+import xarray
+from copy import deepcopy
+
+import foxes.variables as FV
+
+
+class PandasFileHelper:
+    """
+    This class helps reading and writing data
+    to files via pandas.
+
+    Attributes
+    ----------
+    DEFAULT_READING_PARAMETERS: dict
+        Default parameters for file reading
+        for the supported file formats
+    DEFAULT_WRITING_PARAMETERS: dict
+        Default parameters for file writing
+        for the supported file formats
+    DATA_FILE_FORMAT: list:str
+        The supported file formats for data export
+    DEFAULT_FORMAT_DICT: dict
+        Default column formatting
+
+    :group: utils
+
+    """
+
+    DEFAULT_READING_PARAMETERS = {
+        "csv": {},
+        "csv.gz": {},
+        "csv.bz2": {},
+        "csv.zip": {},
+        "h5": {},
+        "nc": {},
+    }
+
+    DEFAULT_WRITING_PARAMETERS = {
+        "csv": {},
+        "csv.gz": {},
+        "csv.bz2": {},
+        "csv.zip": {},
+        "h5": {"key": "foxes", "mode": "w"},
+        "nc": {},
+    }
+
+    DEFAULT_FORMAT_DICT = {
+        FV.WD: "{:.3f}",
+        FV.AMB_WD: "{:.3f}",
+        FV.YAW: "{:.3f}",
+        FV.AMB_YAW: "{:.3f}",
+        FV.WS: "{:.4f}",
+        FV.AMB_WS: "{:.4f}",
+        FV.REWS: "{:.4f}",
+        FV.AMB_REWS: "{:.4f}",
+        FV.REWS2: "{:.4f}",
+        FV.AMB_REWS2: "{:.4f}",
+        FV.REWS3: "{:.4f}",
+        FV.AMB_REWS3: "{:.4f}",
+        FV.TI: "{:.6f}",
+        FV.AMB_TI: "{:.6f}",
+        FV.RHO: "{:.5f}",
+        FV.AMB_RHO: "{:.5f}",
+        FV.P: "{:.3f}",
+        FV.AMB_P: "{:.3f}",
+        FV.CT: "{:.6f}",
+        FV.AMB_CT: "{:.6f}",
+        FV.T: "{:.3f}",
+        FV.AMB_T: "{:.3f}",
+        FV.YLD: "{:.3f}",
+        FV.AMB_YLD: "{:.3f}",
+        FV.CAP: "{:.5f}",
+        FV.AMB_CAP: "{:.5f}",
+        FV.EFF: "{:.5f}",
+    }
+
+    DATA_FILE_FORMATS = list(DEFAULT_READING_PARAMETERS.keys())
+
+    @classmethod
+    def read_file(cls, file_path, **kwargs):
+        """
+        Helper for reading data according to file ending.
+
+        Parameters
+        ----------
+        file_path: str
+            The path to the file
+        **kwargs: dict, optional
+            Parameters forwarded to the pandas reading method.
+
+        Returns
+        -------
+        pandas.DataFrame :
+            The data
+
+        """
+        fpath = Path(file_path)
+        fname = fpath.name
+        sfx = ".".join(fname.split(".")[1:])
+        f = None
+        for fmt in cls.DATA_FILE_FORMATS:
+            if sfx[:3] == "csv":
+                f = pd.read_csv
+            elif sfx == "h5":
+                f = pd.read_hdf
+            elif sfx == "nc":
+                f = lambda fname, **pars: xarray.open_dataset(
+                    fname, **pars
+                ).to_dataframe()
+
+            if f is not None:
+                pars = deepcopy(cls.DEFAULT_READING_PARAMETERS[fmt])
+                pars.update(kwargs)
+                return f(file_path, **pars)
+
+        raise KeyError(
+            f"Unknown file format '{fname}'. Supported formats: {cls.DATA_FILE_FORMATS}"
+        )
+
+    @classmethod
+    def write_file(cls, data, file_path, format_dict={}, **kwargs):
+        """
+        Helper for writing data according to file ending.
+
+        Parameters
+        ----------
+        data: pandas.DataFrame
+            The data
+        file_path: str
+            The path to the file
+        format_dict: dict
+            Dictionary with format entries for
+            columns, e.g. '{:.4f}'
+        **kwargs: dict, optional
+            Parameters forwarded to the pandas writing method.
+
+        """
+
+        fdict = deepcopy(cls.DEFAULT_FORMAT_DICT)
+        fdict.update(format_dict)
+
+        out = pd.DataFrame(index=data.index, columns=data.columns)
+        for c in data.columns:
+            if c in fdict.keys():
+                out[c] = data[c].map(
+                    lambda x: fdict[c].format(x) if not pd.isna(x) else x
+                )
+            else:
+                out[c] = data[c]
+
+        fpath = Path(file_path)
+        fname = fpath.name
+        sfx = ".".join(fname.split(".")[1:])
+        f = None
+        for fmt in cls.DATA_FILE_FORMATS:
+            if sfx[:3] == "csv":
+                f = out.to_csv
+            elif sfx == "h5":
+                f = out.to_hdf
+            elif sfx == "nc":
+                f = out.to_netcdf
+
+            if f is not None:
+                pars = cls.DEFAULT_WRITING_PARAMETERS[fmt]
+                pars.update(kwargs)
+
+                f(file_path, **pars)
+
+                return
+
+        raise KeyError(
+            f"Unknown file format '{file_path}'. Supported formats: {cls.DATA_FILE_FORMATS}"
+        )

foxes/utils/plotly_utils.py

@@ -0,0 +1,19 @@
+import plotly.io as pio
+import io
+from PIL import Image
+
+
+def show_plotly_fig(fig):
+    """
+    Displays a plotly figure in a window
+
+    Reference:
+    https://stackoverflow.com/questions/53570384/plotly-how-to-make-a-standalone-plot-in-a-window
+
+    :group: utils
+
+    """
+    buf = io.BytesIO()
+    pio.write_image(fig, buf)
+    img = Image.open(buf)
+    img.show()

foxes/utils/xarray_utils.py

@@ -0,0 +1,38 @@
+
+def write_nc(ds, fpath, round="auto", complevel=5, verbosity=1, **kwargs):
+    """
+    Writes a dataset to netCFD file
+    
+    Parameters
+    ----------
+    fpath: str
+        Path to the output file, should be nc
+    round: dict or str, optional
+        The rounding definitions, or auto for 
+        default settings
+    complevel: int
+        The compression level
+    verbosity: int
+        The verbosity level, 0 = silent
+    kwargs: dict, optional
+        Additional parameters for xarray.to_netcdf
+
+    """
+
+    if round is not None:
+        for v in ds.coords.keys():
+            if v in round:
+                if verbosity > 1:
+                    print(f"Rounding {v} to {round[v]} decimals")
+                ds[v].data = ds[v].data.round(decimals=round[v])
+        for v in ds.data_vars.keys():
+            if v in round:
+                if verbosity > 1:
+                    print(f"Rounding {v} to {round[v]} decimals")
+                ds[v].data = ds[v].data.round(decimals=round[v])
+
+    if verbosity > 0:
+        print("Writing file", fpath)
+
+    enc = {k: {"zlib": True, "complevel": complevel} for k in ds.data_vars}
+    ds.to_netcdf(fpath, encoding=enc, **kwargs)

{foxes-0.5.0.2.dist-info → foxes-0.5.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: foxes
-Version: 0.5.0.2
+Version: 0.5.2
 Summary: Farm Optimization and eXtended yield Evaluation Software
 Author: Fraunhofer IWES
 Author-email: jonas.schmidt@iwes.fraunhofer.de