tonik 0.0.1__py3-none-any.whl → 0.0.3__py3-none-any.whl

tonik/__init__.py

@@ -1 +1,23 @@
-from .xarray2hdf5 import xarray2hdf5
+import importlib
+from os import PathLike
+from typing import Optional
+
+from .storage import StorageGroup, Path 
+from .utils import generate_test_data
+
+
+def get_data(filename: Optional[PathLike] = None) -> str:
+    """Return path to tonik package.
+
+    Parameters
+    ----------
+    filename : Pathlike, default None
+        Append `filename` to returned path.
+
+    Returns
+    -------
+    pkgdir_path
+
+    """
+    f = importlib.resources.files(__package__)
+    return str(f) if filename is None else str(f / filename)

tonik/api.py

@@ -0,0 +1,276 @@
+from argparse import ArgumentParser
+from datetime import timedelta, datetime
+import logging
+import os
+
+from cftime import num2date, date2num
+import datashader as dsh
+import numpy as np
+import pandas as pd
+import uvicorn
+from fastapi import FastAPI, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import HTMLResponse, StreamingResponse
+from pydantic import BaseModel
+from typing import List
+
+from .storage import StorageGroup
+from . import get_data
+
+logger = logging.getLogger(__name__)
+
+                          
+class TonikAPI:
+
+    def __init__(self, rootdir) -> None:
+        self.rootdir = rootdir
+        self.app = FastAPI()
+
+        # -- allow any origin to query API
+        self.app.add_middleware(CORSMiddleware,
+                                allow_origins=["*"])
+
+        self.app.get("/", response_class=HTMLResponse)(self.root)
+        self.app.get("/feature")(self.feature)
+
+    async def root(self):
+        with open(get_data("package_data/index.html"), "r", encoding="utf-8") as file:
+            html_content = file.read()
+        return HTMLResponse(content=html_content, status_code=200)
+
+
+    def feature(self,
+                name: str='rsam',
+                group: str='Ruapehu',
+                site: str='MAVZ',
+                sensor: str='10',
+                channel: str='HHZ',
+                starttime: datetime=datetime.utcnow()-timedelta(days=30),
+                endtime: datetime=datetime.utcnow(),
+                resolution: str='full',
+                verticalres: int=10,
+                log: bool=True,
+                normalise: bool=False):
+        
+        _st = datetime.fromisoformat(str(starttime))
+        _st = _st.replace(tzinfo=None)
+        _et = datetime.fromisoformat(str(endtime))
+        _et = _et.replace(tzinfo=None)
+        g = StorageGroup(group, rootdir=self.rootdir,
+                        starttime=_st, endtime=_et)
+        c = g.get_store(site=site, sensor=sensor, channel=channel)
+        try:
+            feat = c(name)
+        except ValueError as e:
+            msg = f"Feature {name} not found in directory {l.sitedir}:"
+            msg += f"{e}"
+            raise HTTPException(status_code=404, detail=msg)
+        if len(feat.shape) > 1:
+            # assume first dimension is frequency
+            nfreqs = feat.shape[0]
+            dates = feat.coords[feat.dims[1]].values
+            if resolution != 'full':
+                freq, dates, spec = self.aggregate_feature(resolution, verticalres, feat, nfreqs, dates)
+            else:
+                spec = feat.values
+                freq = feat.coords[feat.dims[0]].values
+            vals = spec.ravel(order='C')
+            if log and feat.name != 'sonogram':
+                vals = 10*np.log10(vals)
+            if normalise:
+                vals = (vals - np.nanmin(vals))/(np.nanmax(vals) - np.nanmin(vals))
+            freqs = freq.repeat(dates.size)
+            dates = np.tile(dates, freq.size)
+            df = pd.DataFrame({'dates': dates, 'freqs': freqs, 'feature': vals})
+            output = df.to_csv(index=False,
+                            columns=['dates', 'freqs', 'feature'])
+        else:
+            df = pd.DataFrame(data=feat.to_pandas(), columns=[feat.name])
+            df['dates'] = df.index
+            try:
+                df = df.resample(str(float(resolution)/60000.0)+'T').mean()
+            except ValueError as e:
+                logger.warning(f"Cannot resample {feat.name} to {resolution}: e")
+            df.rename(columns={feat.name: 'feature'}, inplace=True)
+            output = df.to_csv(index=False, columns=['dates', 'feature'])
+        return StreamingResponse(iter([output]),
+                                media_type='text/csv',
+                                headers={"Content-Disposition":
+                                        "attachment;filename=<VUMT_feature>.csv",
+                                        'Content-Length': str(len(output))})
+
+
+    def aggregate_feature(self, resolution, verticalres, feat, nfreqs, dates):
+        resolution = np.timedelta64(pd.Timedelta(resolution), 'ms').astype(float)
+        ndays = np.timedelta64(dates[-1] - dates[0], 'ms').astype(float)
+        canvas_x =  int(ndays/resolution)
+        canvas_y = min(nfreqs, verticalres)
+        dates = date2num(dates.astype('datetime64[us]').astype(datetime),
+                                units='hours since 1970-01-01 00:00:00.0',
+                                calendar='gregorian')
+        feat = feat.assign_coords({'datetime': dates})
+        cvs = dsh.Canvas(plot_width=canvas_x,
+                                plot_height=canvas_y)
+        agg = cvs.raster(source=feat)
+        freq_dim = feat.dims[0]
+        freq, d, spec = agg.coords[freq_dim].values, agg.coords['datetime'].values, agg.data
+        dates = num2date(d, units='hours since 1970-01-01 00:00:00.0', calendar='gregorian')
+        return freq,dates,spec
+
+
+# #pydanticmodel output: Json file
+# class Feature(BaseModel):
+#     name: list
+
+
+# class Channel(BaseModel):
+#     name: str
+#     features: List[Feature] = []
+
+
+# class Location(BaseModel):
+#     name: str
+#     channels: List[Channel] = [] 
+
+
+# class Station(BaseModel):
+#     name: str
+#     lat: float
+#     lon: float
+#     locations: List[Location] = []
+
+
+# class Group(BaseModel):
+#     volcano: str
+#     stations: List[Station] = []
+
+
+# def get_pydanticModel(group, station, location, channel, feature_list):
+
+#     channels_data = {"name": channel, "features": feature_list}
+#     channel_models = []
+#     channel_model = Channel(**channels_data)
+#     channel_models.append(channel_model)
+
+#     location_data = {"name": location, "channels": channel_models}
+#     location_models = []
+#     location_model = Location(**location_data)
+#     location_models.append(location_model)
+
+#     stations_data = {"name": station, "lat": "42", "lon": "171",
+#                      "locations": location_models}
+#     station_models = []
+#     station_model = Station(**stations_data)
+#     station_models.append(station_model)
+
+#     group_model = Group(group=group, stations=station_models)
+
+#     # Exporting to JSON
+#     json_data = group_model.json()
+#     return json_data
+
+
+# write a function that scans LOCKERROOMROOT for 
+# available groups, stations, locations, channels, and features
+# and returns a pydantic model
+# def get_available_features():
+#     groups = os.listdir(ROOT)
+#     group_models = []
+#     for group in groups:
+#         stations = os.listdir(os.path.join(LOCKERROOMROOT, group))
+#         station_models = []
+#         for station in stations:
+#             locations = os.listdir(os.path.join(LOCKERROOMROOT, group, station))
+#             location_models = []
+#             for location in locations:
+#                 channels = os.listdir(os.path.join(LOCKERROOMROOT, group, station, location))
+#                 channel_models = []
+#                 for channel in channels:
+#                     features = os.listdir(os.path.join(LOCKERROOMROOT, group, station, location, channel))
+#                     feature_list = []
+#                     for feature in features:
+#                         feature_list.append(feature)
+#                     channel_data = {"name": channel, "features": feature_list}
+#                     channel_model = Channel(**channel_data)
+#                     channel_models.append(channel_model)
+#                 location_data = {"name": location, "channels": channel_models}
+#                 location_model = Location(**location_data)
+#                 location_models.append(location_model)
+#             station_data = {"name": station, "lat": "42", "lon": "171", "locations": location_models}
+#             station_model = Station(**station_data)
+#             station_models.append(station_model)
+#         group_data = {"volcano": group, "stations": station_models}
+#         group_model = Group(**group_data)
+#         group_models.append(group_model)
+#     return group_models
+
+# @app.get("/featureEndpoint")
+# def featureEndpoint(group: str="all", station: str="all", channel: str="all",
+#                     type: str="all"):
+#     groups = vm.get_available_volcanoes()
+
+#     station_model_list = []
+#     channel_model_list = []
+#     volcano_model_list = []
+#     for _volcano in volcanoes:
+#         streams = vm.get_available_streams(_volcano) 
+#         for _stream in streams:
+#             _, _station, _, _channel = _stream.split('.') 
+#             stream_dir = os.path.join(FEATUREDIR, _volcano, _station, _channel)
+#             try:
+#                 feature_list = os.listdir(stream_dir)
+#             except (NotADirectoryError, FileNotFoundError):
+#                 continue
+#             feature_list = sorted([str(os.path.basename(path)).split('.nc')[0] for path in feature_list])
+#             channels_data = {"name": _channel, "features":feature_list}
+#             channel_model = Channel(**channels_data)
+#             channel_model_list.append(channel_model)
+#             try:
+#                 site_info = vm.get_site_information(_station)
+#                 lat = site_info['latitude']
+#                 lon = site_info['longitude'] 
+#             except:
+#                 lat, lon = -999.9, -999.9
+#             stations_data = {"name": _station, "lat": lat, "lon": lon, "channels":channel_model_list}
+#             station_model = Station(**stations_data)
+#             station_model_list.append(station_model)
+
+#         volcano_model = Volcano(volcano=_volcano, stations=station_model_list)
+#         volcano_model_list.append(volcano_model)
+
+#     if len(volcano_model_list) == 0:
+#         return('no volcano')
+
+#     scenario_model = Scenario(scenario='VUMT', volcanoes=volcano_model_list)
+#     if volcano != "all":
+#         # return all stations for a volcano
+#         for _volcano in scenario_model.volcanoes:
+#             if _volcano.volcano == volcano:
+#                 if station == "all":
+#                     return _volcano
+#                 for _station in _volcano.stations:
+#                     if _station.name == station:
+#                         if channel == "all":
+#                             return _station
+#                         for _channel in _station.channels:
+#                             if _channel.name == channel:
+#                                 feature_list_filtered = []
+#                                 for _f in _channel.features:
+#                                     if _f in FeatureRequest.feat_dict[type]:
+#                                         feature_list_filtered.append(_f)    
+#                                 _channel.features = feature_list_filtered
+#                                 return _channel
+
+#     return scenario_model
+
+
+
+def main(argv=None):
+    parser = ArgumentParser()
+    parser.add_argument("--rootdir", default='/tmp')
+    args = parser.parse_args(argv)
+    ta = TonikAPI(args.rootdir)
+    uvicorn.run(ta.app, host="0.0.0.0", port=8003)
+
+if __name__ == "__main__":
+    main()

