eliminate string constants from processing

toargridding/grids.py

@@ -14,7 +14,11 @@ from toargridding.toar_rest_client import (
     STATION_LON,
     COORDS,
 )
-from toargridding.metadata import GLOBAL, LATITUDE, LONGITUDE, get_variable_attributes
+from toargridding.metadata import (
+    Variables,
+    get_variable_attributes,
+    get_global_attributes,
+)
 
 GridType = Enum("GridType", ["regular"])
 
@@ -108,13 +112,13 @@ class RegularGrid(GridDefinition):
 
     def get_cell_statistics(self, groups):
         stats = {
-            "mean": groups.mean(),
-            "std": groups.std(),
-            "n": groups.count(),
+            Variables.mean.name: groups.mean(),
+            Variables.std.name: groups.std(),
+            Variables.n.name: groups.count(),
         }
-        idx = stats["n"] == 0
-        stats["mean"][idx] = self.fill_value
-        stats["std"][idx] = self.fill_value
+        idx = stats[Variables.n.name] == 0
+        stats[Variables.mean.name][idx] = self.fill_value
+        stats[Variables.std.name][idx] = self.fill_value
 
         return stats
 
@@ -123,9 +127,9 @@ class RegularGrid(GridDefinition):
         time = pd.DatetimeIndex(random_df.columns)
 
         gridded_ds = self.get_empty_grid(time, metadata)
-        for cell_statistic, grouped_timeseries in cell_statistics.items():
+        for cell_statistic, aggregated_timeseries in cell_statistics.items():
             gridded_ds = self.assign_statistic_to_grid(
-                gridded_ds, cell_statistic, grouped_timeseries, time
+                gridded_ds, cell_statistic, aggregated_timeseries, time
             )
 
         return gridded_ds
@@ -137,7 +141,16 @@ class RegularGrid(GridDefinition):
         metadata = get_variable_attributes(cell_statistic)
 
         gridded_ds = gridded_ds.assign(  # maybe better all in one ? (memory)
-            {cell_statistic: (["latitude", "longitude", "time"], values)}
+            {
+                cell_statistic: (
+                    [
+                        Variables.latitude.name,
+                        Variables.longitude.name,
+                        Variables.time.name,
+                    ],
+                    values,
+                )
+            }
         )
 
         return gridded_ds
@@ -172,9 +185,13 @@ class RegularGrid(GridDefinition):
         self, time: pd.DatetimeIndex, metadata: pd.DataFrame
     ) -> xr.Dataset:  # TODO make CF-compliant => docs
         coords = {
-            "longitude": self.lon,
-            "latitude": self.lat,
-            "time": time,
+            Variables.longitude.name: self.lon,
+            Variables.latitude.name: self.lat,
+            Variables.time.name: time,
         }
 
-        return xr.Dataset(coords=coords, attrs=GLOBAL)
+        ds = xr.Dataset(coords=coords, attrs=get_global_attributes(metadata))
+        ds.longitude.attrs = get_variable_attributes(Variables.longitude)
+        ds.latitude.attrs = get_variable_attributes(Variables.latitude)
+
+        return ds

toargridding/metadata.py

 from datetime import datetime
+from enum import Enum
 
 import numpy as np
 
 date_created = datetime.utcnow().strftime("%Y-%m-dT%H:%M:%SZ")
 
+Variables = Enum("Variables", ["latitude", "longitude", "time", "mean", "std", "n"])
+
 GLOBAL = {
     "title": "foo",
     "date_created": date_created,
@@ -31,11 +34,11 @@ ENCODING = {
     "time": {"dtype": "int32", "_FillValue": None},
     "latitude": {
         "dtype": "int32",
-        "_FillValue": None,
+        "_FillValue": -1000,
     },
     "longitude": {
         "dtype": "int32",
-        "_FillValue": None,
+        "_FillValue": -1000,
     },
     "mean": {
         "dtype": "float32",
@@ -55,5 +58,13 @@ ENCODING = {
 }
 
 
-def get_variable_attributes(statistic):
+def get_global_attributes(metadata):
+    pass
+
+
+def get_variable_attributes(variable: Variables):
+    pass
+
+
+def get_variable_encoding(variable: Variables):
     pass