tonik 0.1.15__py3-none-any.whl → 0.1.16__py3-none-any.whl

tonik/grafana_annotations.py

@@ -0,0 +1,152 @@
+"""
+Post labels as Grafana annotations and retrieve them via the Grafana API.
+Labels are assumed to be in the following format:
+
+[
+    {"time": "2023-01-01T00:00:00Z",
+     "title": "Label 1",
+     "description": "Some description",
+     "tags": ["tag1", "tag2"],
+     "id": 12345
+     },
+    {"time": "2023-02-01T00:00:00Z",
+     "timeEnd": "2023-02-01T01:00:00Z",
+     "title": "Label 2", description:
+     "description": "Another description",
+     "tags": ["tag1", "tag2"],
+     "id": 12346
+     },
+     ...
+]
+
+Note: The `timeEnd` field is optional. If it is provided, the grafana annotation will 
+be a range annotation, otherwise it will be a point annotation. The label id is used to
+check if an annotation was already added to Grafana. If the label id is not present in the
+annotations, a new annotation will be created. If the label id is present, the annotation
+will be skipped to avoid duplicates.
+"""
+
+import numpy as np
+import requests
+import uuid
+from typing import List, Dict, Any, Optional
+
+
+def get_annotations(baseurl: str, tags: Optional[List[str]] = None) -> Dict[str, Dict[str, Any]]:
+    """
+    Get existing annotations from the Grafana API.
+
+    Parameters
+    ----------
+    baseurl : str
+        The base URL of the Grafana API. This is typically in the format
+        "http://<grafana-user>:<user-pwd>@<grafana-host>:<port>".
+    tags : list of str, optional
+        A list of tags to filter the annotations. If None, all annotations are retrieved.
+    Returns
+    -------
+    annotations : dict
+        A dictionary containing the annotations, where the keys are the label IDs
+        and the values are dictionaries with the following keys:
+            - 'text': The text of the annotation.
+            - 'time': The start time of the annotation in milliseconds since epoch.
+            - 'timeEnd': (optional) The end time of the annotation in milliseconds since epoch.
+            - 'tags': A list of tags associated with the annotation.
+            - 'id': The ID of the annotation.
+    """
+    url = baseurl + "/api/annotations"
+    params = {}
+    if tags is not None:
+        params = {"tags": tags}
+    rval = requests.get(url, params=params)
+    if rval.status_code != 200:
+        raise RuntimeError(
+            f"Failed to retrieve annotations: {rval.status_code} {rval.text}")
+    annotations = {}
+    for atn in rval.json():
+        # Extract label ID from text using regex
+        try:
+            label_id = atn["text"].split("Id: ")[-1].strip()
+        except IndexError:
+            label_id = str(uuid.uuid4())
+        annotations[label_id] = {"text": atn["text"],
+                                 "time": atn["time"],
+                                 "timeEnd": atn.get("timeEnd", None),
+                                 "tags": atn.get("tags", []),
+                                 "id": atn["id"]}
+    return annotations
+
+
+def post_annotations(baseurl: str, labels: List[Dict[str, Any]]) -> None:
+    """
+    Post annotations from a list of labels if they do not already exist.
+
+    Parameters
+    ----------
+    baseurl : str
+        The base URL of the Grafana API. This is typically in the format
+        "http://<grafana-user>:<user-pwd>@<grafana-host>:<port>".
+    labels : list of dict
+        A list of dictionaries containing label information. Each dictionary
+        should have the following keys:
+            - 'time': The start time of the annotation in ISO format.
+            - 'timeEnd': (optional) The end time of the annotation in ISO format.
+            - 'title': The title of the annotation.
+            - 'description': The description of the annotation.
+            - 'tags': A list of tags associated with the annotation.
+            - 'id': A unique identifier for the label, used to check for duplicates.
+    """
+    url = baseurl + "/api/annotations"
+    header = {"Content-type": "application/json"}
+    for label in labels:
+        existing_labels = get_annotations(baseurl, tags=label['tags'])
+        if str(label['id']) in existing_labels:
+            print(
+                f"Label with ID {label['id']} already exists. Skipping post.")
+            continue
+        starttime = np.datetime64(label['time']).astype(
+            'datetime64[ms]').astype(int)
+        try:
+            endtime = np.datetime64(label['timeEnd']).astype(
+                'datetime64[ms]').astype(int)
+            endtime = int(endtime)
+        except KeyError:
+            endtime = None
+        text = f"{label['title']}\n{label['description']}\nId: {label['id']}"
+        new_annotation = {
+            "time": int(starttime),
+            "timeEnd": endtime,
+            "text": text,
+            "tags": label['tags']
+        }
+        rval = requests.post(url, headers=header, json=new_annotation)
+        if rval.status_code != 200:
+            raise RuntimeError(
+                f"Failed to post annotation: {rval.status_code} {rval.text}")
+        else:
+            print("Annotation posted successfully.")
+
+
+def main(argv=None):
+    import argparse
+    import json
+    parser = argparse.ArgumentParser(
+        description=__doc__)
+    parser.add_argument('url', type=str,
+                        help='Grafana API URL for annotations.')
+    parser.add_argument('--labels', type=str, default=None,
+                        help='Path to JSON file containing labels to post.')
+    parser.add_argument('--get-annotations', action='store_true',
+                        help='Get existing annotations from Grafana API.')
+    args = parser.parse_args(argv)
+    if args.labels is not None:
+        with open(args.labels, 'r') as f:
+            labels = json.load(f)
+        post_annotations(args.url, labels)
+    elif args.get_annotations:
+        annotations = get_annotations(args.url)
+        print(json.dumps(annotations, indent=2))
+
+
+if __name__ == "__main__":
+    main()