tonik/package_data/index.html

@@ -0,0 +1,99 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>SAM API Documentation</title>
+    <style>
+        body {
+            font-family: Arial, sans-serif;
+            margin: 0;
+            padding: 0;
+            background-color: #f5f5f5;
+        }
+        header {
+            background-color: #333;
+            color: white;
+            text-align: center;
+            padding: 1em;
+        }
+        section {
+            max-width: 800px;
+            margin: 2em auto;
+            padding: 2em;
+            background-color: white;
+            border-radius: 8px;
+            box-shadow: 0 0 10px rgba(0, 0, 0, 0.1);
+        }
+        h1 {
+            color: #333;
+        }
+        p {
+            line-height: 1.6;
+            color: #666;
+        }
+    </style>
+</head>
+<body>
+
+<header>
+    <h1>Your API Name</h1>
+    <p>Seismic Acoustic Monitoring Tool (SAM) - API</p>
+</header>
+
+<section>
+    <h2>Overview</h2>
+    <p>
+        Welcome to the documentation for Seismic Acoustic Monitoring API. This API provides access to waveform features and
+        analysis results computed by SAM.
+    </p>
+
+    <!--h2>Authentication</h2>
+    <p>
+        To access the API, you need to authenticate using [authentication method]. Obtain your API key from [location].
+    </p-->
+
+    <h2>Endpoints</h2>
+    <p>
+        The endpoints available in the API are:
+    </p>
+    <ul>
+        <li><strong>GET /feature:</strong> Request waveform features and analysis results.</li>
+        <li><strong>GET /featureEndpoint:</strong> Request meta information on available stations, features and results.</li>
+    </ul>
+
+    <h2>Code Examples</h2>
+    <h3>Requesting meta data</h3>
+    The following will return information on available stations, features and results in JSON format.
+    <pre>
+        curl -X GET "http://your.host.server:yourport/featureEndpoint"
+    </pre>
+    To do the same with Python using requests you can use the following code:
+    <pre>
+        import requests
+        url = "http://your.host.server:yourport/featureEndpoint"
+        response = requests.get(url)
+        response.json()
+    </pre>
+    <h3>Requesting data</h3>
+    The following example shows how to request RSAM data for station WIZ at volcano Whakaari
+    between 2019-12-01 and 2019-12-31. The return format is CSV.
+    <pre>
+    curl -X GET "http://your.host.server:yourport/feature?name=rsam&starttime=2019-12-01T00:00:00&endtime=2019-12-31T00:00:00&volcano=Whakaari&site=WIZ"
+    </pre>
+    To do the same with Python using pandas you can use the following code:
+    <pre>
+        import pandas as pd
+        feature="rsam"
+        starttime="2019-12-01T00:00:00"
+        endtime="2019-12-31T00:00:00"
+        volcano="Whakaari"
+        site="WIZ"
+        url = f"http://your.host.server:yourport/feature?name={feature}&starttime={starttime}&endtime={endtime}&volcano={volcano}&site={site}"
+        pd.read_csv(url, parse_dates=True, index_col=0)
+    </pre>
+</section>
+</section>
+
+</body>
+</html>

