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 about VArray 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 sizes

  print(varray.shape)  # (1753920, 721, 1440, 22)

named_shape: tuple of tuples that contain both dimension names and sizes

  print(varray.named_shape)  # (('dt', 1753920), ('y', 721), ('x', 1440), ('layers', 22))

dtype: data type stored in the array

  print(varray.dtype)  # <class 'numpy.float64'>

fill_value: value stored in array cells considered to be empty
```
  print(varray.fill_value)  # nan
```
primary_attributes: an immutable ordered dictionary of VArray primary attributes
```
  print(varray.primary_attributes)  # OrderedDict([('model_name', 'weather_nowcast')])
```

custom_attributes: dictionary with optional supplementary information associated with particular VArray

 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 Python datetime objects
for x and y dimensions we would use float 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


            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


            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`'}