tonik/package_data/whakaari_labels.json

@@ -0,0 +1,162 @@
+[
+    {
+        "time": "2012-08-04T00:00:00",
+        "title": "Eruption",
+        "description": "Explosive eruption",
+        "tags": ["volcano", "eruption"],
+        "id": 1
+
+    },
+    {
+        "time": "2012-11-22T00:00:00",
+        "timeEnd": "2012-12-10T00:00:00",
+        "title": "Dome extrusion",
+        "description": "Dome extrusion",
+        "tags": ["volcano", "eruption"],
+        "id": 2
+
+    },
+    {
+        "time": "2013-01-15T00:00:00",
+        "timeEnd": "2013-04-10T00:00:00",
+        "title": "Geysering",
+        "description": "Geysering",
+        "tags": ["volcano", "eruption"],
+        "id": 3
+
+    },
+    {
+        "time": "2013-08-19T00:00:00",
+        "title": "Steam and mud eruption",
+        "description": "Minor steam and mud eruption",
+        "tags": ["volcano", "eruption"],
+        "id": 4
+    },
+    {
+        "time": "2013-10-04T00:00:00",
+        "title": "Steam and mud eruption",
+        "description": "Minor steam and mud eruption",
+        "tags": ["volcano", "eruption"],
+        "id": 5
+    },
+    
+    {
+        "time": "2013-10-08T00:00:00",
+        "title": "Steam and mud eruption",
+        "description": "Minor steam and mud eruption",
+        "tags": ["volcano", "eruption"],
+        "id": 6
+    },
+    {
+        "time": "2013-10-11T00:00:00",
+        "title": "Eruption",
+        "description": "Explosive eruption",
+        "tags": ["volcano", "eruption"],
+        "id": 7
+
+    },
+    {
+        "time": "2015-10-13T00:00:00",
+        "timeEnd": "2015-10-20T00:00:00",
+        "title": "Banded tremor",
+        "description": "Banded tremor",
+        "tags": ["volcano", "tremor"],
+        "id": 8
+
+    },
+    {
+        "time": "2016-04-27T00:00:00",
+        "title": "Eruption",
+        "description": "Explosive eruption",
+        "tags": ["volcano", "eruption"],
+        "id": 9
+
+    },
+    {
+        "time": "2016-09-13T00:00:00",
+        "timeEnd": "2016-09-18T00:00:00",
+        "title": "Ashing",
+        "description": "Non-explosive ash venting",
+        "tags": ["volcano", "ash"],
+        "id": 10 
+
+    },
+    {
+        "time": "2019-04-23T00:00:00",
+        "timeEnd": "2019-07-01T00:00:00",
+        "title": "Earthquake swarm",
+        "description": "Earthquake swarm",
+        "tags": ["volcano", "swarm"],
+        "id": 11 
+
+    },
+    {
+        "time": "2019-12-09T00:00:00",
+        "title": "Eruption",
+        "description": "Explosive eruption",
+        "tags": ["volcano", "eruption"],
+        "id": 12 
+
+    },
+    {
+        "time": "2019-12-23T00:00:00",
+        "timeEnd": "2019-12-29T00:00:00",
+        "title": "Ashing",
+        "description": "Minor ash emissions",
+        "tags": ["volcano", "ash"],
+        "id": 13 
+
+    },
+    {
+        "time": "2020-01-10T00:00:00",
+        "timeEnd": "2020-01-20T00:00:00",
+        "title": "Dome extrusion",
+        "description": "Dome extrusion",
+        "tags": ["volcano", "eruption"],
+        "id": 14 
+
+    },
+    {
+        "time": "2020-11-13T00:00:00",
+        "timeEnd": "2020-12-01T00:00:00",
+        "title": "Ashing",
+        "description": "Minor ash emissions",
+        "tags": ["volcano", "ash"],
+        "id": 15 
+
+    },
+    {
+        "time": "2020-12-29T00:00:00",
+        "title": "Eruption",
+        "description": "Small steam explosions",
+        "tags": ["volcano", "eruption"],
+        "id": 16 
+
+    },
+    {
+        "time": "2022-09-18T00:00:00",
+        "timeEnd": "2022-09-24T00:00:00",
+        "title": "Ashing",
+        "description": "Minor ash emissions",
+        "tags": ["volcano", "ash"],
+        "id": 17 
+
+    },
+    {
+        "time": "2024-05-24T00:00:00",
+        "title": "Eruption",
+        "description": "Small steam explosions",
+        "tags": ["volcano", "eruption"],
+        "id": 18 
+
+    },
+    {
+        "time": "2024-07-24T00:00:00",
+        "timeEnd": "2024-09-10T00:00:00",
+        "title": "Ashing",
+        "description": "Minor ash emissions",
+        "tags": ["volcano", "ash"],
+        "id": 19 
+
+    }
+]

