Skip to content

rslearn.tile_stores.tile_store

tile_store

Base class for tile stores.

TileStore

An abstract class for a tile store.

A tile store supports operations to read and write raster and vector data.

Source code in rslearn/tile_stores/tile_store.py 
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
class TileStore:
    """An abstract class for a tile store.

    A tile store supports operations to read and write raster and vector data.
    """

    def set_dataset_path(self, ds_path: UPath) -> None:
        """Set the dataset path.

        This is in case the TileStore wants to use the ds_path to help determine where
        to store data.

        Args:
            ds_path: the dataset path that this TileStore is a part of.
        """
        pass

    def is_raster_ready(self, layer_name: str, item: Item, bands: list[str]) -> bool:
        """Checks if this raster has been written to the store.

        Args:
            layer_name: the layer name or alias.
            item: the item.
            bands: the list of bands identifying which specific raster to read.

        Returns:
            whether there is a raster in the store matching the source, item, and
                bands.
        """
        raise NotImplementedError

    def get_raster_bands(self, layer_name: str, item: Item) -> list[list[str]]:
        """Get the sets of bands that have been stored for the specified item.

        Args:
            layer_name: the layer name or alias.
            item: the item.

        Returns:
            a list of lists of bands that are in the tile store (with one raster
                stored corresponding to each inner list). If no rasters are ready for
                this item, returns empty list.
        """
        raise NotImplementedError

    def get_raster_bounds(
        self, layer_name: str, item: Item, bands: list[str], projection: Projection
    ) -> PixelBounds:
        """Get the bounds of the raster in the specified projection.

        Args:
            layer_name: the layer name or alias.
            item: the item to check.
            bands: the list of bands identifying which specific raster to read. These
                bands must match the bands of a stored raster.
            projection: the projection to get the raster's bounds in.

        Returns:
            the bounds of the raster in the projection.
        """
        raise NotImplementedError

    def get_raster_metadata(
        self, layer_name: str, item: Item, bands: list[str]
    ) -> RasterMetadata:
        """Get metadata for a stored raster without reading pixel data.

        Args:
            layer_name: the layer name or alias.
            item: the item.
            bands: the list of bands identifying which specific raster to read.

        Returns:
            a RasterMetadata instance (may have None fields if the store
            does not track a given piece of metadata).
        """
        raise NotImplementedError

    def read_raster(
        self,
        layer_name: str,
        item: Item,
        bands: list[str],
        projection: Projection,
        bounds: PixelBounds,
        resampling: Resampling = Resampling.bilinear,
    ) -> RasterArray:
        """Read raster data from the store.

        Args:
            layer_name: the layer name or alias.
            item: the item to read.
            bands: the list of bands identifying which specific raster to read. These
                bands must match the bands of a stored raster.
            projection: the projection to read in.
            bounds: the bounds to read.
            resampling: the resampling method to use in case reprojection is needed.

        Returns:
            the raster data
        """
        raise NotImplementedError

    def write_raster(
        self,
        layer_name: str,
        item: Item,
        bands: list[str],
        projection: Projection,
        bounds: PixelBounds,
        raster: RasterArray,
    ) -> None:
        """Write raster data to the store.

        Args:
            layer_name: the layer name or alias.
            item: the item to write.
            bands: the list of bands in the array.
            projection: the projection of the array.
            bounds: the bounds of the array.
            raster: the raster data.
        """
        raise NotImplementedError

    def write_raster_file(
        self,
        layer_name: str,
        item: Item,
        bands: list[str],
        fname: UPath,
        time_range: tuple[datetime, datetime] | None = None,
    ) -> None:
        """Write raster data to the store.

        Args:
            layer_name: the layer name or alias.
            item: the item to write.
            bands: the list of bands in the array.
            fname: the raster file.
            time_range: optional time range for the raster.
        """
        raise NotImplementedError

    def is_vector_ready(self, layer_name: str, item: Item) -> bool:
        """Checks if this vector item has been written to the store.

        Args:
            layer_name: the layer name or alias.
            item: the item.

        Returns:
            whether the vector data from the item has been stored.
        """
        raise NotImplementedError

    def read_vector(
        self,
        layer_name: str,
        item: Item,
        projection: Projection,
        bounds: PixelBounds,
    ) -> list[Feature]:
        """Read vector data from the store.

        Args:
            layer_name: the layer name or alias.
            item: the item to read.
            projection: the projection to read in.
            bounds: the bounds within which to read.

        Returns:
            the vector data
        """
        raise NotImplementedError

    def write_vector(
        self, layer_name: str, item: Item, features: list[Feature]
    ) -> None:
        """Write vector data to the store.

        Args:
            layer_name: the layer name or alias.
            item: the item to write.
            features: the vector data.
        """
        raise NotImplementedError