tonik/storage.py

@@ -0,0 +1,299 @@
+from datetime import datetime, timedelta
+import glob
+import logging
+import logging.config
+import os
+import re
+import tempfile
+
+import pandas as pd
+import xarray as xr
+
+from .xarray2hdf5 import xarray2hdf5
+
+
+ERROR_LOG_FILENAME = "tonik.log"
+
+LOGGING_CONFIG = {
+    "version": 1,
+    "disable_existing_loggers": False,
+    "formatters": {      
+        "default": {  # The formatter name, it can be anything that I wish
+            "format": "%(asctime)s:%(name)s:%(process)d:%(lineno)d " "%(levelname)s %(message)s",  #  What to add in the message
+            "datefmt": "%Y-%m-%d %H:%M:%S",  # How to display dates
+        },
+        "json": {  # The formatter name
+         "()": "pythonjsonlogger.jsonlogger.JsonFormatter",  # The class to instantiate!
+            # Json is more complex, but easier to read, display all attributes!
+            "format": """
+                    asctime: %(asctime)s
+                    created: %(created)f
+                    filename: %(filename)s
+                    funcName: %(funcName)s
+                    levelname: %(levelname)s
+                    levelno: %(levelno)s
+                    lineno: %(lineno)d
+                    message: %(message)s
+                    module: %(module)s
+                    msec: %(msecs)d
+                    name: %(name)s
+                    pathname: %(pathname)s
+                    process: %(process)d
+                    processName: %(processName)s
+                    relativeCreated: %(relativeCreated)d
+                    thread: %(thread)d
+                    threadName: %(threadName)s
+                    exc_info: %(exc_info)s
+                """,
+            "datefmt": "%Y-%m-%d %H:%M:%S",  # How to display dates
+        },
+    }, 
+    "handlers": {
+        "logfile": {  # The handler name
+            "formatter": "json",  # Refer to the formatter defined above
+            "level": "ERROR",  # FILTER: Only ERROR and CRITICAL logs
+            "class": "logging.handlers.RotatingFileHandler",  # OUTPUT: Which class to use
+            "filename": ERROR_LOG_FILENAME,  # Param for class above. Defines filename to use, load it from constant
+            "backupCount": 2,  # Param for class above. Defines how many log files to keep as it grows
+        }, 
+        "simple": {  # The handler name
+            "formatter": "default",  # Refer to the formatter defined above
+            "class": "logging.StreamHandler",  # OUTPUT: Same as above, stream to console
+            "stream": "ext://sys.stdout",
+        },
+    },
+    "loggers": { 
+        "zizou": {  # The name of the logger, this SHOULD match your module!
+            "level": "DEBUG",  # FILTER: only INFO logs onwards from "tryceratops" logger
+            "handlers": [
+                "simple",  # Refer the handler defined above
+            ],
+        },
+    },
+    "root": {
+        "level": "ERROR",  # FILTER: only INFO logs onwards
+        "handlers": [
+            "logfile",  # Refer the handler defined above
+        ]
+    },
+}
+
+logging.config.dictConfig(LOGGING_CONFIG)
+logger = logging.getLogger("__name__")
+
+
+class Path(object):
+    def __init__(self, name, parentdir):
+        self.name = name
+        self.path = os.path.join(parentdir, name)
+        os.makedirs(self.path, exist_ok=True)
+        self.children = {}
+    
+    def __str__(self):
+        return self.path
+    
+    def __getitem__(self, key):
+        try:
+            return self.children[key]
+        except KeyError:
+            self.children[key] = Path(key, self.path)
+            return self.children[key]
+
+    def feature_path(self, feature):
+        _feature_path = os.path.join(self.path, feature + ".nc")
+        if not os.path.exists(_feature_path):
+            raise FileNotFoundError(f"File {_feature_path} not found")
+        self.children[feature] = _feature_path
+        return _feature_path
+
+    def __call__(self, feature, stack_length=None, interval='10min'):
+        """
+        Request a particular feature
+
+        :param feature: Feature name
+        :type feature: str
+        :param stack_length: length of moving average in time
+        :type stack_length: str
+
+        """
+        if self.endtime <= self.starttime:
+            raise ValueError('Startime has to be smaller than endtime.')
+
+        feature = feature.lower()
+        filename = self.feature_path(feature)
+
+        logger.debug(f"Reading feature {feature} between {self.starttime} and {self.endtime}")
+        num_periods = None
+        if stack_length is not None:
+            valid_stack_units = ['W', 'D', 'H', 'T', 'min', 'S']
+            if not re.match(r'\d*\s*(\w*)', stack_length).group(1)\
+                   in valid_stack_units:
+                raise ValueError(
+                    'Stack length should be one of: {}'.
+                        format(', '.join(valid_stack_units))
+                )
+
+            if pd.to_timedelta(stack_length) < pd.to_timedelta(interval):
+                raise ValueError('Stack length {} is less than interval {}'.
+                                 format(stack_length, interval))
+
+            # Rewind starttime to account for stack length
+            self.starttime -= pd.to_timedelta(stack_length)
+
+            num_periods = (pd.to_timedelta(stack_length)/
+                           pd.to_timedelta(interval))
+            if not num_periods.is_integer():
+                raise ValueError(
+                    'Stack length {} / interval {} = {}, but it needs'
+                    ' to be a whole number'.
+                        format(stack_length, interval, num_periods))
+
+        xd_index = dict(datetime=slice(self.starttime, self.endtime))
+        with xr.open_dataset(filename, group='original', engine='h5netcdf') as ds:
+            ds.sortby("datetime")
+            rq = ds.loc[xd_index].load()
+
+        # Stack features
+        if stack_length is not None:
+            logger.debug("Stacking feature...")
+            try:
+                xdf = rq[feature].rolling(datetime=int(num_periods),
+                                        center=False,
+                                        min_periods=1).mean()
+                # Return requested timeframe to that defined in initialisation
+                self.starttime += pd.to_timedelta(stack_length)
+                xdf_new = xdf.loc[
+                        self.starttime:
+                        self.endtime-pd.to_timedelta(interval)]
+                xdf_new = xdf_new.rename(feature)
+            except ValueError as e:
+                logger.error(e)
+                logger.error('Stack length {} is not valid for feature {}'.
+                             format(stack_length, feature))
+            else:
+                return xdf_new
+
+        return rq[feature]
+
+    def load(self, *args, **kwargs):
+        """
+        Load a feature from disk
+        """
+        self.__call__(*args, **kwargs)
+
+    def save(self, data):
+        """
+        Save a feature to disk
+        """
+        xarray2hdf5(data, self.path)
+
+
+class StorageGroup(Path):
+    """
+    Query computed features
+
+    :param rootdir: Path to parent directory.
+    :type rootdir: str
+    :param starttime: Begin of request
+    :type starttime: :class:`datetime.datetime`
+    :param endtime: Begin of request
+    :type endtime: :class:`datetime.datetime`
+
+    >>> import datetime
+    >>> g = Group('Whakaari')
+    >>> start = datetime.datetime(2012,1,1,0,0,0)
+    >>> end = datetime.datetime(2012,1,2,23,59,59)
+    >>> g.starttime = start
+    >>> g.endtime = end
+    >>> c = g.channel(site='WIZ', sensor='00', channel='HHZ')
+    >>> rsam = c("rsam")
+    """
+    def __init__(self, name, rootdir=None, starttime=None, endtime=None):
+        self.stores = set() 
+        self.starttime = starttime
+        self.endtime = endtime
+        super().__init__(name, rootdir)
+
+    def __repr__(self):
+        rstr = f"Group: {self.name}\n"
+        last_site = False
+        for j, site in enumerate(self.children.values()):
+            if j == len(self.children) - 1:
+                last_site = True
+            rstr += f"|__ {site.name}\n"
+            last_sensor = False
+            for i, sensor in enumerate(site.children.values()):
+                if i == len(site.children) - 1:
+                    last_sensor = True
+                rstr += (" " if last_site else "|") + f"  |__ {sensor.name}\n"
+                for k, channel in enumerate(sensor.children.values()):
+                    rstr += ("   " if last_site else "|  ") 
+                    rstr += ("   " if last_sensor else "|  ") 
+                    rstr += f"|__ {channel.name}\n"
+        return rstr
+
+    def get_store(self, site, sensor, channel):
+        # return the store for a given site, sensor, or channel
+        # if one of them is None return the store for the level above
+        # if all are None return the root store
+        try:
+            st = self[site][sensor][channel]
+        except:
+            try:
+                st = self[site][sensor]
+            except:
+                try:
+                    st = self[site]
+                except:
+                    return self
+
+        st.starttime = self.starttime
+        st.endtime = self.endtime
+        self.stores.add(st)
+        return st 
+
+    def from_directory(self):
+        feature_files = glob.glob(os.path.join(self.path, '**', '*.nc'),
+                                  recursive=True)
+        for _f in feature_files:
+            subdir = _f.split(self.path)[1].strip(os.sep)
+            # split the path into parts
+            # get the subdirectories
+            site, sensor, channel, ffile = subdir.split(os.sep) 
+            fname = ffile.strip('.nc')
+            c = self.get_store(site, sensor, channel) 
+
+    def get_starttime(self):
+        return self.__starttime
+
+    def set_starttime(self, time):
+        if time is None:
+            self.__starttime = None
+            self.__sdate = None
+            return
+        self.__starttime = time
+        self.__sdate = '{}{:02d}{:02d}'.format(time.year,
+                                               time.month,
+                                               time.day)
+        for s in self.stores:
+            s.starttime = time
+
+    def get_endtime(self):
+        return self.__endtime
+
+    def set_endtime(self, time):
+        if time is None:
+            self.__endtime = None
+            self.__edate = None
+            return
+        self.__endtime = time
+        self.__edate = '{}{:02d}{:02d}'.format(time.year,
+                                               time.month,
+                                               time.day)
+        for s in self.stores:
+            s.endtime = time
+
+
+    starttime = property(get_starttime, set_starttime)
+    endtime = property(get_endtime, set_endtime)
+