tonik/utils.py

@@ -59,8 +59,55 @@ def generate_test_data(dim=1, ndays=30, nfreqs=10,
     return xds
 
 
+def get_dt(times):
+    """
+    Infer the sampling of the time dimension.
+    """
+    pd_times = pd.to_datetime(times)
+    dt = pd.infer_freq(pd_times)
+    if dt is None:
+        dt = pd_times.diff().median()
+    try:
+        dt = pd.Timedelta(dt)
+    except ValueError:
+        dt = pd.Timedelta(f"1{dt}")
+    return dt
+
+
+def fill_time_gaps(xds: xr.Dataset, timedim: str = 'datetime') -> xr.Dataset:
+    """
+    Fill gaps in time series with NaN values by reindexing to a complete datetime range.
+
+    Parameters
+    ----------
+    xds : xr.Dataset
+        Input dataset with potential time gaps
+    freq : str, optional
+        Frequency string (e.g., 'H', 'D', '15min'). If None, will try to infer.
+    timedim : str
+        Name of the time dimension, by default 'datetime'
+
+    Returns
+    -------
+    xr.Dataset
+        Dataset with gaps filled with NaN
+    """
+    if timedim not in xds.coords:
+        raise ValueError(
+            f"{timedim} coordinate not found in dataset coordinates.")
+
+    # Infer sample interval
+    dt = get_dt(xds.coords[timedim])
+    start_time = xds[timedim].values[0]
+    end_time = xds[timedim].values[-1]
+    complete_time = pd.date_range(start=start_time, end=end_time, freq=dt)
+
+    # Reindex to fill gaps with NaN
+    return xds.reindex({timedim: complete_time})
+
+
 def merge_arrays(xds_old: xr.DataArray, xds_new: xr.DataArray,
-                 resolution: float = None) -> xr.DataArray:
+                 timedim: str = 'datetime', resolution: float = None) -> xr.DataArray:
     """
     Merge two xarray datasets with the same datetime index.
 
@@ -79,16 +126,17 @@ def merge_arrays(xds_old: xr.DataArray, xds_new: xr.DataArray,
         Merged array.
     """
     xda_old = xds_old.drop_duplicates(
-        'datetime', keep='last')
+        timedim, keep='last')
     xda_new = xds_new.drop_duplicates(
-        'datetime', keep='last')
+        timedim, keep='last')
     xda_new = xda_new.combine_first(xda_old)
     if resolution is not None:
         new_dates = pd.date_range(
-            xda_new.datetime.values[0],
-            xda_new.datetime.values[-1],
+            xda_new[timedim].values[0],
+            xda_new[timedim].values[-1],
             freq=f'{resolution}h')