set_dataset_path 

set_dataset_path(ds_path: UPath) -> None

Set the dataset path.

This is in case the TileStore wants to use the ds_path to help determine where to store data.

Parameters:

Name Type Description Default
ds_path UPath

the dataset path that this TileStore is a part of.

 required
Source code in rslearn/tile_stores/tile_store.py 
24
25
26
27
28
29
30
31
32
33
def set_dataset_path(self, ds_path: UPath) -> None:
    """Set the dataset path.

    This is in case the TileStore wants to use the ds_path to help determine where
    to store data.

    Args:
        ds_path: the dataset path that this TileStore is a part of.
    """
    pass

is_raster_ready 

is_raster_ready(layer_name: str, item: Item, bands: list[str]) -> bool

Checks if this raster has been written to the store.

Parameters:

Name Type Description Default
layer_name str

the layer name or alias.

 required
item Item

the item.

 required
bands list[str]

the list of bands identifying which specific raster to read.

 required

Returns:

Type Description
bool

whether there is a raster in the store matching the source, item, and bands.
Source code in rslearn/tile_stores/tile_store.py 
35
36
37
38
39
40
41
42
43
44
45
46
47
def is_raster_ready(self, layer_name: str, item: Item, bands: list[str]) -> bool:
    """Checks if this raster has been written to the store.

    Args:
        layer_name: the layer name or alias.
        item: the item.
        bands: the list of bands identifying which specific raster to read.

    Returns:
        whether there is a raster in the store matching the source, item, and
            bands.
    """
    raise NotImplementedError

get_raster_bands 

get_raster_bands(layer_name: str, item: Item) -> list[list[str]]

Get the sets of bands that have been stored for the specified item.

Parameters:

Name Type Description Default
layer_name str

the layer name or alias.

 required
item Item

the item.

 required

Returns:

Type Description
list[list[str]]

a list of lists of bands that are in the tile store (with one raster stored corresponding to each inner list). If no rasters are ready for this item, returns empty list.
Source code in rslearn/tile_stores/tile_store.py 
49
50
51
52
53
54
55
56
57
58
59
60
61
def get_raster_bands(self, layer_name: str, item: Item) -> list[list[str]]:
    """Get the sets of bands that have been stored for the specified item.

    Args:
        layer_name: the layer name or alias.
        item: the item.

    Returns:
        a list of lists of bands that are in the tile store (with one raster
            stored corresponding to each inner list). If no rasters are ready for
            this item, returns empty list.
    """
    raise NotImplementedError

get_raster_bounds 

get_raster_bounds(layer_name: str, item: Item, bands: list[str], projection: Projection) -> PixelBounds

Get the bounds of the raster in the specified projection.

Parameters:

Name Type Description Default
layer_name str

the layer name or alias.

 required
item Item

the item to check.

 required
bands list[str]

the list of bands identifying which specific raster to read. These bands must match the bands of a stored raster.

 required
projection Projection

the projection to get the raster's bounds in.

 required

Returns:

Type Description
PixelBounds

