xarray-sql 0.1.0__py3-none-any.whl → 0.1.2__py3-none-any.whl
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- xarray_sql/df.py +68 -9
- xarray_sql/df_test.py +249 -44
- xarray_sql/sql_test.py +757 -8
- {xarray_sql-0.1.0.dist-info → xarray_sql-0.1.2.dist-info}/METADATA +70 -23
- xarray_sql-0.1.2.dist-info/RECORD +12 -0
- xarray_sql-0.1.0.dist-info/RECORD +0 -12
- {xarray_sql-0.1.0.dist-info → xarray_sql-0.1.2.dist-info}/WHEEL +0 -0
- {xarray_sql-0.1.0.dist-info → xarray_sql-0.1.2.dist-info}/licenses/LICENSE +0 -0
- {xarray_sql-0.1.0.dist-info → xarray_sql-0.1.2.dist-info}/top_level.txt +0 -0
xarray_sql/df.py
CHANGED
|
@@ -5,8 +5,9 @@ import numpy as np
|
|
|
5
5
|
import pandas as pd
|
|
6
6
|
import pyarrow as pa
|
|
7
7
|
import xarray as xr
|
|
8
|
+
from datafusion.context import ArrowStreamExportable
|
|
8
9
|
|
|
9
|
-
Block = t.Dict[
|
|
10
|
+
Block = t.Dict[t.Hashable, slice]
|
|
10
11
|
Chunks = t.Optional[t.Dict[str, int]]
|
|
11
12
|
|
|
12
13
|
|
|
@@ -54,7 +55,42 @@ def explode(ds: xr.Dataset, chunks: Chunks = None) -> t.Iterator[xr.Dataset]:
|
|
|
54
55
|
|
|
55
56
|
|
|
56
57
|
def _block_len(block: Block) -> int:
|
|
57
|
-
return np.prod([v.stop - v.start for v in block.values()])
|
|
58
|
+
return int(np.prod([v.stop - v.start for v in block.values()]))
|
|
59
|
+
|
|
60
|
+
|
|
61
|
+
def from_map_batched(
|
|
62
|
+
func: t.Callable[[...], pd.DataFrame],
|
|
63
|
+
*iterables,
|
|
64
|
+
args: t.Optional[t.Tuple] = None,
|
|
65
|
+
schema: pa.Schema = None,
|
|
66
|
+
**kwargs,
|
|
67
|
+
) -> pa.RecordBatchReader:
|
|
68
|
+
"""Create a PyArrow RecordBatchReader by mapping a function over iterables.
|
|
69
|
+
|
|
70
|
+
This is equivalent to dask's from_map but returns a PyArrow
|
|
71
|
+
RecordBatchReader that can be used with DataFusion. It iterates over
|
|
72
|
+
RecordBatches which are created via the `func` one-at-a-time.
|
|
73
|
+
|
|
74
|
+
Args:
|
|
75
|
+
func: Function to apply to each element of the iterables. Currently, the function
|
|
76
|
+
must return a Pandas DataFrame.
|
|
77
|
+
*iterables: Iterable objects to map the function over.
|
|
78
|
+
schema: Optional schema needed for the RecordBatchReader.
|
|
79
|
+
args: Additional positional arguments to pass to func.
|
|
80
|
+
**kwargs: Additional keyword arguments to pass to func.
|
|
81
|
+
|
|
82
|
+
Returns:
|
|
83
|
+
A PyArrow RecordBatchReader containing the stream of RecordBatches.
|
|
84
|
+
"""
|
|
85
|
+
if args is None:
|
|
86
|
+
args = ()
|
|
87
|
+
|
|
88
|
+
def map_batches():
|
|
89
|
+
for items in zip(*iterables):
|
|
90
|
+
df = func(*items, *args, **kwargs)
|
|
91
|
+
yield pa.RecordBatch.from_pandas(df, schema=schema)
|
|
92
|
+
|
|
93
|
+
return pa.RecordBatchReader.from_batches(schema, map_batches())
|
|
58
94
|
|
|
59
95
|
|
|
60
96
|
def from_map(
|
|
@@ -109,7 +145,29 @@ def from_map(
|
|
|
109
145
|
return pa.concat_tables(results)
|
|
110
146
|
|
|
111
147
|
|
|
112
|
-
def
|
|
148
|
+
def pivot(ds: xr.Dataset) -> pd.DataFrame:
|
|
149
|
+
"""Converts an xarray Dataset to a pandas DataFrame."""
|
|
150
|
+
return ds.to_dataframe().reset_index()
|
|
151
|
+
|
|
152
|
+
|
|
153
|
+
def _parse_schema(ds) -> pa.Schema:
|
|
154
|
+
"""Extracts a `pa.Schema` from the Dataset, treating dims and data_vars as columns."""
|
|
155
|
+
columns = []
|
|
156
|
+
|
|
157
|
+
for coord_name, coord_var in ds.coords.items():
|
|
158
|
+
# Only include dimension coordinates
|
|
159
|
+
if coord_name in ds.dims:
|
|
160
|
+
pa_type = pa.from_numpy_dtype(coord_var.dtype)
|
|
161
|
+
columns.append(pa.field(coord_name, pa_type))
|
|
162
|
+
|
|
163
|
+
for var_name, var in ds.data_vars.items():
|
|
164
|
+
pa_type = pa.from_numpy_dtype(var.dtype)
|
|
165
|
+
columns.append(pa.field(var_name, pa_type))
|
|
166
|
+
|
|
167
|
+
return pa.schema(columns)
|
|
168
|
+
|
|
169
|
+
|
|
170
|
+
def read_xarray(ds: xr.Dataset, chunks: Chunks = None) -> pa.RecordBatchReader:
|
|
113
171
|
"""Pivots an Xarray Dataset into a PyArrow Table, partitioned by chunks.
|
|
114
172
|
|
|
115
173
|
Args:
|
|
@@ -121,14 +179,15 @@ def read_xarray(ds: xr.Dataset, chunks: Chunks = None) -> pa.Table:
|
|
|
121
179
|
Returns:
|
|
122
180
|
A PyArrow Table, which is a table representation of the input Dataset.
|
|
123
181
|
"""
|
|
182
|
+
|
|
183
|
+
def pivot_block(b: Block):
|
|
184
|
+
return pivot(ds.isel(b))
|
|
185
|
+
|
|
124
186
|
fst = next(iter(ds.values())).dims
|
|
125
187
|
assert all(
|
|
126
188
|
da.dims == fst for da in ds.values()
|
|
127
189
|
), "All dimensions must be equal. Please filter data_vars in the Dataset."
|
|
128
190
|
|
|
129
|
-
|
|
130
|
-
|
|
131
|
-
|
|
132
|
-
return ds.isel(b).to_dataframe().reset_index()
|
|
133
|
-
|
|
134
|
-
return from_map(pivot, blocks)
|
|
191
|
+
schema = _parse_schema(ds)
|
|
192
|
+
blocks = block_slices(ds, chunks)
|
|
193
|
+
return from_map_batched(pivot_block, blocks, schema=schema)
|
xarray_sql/df_test.py
CHANGED
|
@@ -1,4 +1,5 @@
|
|
|
1
1
|
import itertools
|
|
2
|
+
import tracemalloc
|
|
2
3
|
import unittest
|
|
3
4
|
|
|
4
5
|
import numpy as np
|
|
@@ -6,7 +7,7 @@ import pandas as pd
|
|
|
6
7
|
import pyarrow as pa
|
|
7
8
|
import xarray as xr
|
|
8
9
|
|
|
9
|
-
from .df import explode, read_xarray, block_slices, from_map
|
|
10
|
+
from .df import explode, read_xarray, block_slices, from_map, pivot, from_map_batched
|
|
10
11
|
|
|
11
12
|
|
|
12
13
|
def rand_wx(start: str, end: str) -> xr.Dataset:
|
|
@@ -34,6 +35,38 @@ def rand_wx(start: str, end: str) -> xr.Dataset:
|
|
|
34
35
|
)
|
|
35
36
|
|
|
36
37
|
|
|
38
|
+
def create_large_dataset(time_steps=1000, lat_points=100, lon_points=100):
|
|
39
|
+
"""Create a large xarray dataset for memory testing."""
|
|
40
|
+
np.random.seed(42)
|
|
41
|
+
|
|
42
|
+
# Create coordinates
|
|
43
|
+
time = pd.date_range('2020-01-01', periods=time_steps, freq='h')
|
|
44
|
+
lat = np.linspace(-90, 90, lat_points)
|
|
45
|
+
lon = np.linspace(-180, 180, lon_points)
|
|
46
|
+
|
|
47
|
+
# Create large data arrays
|
|
48
|
+
temp_data = np.random.rand(time_steps, lat_points, lon_points) * 40 - 10
|
|
49
|
+
precip_data = np.random.rand(time_steps, lat_points, lon_points) * 100
|
|
50
|
+
|
|
51
|
+
return xr.Dataset(
|
|
52
|
+
{
|
|
53
|
+
'temperature': (['time', 'lat', 'lon'], temp_data),
|
|
54
|
+
'precipitation': (['time', 'lat', 'lon'], precip_data),
|
|
55
|
+
},
|
|
56
|
+
coords={
|
|
57
|
+
'time': time,
|
|
58
|
+
'lat': lat,
|
|
59
|
+
'lon': lon,
|
|
60
|
+
},
|
|
61
|
+
)
|
|
62
|
+
|
|
63
|
+
|
|
64
|
+
def adding_function(x, y):
|
|
65
|
+
"""Simple function that adds two values and returns a DataFrame."""
|
|
66
|
+
result = pd.DataFrame({'x': [x], 'y': [y], 'sum': [x + y]})
|
|
67
|
+
return result
|
|
68
|
+
|
|
69
|
+
|
|
37
70
|
class DaskTestCase(unittest.TestCase):
|
|
38
71
|
|
|
39
72
|
def setUp(self) -> None:
|
|
@@ -81,49 +114,6 @@ class ExplodeTest(DaskTestCase):
|
|
|
81
114
|
self.assertEqual(self.air.isel(iselection), ds)
|
|
82
115
|
|
|
83
116
|
|
|
84
|
-
class PyArrowTableTest(DaskTestCase):
|
|
85
|
-
|
|
86
|
-
def test_sanity(self):
|
|
87
|
-
table = read_xarray(self.air_small)
|
|
88
|
-
self.assertIsNotNone(table)
|
|
89
|
-
self.assertIsInstance(table, pa.Table)
|
|
90
|
-
self.assertEqual(len(table), np.prod(list(self.air_small.sizes.values())))
|
|
91
|
-
|
|
92
|
-
def test_columns(self):
|
|
93
|
-
table = read_xarray(self.air_small)
|
|
94
|
-
cols = table.column_names
|
|
95
|
-
self.assertEqual(cols, ['lat', 'time', 'lon', 'air'])
|
|
96
|
-
|
|
97
|
-
def test_dtypes(self):
|
|
98
|
-
table = read_xarray(self.air_small)
|
|
99
|
-
# Convert to pandas to check dtypes
|
|
100
|
-
df = table.to_pandas()
|
|
101
|
-
types = list(df.dtypes)
|
|
102
|
-
self.assertEqual([self.air_small[c].dtype for c in df.columns], types)
|
|
103
|
-
|
|
104
|
-
def test_different_chunk_sizes(self):
|
|
105
|
-
default_table = read_xarray(self.air_small)
|
|
106
|
-
chunked_table = read_xarray(self.air_small, dict(time=5))
|
|
107
|
-
|
|
108
|
-
# Both should produce valid tables
|
|
109
|
-
self.assertIsInstance(default_table, pa.Table)
|
|
110
|
-
self.assertIsInstance(chunked_table, pa.Table)
|
|
111
|
-
# Should have same number of rows
|
|
112
|
-
self.assertEqual(len(default_table), len(chunked_table))
|
|
113
|
-
|
|
114
|
-
def test_chunk_perf(self):
|
|
115
|
-
table = read_xarray(self.air, chunks=dict(time=6))
|
|
116
|
-
self.assertIsNotNone(table)
|
|
117
|
-
self.assertEqual(len(table), np.prod(list(self.air.sizes.values())))
|
|
118
|
-
|
|
119
|
-
def test_column_metadata_preserved(self):
|
|
120
|
-
try:
|
|
121
|
-
table = read_xarray(self.randwx, chunks=dict(time=24))
|
|
122
|
-
self.assertIsInstance(table, pa.Table)
|
|
123
|
-
except Exception as e:
|
|
124
|
-
self.fail(f'Unexpected error: {e}')
|
|
125
|
-
|
|
126
|
-
|
|
127
117
|
class FromMapTest(unittest.TestCase):
|
|
128
118
|
|
|
129
119
|
def test_basic_from_map(self):
|
|
@@ -178,5 +168,220 @@ class FromMapTest(unittest.TestCase):
|
|
|
178
168
|
self.assertEqual(len(result), 3)
|
|
179
169
|
|
|
180
170
|
|
|
171
|
+
class TestFromMapBatchedCorrectness(DaskTestCase):
|
|
172
|
+
"""Test correctness of from_map_batched function."""
|
|
173
|
+
|
|
174
|
+
def test_basic_functionality(self):
|
|
175
|
+
"""Test that from_map_batched produces correct RecordBatchReader."""
|
|
176
|
+
blocks = list(
|
|
177
|
+
block_slices(self.air_small, chunks={'time': 4, 'lat': 3, 'lon': 4})
|
|
178
|
+
)
|
|
179
|
+
|
|
180
|
+
# Get expected schema
|
|
181
|
+
first_block_df = pivot(self.air_small.isel(blocks[0]))
|
|
182
|
+
expected_schema = pa.Schema.from_pandas(first_block_df)
|
|
183
|
+
|
|
184
|
+
# Create RecordBatchReader
|
|
185
|
+
reader = from_map_batched(
|
|
186
|
+
pivot,
|
|
187
|
+
[self.air_small.isel(block) for block in blocks],
|
|
188
|
+
schema=expected_schema,
|
|
189
|
+
)
|
|
190
|
+
|
|
191
|
+
# Verify it's a RecordBatchReader
|
|
192
|
+
self.assertIsInstance(reader, pa.RecordBatchReader)
|
|
193
|
+
|
|
194
|
+
# Verify schema
|
|
195
|
+
self.assertEqual(reader.schema, expected_schema)
|
|
196
|
+
|
|
197
|
+
# Read all batches and verify content
|
|
198
|
+
batches = list(reader)
|
|
199
|
+
self.assertGreater(len(batches), 0)
|
|
200
|
+
|
|
201
|
+
# Verify each batch has the correct schema
|
|
202
|
+
for batch in batches:
|
|
203
|
+
self.assertEqual(batch.schema, expected_schema)
|
|
204
|
+
self.assertGreater(len(batch), 0)
|
|
205
|
+
|
|
206
|
+
def test_multiple_iterables(self):
|
|
207
|
+
"""Test from_map_batched with multiple iterables."""
|
|
208
|
+
x_values = [1, 2, 3, 4, 5]
|
|
209
|
+
y_values = [10, 20, 30, 40, 50]
|
|
210
|
+
|
|
211
|
+
expected_schema = pa.schema(
|
|
212
|
+
[('x', pa.int64()), ('y', pa.int64()), ('sum', pa.int64())]
|
|
213
|
+
)
|
|
214
|
+
|
|
215
|
+
reader = from_map_batched(
|
|
216
|
+
adding_function, x_values, y_values, schema=expected_schema
|
|
217
|
+
)
|
|
218
|
+
|
|
219
|
+
# Read all data
|
|
220
|
+
table = reader.read_all()
|
|
221
|
+
df = table.to_pandas()
|
|
222
|
+
|
|
223
|
+
# Verify results
|
|
224
|
+
expected_df = pd.DataFrame(
|
|
225
|
+
{
|
|
226
|
+
'x': x_values,
|
|
227
|
+
'y': y_values,
|
|
228
|
+
'sum': [x + y for x, y in zip(x_values, y_values)],
|
|
229
|
+
}
|
|
230
|
+
)
|
|
231
|
+
|
|
232
|
+
pd.testing.assert_frame_equal(df, expected_df)
|
|
233
|
+
|
|
234
|
+
def test_with_args_and_kwargs(self):
|
|
235
|
+
"""Test from_map_batched with additional args and kwargs."""
|
|
236
|
+
|
|
237
|
+
def multiply_and_add(x, multiplier, offset=0):
|
|
238
|
+
result = pd.DataFrame({'x': [x], 'result': [x * multiplier + offset]})
|
|
239
|
+
return result
|
|
240
|
+
|
|
241
|
+
values = [1, 2, 3]
|
|
242
|
+
expected_schema = pa.schema([('x', pa.int64()), ('result', pa.int64())])
|
|
243
|
+
|
|
244
|
+
reader = from_map_batched(
|
|
245
|
+
multiply_and_add,
|
|
246
|
+
values,
|
|
247
|
+
args=(2,), # multiplier = 2
|
|
248
|
+
offset=5, # offset = 5
|
|
249
|
+
schema=expected_schema,
|
|
250
|
+
)
|
|
251
|
+
|
|
252
|
+
table = reader.read_all()
|
|
253
|
+
df = table.to_pandas()
|
|
254
|
+
|
|
255
|
+
# Verify results: x * 2 + 5
|
|
256
|
+
expected_df = pd.DataFrame(
|
|
257
|
+
{'x': [1, 2, 3], 'result': [7, 9, 11]} # (1*2+5, 2*2+5, 3*2+5)
|
|
258
|
+
)
|
|
259
|
+
|
|
260
|
+
pd.testing.assert_frame_equal(df, expected_df)
|
|
261
|
+
|
|
262
|
+
def test_empty_iterables(self):
|
|
263
|
+
"""Test from_map_batched with empty iterables."""
|
|
264
|
+
empty_schema = pa.schema([('value', pa.int64())])
|
|
265
|
+
|
|
266
|
+
reader = from_map_batched(
|
|
267
|
+
lambda x: pd.DataFrame({'value': [x]}), [], schema=empty_schema
|
|
268
|
+
)
|
|
269
|
+
|
|
270
|
+
batches = list(reader)
|
|
271
|
+
self.assertEqual(len(batches), 0)
|
|
272
|
+
|
|
273
|
+
def test_consistency_with_regular_map(self):
|
|
274
|
+
"""Test that results are consistent with regular mapping."""
|
|
275
|
+
blocks = list(block_slices(self.air_small, chunks={'time': 4, 'lat': 3}))
|
|
276
|
+
datasets = [self.air_small.isel(block) for block in blocks]
|
|
277
|
+
|
|
278
|
+
# Get schema from first block
|
|
279
|
+
first_df = pivot(datasets[0])
|
|
280
|
+
schema = pa.Schema.from_pandas(first_df)
|
|
281
|
+
|
|
282
|
+
# Use from_map_batched
|
|
283
|
+
reader = from_map_batched(pivot, datasets, schema=schema)
|
|
284
|
+
batched_table = reader.read_all()
|
|
285
|
+
|
|
286
|
+
# Regular map approach
|
|
287
|
+
regular_dfs = [pivot(ds) for ds in datasets]
|
|
288
|
+
regular_table = pa.Table.from_pandas(
|
|
289
|
+
pd.concat(regular_dfs, ignore_index=True)
|
|
290
|
+
)
|
|
291
|
+
|
|
292
|
+
# Results should be identical
|
|
293
|
+
self.assertEqual(batched_table.schema, regular_table.schema)
|
|
294
|
+
self.assertEqual(len(batched_table), len(regular_table))
|
|
295
|
+
|
|
296
|
+
# Compare data (allowing for potential column order differences)
|
|
297
|
+
batched_df = (
|
|
298
|
+
batched_table.to_pandas()
|
|
299
|
+
.sort_values(['time', 'lat', 'lon'])
|
|
300
|
+
.reset_index(drop=True)
|
|
301
|
+
)
|
|
302
|
+
regular_df = (
|
|
303
|
+
regular_table.to_pandas()
|
|
304
|
+
.sort_values(['time', 'lat', 'lon'])
|
|
305
|
+
.reset_index(drop=True)
|
|
306
|
+
)
|
|
307
|
+
|
|
308
|
+
pd.testing.assert_frame_equal(batched_df, regular_df)
|
|
309
|
+
|
|
310
|
+
def test_integration_with_datafusion_via_read_xarray(self):
|
|
311
|
+
"""Test integration with the read_xarray function that uses from_map_batched."""
|
|
312
|
+
|
|
313
|
+
# Use a small dataset
|
|
314
|
+
air = xr.tutorial.open_dataset('air_temperature')
|
|
315
|
+
air_small = air.isel(time=slice(0, 50), lat=slice(0, 10), lon=slice(0, 15))
|
|
316
|
+
air_chunked = air_small.chunk({'time': 25, 'lat': 5, 'lon': 8})
|
|
317
|
+
|
|
318
|
+
# read_xarray uses from_map_batched internally
|
|
319
|
+
arrow_stream = read_xarray(
|
|
320
|
+
air_chunked, chunks={'time': 25, 'lat': 5, 'lon': 8}
|
|
321
|
+
)
|
|
322
|
+
|
|
323
|
+
# Verify it returns a proper ArrowStreamExportable (RecordBatchReader)
|
|
324
|
+
self.assertTrue(hasattr(arrow_stream, 'schema'))
|
|
325
|
+
self.assertTrue(hasattr(arrow_stream, '__iter__'))
|
|
326
|
+
|
|
327
|
+
# Should be able to read all data
|
|
328
|
+
table = arrow_stream.read_all()
|
|
329
|
+
self.assertGreater(len(table), 0)
|
|
330
|
+
|
|
331
|
+
# Should have the expected columns
|
|
332
|
+
expected_columns = {'time', 'lat', 'lon', 'air'}
|
|
333
|
+
actual_columns = set(table.column_names)
|
|
334
|
+
self.assertTrue(expected_columns.issubset(actual_columns))
|
|
335
|
+
|
|
336
|
+
|
|
337
|
+
class ReadXarrayStreamingTest(unittest.TestCase):
|
|
338
|
+
|
|
339
|
+
def setUp(self):
|
|
340
|
+
self.large_ds = create_large_dataset().chunk({'time': 25})
|
|
341
|
+
|
|
342
|
+
def test_read_xarray__loads_one_chunk_at_a_time(self):
|
|
343
|
+
tracemalloc.start()
|
|
344
|
+
iterable = read_xarray(self.large_ds)
|
|
345
|
+
first_size, first_peak = tracemalloc.get_traced_memory()
|
|
346
|
+
tracemalloc.reset_peak()
|
|
347
|
+
|
|
348
|
+
sizes, peaks = [], []
|
|
349
|
+
|
|
350
|
+
first_chunk = self.large_ds.isel(next(block_slices(self.large_ds)))
|
|
351
|
+
chunk_size = first_chunk.nbytes
|
|
352
|
+
|
|
353
|
+
# Creating the iterator should be inexpensive -- less than one chunk.
|
|
354
|
+
# We multiply by constant factors because chunks have additional overhead
|
|
355
|
+
self.assertLess(first_size, chunk_size * 3)
|
|
356
|
+
self.assertLess(first_peak, chunk_size * 6)
|
|
357
|
+
|
|
358
|
+
for it in iterable:
|
|
359
|
+
_ = it
|
|
360
|
+
cur_size, cur_peak = tracemalloc.get_traced_memory()
|
|
361
|
+
tracemalloc.reset_peak()
|
|
362
|
+
sizes.append(cur_size), peaks.append(cur_peak)
|
|
363
|
+
|
|
364
|
+
mean_size = np.mean(sizes)
|
|
365
|
+
mean_peak = np.mean(peaks)
|
|
366
|
+
|
|
367
|
+
# Provide a bound for each size and peak
|
|
368
|
+
for size in sizes:
|
|
369
|
+
self.assertGreater(mean_size * 1.1, size)
|
|
370
|
+
self.assertGreater(chunk_size * 3, size)
|
|
371
|
+
# malloc size is about 2.66x chunk_size on average
|
|
372
|
+
self.assertLess(chunk_size * 2, size)
|
|
373
|
+
|
|
374
|
+
for peak in peaks:
|
|
375
|
+
self.assertGreater(mean_peak * 1.1, peak)
|
|
376
|
+
self.assertGreater(chunk_size * 7, peak)
|
|
377
|
+
# malloc peak is about 6.89x chunk_size on average
|
|
378
|
+
self.assertLess(chunk_size * 4, peak)
|
|
379
|
+
|
|
380
|
+
# The peak malloc should never be more than the original dataset!
|
|
381
|
+
self.assertLess(max(peaks), self.large_ds.nbytes)
|
|
382
|
+
|
|
383
|
+
tracemalloc.stop()
|
|
384
|
+
|
|
385
|
+
|
|
181
386
|
if __name__ == '__main__':
|
|
182
387
|
unittest.main()
|