tonik/utils.py

@@ -0,0 +1,43 @@
+from datetime import datetime
+
+import numpy as np
+import pandas as pd
+import xarray as xr
+
+
+def generate_test_data(dim=1, ndays=30, nfreqs=10,
+                       tstart=datetime.utcnow(),
+                       feature_name=None,
+                       freq_name=None):
+    """
+    Generate a 1D or 2D feature for testing.
+    """
+    assert dim < 3
+    assert dim > 0
+
+    nints = ndays * 6 * 24
+    dates = pd.date_range(tstart.strftime('%Y-%m-%d'), freq='10min', periods=nints)
+    rs = np.random.default_rng(42)
+    # Random walk as test signal
+    data = np.abs(np.cumsum(rs.normal(0, 8., len(dates))))
+    if dim == 2:
+        data = np.tile(data, (nfreqs, 1))
+    # Add 10% NaNs
+    idx_nan = rs.integers(0, nints-1, int(0.1*nints))
+    if dim == 1:
+        data[idx_nan] = np.nan
+        if feature_name is None:
+            feature_name = 'rsam'
+        xrd = xr.Dataset({feature_name: xr.DataArray(data, coords=[dates], dims=['datetime'])})
+    if dim == 2:
+        data[:, idx_nan] = np.nan
+        freqs = np.arange(nfreqs)
+        if feature_name is None:
+            feature_name = 'ssam'
+        if freq_name is None:
+            freq_name = 'frequency'
+        xrd = xr.Dataset({feature_name: xr.DataArray(data, coords=[freqs, dates], dims=[freq_name, 'datetime'])})
+    xrd.attrs['starttime'] = dates[0].isoformat()
+    xrd.attrs['endtime'] = dates[-1].isoformat()
+    xrd.attrs['station'] = 'MDR'
+    return xrd