the bounds of the raster in the projection.
Source code in rslearn/tile_stores/tile_store.py 
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
def get_raster_bounds(
    self, layer_name: str, item: Item, bands: list[str], projection: Projection
) -> PixelBounds:
    """Get the bounds of the raster in the specified projection.

    Args:
        layer_name: the layer name or alias.
        item: the item to check.
        bands: the list of bands identifying which specific raster to read. These
            bands must match the bands of a stored raster.
        projection: the projection to get the raster's bounds in.

    Returns:
        the bounds of the raster in the projection.
    """
    raise NotImplementedError

get_raster_metadata 

get_raster_metadata(layer_name: str, item: Item, bands: list[str]) -> RasterMetadata

Get metadata for a stored raster without reading pixel data.

Parameters:

Name Type Description Default
layer_name str

the layer name or alias.

 required
item Item

the item.

 required
bands list[str]

the list of bands identifying which specific raster to read.

 required

Returns:

Type Description
RasterMetadata

a RasterMetadata instance (may have None fields if the store
RasterMetadata

does not track a given piece of metadata).
Source code in rslearn/tile_stores/tile_store.py 
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
def get_raster_metadata(
    self, layer_name: str, item: Item, bands: list[str]
) -> RasterMetadata:
    """Get metadata for a stored raster without reading pixel data.

    Args:
        layer_name: the layer name or alias.
        item: the item.
        bands: the list of bands identifying which specific raster to read.

    Returns:
        a RasterMetadata instance (may have None fields if the store
        does not track a given piece of metadata).
    """
    raise NotImplementedError

read_raster 

read_raster(layer_name: str, item: Item, bands: list[str], projection: Projection, bounds: PixelBounds, resampling: Resampling = bilinear) -> RasterArray

Read raster data from the store.

Parameters:

Name Type Description Default
layer_name str

the layer name or alias.

 required
item Item

the item to read.

 required
bands list[str]

the list of bands identifying which specific raster to read. These bands must match the bands of a stored raster.

 required
projection Projection

the projection to read in.

 required
bounds PixelBounds

the bounds to read.

 required
resampling Resampling

the resampling method to use in case reprojection is needed.

 bilinear

Returns:

Type Description
RasterArray

the raster data
Source code in rslearn/tile_stores/tile_store.py 
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
def read_raster(
    self,
    layer_name: str,
    item: Item,
    bands: list[str],
    projection: Projection,
    bounds: PixelBounds,
    resampling: Resampling = Resampling.bilinear,
) -> RasterArray:
    """Read raster data from the store.

    Args:
        layer_name: the layer name or alias.
        item: the item to read.
        bands: the list of bands identifying which specific raster to read. These
            bands must match the bands of a stored raster.
        projection: the projection to read in.
        bounds: the bounds to read.
        resampling: the resampling method to use in case reprojection is needed.

    Returns:
        the raster data
    """
    raise NotImplementedError

write_raster 

write_raster(layer_name: str, item: Item, bands: list[str], projection: Projection, bounds: PixelBounds, raster: RasterArray) -> None

Write raster data to the store.

Parameters:

Name Type Description Default
layer_name str

the layer name or alias.

 required
item Item

the item to write.

 required
bands list[str]

the list of bands in the array.

 required
projection Projection

the projection of the array.

 required
bounds PixelBounds

the bounds of the array.

 required
raster RasterArray

the raster data.

 required
Source code in rslearn/tile_stores/tile_store.py 
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
def write_raster(
    self,
    layer_name: str,
    item: Item,
    bands: list[str],
    projection: Projection,
    bounds: PixelBounds,
    raster: RasterArray,
) -> None:
    """Write raster data to the store.

    Args:
        layer_name: the layer name or alias.
        item: the item to write.
        bands: the list of bands in the array.
        projection: the projection of the array.
        bounds: the bounds of the array.
        raster: the raster data.
    """
    raise NotImplementedError

write_raster_file 

write_raster_file(layer_name: str, item: Item, bands: list[str], fname: UPath, time_range: tuple[datetime, datetime] | None = None) -> None

Write raster data to the store.

Parameters:

Name Type Description Default
layer_name str

the layer name or alias.

 required
item Item

the item to write.

 required
bands list[str]

the list of bands in the array.

 required
fname UPath