-        xda_new = xda_new.reindex(datetime=new_dates)
+        xda_new = xda_new.reindex(dict(timedim=new_dates))
+    xda_new = fill_time_gaps(xda_new, timedim=timedim)
     return xda_new
 
 

tonik/xarray2zarr.py

@@ -1,6 +1,8 @@
 import logging
 import os
 
+import numpy as np
+import pandas as pd
 import xarray as xr
 try:
     from zarr.errors import PathNotFoundError
@@ -8,12 +10,142 @@ except ImportError:
     class PathNotFoundError(Exception):
         pass
 
-from .utils import merge_arrays
+from .utils import merge_arrays, fill_time_gaps, get_dt
 
 logger = logging.getLogger(__name__)
 
 
-def xarray2zarr(xds: xr.Dataset, path: str, mode: str = 'a', group='original'):
+def get_chunks(xda: xr.DataArray, chunks: int = 1,
+               timedim: str = 'datetime') -> dict:
+    """
+    Determine the chunk size for the datetime dimension. Other dimensions are assumed to be 
+    small enough to not require chunking.
+
+    Parameters
+    ----------
+    coords : xr.core.coordinates.DatasetCoordinates
+        Coordinates of the dataset.
+    chunks : int, optional
+        Number of chunks in days to divide the datetime dimension into, by default 1.
+    """
+    if timedim not in xda.coords:
+        raise ValueError(
+            f"Datetime coordinate {timedim} not found in dataset coordinates.")
+    dt = get_dt(xda.coords[timedim])
+    chunklength = int(pd.Timedelta('%dD' % chunks) / dt)
+    return chunklength
+
+
+def fill_time_gaps_between_datasets(xds_existing: xr.DataArray, xds_new: xr.DataArray, mode: str,
+                                    timedim: str = 'datetime') -> xr.DataArray:
+    """
+    Fill gaps between existing and new datasets.
+
+    Parameters
+    ----------
+    xds_existing : xr.Dataset
+        Existing dataset on disk
+    xds_new : xr.Dataset  
+        New dataset to append
+    timedim : str
+        Name of the time dimension
+
+    Returns
+    -------
+    xr.Dataset
+        Combined dataset with gaps filled
+    """
+    if mode not in ['a', 'p']:
+        raise ValueError(
+            'Mode has to be either "a" for append or "p" for prepend')
+
+    # get the sample interval
+    dt = get_dt(xds_new.coords[timedim])
+
+    existing_endpoint = xds_existing[timedim].values
+    # Get time ranges
+    if mode == 'a':
+        gap_start = existing_endpoint + dt
+        gap_end = xds_new[timedim].values[0] - dt
+    elif mode == 'p':
+        gap_end = existing_endpoint - dt
+        gap_start = xds_new[timedim].values[-1] + dt
+
+    if gap_start <= gap_end:
+        gap_times = pd.date_range(start=gap_start, end=gap_end, freq=dt)
+
+        # Create NaN array with same shape as variable but for gap times
+        gap_shape = (len(gap_times),) + \
+            xds_new.shape[1:]  # Skip time dimension
+        gap_values = np.full(gap_shape, np.nan)
+
+        # Create coordinates for gap dataset
+        gap_coords = {timedim: gap_times}
+        for coord_name, coord in xds_new.coords.items():
+            if coord_name != timedim:
+                gap_coords[coord_name] = coord
+
+        gap_data = xr.DataArray(
+            gap_values,
+            coords=gap_coords,
+            dims=xds_new.dims,
+            name=xds_new.name
+        )
+
+        # Combine: existing + gap + new
+        if mode == 'a':
+            combined = xr.concat([gap_data, xds_new], dim=timedim)
+        elif mode == 'p':
+            combined = xr.concat([xds_new, gap_data], dim=timedim)
+        return combined
+    else:
+        return xds_new
+
+
+def _build_append_payload_full_chunks(payload: xr.DataArray, mode: str,
+                                      chunklen: int, timedim: str = "datetime") -> xr.DataArray:
+    """
+    Construct the sequence to append so that the final total length is a multiple of `chunklen`
+    """
+    if mode not in ['a', 'p']:
+        raise ValueError(
+            'Mode has to be either "a" for append or "p" for prepend')
+
+    # pad the tail so that payload_len % chunklen == 0
+    pay_len = payload.sizes[timedim]
+    need = -pay_len % chunklen  # 0..chunklen-1
+
+    if need > 0:
+        dt = get_dt(payload.coords[timedim])
+        if mode == 'a':
+            start = payload[timedim].values[-1] + dt
+        elif mode == 'p':
+            start = payload[timedim].values[0] - (need+1)*dt
+        pad_times = pd.date_range(start=start, periods=need, freq=dt)
+        pad_shape = []
+        for i, d in enumerate(payload.dims):
+            if d == timedim:
+                pad_shape.append(need)
+            else:
+                pad_shape.append(payload.shape[i])
+        pad_vals = np.full(pad_shape, np.nan)
+        pad_coords = {timedim: pad_times}
+        for c in payload.coords:
+            if c != timedim:
+                pad_coords[c] = payload.coords[c]
+        pad_da = xr.DataArray(pad_vals, coords=pad_coords,
+                              dims=payload.dims, name=payload.name, attrs=payload.attrs)
+        if mode == 'a':
+            payload = xr.concat([payload, pad_da], dim=timedim)
+        elif mode == 'p':
+            payload = xr.concat([pad_da, payload], dim=timedim)
+        payload = payload.chunk({timedim: chunklen})
+    return payload
+#
+
+
+def xarray2zarr(xds: xr.Dataset, path: str, mode: str = 'a', group='original',
+                chunks: int = 10, timedim: str = 'datetime') -> None:
     """
     Write xarray dataset to zarr files.
 
@@ -27,41 +159,78 @@ def xarray2zarr(xds: xr.Dataset, path: str, mode: str = 'a', group='original'):
         Write mode, by default 'a'.
     group : str, optional
         Group name, by default 'original'
+    chunks : int, optional
+        Chunk size as the number of days.
+    timedim : str
+        Name of the time dimension, by default 'datetime'
+    fill_gaps : bool, optional
+        Whether to fill time gaps with NaN before writing, by default False
 
     Returns
     -------
     None
     """