tonik/xarray2hdf5.py

@@ -3,10 +3,9 @@ import logging
 import os
 from warnings import filterwarnings
 
-from cftime import num2date, date2num, date2index
+from cftime import num2date, date2num
 import h5netcdf
 import numpy as np
-import xarray as xr
 
 
 def xarray2hdf5(xArray, fdir, rootGroupName="original", timedim="datetime"):

{tonik-0.0.1.dist-info → tonik-0.0.3.dist-info}/METADATA

@@ -1,8 +1,8 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.3
 Name: tonik
-Version: 0.0.1
+Version: 0.0.3
 Summary: A collection of tools to integrate with GNS Science's time series classification platform.
-Project-URL: Homepage, https://github.com/tsc-tools/tonik
+Project-URL: Homepage, https://tsc-tools.github.io/tonik.github.io
 Project-URL: Issues, https://github.com/tsc-tools/tonik/issues
 Author-email: Yannik Behr <y.behr@gns.cri.nz>, Christof Mueller <c.mueller@gns.cri.nz>
 License-File: LICENSE
@@ -10,12 +10,17 @@ Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
 Requires-Python: >=3.7
-Requires-Dist: h5netcdf
-Requires-Dist: h5py
-Requires-Dist: netcdf4
-Requires-Dist: pandas
-Requires-Dist: pytest
-Requires-Dist: xarray
+Requires-Dist: datashader>=0.14
+Requires-Dist: fastapi>=0.95
+Requires-Dist: h5netcdf>=1.1
+Requires-Dist: h5py>=3.8
+Requires-Dist: netcdf4>=1.6
+Requires-Dist: pandas>=2.0
+Requires-Dist: python-json-logger>=2.0
+Requires-Dist: uvicorn[standard]>=0.22
+Requires-Dist: xarray>=2023.4
+Provides-Extra: dev
+Requires-Dist: pytest; extra == 'dev'
 Description-Content-Type: text/markdown
 
 # Time series classification tools