the raster file.

 required
time_range tuple[datetime, datetime] | None

optional time range for the raster.

 None
Source code in rslearn/tile_stores/tile_store.py 
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
def write_raster_file(
    self,
    layer_name: str,
    item: Item,
    bands: list[str],
    fname: UPath,
    time_range: tuple[datetime, datetime] | None = None,
) -> None:
    """Write raster data to the store.

    Args:
        layer_name: the layer name or alias.
        item: the item to write.
        bands: the list of bands in the array.
        fname: the raster file.
        time_range: optional time range for the raster.
    """
    raise NotImplementedError

is_vector_ready 

is_vector_ready(layer_name: str, item: Item) -> bool

Checks if this vector item has been written to the store.

Parameters:

Name Type Description Default
layer_name str

the layer name or alias.

 required
item Item

the item.

 required

Returns:

Type Description
bool

whether the vector data from the item has been stored.
Source code in rslearn/tile_stores/tile_store.py 
161
162
163
164
165
166
167
168
169
170
171
def is_vector_ready(self, layer_name: str, item: Item) -> bool:
    """Checks if this vector item has been written to the store.

    Args:
        layer_name: the layer name or alias.
        item: the item.

    Returns:
        whether the vector data from the item has been stored.
    """
    raise NotImplementedError

read_vector 

read_vector(layer_name: str, item: Item, projection: Projection, bounds: PixelBounds) -> list[Feature]

Read vector data from the store.

Parameters:

Name Type Description Default
layer_name str

the layer name or alias.

 required
item Item

the item to read.

 required
projection Projection

the projection to read in.

 required
bounds PixelBounds

the bounds within which to read.

 required

Returns:

Type Description
list[Feature]

the vector data
Source code in rslearn/tile_stores/tile_store.py 
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
def read_vector(
    self,
    layer_name: str,
    item: Item,
    projection: Projection,
    bounds: PixelBounds,
) -> list[Feature]:
    """Read vector data from the store.

    Args:
        layer_name: the layer name or alias.
        item: the item to read.
        projection: the projection to read in.
        bounds: the bounds within which to read.

    Returns:
        the vector data
    """
    raise NotImplementedError

write_vector 

write_vector(layer_name: str, item: Item, features: list[Feature]) -> None

Write vector data to the store.

Parameters:

Name Type Description Default
layer_name str

the layer name or alias.

 required
item Item

the item to write.

 required
features list[Feature]

the vector data.

 required
Source code in rslearn/tile_stores/tile_store.py 
193
194
195
196
197
198
199
200
201
202
203
def write_vector(
    self, layer_name: str, item: Item, features: list[Feature]
) -> None:
    """Write vector data to the store.

    Args:
        layer_name: the layer name or alias.
        item: the item to write.
        features: the vector data.
    """
    raise NotImplementedError

TileStoreWithLayer

Convenience class to access TileStore in the context of a layer.

