DEKER™ Tutorial
Deker™ Tutorial
This brief tutorial shows how to access OpenWeather historical weather data using open-source Deker™ multidimensional array storage engine.
Get access
First of all, to get access please follow instructions at this page. You
will receive your personal access credentials (username
and password
) and Deker™
deker_host
.
Install
Meanwhile you should install Deker™ dependencies on your machine. Open terminal and check your local Python version
python --version
Minimum Python version supported by Deker™ is 3.9.
If you do not have Python (or its version < 3.9), you have to to install one. Installation instructions can be found in official Python documentation. If you want to preserve older versions of Python on your system, you may want to use pyenv Python version management tool.
Setup Python venv
Deker™ has its own specific requirements for dependency packages versions, so you may want to create venv for you project.
Let's create project directory named deker_weather
and initialize new virtual environment
stored in .venv
subdirectory:
mkdir deker_weather
cd deker_weather
python -m venv ./.venv
.venv/bin/activate
Install Deker™
Now install Deker™ package with all dependencies:
pip install deker[all]
You will have the following major packages installed:
Package | Description |
---|---|
deker |
Deker™ core package |
deker-server-adapters |
Storage plugin for remote Deker™ server storage support |
deker-shell |
Interactive Deker™ data access and management shell |
deker-local-adapters |
Storage adapter plugin for local HDF5 storage support |
numpy |
Multi-dimensional arrays and matrices support |
h5py |
HDF5 file format support |
hdf5plugin |
HDF5 compression and filtration support |
xarray |
Array dimensions and coordinates labeling library, also supporting data export to pandas |
Please note, this tutorial only covers access to the OpenWeather hosted Deker™ data servers. If you are looking to use Deker™ to store your data locally, please refer to its comprehensive documentation.
Connect to server
Now let's open your favorite development environment, switch to deker_weather
directory,
create a new Python project and activate the existing Python virtual environment in it.
Create a new file main.py
and open it for editing.
First we need to import and instantiate Deker™
Client
.
You have to provide the Client
with a URI, containing credentials and remote server Deker™ host
address from our email.
# we will use those imports later in owr sample code
import datetime
from pprint import pprint
from deker import Client
USERNAME = 'username' # replace with provided username
PASSWORD = 'password' # password
DEKER_HOST = 'deker_host' # Deker server host
DEKER_URI = f"https://{USERNAME}:{PASSWORD}@{DEKER_HOST}"
with Client(DEKER_URI) as client:
# now we have initialized Deker client
Click here to learn how to use interactive shell
Optionally, you may want to play with interactive shel instead of using a code editor.
Open terminal and go to deker_weather
directory, activate your Python virtual environment
with Deker™ inside and launch interactive shell.
You must provide Deker™ server URI, containing access credentials and Deker™ host address as a command line parameter:
cd deker_weather
source .venv/bin/activate
deker https://{username}:{password}@{deker_host}
You will get to the interactive custom Python REPL with the following predefined variables and preimported packages:
- client: pre-initialized Deker™
Client
instance - collections: list of server collections
- collection: variable containing selected
Collection
object (None
at the start) - np: alias for imported
numpy
library - datetime: imported
datetime
library
Get data collection
Data on server is stored in collections. In particular weather historical data is stored in
collection named weather_nowcast
. You should use initialized CLient
to access it:
with Client(DEKER_URI) as client:
collection = client.get_collection("weather_nowcast")
print(collection) # "weather_nowcast"
You can also manually iterate over the client to get all collections available on server:
with Client(DEKER_URI) as client:
for col in client:
print(col) # "weather_nowcast"
Click here to learn how to using interactive shell
Check list of available collections and currently selected collection:
python
collections # output: ["weather_nowcast"]
collection # output: None
Now select weather history collection:
python
use("weather_nowcast")
collection # output: "weather_nowcast"
Get data array
Deker™ collections consist of either Array
or
VArray
objects. Both of these types
provide storage for multidimensional numeric data arrays. VArray
it typically used for larger
amounts of data. But from user perspective there is no difference between them, as they have the same
interface.
Please note, you can find more the details in Deker™ documentation.
In particular weather_nowcast
collection contains only one VArray
with
hourly data from 2022-08-01 00:00:00 UTC and up to the current moment. In our commercial offering
we provide access to full weather history archive since 1979.
For full list of available data collections please refer to Deker™ Data Sets article.
Each VArray
in collection has its unique identifiers. One of them is a dictionary of
primary_attributes
. You may think of unique combination of primary_attributes
values as of primary keys in relational database. In weather_nowcast
the only one primary
attribute is named model_name
and its value for our VArray
is
weather_nowcast
.
Click here to learn how to use interactive shell
From now on all code examples will work in both Deker™ shell
and in your Python script. The only
prerequisite is that you import pprint
in interactive shell:
python
from pprint import pprint
In order to retrieve our VArray
from the collection by its primary attribute:
varray = collection.filter({"model_name": "weather_nowcast"}).first()
print(varray.primary_attributes) # OrderedDict([('model_name', 'weather_nowcast')])
Also, you can iterate over the collection to get all VArray
objects stored in it one by one:
for varray in collection:
print(varray.primary_attributes) # OrderedDict([('model_name', 'weather_nowcast')])
VArray
contains some metadata which you may find useful to understand its data structure:
-
dimensions
: information aboutVArray
dimensions:# we have a special dimension type for time from Deker™ import TimeDimension pprint(varray.dimensions) for n, dim in enumerate(varray.dimensions): print(n) # dimension index print(dim.name) # dimension name ("dt", "x", "y", etc.) print(dim.size) # dimension size (i.e. number of values along dimension) if isinstance(dim, TimeDimension): print(dim.start_value) # date and time that corresponds to dimension start print(dim.step) # timedelta between two neighbour point on dimension else: print(dim.scale) # scale that corresponds to dimension points print(dim.labels) # text labels that correspond to dimension points
-
shape
: tuple that contains all dimensions sizesprint(varray.shape) # (1753920, 721, 1440, 22)
-
named_shape
: tuple of tuples that contain both dimension names and sizesprint(varray.named_shape) # (('dt', 1753920), ('y', 721), ('x', 1440), ('layers', 22))
-
dtype
: data type stored in the arrayprint(varray.dtype) # <class 'numpy.float64'>
-
fill_value
: value stored in array cells considered to be emptyprint(varray.fill_value) # nan
-
primary_attributes
: an immutable ordered dictionary ofVArray
primary attributesprint(varray.primary_attributes) # OrderedDict([('model_name', 'weather_nowcast')])
-
custom_attributes
: dictionary with optional supplementary information associated with particularVArray
print(varray.custom_attributes) # {'units': ('%', '°K', 'hPa', '%', 'hPa', '°K', 'mm', 'mm', 'mm', 'mm', 'mm', 'mm', 'mm', 'mm', 'mm', 'mm/s', 'mm', 'm', 'mm', 'mm', 'deg', 'm/s')}
Get data subset
Now as we have retrieved VArray
and understood its characteristics we can finally move to
retrieving data itself. To do it you must request VSubset
from the VArray
.
If you previously tried to get the named_shape
property, you know that the VArray
has 4 dimensions:
index | name | type | size | desc |
---|---|---|---|---|
0 | dt |
TimeDimension |
1753920 |
Time series dimension. Its start_value (or index 0 ) is set to
1900-01-01 00:00:00 UTC (but as noted above actual available data only starts at
2022-01-01 00:00:00 UTC.
|
1 | y |
Dimension |
721 |
Latitudes dimension. It has a provided scale property with the
start_value (or index 0 ) set to 90.0 degree and the grid
step set to -0.25 degree. Which means that we move from north to south
with 0.25 degree step.
|
2 | x |
Dimension |
1440 |
Longitudes dimension. It has a provided scale property with the
start_value (or index 0 ) set to -180.0 degree and the grid
step set to 0.25 degree. Which means that we move from west to east with
0.25 degree step.
|
3 | layers |
Dimension |
22 |
Weather data layers containing different parameters such as temperature, dew point, humidity, etc. |
Also, in custom_attributes
you can find a tuple of units for these layers.
By assembling this information together we get the following mapping:
Index | Label | Unit |
---|---|---|
0 |
clouds.all |
% |
1 |
main.dew_point |
°K |
2 |
main.grnd_pressure |
hPa |
3 |
main.humidity |
% |
4 |
main.pressure |
hPa |
5 |
main.temp |
°K |
6 |
precipitation.accumulated |
mm |
7 |
precipitation.convective |
mm |
8 |
precipitation.fr_rain |
mm |
9 |
precipitation.graupel |
mm |
10 |
precipitation.hail |
mm |
11 |
precipitation.ice |
mm |
12 |
precipitation.ice_pellets |
mm |
13 |
precipitation.mix_rain_snow |
mm |
14 |
precipitation.rain |
mm |
15 |
precipitation.rate |
mm/s |
16 |
precipitation.snow |
mm |
17 |
precipitation.snow_depth |
m |
18 |
precipitation.thunderstorm |
mm |
19 |
precipitation.wet_snow |
mm |
20 |
wind.deg |
deg |
21 |
wind.speed |
m/s |
Now we know which array dimensions are available we could slice VArray
within
mentioned dimensions sizes. To do so we could either specify integer indexes of data cells inside array (as
we would do for normal Python array or numpy ndarray
) or use what we name fancy slicing.
Fancy slicing allows you to specify string labels associated with particular
dimension indexes, datetime
objects and strings for time dimensions or float values for
dimensions with associated scales. We will use this approach in examples below.
For example:
- to index
layers
dimension we will use string labels with weather parameter names, - for
dt
time dimension we will use ISO 8601 format strings,float
timestamps and Pythondatetime
objects - for
x
andy
dimensions we would usefloat
latitude and longitude values
Attention: Be mindful of using float
values for fancy slicing. If by
mistake you specify integer in place of float, say 0
instead of 0.0
when
addressing latitude, you will fall back to standard Python indexing and will get first item on the
dimension axis instead of 0 latitude.
Please note, Deker™ does not support slicing
step different from 1
or
None
.
Get temperature in one point at certain time
Let's get air temperature data in London at 2022-11-15 12:00:00 UTC.
Note: OpenWeather weather model has a grid with 0.25
degrees step, which
means you cannot specify arbitrary coordinates when requesting data. You shall round
them to the closest values using this step. For example for London we will round its latitude of
51.509865
to 51.50
and longitude of -0.118092
to 0.0
.
dt = datetime.datetime(2022, 11, 15, 12, tzinfo=datetime.timezone.utc) # 2022-11-15 12:00:00 UTC
subset = varray[dt, # dt
51.5, # y
0.0, # x
'main.temp'] # layers
pprint(subset.describe())
print(subset.bounds) # (1077084, 154, 720, 5)
data = subset.read()
units = varray.custom_attributes['units']
print(data, units[subset.bounds[-1]]) # 285.1268310546875 °K
TimeDimension
can be sliced both with datetime ISO 8601 strings and timestamps:
dt_str: str = dt.isoformat()
subset_str = varray[dt_str, 51.5, 0.0, 'main.temp']
dt_tm: float = dt.timestamp()
subset_tm = varray[dt_tm, 51.5, 0.0, 'main.temp']
assert subset_tm.bounds == subset_str.bounds == subset.bounds
Please note that x
dimension integer index 0
points to array's first element,
not to the longitude 0.0
:
assert varray[dt, 51.5, 0, 'main.temp'].bounds != varray[dt, 51.5, 0.0, 'main.temp'].bounds
Get multiple weather parameters in one point certain time
Let's get humidity, pressure and air temperature data in London at 2022-11-15 12:00:00 UTC.
dt = datetime.datetime(2022, 11, 15, 12, tzinfo=datetime.timezone.utc) # 2022-11-15 12:00:00 UTC
subset = varray[dt, 51.5, 0.0, 'main.humidity':'precipitation.accumulated']
pprint(subset.describe())
print(subset.bounds) # (1077084, 154, 720, slice(3, 6, None))
units = varray.custom_attributes["units"]
labels = varray.dimensions[-1].labels # labels for last (layers) dimension
data = subset.read()
output = list(zip(labels[subset.bounds[-1]],
data.tolist(),
units[subset.bounds[-1]]))
print(output) # [('main.humidity', 94.67348428777615, '%'), ('main.pressure', 993.675625, 'hPa'), ('main.temp', 285.1268310546875, '°K')]
Get all weather parameters in one point at certain time
Let's get all weather data in London at 2022-11-15 12:00:00 UTC.
dt = datetime.datetime(2022, 11, 15, 12, tzinfo=datetime.timezone.utc) # 2022-11-15 12:00:00 UTC
subset = varray[dt, # dt
51.5, # y
0.0, # x
:] # layers
pprint(subset.describe())
print(subset.bounds) # (1077084, 154, 720, slice(None, None, None))
data = subset.read()
units = varray.custom_attributes["units"]
labels = varray.dimensions[-1].labels # labels for last (layers) dimension
output = list(zip(labels[subset.bounds[-1]], data.tolist(), units[subset.bounds[-1]]))
pprint(output)
# other options to get whole dimension:
subset1 = varray[dt, 51.5, 0.0, ...]
assert (data == subset1.read()).all()
subset2 = varray[dt, 51.5, 0.0]
assert (data == subset2.read()).all()
Open the output
[('clouds.all', 100.0, '%'),
('main.dew_point', 284.19908142089844, '°K'),
('main.grnd_pressure', 987.0112890625, 'hPa'),
('main.humidity', 94.67348428777615, '%'),
('main.pressure', 993.675625, 'hPa'),
('main.temp', 285.1268310546875, '°K'),
('precipitation.accumulated', 1.1754035949707031, 'mm'),
('precipitation.convective', 0.02956390380859375, 'mm'),
('precipitation.fr_rain', 0.0, 'mm'),
('precipitation.graupel', 0.0, 'mm'),
('precipitation.hail', 0.0, 'mm'),
('precipitation.ice', 0.0, 'mm'),
('precipitation.ice_pellets', 0.0, 'mm'),
('precipitation.mix_rain_snow', 0.0, 'mm'),
('precipitation.rain', 1.1754035949707031, 'mm'),
('precipitation.rate', 0.00032639503479003906, 'mm/s'),
('precipitation.snow', 0.0, 'mm'),
('precipitation.snow_depth', 0.0, 'm'),
('precipitation.thunderstorm', 0.0, 'mm'),
('precipitation.wet_snow', 0.0, 'mm'),
('wind.deg', 168.21540991593272, 'deg'),
('wind.speed', 7.61756099139834, 'm/s')]
Get temperature in several nearby points at certain time
Let's get air temperature data within some area nearby London at 2022-11-15 12:00:00 UTC.
Let's assume, you are interested in the latitudes from 50.25
to 53.75
inclusively and in longitudes from -1.0
to 1.0
exclusively.
Attention: If you check varray.dimension[1].scale
and
varray.dimension[2].scale
properties, you will find out that the first one has
step
of -0.25
and start_value
of 90.0
, and the second
one has step
of 0.25
and start_value
of -180.0
.
The Earth grid zero point (or array index [..., 0, 0, ...]
) is set to the upper-left corner
of the map with latitude 90.0
and longitude -180.0
.
That's why the calculation and the indication of latitudes in the slice goes in reverse and of longitudes in the direct way.
dt = datetime.datetime(2022, 11, 15, 12, tzinfo=datetime.timezone.utc) # 2022-11-15 12:00:00 UTC
# take note of indexes order of x and y dimensions
subset = varray[dt, # dt
53.75:50.0, # y
-1.0:1.0, # x
'main.temp'] # layers
pprint(subset.describe())
print(subset.bounds) # (1077084, slice(145, 160, None), slice(716, 724, None), 5)
print(subset.shape) # (15, 8)
data = subset.read()
pprint(data) # a bbox with temperature data inside
assert data.shape == subset.shape
Open the output
array([[284.5604248 , 284.51159668, 284.3338623 , 284.43151855,
284.67956543, 284.9744873 , 285.2322998 , 285.27331543],
[284.4822998 , 284.51745605, 284.31628418, 284.36120605,
284.43933105, 284.77526855, 285.04284668, 285.10144043],
[284.4197998 , 284.47253418, 284.2947998 , 284.25769043,
284.24987793, 284.62878418, 284.94714355, 285.07995605],
[284.42956543, 284.47058105, 284.41003418, 284.43151855,
284.46472168, 284.66003418, 284.78308105, 284.76550293],
[284.30456543, 284.31628418, 284.39050293, 284.46862793,
284.6385498 , 284.53894043, 284.54870605, 284.39440918],
[284.25769043, 284.36706543, 284.5213623 , 284.67565918,
284.7791748 , 284.65222168, 284.54089355, 284.42565918],
[284.43933105, 284.5369873 , 284.6229248 , 284.73815918,
284.74597168, 284.56628418, 284.43933105, 284.3885498 ],
[284.6619873 , 284.72058105, 284.68347168, 284.66589355,
284.63269043, 284.51159668, 284.4666748 , 284.63269043],
[284.86706543, 284.9354248 , 284.8651123 , 284.80651855,
284.76159668, 284.69909668, 284.7322998 , 285.03894043],
[285.25964355, 285.32800293, 285.30065918, 285.17175293,
285.12683105, 285.0916748 , 285.0291748 , 285.30651855],
[285.71081543, 285.7401123 , 285.70495605, 285.5213623 ,
285.2401123 , 285.14440918, 285.06433105, 285.03503418],
[286.2479248 , 286.28894043, 286.21081543, 285.96862793,
285.61315918, 285.5369873 , 285.52331543, 285.6697998 ],
[287.12878418, 287.2635498 , 287.40222168, 287.3572998 ,
287.18933105, 287.1229248 , 287.05065918, 286.96276855],
[287.6229248 , 287.77722168, 287.74597168, 287.68347168,
287.49597168, 287.3338623 , 287.22644043, 287.01940918],
[287.52722168, 287.66784668, 287.64050293, 287.58190918,
287.4510498 , 287.3182373 , 287.14245605, 286.83190918]])
Get temperature in one point for a time period
Let's get air temperature data in London during the day of 2022-11-15.
dt_start = datetime.datetime(2022, 11, 15, tzinfo=datetime.timezone.utc) # 2022-11-15 12:00:00 UTC
dt_stop = datetime.datetime(2022, 11, 16, tzinfo=datetime.timezone.utc) # 2022-11-16 12:00:00 UTC
subset = varray[dt_start:dt_stop, # dt
51.5, # y
0.0, # x
'main.temp'] # layers
pprint(subset.describe())
print(subset.bounds) # (slice(1077072, 1077096, None), 154, 720, 5)
print(subset.shape) # (24,)
data = subset.read()
pprint(data) # a bbox with temperature data inside
assert data.shape == subset.shape
TimeDimensions
can be sliced with datetime ISO 8601 strings and float timestamps:
subset_str = varray[dt_start.isoformat():dt_stop.isoformat(), 51.5, 0.0, 'main.temp']
subset_tm = varray[dt_start.timestamp():dt_stop.timestamp(), 51.5, 0.0, 'main.temp']
assert subset_tm.bounds == subset_str.bounds == subset.bounds
Open the output
array([282.37402344, 281.96641541, 282.09506226, 282.55560303,
283.50241089, 284.20826721, 284.3684082 , 284.02146912,
284.08099365, 284.63772583, 284.65884399, 284.79205322,
285.12683105, 285.71865845, 286.28279114, 286.340271 ,
285.63284302, 284.46965027, 283.65153503, 282.85699463,
282.60710144, 282.64733887, 281.64945984, 281.515625 ])
Export to Xarray and pandas
Let's get wind.speed
and wind.deg
data within some area nearby London at 2022-11-15
12:00:00 UTC and export it to Xarray and pandas.
Let's assume, you are interested in the latitudes from 50.25
to 53.75
inclusively and in longitudes from -1.0
to 1.0
exclusively.
dt = datetime.datetime(2022, 11, 15, 12, tzinfo=datetime.timezone.utc) # 2022-11-15 12:00:00 UTC
# take note of indexes order of x and y dimensions
subset = varray[dt, # dt
53.75:50.0, # y
-1.0:1.0, # x
'wind.deg':] # layers
pprint(subset.describe())
print(subset.bounds) # (1077084, slice(145, 160, None), slice(716, 724, None), slice(20, 22, None))
print(subset.shape) # (15, 8, 2)
# read data as xarray
data = subset.read_xarray()
pprint(data) # an `xarray.DataArray` instance
Open the output of xarray.DataArray
<xarray.DataArray 'Deker VSubset of VArray(id=918b1e23-fcd2-5a30-8fd5-b8b1e0eb62d2) from collection `weather_nowcast`' (layers: 2)>
array([[[[145.25567603, 7.23293691],
[147.9206404 , 7.6090333 ],
[149.38010375, 7.99343928],
[150.18962175, 9.08944526],
[150.18050845, 11.04880989],
[150.85017533, 12.21385952],
[151.27216548, 13.43822285],
[153.46276627, 13.29632177]],
[[149.8326678 , 7.48772941],
[150.43012454, 7.74168784],
[151.11358563, 7.88425607],
[152.33080996, 8.57203457],
[153.42895265, 9.2591694 ],
[152.3914429 , 10.89260669],
[152.31499281, 12.29418516],
[154.27790838, 12.75833693]],
[[152.23166513, 7.74104894],
[152.40075746, 8.01447842],
...
[180.45581629, 12.63220516],
[175.34875359, 12.85088443]],
[[213.74020716, 12.62206662],
[207.54097719, 14.17568929],
[205.39651647, 15.35818708],
[202.42481189, 15.71043931],
[198.60102288, 15.63506204],
[192.49788578, 14.48080198],
[186.53589298, 13.80354946],
[178.72276173, 13.36657175]],
[[217.36264092, 13.41584646],
[211.14962255, 14.74620297],
[208.52252967, 15.48150821],
[205.09825687, 15.90393574],
[201.33344183, 16.01742021],
[195.85678405, 14.79640559],
[189.80683699, 13.57628149],
[182.37080715, 12.34452032]]]])
Coordinates:
* dt (dt) object 2022-11-15T12:00:00+00:00
* y (y) float64 53.75 53.5 53.25 53.0 52.75 ... 51.0 50.75 50.5 50.25
* x (x) float64 -1.0 -0.75 -0.5 -0.25 0.0 0.25 0.5 0.75
* layers (layers) <U10 'wind.deg' 'wind.speed'
Attributes:
primary_attributes: OrderedDict([('model_name', 'weather_nowcast')])
custom_attributes: {'units': ('%', '°K', 'hPa', '%', 'hPa', '°K', 'mm',...
Convert the result into pandas.DataFrame
:
pd = data.to_dataframe()
pprint(pd)
Open the output of pandas.DataFrame
pandas.DataFrame
Deker VSubset of VArray(id=918b1e23-fcd2-5a30-8fd5-b8b1e0eb62d2) from collection `weather_nowcast`
dt y x layers
2022-11-15 12:00:00+00:00 53.75 -1.00 wind.deg 145.255676
wind.speed 7.232937
-0.75 wind.deg 147.920640
wind.speed 7.609033
-0.50 wind.deg 149.380104
... ...
50.25 0.25 wind.speed 14.796406
0.50 wind.deg 189.806837
wind.speed 13.576281
0.75 wind.deg 182.370807
wind.speed 12.344520
[240 rows x 1 columns]
Convert the result into pandas.Series
:
sr = data.to_series()
pprint(sr)
Open the output of pandas.Series
pandas.Series
dt y x layers
2022-11-15 12:00:00+00:00 53.75 -1.00 wind.deg 145.255676
wind.speed 7.232937
-0.75 wind.deg 147.920640
wind.speed 7.609033
-0.50 wind.deg 149.380104
...
50.25 0.25 wind.speed 14.796406
0.50 wind.deg 189.806837
wind.speed 13.576281
0.75 wind.deg 182.370807
wind.speed 12.344520
Name: Deker VSubset of VArray(id=918b1e23-fcd2-5a30-8fd5-b8b1e0eb62d2) from collection `weather_nowcast`, Length: 240, dtype: float64
Convert the result into Python dict
:
dic = data.to_dict()
pprint(dic)
Open the output of dictionary
{'attrs': {'custom_attributes': {'units': ('%',
'°K',
'hPa',
'%',
'hPa',
'°K',
'mm',
'mm',
'mm',
'mm',
'mm',
'mm',
'mm',
'mm',
'mm',
'mm/s',
'mm',
'm',
'mm',
'mm',
'deg',
'm/s')},
'primary_attributes': OrderedDict([('model_name', 'weather_nowcast')])},
'coords': {'dt': {'attrs': {},
'data': [Timestamp('2022-11-15 12:00:00+0000', tz='UTC')],
'dims': ('dt',)},
'layers': {'attrs': {},
'data': ['wind.deg', 'wind.speed'],
'dims': ('layers',)},
'x': {'attrs': {},
'data': [-1.0, -0.75, -0.5, -0.25, 0.0, 0.25, 0.5, 0.75],
'dims': ('x',)},
'y': {'attrs': {},
'data': [53.75,
53.5,
53.25,
53.0,
52.75,
52.5,
52.25,
52.0,
51.75,
51.5,
51.25,
51.0,
50.75,
50.5,
50.25],
'dims': ('y',)}},
'data': [[[[145.25567602707267, 7.232936910457338],
[147.92064040399612, 7.609033299461203],
[149.38010375294866, 7.99343927581919],
[150.1896217519439, 9.08944525918969],
[150.18050845040887, 11.048809886069009],
[150.85017532675738, 12.21385951883367],
[151.27216548042955, 13.438222854946561],
[153.46276627423057, 13.296321772568442]],
[[149.83266779673434, 7.487729406568997],
[150.43012454424624, 7.741687843822061],
[151.11358563047506, 7.884256066867523],
[152.33080996260884, 8.572034574672887],
[153.4289526518475, 9.259169399942062],
[152.39144289974888, 10.892606686713174],
[152.31499280905814, 12.294185162849223],
[154.2779083798769, 12.758336932203983]],
[[152.23166512820393, 7.741048939538837],
[152.40075745973246, 8.014478416145455],
[152.64275971716395, 8.188211599964024],
[153.41344730405, 8.400991508019708],
[154.36209901356366, 8.630968489521528],
[152.4353151794691, 10.269146494243593],
[151.7395087998305, 11.723539747260409],
[153.5065759385801, 12.500167488302255]],
[[155.36558597751986, 8.125221283013028],
[154.92013678778704, 8.354009921491869],
[154.2304338773671, 8.423639378621065],
[153.78393760049738, 8.588508273698935],
[153.61664118654542, 8.784049070467537],
[153.6821654130187, 10.30218132713206],
[154.3604354053278, 11.593704275355309],
[156.1611982443143, 12.081466953078687]],
[[158.71025984936776, 8.558653378703301],
[158.4537942656187, 8.650338864704551],
[158.37380734579202, 8.566875287173234],
[157.45097613233636, 8.610365186392576],
[156.033536872458, 8.532486679781274],
[155.90302862461235, 8.65883385195775],
[156.34230129286644, 9.357686975287406],
[158.715500632957, 9.537227617089767]],
[[162.03396841147116, 8.402860791943343],
[162.17079032819606, 8.462036167701179],
[160.88730145336967, 8.440845487315075],
[159.2397617290471, 8.397759212893106],
[156.68792052587608, 8.464416838721359],
[156.52445646356483, 8.482323151347053],
[156.88390450963456, 8.571993198463815],
[159.03754445618264, 8.650636371580855]],
[[165.62053054881932, 7.963309551972954],
[165.03168576623182, 8.159648560475851],
[163.85171486268874, 8.20962137534443],
[161.45920339252734, 8.243244299211703],
[158.0715581708301, 8.71338187217929],
[157.67051645665677, 8.903967548684685],
[158.00735988148966, 8.93954509784058],
[159.67192832233056, 8.99578420313114]],
[[169.23250850419555, 7.6164918128239645],
[167.74988655782863, 7.732677875225827],
[166.4744255647266, 7.9881164763462005],
[163.36515682595308, 8.402402519032076],
[160.11873488474404, 8.629529182451137],
[159.43958305019427, 8.753858461998547],
[159.19397804379864, 9.138901064278137],
[159.87205063957998, 9.60930426085029]],
[[173.54828585642775, 7.362023568064465],
[170.61128067094114, 7.549340377171486],
[168.96040812482184, 7.854296847362559],
[166.1332089711816, 8.056047571375961],
[162.95703097070935, 8.03035511477254],
[161.73100432033328, 8.389644292551322],
[161.2210938198236, 8.76127283287723],
[161.04001281227423, 9.783707289195705]],
[[178.459108565785, 7.593535707363151],
[175.35665557498714, 7.757853232854952],
[173.52250071138266, 7.8695427292888045],
[171.25914122058404, 7.795587365143062],
[168.21540991593272, 7.61756099139834],
[166.3184411781594, 8.134092236315604],
[164.070248148151, 8.49005941893459],
[162.89164676120907, 9.759971911620818]],
[[184.84038770255714, 7.683622142606445],
[182.1527454773994, 8.342771566208373],
[180.75698773935403, 8.41964963042785],
[178.77534013550434, 8.320229386308535],
[175.89516124969754, 8.15957277276798],
[171.7590899939697, 8.190007103133564],
[168.8561627877987, 8.423441251706338],
[167.7206503093093, 8.857891181049448]],
[[195.96496835863786, 8.01313738733779],
[192.38170759094638, 9.026320865099118],
[190.44137306162017, 9.531831836627255],
[187.32762207941911, 9.60083980698041],
[183.45364115460964, 9.400831706063745],
[179.01473597239527, 9.09213406063544],
[174.85939427088942, 9.123580267460099],
[173.43745113845148, 9.861459908064795]],
[[205.19506307240843, 10.487992250112185],
[200.90867690489057, 12.412022261910387],
[199.83850145941076, 14.079698953392633],
[196.75587520608883, 14.39942921294576],
[192.68556428084176, 14.101012496908268],
[186.89065305629464, 13.169311124935058],
[180.45581628654983, 12.632205163317174],
[175.34875358962404, 12.85088442873137]],
[[213.7402071554717, 12.62206661770322],
[207.5409771866554, 14.175689287339377],
[205.39651647155964, 15.3581870778161],
[202.42481188947926, 15.710439313042162],
[198.60102287603974, 15.635062039476551],
[192.4978857766338, 14.480801978353432],
[186.53589297549598, 13.80354946468435],
[178.72276173020236, 13.366571745869969]],
[[217.36264091632376, 13.41584645586849],
[211.1496225475926, 14.746202974546517],
[208.52252967104837, 15.48150820933801],
[205.09825686870295, 15.903935742145933],
[201.33344183102892, 16.017420205999667],
[195.85678405112543, 14.796405589738054],
[189.80683699219537, 13.576281487490668],
[182.3708071476758, 12.344520315824283]]]],
'dims': ('dt', 'y', 'x', 'layers'),
'name': 'Deker VSubset of VArray(id=918b1e23-fcd2-5a30-8fd5-b8b1e0eb62d2) '
'from collection `weather_nowcast`'}