tonik-0.0.3.dist-info/RECORD

@@ -0,0 +1,11 @@
+tonik/__init__.py,sha256=p97Bbz-yujI-uNmbqn1S61lq-zfF1VPaS5c1fxs1Fa8,516
+tonik/api.py,sha256=zTZZbpPsetoM5EH8ao8RlwR39lU1jEWpxwATC4S8Qq0,11012
+tonik/storage.py,sha256=F1NnRIZLq7uB7TTK1-5VHYix6_e_fl2J1FmiCFYqIJ0,10719
+tonik/utils.py,sha256=jEjvUNcU9nUhQZTgu8iwfPmF4U2odyOT8EJu0v1DaA0,1433
+tonik/xarray2hdf5.py,sha256=biQ3KVt0QrxJhOWm38FwglzYkLhPtO13G1B1vVF2c6o,4090
+tonik/package_data/index.html,sha256=IaPMU-A_FswjMAKA6PrHp9VFTuKJ6o_PGyjg_CTutrY,3082
+tonik-0.0.3.dist-info/METADATA,sha256=9MLYvdxjaYM0okuTgI2JhOFwiEV_Gir-7N6PnI2VTeo,1085
+tonik-0.0.3.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
+tonik-0.0.3.dist-info/entry_points.txt,sha256=VnGfC5qAzpntEHAb5pooUEpYABSgOfQoNhCEtLDJyf8,45
+tonik-0.0.3.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+tonik-0.0.3.dist-info/RECORD,,

{tonik-0.0.1.dist-info → tonik-0.0.3.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.17.1
+Generator: hatchling 1.25.0
 Root-Is-Purelib: true
 Tag: py3-none-any

tonik-0.0.3.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+tonik_api = tonik.api:main

tonik-0.0.1.dist-info/RECORD

@@ -1,6 +0,0 @@
-tonik/__init__.py,sha256=d7gnshn92xGI-U7YTs7Q5cMWjvLW45m-EXJ5IcYaZrs,36
-tonik/xarray2hdf5.py,sha256=sImRJ80EQ3yI_7xJg34VfS8SSIzkDtRHda3Mg959xPs,4122
-tonik-0.0.1.dist-info/METADATA,sha256=KS91xVocqwwtwLKprecpfp0JU15s-1xERkMqKBSpPS4,873
-tonik-0.0.1.dist-info/WHEEL,sha256=KGYbc1zXlYddvwxnNty23BeaKzh7YuoSIvIMO4jEhvw,87
-tonik-0.0.1.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-tonik-0.0.1.dist-info/RECORD,,