Source code in rslearn/tile_stores/tile_store.py 
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
class TileStoreWithLayer:
    """Convenience class to access TileStore in the context of a layer."""

    def __init__(self, tile_store: TileStore, layer_name: str):
        """Create a new TileStoreWithLayer.

        Args:
            tile_store: underlying TileStore.
            layer_name: the layer name.
        """
        self.tile_store = tile_store
        self.layer_name = layer_name

    def is_raster_ready(self, item: Item, bands: list[str]) -> bool:
        """Checks if this raster has been written to the store.

        Args:
            item: the item.
            bands: the list of bands identifying which specific raster to read.

        Returns:
            whether there is a raster in the store matching the source, item, and
                bands.
        """
        return self.tile_store.is_raster_ready(self.layer_name, item, bands)

    def get_raster_bands(self, item: Item) -> list[list[str]]:
        """Get the sets of bands that have been stored for the specified item.

        Args:
            item: the item.

        Returns:
            a list of lists of bands that are in the tile store (with one raster
                stored corresponding to each inner list). If no rasters are ready for
                this item, returns empty list.
        """
        return self.tile_store.get_raster_bands(self.layer_name, item)

    def get_raster_bounds(
        self, item: Item, bands: list[str], projection: Projection
    ) -> PixelBounds:
        """Get the bounds of the raster in the specified projection.

        Args:
            item: the item to check.
            bands: the list of bands identifying which specific raster to read. These
                bands must match the bands of a stored raster.
            projection: the projection to get the raster's bounds in.

        Returns:
            the bounds of the raster in the projection.
        """
        return self.tile_store.get_raster_bounds(
            self.layer_name, item, bands, projection
        )

    def get_raster_metadata(self, item: Item, bands: list[str]) -> RasterMetadata:
        """Get metadata for a stored raster without reading pixel data.

        Args:
            item: the item.
            bands: the list of bands identifying which specific raster to read.

        Returns:
            a RasterMetadata instance.
        """
        return self.tile_store.get_raster_metadata(self.layer_name, item, bands)

    def read_raster(
        self,
        item: Item,
        bands: list[str],
        projection: Projection,
        bounds: PixelBounds,
        resampling: Resampling = Resampling.bilinear,
    ) -> RasterArray:
        """Read raster data from the store.

        Args:
            item: the item to read.
            bands: the list of bands identifying which specific raster to read. These
                bands must match the bands of a stored raster.
            projection: the projection to read in.
            bounds: the bounds to read.
            resampling: the resampling method to use in case reprojection is needed.

        Returns:
            the raster data
        """
        return self.tile_store.read_raster(
            self.layer_name, item, bands, projection, bounds, resampling
        )

    def write_raster(
        self,
        item: Item,
        bands: list[str],
        projection: Projection,
        bounds: PixelBounds,
        raster: RasterArray,
    ) -> None:
        """Write raster data to the store.

        Args:
            item: the item to write.
            bands: the list of bands in the array.
            projection: the projection of the array.
            bounds: the bounds of the array.
            raster: the raster data.
        """
        self.tile_store.write_raster(
            self.layer_name, item, bands, projection, bounds, raster
        )

    def write_raster_file(
        self,
        item: Item,
        bands: list[str],
        fname: UPath,
        time_range: tuple[datetime, datetime] | None = None,
    ) -> None:
        """Write raster data to the store.

        Args:
            item: the item to write.
            bands: the list of bands in the array.
            fname: the raster file.
            time_range: optional time range for the raster.
        """
        self.tile_store.write_raster_file(
            self.layer_name, item, bands, fname, time_range=time_range
        )

    def is_vector_ready(self, item: Item) -> bool:
        """Checks if this vector item has been written to the store.

        Args:
            item: the item.

        Returns:
            whether the vector data from the item has been stored.
        """
        return self.tile_store.is_vector_ready(self.layer_name, item)

    def read_vector(
        self, item: Item, projection: Projection, bounds: PixelBounds
    ) -> list[Feature]:
        """Read vector data from the store.

        Args:
            item: the item to read.
            projection: the projection to read in.
            bounds: the bounds within which to read.

        Returns:
            the vector data
        """
        return self.tile_store.read_vector(self.layer_name, item, projection, bounds)

    def write_vector(self, item: Item, features: list[Feature]) -> None:
        """Write vector data to the store.

        Args:
            item: the item to write.
            features: the vector data.
        """
        self.tile_store.write_vector(self.layer_name, item, features)

is_raster_ready 

is_raster_ready(item: Item, bands: list[str]) -> bool

Checks if this raster has been written to the store.

Parameters:

Name Type Description Default
item Item

the item.

 required
bands list[str]

the list of bands identifying which specific raster to read.

 required

Returns:

Type Description
bool

whether there is a raster in the store matching the source, item, and bands.
Source code in rslearn/tile_stores/tile_store.py 
219
220
221
222
223
224
225
226
227
228
229
230
def is_raster_ready(self, item: Item, bands: list[str]) -> bool:
    """Checks if this raster has been written to the store.

    Args:
        item: the item.
        bands: the list of bands identifying which specific raster to read.

    Returns:
        whether there is a raster in the store matching the source, item, and
            bands.
    """
    return self.tile_store.is_raster_ready(self.layer_name, item, bands)