+
+    if timedim not in xds.dims:
+        raise ValueError(f"{timedim} dimension not found in Dataset.")
+
+    # Fill gaps
+    xds = xds.drop_duplicates(timedim, keep='last')
+    xds = fill_time_gaps(xds, timedim=timedim)
+
     for feature in xds.data_vars.keys():
         fout = os.path.join(path, feature + '.zarr')
-        if not os.path.exists(fout) or mode == 'w':
-            xds[feature].to_zarr(
-                fout, group=group, mode='w')
+        # nchunks = get_chunks(xds[feature], chunks)
+        nchunks = chunks
+        try:
+            xds_existing = xr.open_zarr(fout, group=group)
+            has_store = True
+        except (PathNotFoundError, FileNotFoundError, KeyError):
+            has_store = False
+
+        if not has_store:
+            xda_new = _build_append_payload_full_chunks(
+                xds[feature], 'a', nchunks)
+            xda_new.to_zarr(fout, group=group, mode='w',
+                            write_empty_chunks=True)
+            continue
+
+        if xds_existing[timedim][0] > xds[timedim][-1]:
+            # prepend
+            xda_new = fill_time_gaps_between_datasets(xds_existing[feature].isel({timedim: 0}),
+                                                      xds[feature], mode='p')
+            xda_new = _build_append_payload_full_chunks(
+                xda_new, 'p', nchunks)
+            combined = xda_new.combine_first(xds_existing[feature]).compute()
+            combined.chunk({timedim: nchunks}).to_zarr(fout, group=group, mode='w',
+                                                       write_empty_chunks=True)
+        elif xds_existing[timedim][-1] < xds[timedim][0]:
+            # append
+            xda_new = fill_time_gaps_between_datasets(xds_existing[feature].isel({timedim: -1}),
+                                                      xds[feature], mode='a')
+            xda_new = _build_append_payload_full_chunks(
+                xda_new, 'a', nchunks)
+            xda_new.to_zarr(fout, group=group, mode='a',
+                            append_dim=timedim)
+        elif xds_existing[timedim][0] > xds[timedim][0] and xds_existing[timedim][-1] < xds[timedim][-1]:
+            # existing datetimes are contained in new array
+            xda_new = _build_append_payload_full_chunks(
+                xds[feature], 'a', nchunks)
+            xda_new.to_zarr(fout, group=group, mode='w',
+                            write_empty_chunks=True)
         else:
