snowpat 0.3.1__tar.gz

snowpat-0.3.1/PKG-INFO

@@ -0,0 +1,181 @@
+Metadata-Version: 2.1
+Name: snowpat
+Version: 0.3.1
+Summary: 
+Author: leibersp
+Author-email: patrick.leibersperger@slf.ch
+Requires-Python: >=3.9,<4.0
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Dist: h5py (>=3.5,<4.0)
+Requires-Dist: matplotlib (>=3.8.3,<4.0.0)
+Requires-Dist: numpy (>=1.26,<2.0)
+Requires-Dist: pandas (>=2,<3)
+Description-Content-Type: text/markdown
+
+# SNOWPAT
+
+This is a toolbox for handling file formates most often used at SLF.
+
+There are two submodules:
+pysmet: Used to read and write SMET files
+snowpackreader: Used to read SNOWPACK output files (.pro) and handle profiles easily (soon also with visualization)
+SnowLense: Plotting Framework for files that can be read with this module (SMET not yet available) ([see Documentation](https://snowpat-patrick-leibersperger-c7ec84b7d2c6ab235482777a3905915fe.gitlab-pages.wsl.ch/indexplot/))
+
+## News
+
+2024-03-08: Plotting of Snow Profiles is available with SnowLense module
+
+2024-03-01: A simple merge function is now available to join to SMET Files: merge(SMETFile, override) and mergeFromFile(filename, override)
+
+## Installation
+
+Installation via pip and poetry is supported. 
+
+The easiest way to is to directly install from git (needs git to be installed):
+
+```bash
+pip install [--user] git+https://gitlabext.wsl.ch/patrick.leibersperger/snowpat.git
+```
+
+the --user option might be needed if you do not have admin rights.
+
+### Upgrade
+
+If you already have an installation of Sowpat, that is out of date, run:
+
+```bash
+pip install [--user] --upgrade git+https://gitlabext.wsl.ch/patrick.leibersperger/snowpat.git
+```
+
+### Manually
+
+Download the folder, and from the main directory run:
+
+```bash
+poetry install
+```
+
+or:
+
+```bash
+pip install [--user] .
+```
+
+## Documentation
+
+The main documentation can be found under the respective module names, i.e. pySMET and SMET, as well as snowpackreader
+
+Extensive Documentation is available [online](http://snowpat-patrick-leibersperger-c7ec84b7d2c6ab235482777a3905915fe.gitlab-pages.wsl.ch/), it uses http, so you might get a privacy error in your browser;
+Or prepuilt in artifacts.zip, whic can be found in [job artifacts](https://gitlabext.wsl.ch/patrick.leibersperger/snowpat/-/artifacts): under (Number) files download the folder.
+
+If you download the zip folder just open index.html in your browser.
+
+Or you can build the docs yourself.
+
+### MkDocs
+
+To create the docs with MkDocs:
+Install via
+
+```bash
+pip install mkdocs
+```
+
+run:
+
+```bash
+mkdocs serve
+```
+
+from the main directory and follow the link shown (localhost)
+
+
+## License
+
+This project is licensed under the terms of the GNU-GPL-3.0 license.
+
+## Examples
+
+Please see the Documentation for more Examples and information on the full capabilities
+
+```python
+from snowpat import pysmet as smet
+from snowpat import snowpackreader as spr
+```
+
+### Examples pySMET
+
+```python
+from snowpat import pysmet as smet
+
+file = smet.read(filename)
+data_pandas = file.data
+data_numpy = file.toNumpy()
+# meta_data only contains the mandatory SMET metadata
+station_id = file.meta_data.station_id
+lon = file.meta_data.location.longitude
+
+# optional_meta_data according to the file format can be accessed like this:
+timezone = file.optional_meta_data.tz
+
+# acdd metadata (anything preceded with acdd_ or known acdd attributes are stored in acdd metadata)
+acdd_creator_name = file.acdd_meta_data.get_attribute("creator_name")
+
+# everything else is in other metadata
+value = file.other_metadata["key"]
+
+# changing metadata
+file.meta_data.station_ID = "WFJ"
+file.acdd_meta_data.set_attribute("creator_name", "SomeName")
+
+# and for writing to an output again (if no output filename is provided, the given filename is used with an out flag):
+file.write(out_filename)
+
+# a summary is also available wih
+file.info()
+
+#UNTESTED:
+# it is also possible to merge to SMET files, as long as they are compatible (metadata and fields)
+other_file = smet.read(other_filename)
+file.merge(other_file)
+
+# or
+list_of_files_to_merge = [filename1, filename2,filename3,...]
+merged_file = smet.merge_files(list_of_files_to_merge)
+```
+
+### Examples snowpackreader
+
+```python
+from snowpat import snowpackreader as spr
+pro = spr.readPRO("test.pro")
+
+# print a summary of the file
+pro.info()
+
+# all available dates
+dates = pro.get_all_dates()
+
+# will only return data above the ground after this
+pro.discard_below_ground(True)
+# get a Snowpack object (internal data class for Profiles) on a specific date
+profile = pro.get_profile_on(dates[0])
+# convert it to a dataframe with minimum stability and surface hoar as metadata
+# column names will be data codes, except for "0500"= height (layer boundaries)-> 2 columns: layer middle and layer thickness
+profile.toDf().head()
+wl = profile.weak_layer # or profile.get_param["0534"]
+sh = profile.surface_hoar # pr profile.get_param["0514"]
+
+# There is help, to deal with the DataCodes:
+# per default, the names are as in the .pro Header (without units)
+pro.update_name_of_code("0503", "Snow Density")
+density_code = pro.name_to_code("Snow Density")
+
+
+```
+
+Logo was creaeted with: hotpot.ai/art-generator

snowpat-0.3.1/README.md

@@ -0,0 +1,163 @@
+# SNOWPAT
+
+This is a toolbox for handling file formates most often used at SLF.
+
+There are two submodules:
+pysmet: Used to read and write SMET files
+snowpackreader: Used to read SNOWPACK output files (.pro) and handle profiles easily (soon also with visualization)
+SnowLense: Plotting Framework for files that can be read with this module (SMET not yet available) ([see Documentation](https://snowpat-patrick-leibersperger-c7ec84b7d2c6ab235482777a3905915fe.gitlab-pages.wsl.ch/indexplot/))
+
+## News
+
+2024-03-08: Plotting of Snow Profiles is available with SnowLense module
+
+2024-03-01: A simple merge function is now available to join to SMET Files: merge(SMETFile, override) and mergeFromFile(filename, override)
+
+## Installation
+
+Installation via pip and poetry is supported. 
+
+The easiest way to is to directly install from git (needs git to be installed):
+
+```bash
+pip install [--user] git+https://gitlabext.wsl.ch/patrick.leibersperger/snowpat.git
+```
+
+the --user option might be needed if you do not have admin rights.
+
+### Upgrade
+
+If you already have an installation of Sowpat, that is out of date, run:
+
+```bash
+pip install [--user] --upgrade git+https://gitlabext.wsl.ch/patrick.leibersperger/snowpat.git
+```
+
+### Manually
+
+Download the folder, and from the main directory run:
+
+```bash
+poetry install
+```
+
+or:
+
+```bash
+pip install [--user] .
+```
+
+## Documentation
+
+The main documentation can be found under the respective module names, i.e. pySMET and SMET, as well as snowpackreader
+
+Extensive Documentation is available [online](http://snowpat-patrick-leibersperger-c7ec84b7d2c6ab235482777a3905915fe.gitlab-pages.wsl.ch/), it uses http, so you might get a privacy error in your browser;
+Or prepuilt in artifacts.zip, whic can be found in [job artifacts](https://gitlabext.wsl.ch/patrick.leibersperger/snowpat/-/artifacts): under (Number) files download the folder.
+
+If you download the zip folder just open index.html in your browser.
+
+Or you can build the docs yourself.
+
+### MkDocs
+
+To create the docs with MkDocs:
+Install via
+
+```bash
+pip install mkdocs
+```
+
+run:
+
+```bash
+mkdocs serve
+```
+
+from the main directory and follow the link shown (localhost)
+
+
+## License
+
+This project is licensed under the terms of the GNU-GPL-3.0 license.
+
+## Examples
+
+Please see the Documentation for more Examples and information on the full capabilities
+
+```python
+from snowpat import pysmet as smet
+from snowpat import snowpackreader as spr
+```
+
+### Examples pySMET
+
+```python
+from snowpat import pysmet as smet
+
+file = smet.read(filename)
+data_pandas = file.data
+data_numpy = file.toNumpy()
+# meta_data only contains the mandatory SMET metadata
+station_id = file.meta_data.station_id
+lon = file.meta_data.location.longitude
+
+# optional_meta_data according to the file format can be accessed like this:
+timezone = file.optional_meta_data.tz
+
+# acdd metadata (anything preceded with acdd_ or known acdd attributes are stored in acdd metadata)
+acdd_creator_name = file.acdd_meta_data.get_attribute("creator_name")
+
+# everything else is in other metadata
+value = file.other_metadata["key"]
+
+# changing metadata
+file.meta_data.station_ID = "WFJ"
+file.acdd_meta_data.set_attribute("creator_name", "SomeName")
+
+# and for writing to an output again (if no output filename is provided, the given filename is used with an out flag):
+file.write(out_filename)
+
+# a summary is also available wih
+file.info()
+
+#UNTESTED:
+# it is also possible to merge to SMET files, as long as they are compatible (metadata and fields)
+other_file = smet.read(other_filename)
+file.merge(other_file)
+
+# or
+list_of_files_to_merge = [filename1, filename2,filename3,...]
+merged_file = smet.merge_files(list_of_files_to_merge)
+```
+
+### Examples snowpackreader
+
+```python
+from snowpat import snowpackreader as spr
+pro = spr.readPRO("test.pro")
+
+# print a summary of the file
+pro.info()
+
+# all available dates
+dates = pro.get_all_dates()
+
+# will only return data above the ground after this
+pro.discard_below_ground(True)
+# get a Snowpack object (internal data class for Profiles) on a specific date
+profile = pro.get_profile_on(dates[0])
+# convert it to a dataframe with minimum stability and surface hoar as metadata
+# column names will be data codes, except for "0500"= height (layer boundaries)-> 2 columns: layer middle and layer thickness
+profile.toDf().head()
+wl = profile.weak_layer # or profile.get_param["0534"]
+sh = profile.surface_hoar # pr profile.get_param["0514"]
+
+# There is help, to deal with the DataCodes:
+# per default, the names are as in the .pro Header (without units)
+pro.update_name_of_code("0503", "Snow Density")
+density_code = pro.name_to_code("Snow Density")
+
+
+```
+
+Logo was creaeted with: hotpot.ai/art-generator

snowpat-0.3.1/pyproject.toml

@@ -0,0 +1,23 @@
+[tool.poetry]
+name = "snowpat"
+version = "0.3.1"
+description = ""
+authors = ["leibersp <patrick.leibersperger@slf.ch>"]
+readme = "README.md"
+
+[tool.poetry.dependencies]
+python = "^3.9"
+pandas = "^2"
+h5py = "^3.5"
+numpy = "^1.26"
+matplotlib = "^3.8.3"
+
+
+[tool.poetry.group.dev.dependencies]
+ipykernel = "^6.29.2"
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"
+
+[tool.poetry_bumpversion.file."snowpat/__init__.py"]

snowpat-0.3.1/snowpat/SnowLens/Utils.py

@@ -0,0 +1,152 @@
+from enum import Enum
+from datetime import datetime
+from typing import Union, Dict, Callable, get_origin, get_args
+from matplotlib.colors import Colormap, Normalize
+from numpy import ndarray
+from collections.abc import Callable as CallableType
+import matplotlib.pyplot as plt
+import numpy as np
+
+class PlotType(Enum):
+    PRO = 1
+    SMET = 2
+    PROFILE = 3
+
+from typing import get_origin, get_args, Union, Callable
+
+def show_figure(fig:plt.Figure):
+    """
+    A helper function, to easily make a figure available to be displayed with plt.show .
+
+    Parameters:
+    fig (matplotlib.figure.Figure): The figure to be displayed.
+
+    """
+    dummy = plt.figure()
+    new_manager = dummy.canvas.manager
+    new_manager.canvas.figure = fig
+    fig.set_canvas(new_manager.canvas)
+
+
+def _type_to_string(t):
+    origin = get_origin(t)
+    if origin is None:
+        # t is a plain type
+        return t.__name__
+    elif origin is Union:
+        # t is a Union type
+        args = ", or ".join(_type_to_string(arg) for arg in get_args(t))
+        return f"Either: {args}"
+    elif origin is CallableType:
+        # t is a Callable type
+        arg_types = get_args(t)[:-1]
+        return_type = get_args(t)[-1]
+        arg_types_str = ", ".join(_type_to_string(arg) for arg in arg_types[0])
+        return_type_str = _type_to_string(return_type)
+        return f"function({arg_types_str}) -> {return_type_str}"
+    else:
+        # t is another kind of special type
+        args = ", ".join(_type_to_string(arg) for arg in get_args(t))
+        return f"{origin.__name__}[{args}]"
+    
+def _is_of_type(value, needed_type)->bool:
+    v_origin = get_origin(value)
+    n_origin = get_origin(needed_type)
+    if n_origin is None:
+        return isinstance(value, needed_type)
+    elif n_origin is Union:
+        return any(_is_of_type(value, arg) for arg in get_args(needed_type))
+    elif n_origin is CallableType:
+        return _check_function(value)        
+    elif n_origin is list:
+        if not isinstance(value, list):
+            return False
+        if not value:
+            return True
+        return all(_is_of_type(val, get_args(needed_type)[0]) for val in value)
+    elif n_origin is dict:
+        if not isinstance(value, dict):
+            return False
+        if not value:
+            return True
+        key_type, dval_type = get_args(needed_type)
+        return all(_is_of_type(key, key_type) and _is_of_type(val, dval_type) for key, val in value.items())        
+    else:
+        return isinstance(value, needed_type)       
+    
+def _check_function(func)->bool:
+    if not callable(func):
+        return False
+    code = "0501"
+    data = np.array([0, 1, 2, 3, 4])
+    try:
+        res = func(code, data)
+        if not isinstance(res, np.ndarray):
+            print("The data editing function needs to return a numpy array")
+            return False
+        if res.shape != data.shape:
+            print("the data editing function needs to return an array of the same shape as the input")
+            return False
+    except:
+        return False
+    return True
+    
+GENERAL_KWARGS = {
+    "outfile": str
+}
+GENERAL_HELP_TEXT = {
+    "outfile": "The path to save the plot to"
+}
+    
+SMET_KWARGS = {}
+SMET_HELP_TEXT = {}
+
+PROFILE_KWARGS = {
+    "ind_mfcrust": bool,
+    "standardized_limits": bool
+}
+PROFILE_HELP_TEXT = {
+    "ind_mfcrust": "If True, the MF crust will be indicated",
+    "standardized_limits": "If True, the limits of the plot will be set as in niviz, otherwise depending on data"
+}
+
+SNOWPACK_KWARGS = {
+    "start": datetime,
+    "stop": datetime,
+    "resolution": str,
+    "num_ticks": int,
+    "cmap": Union[Colormap, Dict[str, Colormap], Dict[str, str]],
+    "norm": Union[Normalize, Dict[str, Normalize]],
+    "cbar_label": Union[str, Dict[str, str], type(None)],
+    "n_cols": int,
+    "title": str,
+    "vmin": Union[int, Dict[str, int]],
+    "vmax": Union[int, Dict[str, int]],
+    "adjust_data": Callable[[str, ndarray], ndarray],
+    "single_ticks": bool,
+    "set_ylabel": bool,
+    "colorbar": bool,
+    "ind_mfcrust": bool,
+    "profile_on": datetime,
+}
+
+SNOWPACK_HELP_TEXT = {
+    "start": "The start time of the plot",
+    "stop": "The stop time of the plot",
+    "resolution": "The resolution of dates of the plot",
+    "num_ticks": "The number of ticks on the x-axis, if not set, the ticks will be formatted automatically",
+    "cmap": "The colormap to use for the plot, either a single colormap or a dictionary with colormaps for each variable",
+    "norm": "The normalization to use for the plot, either a single normalization or a dictionary with normalizations for each variable",
+    "cbar_label": "The label of the colorbar, either a single label or a dictionary with labels for each variable",
+    "n_cols": "The subplots to be plotted side by side",
+    "title": "The title of the plot",
+    "vmin": "The minimum value of the colorbar, either a single value or a dictionary with values for each variable",
+    "vmax": "The maximum value of the colorbar, either a single value or a dictionary with values for each variable",
+    "adjust_data": "A function to adjust the data before plotting: f(var_code, ndarray) -> ndarray, needs to handle parameter for a single profile",
+    "single_ticks": "If True, ticks will only be plotted per profile will be plotted",
+    "set_ylabel": "If True, the y-label will be set",
+    "colorbar": "If True, a colorbar will be plotted",
+    "ind_mfcrust": "If True, the MF crust will be indicated",
+    "profile_on": "The date of the profile to be plotted"
+}
+    

snowpat-0.3.1/snowpat/SnowLens/__init__.py

@@ -0,0 +1,6 @@
+from .snowlens import plot, help
+from .plot_snowpack import SnowpackPlotter
+from .plotting import plotProfile
+from .Utils import show_figure
+
+__all__ = ['plot', 'help', 'SnowpackPlotter', 'show_figure', 'plotProfile']

snowpat-0.3.1/snowpat/SnowLens/plot_helpers_snowpack.py

@@ -0,0 +1,174 @@
+import matplotlib.colors as mcolors
+import matplotlib.cm as cm
+import matplotlib.pyplot as plt
+import matplotlib.ticker as ticker
+import matplotlib.dates as mdates
+
+from dataclasses import dataclass
+
+import numpy as np
+import datetime
+
+from typing import List, Dict, Optional, Callable, Union
+
+
+grain_type_color = ['greenyellow', 'darkgreen', 'pink', 'lightblue', 'blue', 'magenta', 'red', 'cyan', 'lightblue']
+
+def getColorMap(var_code) -> mcolors.Colormap:
+    if var_code == "0513":
+        cmap = mcolors.ListedColormap(grain_type_color)
+    elif var_code == "0503":
+        cmap = "coolwarm"
+        cmap = cm.get_cmap(cmap)
+    elif var_code == "0502":
+        cmap = "Greys"
+        cmap = cm.get_cmap(cmap)
+    elif var_code == "0535":
+        cmap = "viridis"
+        cmap = cm.get_cmap(cmap)
+    elif var_code == "0506":
+        cmap = "viridis"
+        cmap = cm.get_cmap(cmap)
+    else:
+        cmap = "viridis"
+        cmap = cm.get_cmap(cmap)
+    return cmap
+
+def getNorm(var_code) -> mcolors.Normalize:
+    if var_code == "0513":
+        norm = mcolors.BoundaryNorm([0.5,1.5,2.5,3.5,4.5,5.5,6.5,7.5,8.5,9.5], 9)
+    elif var_code == "0503":
+        norm = mcolors.Normalize(vmin=-20, vmax=0)
+    elif var_code == "0506":
+        norm = mcolors.Normalize(vmin=0, vmax=5)
+    elif var_code == "0502":
+        norm = mcolors.Normalize(vmin=0, vmax=600)
+    elif var_code == "0535":
+        norm = mcolors.Normalize(vmin=0, vmax=60)
+    else:
+        norm = mcolors.LogNorm(vmin=10 ** -1, vmax=1)
+    return norm
+
+def adjustData(var_code:str, data:np.ndarray)->np.ndarray:
+    new_data = data.copy()
+    new_data = np.where(np.isnan(new_data), -999, new_data)
+    if var_code == "0513":
+        new_data = np.where(new_data == 772, -100, new_data)
+        new_data = (divmod(new_data, 100)[0]).astype(int)
+        new_data = np.where(new_data == -10, -999, new_data)
+        new_data = np.where(new_data == -1, 7.2, new_data)
+    if var_code == "0535": # TODO: is this needed?
+        ice_density = 917
+        new_data = 6 / (ice_density * new_data/1000)   
+    return new_data
+        
+@dataclass
+class PlotHelper:
+    set_ylabel : bool = True
+    single_ticks : bool = True
+    colorbar : bool = True
+    set_cbar_label : bool = True
+    ind_mfcrust : bool = True
+    n_cols : int = 1
+    start : Optional[datetime.datetime] = None
+    stop : Optional[datetime.datetime] = None
+    resolution : Optional[str] = None
+    num_ticks : Optional[int] = None
+    cmap : Optional[mcolors.Colormap] = None
+    norm : Optional[mcolors.Normalize] = None
+    cmap_dict : Optional[Dict[str, mcolors.Colormap]] = None
+    norm_dict : Optional[Dict[str, mcolors.Normalize]] = None
+    cbar_label : Optional[Union[str, Dict[str,str]]] = None
+    title : Optional[str] = None
+    subtitle : Optional[Dict[str,str]] = None
+    adjust_data : Optional[Callable[[str,np.ndarray],np.ndarray]] = None
+    
+    def getCbarLabel(self, var_code:str)->str:
+        is_available = False
+        cbar_label = None
+        if self.cbar_label:
+            try:
+                cbar_label = self.cbar_label[var_code]
+                is_available = True
+            except KeyError:
+                pass
+        return cbar_label, is_available
+    
+    def getSubtitle(self, var_code:str)->str:
+        is_available = False
+        subtitle = None
+        if self.subtitle:
+            try:
+                subtitle = self.subtitle[var_code]
+                is_available = True
+            except KeyError:
+                pass
+        return subtitle, is_available
+    
+    
+    def getNorm(self, var_code) -> mcolors.Normalize:
+        if self.norm_dict:
+            try:
+                norm = self.norm_dict[var_code]
+            except KeyError:
+                norm = getNorm(var_code)
+        elif self.norm:
+            norm = self._plot_info.norm 
+        else:
+            norm = getNorm(var_code)
+        return norm
+    
+    def getCmap(self, var_code)->mcolors.Colormap:
+        if self.cmap_dict:
+            try:
+                cmap = self.cmap_dict[var_code]
+            except KeyError:
+                cmap = getColorMap(var_code)
+        elif self.cmap:
+            cmap = self.cmap 
+        else:
+            cmap = getColorMap(var_code)
+        if isinstance(cmap, str):
+            cmap = cm.get_cmap(cmap)
+        return cmap
+    
+    def handleData(self, var_code:str, data:np.ndarray)->np.ndarray:
+        if self.adjust_data:
+            res = self.adjust_data(var_code, data)
+            if var_code == "0513" or var_code == "0503":
+                if np.array_equal(res, data): 
+                    res = adjustData(var_code, data) 
+        else:
+            res = adjustData(var_code, data)
+        return res
+
+class CustomFormatter(mdates.DateFormatter):
+    def __init__(self, month_fmt, year_fmt):
+        self.month_fmt = month_fmt
+        self.year_fmt = year_fmt
+        super().__init__(month_fmt)
+
+    def __call__(self, x, pos=0):
+        # Convert the current x value to a date
+        current_date = mdates.num2date(x)
+
+        # If this is the first date, there's no previous date to compare to
+        if pos == 0:
+            self.prev_date = current_date
+            return current_date.strftime(self.year_fmt)
+
+        # If the current date and the previous one have the same year, return the month format
+        if current_date.year == self.prev_date.year:
+            if current_date.month == self.prev_date.month:
+                return ''
+            else:
+                self.prev_date = current_date
+                return current_date.strftime(self.month_fmt)
+
+        # Otherwise, update the previous date and return the year format
+        self.prev_date = current_date
+        return current_date.strftime(self.year_fmt)
+    
+def _add_crust_lines(ax:plt.Axes, x:list, h:np.ndarray, mesh:np.ndarray):
+    crust_mesh = np.ma.masked_where(mesh != 7.2, mesh)
+    ax.pcolor(x, h, crust_mesh.transpose(), hatch='///', alpha=0.)