get_raster_bands 

get_raster_bands(item: Item) -> list[list[str]]

Get the sets of bands that have been stored for the specified item.

Parameters:

Name Type Description Default
item Item

the item.

 required

Returns:

Type Description
list[list[str]]

a list of lists of bands that are in the tile store (with one raster stored corresponding to each inner list). If no rasters are ready for this item, returns empty list.
Source code in rslearn/tile_stores/tile_store.py 
232
233
234
235
236
237
238
239
240
241
242
243
def get_raster_bands(self, item: Item) -> list[list[str]]:
    """Get the sets of bands that have been stored for the specified item.

    Args:
        item: the item.

    Returns:
        a list of lists of bands that are in the tile store (with one raster
            stored corresponding to each inner list). If no rasters are ready for
            this item, returns empty list.
    """
    return self.tile_store.get_raster_bands(self.layer_name, item)

get_raster_bounds 

get_raster_bounds(item: Item, bands: list[str], projection: Projection) -> PixelBounds

Get the bounds of the raster in the specified projection.

Parameters:

Name Type Description Default
item Item

the item to check.

 required
bands list[str]

the list of bands identifying which specific raster to read. These bands must match the bands of a stored raster.

 required
projection Projection

the projection to get the raster's bounds in.

 required

Returns:

Type Description
PixelBounds

the bounds of the raster in the projection.
Source code in rslearn/tile_stores/tile_store.py 
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
def get_raster_bounds(
    self, item: Item, bands: list[str], projection: Projection
) -> PixelBounds:
    """Get the bounds of the raster in the specified projection.

    Args:
        item: the item to check.
        bands: the list of bands identifying which specific raster to read. These
            bands must match the bands of a stored raster.
        projection: the projection to get the raster's bounds in.

    Returns:
        the bounds of the raster in the projection.
    """
    return self.tile_store.get_raster_bounds(
        self.layer_name, item, bands, projection
    )

get_raster_metadata 

get_raster_metadata(item: Item, bands: list[str]) -> RasterMetadata

Get metadata for a stored raster without reading pixel data.

Parameters:

Name Type Description Default
item Item

the item.

 required
bands list[str]

the list of bands identifying which specific raster to read.

 required

Returns:

Type Description
RasterMetadata

a RasterMetadata instance.
Source code in rslearn/tile_stores/tile_store.py 
263
264
265
266
267
268
269
270
271
272
273
def get_raster_metadata(self, item: Item, bands: list[str]) -> RasterMetadata:
    """Get metadata for a stored raster without reading pixel data.

    Args:
        item: the item.
        bands: the list of bands identifying which specific raster to read.

    Returns:
        a RasterMetadata instance.
    """
    return self.tile_store.get_raster_metadata(self.layer_name, item, bands)

read_raster 

read_raster(item: Item, bands: list[str], projection: Projection, bounds: PixelBounds, resampling: Resampling = bilinear) -> RasterArray

Read raster data from the store.

Parameters:

Name Type Description Default
item Item

the item to read.

 required
bands list[str]

the list of bands identifying which specific raster to read. These bands must match the bands of a stored raster.

 required
projection Projection

the projection to read in.

 required
bounds PixelBounds

the bounds to read.

 required
resampling Resampling

the resampling method to use in case reprojection is needed.

 bilinear

Returns:

Type Description
RasterArray

the raster data
Source code in rslearn/tile_stores/tile_store.py 
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
def read_raster(
    self,
    item: Item,
    bands: list[str],
    projection: Projection,
    bounds: PixelBounds,
    resampling: Resampling = Resampling.bilinear,
) -> RasterArray:
    """Read raster data from the store.

    Args:
        item: the item to read.
        bands: the list of bands identifying which specific raster to read. These
            bands must match the bands of a stored raster.
        projection: the projection to read in.
        bounds: the bounds to read.
        resampling: the resampling method to use in case reprojection is needed.

    Returns:
        the raster data
    """
    return self.tile_store.read_raster(
        self.layer_name, item, bands, projection, bounds, resampling
    )