-            try:
-                xds_existing = xr.open_zarr(fout, group=group)
-            except (PathNotFoundError, FileNotFoundError):
-                xds[feature].to_zarr(fout, group=group, mode='a')
-                continue
-            if xds_existing.datetime[0] > xds.datetime[0] or xds_existing.datetime[-1] > xds.datetime[-1]:
-                xda_new = merge_arrays(xds_existing[feature], xds[feature])
-                xda_new.to_zarr(fout, group=group, mode='w')
-            else:
-                try:
-                    overlap = xds_existing.datetime.where(
-                        xds_existing.datetime == xds.datetime)
-                    if overlap.size > 0:
-                        xds[feature].loc[dict(datetime=overlap)].to_zarr(
-                            fout, group=group, mode='r+', region='auto')
-                        xds[feature].drop_sel(datetime=overlap).to_zarr(
-                            fout, group=group, mode='a', append_dim="datetime")
-                    else:
-                        xds[feature].to_zarr(
-                            fout, group=group, append_dim='datetime')
-                except Exception as e:
-                    msg = f"Appending {feature} to {fout} failed: {e}\n"
-                    msg += "Attempting to merge the two datasets."
-                    logger.error(msg)
-                    # remove duplicate datetime entries
-                    xda_new = merge_arrays(xds_existing[feature], xds[feature])
-                    xda_new.to_zarr(fout, group=group, mode='w')
+            overlap = xds_existing[timedim].where(
+                xds_existing[timedim] == xds[timedim])
+            xds[feature].loc[{timedim: overlap}].to_zarr(
+                fout, group=group, mode='r+', region='auto')
+            remainder = xds[feature].drop_sel({timedim: overlap})
+            if remainder.sizes[timedim] > 0:
+                mode = 'a'
+                if remainder[timedim][-1] < xds_existing[timedim][0]:
+                    mode = 'p'
+                xda_new = fill_time_gaps_between_datasets(xds_existing[feature].isel({timedim: 0}),
+                                                          xds[feature], mode=mode)
+                xda_new = _build_append_payload_full_chunks(
+                    xda_new, mode, nchunks)
+                xda_new.to_zarr(fout, group=group, mode='a',
+                                append_dim=timedim)