write_raster 

write_raster(item: Item, bands: list[str], projection: Projection, bounds: PixelBounds, raster: RasterArray) -> None

Write raster data to the store.

Parameters:

Name Type Description Default
item Item

the item to write.

 required
bands list[str]

the list of bands in the array.

 required
projection Projection

the projection of the array.

 required
bounds PixelBounds

the bounds of the array.

 required
raster RasterArray

the raster data.

 required
Source code in rslearn/tile_stores/tile_store.py 
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
def write_raster(
    self,
    item: Item,
    bands: list[str],
    projection: Projection,
    bounds: PixelBounds,
    raster: RasterArray,
) -> None:
    """Write raster data to the store.

    Args:
        item: the item to write.
        bands: the list of bands in the array.
        projection: the projection of the array.
        bounds: the bounds of the array.
        raster: the raster data.
    """
    self.tile_store.write_raster(
        self.layer_name, item, bands, projection, bounds, raster
    )

write_raster_file 

write_raster_file(item: Item, bands: list[str], fname: UPath, time_range: tuple[datetime, datetime] | None = None) -> None

Write raster data to the store.

Parameters:

Name Type Description Default
item Item

the item to write.

 required
bands list[str]

the list of bands in the array.

 required
fname UPath

the raster file.

 required
time_range tuple[datetime, datetime] | None

optional time range for the raster.

 None
Source code in rslearn/tile_stores/tile_store.py 
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
def write_raster_file(
    self,
    item: Item,
    bands: list[str],
    fname: UPath,
    time_range: tuple[datetime, datetime] | None = None,
) -> None:
    """Write raster data to the store.

    Args:
        item: the item to write.
        bands: the list of bands in the array.
        fname: the raster file.
        time_range: optional time range for the raster.
    """
    self.tile_store.write_raster_file(
        self.layer_name, item, bands, fname, time_range=time_range
    )

is_vector_ready 

is_vector_ready(item: Item) -> bool

Checks if this vector item has been written to the store.

Parameters:

Name Type Description Default
item Item

the item.

 required

Returns:

Type Description
bool

whether the vector data from the item has been stored.
Source code in rslearn/tile_stores/tile_store.py 
340
341
342
343
344
345
346
347
348
349
def is_vector_ready(self, item: Item) -> bool:
    """Checks if this vector item has been written to the store.

    Args:
        item: the item.

    Returns:
        whether the vector data from the item has been stored.
    """
    return self.tile_store.is_vector_ready(self.layer_name, item)

read_vector 

read_vector(item: Item, projection: Projection, bounds: PixelBounds) -> list[Feature]

Read vector data from the store.

Parameters:

Name Type Description Default
item Item

the item to read.

 required
projection Projection

the projection to read in.

 required
bounds PixelBounds

the bounds within which to read.

 required

Returns:

Type Description
list[Feature]

the vector data
Source code in rslearn/tile_stores/tile_store.py 
351
352
353
354
355
356
357
358
359
360
361
362
363
364
def read_vector(
    self, item: Item, projection: Projection, bounds: PixelBounds
) -> list[Feature]:
    """Read vector data from the store.

    Args:
        item: the item to read.
        projection: the projection to read in.
        bounds: the bounds within which to read.

    Returns:
        the vector data
    """
    return self.tile_store.read_vector(self.layer_name, item, projection, bounds)

write_vector 

write_vector(item: Item, features: list[Feature]) -> None

Write vector data to the store.

Parameters:

Name Type Description Default
item Item

the item to write.

 required
features list[Feature]

the vector data.

 required
Source code in rslearn/tile_stores/tile_store.py 
366
367
368
369
370
371
372
373
def write_vector(self, item: Item, features: list[Feature]) -> None:
    """Write vector data to the store.

    Args:
        item: the item to write.
        features: the vector data.
    """
    self.tile_store.write_vector(self.layer_name, item, features)