{tonik-0.1.15.dist-info → tonik-0.1.16.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: tonik
-Version: 0.1.15
+Version: 0.1.16
 Summary: Store time series data as HDF5 files and access them through an API.
 Project-URL: Homepage, https://tsc-tools.github.io/tonik
 Project-URL: Issues, https://github.com/tsc-tools/tonik/issues
@@ -18,10 +18,11 @@ Requires-Dist: matplotlib
 Requires-Dist: netcdf4>=1.6
 Requires-Dist: pandas>=2.0
 Requires-Dist: python-json-logger>=2.0
+Requires-Dist: s3fs
 Requires-Dist: uvicorn[standard]>=0.22
 Requires-Dist: xarray[accel,io,parallel]
-Requires-Dist: zarr<3; python_version < '3.11'
-Requires-Dist: zarr>=3.0.3; python_version >= '3.11'
+Requires-Dist: zarr[remote-tests]<3; python_version < '3.11'
+Requires-Dist: zarr[remote-tests]>=3.0.3; python_version >= '3.11'
 Provides-Extra: dev
 Requires-Dist: httpx; extra == 'dev'
 Requires-Dist: ipykernel; extra == 'dev'

tonik-0.1.16.dist-info/RECORD

@@ -0,0 +1,14 @@
+tonik/__init__.py,sha256=dov-nMeGFBzLspmj4rWKjC4r736vmaPDgMEkHSUfP98,523
+tonik/api.py,sha256=XDKiz1AzYNBOwYfaRxpMgqGRDAPJEE6wWJyBxuYPRLc,7751
+tonik/grafana_annotations.py,sha256=ZU9Cy-HT4vvMfYIQzD9WboaDVOCBDv__NmXbk1qKWJo,5838
+tonik/storage.py,sha256=vFxIrY92cSYOYOpNXHxCAjdXgkrRytaRDpudtK0glmg,10608
+tonik/utils.py,sha256=vRFMoCU7dbfnnm5RALBR-XrpPGDFtQoeTDzxFiYf3bo,7522
+tonik/xarray2netcdf.py,sha256=gDNT6nxnRbXPeRqZ3URW5oXY3Nfh3TCrfueE-eUrIoY,5181
+tonik/xarray2zarr.py,sha256=SSchDqy5oyYrIG4smV8fslsUg2UPSyyQjUA5ZlP1P4I,8630
+tonik/package_data/index.html,sha256=ZCZ-BtGRERsL-6c_dfY43qd2WAaggH7xereennGL6ww,4372
+tonik/package_data/whakaari_labels.json,sha256=96UZSq41yXgAJxuKivLBKlRTw-33jkjh7AGKTsDQ9Yg,3993
+tonik-0.1.16.dist-info/METADATA,sha256=EOwmXNC5b6IJsnTLMelBZ3vL1ljkfZwhM8Hoz6iHiZQ,2191
+tonik-0.1.16.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+tonik-0.1.16.dist-info/entry_points.txt,sha256=y82XyTeQddM87gCTzgSQaTlKF3VFicO4hhClHUv6j1A,127
+tonik-0.1.16.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+tonik-0.1.16.dist-info/RECORD,,

{tonik-0.1.15.dist-info → tonik-0.1.16.dist-info}/WHEEL

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

{tonik-0.1.15.dist-info → tonik-0.1.16.dist-info}/entry_points.txt

@@ -1,3 +1,4 @@
 [console_scripts]
+grafana_annotations = tonik.grafana_annotations:main
 test_data = tonik.utils:main
 tonik_api = tonik.api:main

tonik-0.1.15.dist-info/RECORD

@@ -1,12 +0,0 @@
-tonik/__init__.py,sha256=dov-nMeGFBzLspmj4rWKjC4r736vmaPDgMEkHSUfP98,523
-tonik/api.py,sha256=XDKiz1AzYNBOwYfaRxpMgqGRDAPJEE6wWJyBxuYPRLc,7751
-tonik/storage.py,sha256=vFxIrY92cSYOYOpNXHxCAjdXgkrRytaRDpudtK0glmg,10608
-tonik/utils.py,sha256=9eSVKIbs8TIZlJCz_-B7FrvOUQCQHO3K52v4Heus-uE,6135
-tonik/xarray2netcdf.py,sha256=gDNT6nxnRbXPeRqZ3URW5oXY3Nfh3TCrfueE-eUrIoY,5181
-tonik/xarray2zarr.py,sha256=RhCnS6g3yqe8mrEXhD_4PCN0EI3QPhp5X7ui_wvb_jY,2445
-tonik/package_data/index.html,sha256=ZCZ-BtGRERsL-6c_dfY43qd2WAaggH7xereennGL6ww,4372
-tonik-0.1.15.dist-info/METADATA,sha256=fgLopxgfF1ooNHl2DEYN3dFivpSknlfRrAL2eledYKo,2143
-tonik-0.1.15.dist-info/WHEEL,sha256=KGYbc1zXlYddvwxnNty23BeaKzh7YuoSIvIMO4jEhvw,87
-tonik-0.1.15.dist-info/entry_points.txt,sha256=mT3B4eBE8SHlAeMhFnZGor9-YkVtoWM1NVHVuypJ-uY,74
-tonik-0.1.15.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-tonik-0.1.15.dist-info/RECORD,,