bluesky
diff --git a/‎.gitignore‎
Lines changed: 1 addition & 0 deletions b/‎.gitignore‎
Lines changed: 1 addition & 0 deletions
diff --git a/‎CHANGELOG.md‎
Lines changed: 6 additions & 0 deletions b/‎CHANGELOG.md‎
Lines changed: 6 additions & 0 deletions
diff --git a/‎README.md‎
Lines changed: 17 additions & 20 deletions b/‎README.md‎
Lines changed: 17 additions & 20 deletions
diff --git a/‎docs/source/index.md‎
Lines changed: 1 addition & 0 deletions b/‎docs/source/index.md‎
Lines changed: 1 addition & 0 deletions
diff --git a/‎docs/source/tutorials/export.md‎
Lines changed: 18 additions & 15 deletions b/‎docs/source/tutorials/export.md‎
Lines changed: 18 additions & 15 deletions
diff --git a/‎docs/source/tutorials/navigation.md‎
Lines changed: 79 additions & 46 deletions b/‎docs/source/tutorials/navigation.md‎
Lines changed: 79 additions & 46 deletions
@@ -69,6 +69,7 @@ config.yml
 prometheus_data
 grafana_data
 data
+alembic.ini
 
 tiled/_version.py
 
 
@@ -5,6 +5,12 @@ Write the date in place of the "Unreleased" in the case a new version is release
 
 ## v0.1.0-b33 (Unreleased)
 
+### Added
+
+- Endpoints for (read) data access with zarr v2 and v3 protocols.
+- `data_type` and `coord_data_type` properties for sparse arrays in `COOAdapter`
+  and `COOStructure`.
+
 ### Changed
 
 - Refactored internal server function ``get_root_tree()`` to not use FastAPI
 
@@ -64,25 +64,22 @@ any HTTP client.
 >>> client = from_uri("http://localhost:8000")
 
 >>> client
-<Container {'short_table', 'long_table', 'structured_data', ...} ~10 entries>
+<Container {'scalars', 'nested', 'tables', 'structured_data', ...} ~8 entries>
 
 >>> list(client)
-'big_image',
- 'small_image',
- 'tiny_image',
- 'tiny_cube',
- 'tiny_hypercube',
+['scalars',
+ 'nested',
+ 'tables',
+ 'structured_data',
+ 'flat_array',
  'low_entropy',
  'high_entropy',
- 'short_table',
- 'long_table',
- 'labeled_data',
- 'structured_data']
+ 'dynamic']
 
->>> client['medium_image']
+>>> client['nested/images/medium_image']
 <ArrayClient>
 
->>> client['medium_image'][:]
+>>> client['nested/images/medium_image'][:]
 array([[0.49675483, 0.37832119, 0.59431287, ..., 0.16990737, 0.5396537 ,
         0.61913812],
        [0.97062498, 0.93776709, 0.81797714, ..., 0.96508877, 0.25208564,
@@ -97,10 +94,10 @@ array([[0.49675483, 0.37832119, 0.59431287, ..., 0.16990737, 0.5396537 ,
        [0.16567224, 0.1347261 , 0.48809697, ..., 0.55021249, 0.42324589,
         0.31440635]])
 
->>> client['long_table']
+>>> client['tables/long_table']
 <DataFrameClient ['A', 'B', 'C']>
 
->>> client['long_table'].read()
+>>> client['tables/long_table'].read()
               A         B         C
 index
 0      0.246920  0.493840  0.740759
@@ -117,7 +114,7 @@ index
 
 [100000 rows x 3 columns]
 
->>> client['long_table'].read(['A', 'B'])
+>>> client['tables/long_table'].read(['A', 'B'])
               A         B
 index
 0      0.246920  0.493840
@@ -139,19 +136,19 @@ data in whole or in efficiently-chunked parts in the format of your choice:
 
 ```
 # Download tabular data as CSV
-http://localhost:8000/api/v1/table/full/long_table?format=csv
+http://localhost:8000/api/v1/table/full/tables/long_table?format=csv
 
 # or XLSX (Excel)
-http://localhost:8000/api/v1/table/full/long_table?format=xslx
+http://localhost:8000/api/v1/table/full/tables/long_table?format=xslx
 
 # and subselect columns.
-http://localhost:8000/api/v1/table/full/long_table?format=xslx&field=A&field=B
+http://localhost:8000/api/v1/table/full/tables/long_table?format=xslx&field=A&field=B
 
 # View or download (2D) array data as PNG
-http://localhost:8000/api/v1/array/full/medium_image?format=png
+http://localhost:8000/api/v1/array/full/nested/images/medium_image?format=png
 
 # and slice regions of interest.
-http://localhost:8000/api/v1/array/full/medium_image?format=png&slice=:50,100:200
+http://localhost:8000/api/v1/array/full/nested/images/medium_image?format=png&slice=:50,100:200
 ```
 
 Web-based data access usually involves downloading complete files, in the
 
@@ -14,6 +14,7 @@ tutorials/search
 tutorials/writing
 tutorials/simple-server
 tutorials/plotly-integration
+tutorials/zarr-integration
 ```
 
 ```{toctree}
 
@@ -15,54 +15,57 @@ Now, in a Python interpreter, connect, with the Python client.
 from tiled.client import from_uri
 
 client = from_uri("http://localhost:8000")
+
+tables = client["tables"]         # Container of demo tables
+images = client["nested/images"]  # Container of demo images
 ```
 
 The Tiled server can encode its structures in various formats.
 These are just a couple of the supported formats:
 
 ```python
 # Table
-client["short_table"].export("table.xlsx")  # Excel
-client["short_table"].export("table.csv")  # CSV
+tables["short_table"].export("table.xlsx")  # Excel
+tables["short_table"].export("table.csv")  # CSV
 
 # Array
-client["medium_image"].export("numbers.csv")  # CSV
-client["medium_image"].export("image.png")  # PNG image
-client["medium_image"].export("image.tiff")  # TIFF image
+images["medium_image"].export("numbers.csv")  # CSV
+images["medium_image"].export("image.png")  # PNG image
+images["medium_image"].export("image.tiff")  # TIFF image
 ```
 
 It's possible to select a subset of the data to only "pay" for what you need.
 
 ```python
 # Export just some of the columns...
-client["short_table"].export("table.csv", columns=["A", "B"])
+tables["short_table"].export("table.csv", columns=["A", "B"])
 
 # Export an N-dimensional slice...
-client["medium_image"].export("numbers.csv", slice=[0])  # like arr[0]
+images["medium_image"].export("numbers.csv", slice=[0])  # like arr[0]
 import numpy
-client["medium_image"].export("numbers.csv", slice=numpy.s_[:10, 100:200])  # like arr[:10, 100:200]
+images["medium_image"].export("numbers.csv", slice=numpy.s_[:10, 100:200])  # like arr[:10, 100:200]
 ```
 
 In the examples above, the desired format is automatically detected from the
 file extension (`table.csv` -> `csv`). It can also be specified explicitly.
 
 ```python
 # Format inferred from filename...
-client["short_table"].export("table.csv")
+tables["short_table"].export("table.csv")
 
 # Format given as a file extension...
-client["short_table"].export("table.csv", format="csv")
+tables["short_table"].export("table.csv", format="csv")
 
 # Format given as a media type (MIME)...
-client["short_table"].export("table.csv", format="text/csv")
+tables["short_table"].export("table.csv", format="text/csv")
 ```
 
 ## Supported Formats
 
 To list the supported formats for a given structure:
 
 ```py
-client["short_table"].formats
+tables["short_table"].formats
 ```
 
 **It is easy to add formats and customize the details of how they are exported,
@@ -116,13 +119,13 @@ buffer) in which case the format must be specified.
 ```python
 # Writing directly to an open file
 with open("table.csv", "wb") as file:
-    client["short_table"].export(file, format="csv")
+    tables["short_table"].export(file, format="csv")
 
 # Writing to a buffer
 from io import BytesIO
 
 buffer = BytesIO()
-client["short_table"].export(buffer, format="csv")
+tables["short_table"].export(buffer, format="csv")
 ```
 
 ## Limitations
@@ -136,7 +139,7 @@ data you want, not on formatting it "just so". To do more refined export, use
 standard Python tools, as in:
 
 ```python
-df = client["short_table"].read()
+df = tables["short_table"].read()
 # At this point we are done with Tiled. From here, we just use pandas,
 # or whatever we want.
 df.to_csv("table.csv", sep=";", header=["custom", "column", "headings"])
 
@@ -25,20 +25,27 @@ Tiled provides a utility for visualizing a nested structure.
 ```python
 >>> from tiled.utils import tree
 >>> tree(client)
-├── big_image
-├── small_image
-├── medium_image
-├── sparse_image
-├── awkward_array
-├── tiny_image
-├── tiny_cube
-├── tiny_hypercube
-├── short_table
-├── long_table
-├── wide_table
-├── structured_data
-│   ├── pets
-│   └── xarray_dataset
+├── scalars
+│   ├── pi
+│   ├── e_arr
+│   ├── fsc
+│   └── fortytwo
+├── nested
+│   ├── images
+│   │   ├── tiny_image
+│   │   ├── small_image
+│   │   ├── medium_image
+│   │   └── big_image
+│   ├── cubes
+│   │   ├── tiny_cube
+│   │   └── tiny_hypercube
+│   ├── complex
+│   ├── sparse_image
+│   └── awkward_array
+├── tables
+│   ├── short_table
+│   ├── long_table
+<Output truncated at 20 lines. Adjust tree's max_lines parameter to see more.>
 ```
 
 Each (sub)tree displays the names of a couple of its entries---up to
@@ -47,41 +54,55 @@ however many fit on one line.
 
 ```python
 >>> client
-<Container {'big_image', 'small_image', 'medium_image', ...} ~16 entries>
+<Container {'scalars', 'nested', 'tables', 'structured_data', ...} ~8 entries>
 ```
 
 Containers act like (nested) mappings in Python. All the (read-only) methods
-that work on Python dictionaries work on Containers. We can lookup a specific
-value by its key
+that work on Python dictionaries work on Containers. We can
+
+* lookup a specific value by its key
 
 ```python
 >>> client['structured_data']
 <Container {'pets', 'xarray_dataset'}>
 ```
 
-list all the keys
+* easily access nested hierarchies
+
+```python
+>>> client['nested']['images']['tiny_image']
+<ArrayClient shape=(50, 50) chunks=((50,), (50,)) dtype=float64>
+```
+
+* or using a simplified syntax
+
+```python
+>>> client['nested', 'images', 'tiny_image']
+<ArrayClient shape=(50, 50) chunks=((50,), (50,)) dtype=float64>
+```
+
+* or even
+
+```python
+>>> client['nested/images/tiny_image']
+<ArrayClient shape=(50, 50) chunks=((50,), (50,)) dtype=float64>
+```
+
+* list all the keys
 
 ```python
 >>> list(client)
-['big_image',
- 'small_image',
- 'medium_image',
- 'sparse_image',
- 'awkward_array',
- 'tiny_image',
- 'tiny_cube',
- 'tiny_hypercube',
- 'short_table',
- 'long_table',
- 'wide_table',
+['scalars',
+ 'nested',
+ 'tables',
  'structured_data',
  'flat_array',
  'low_entropy',
  'high_entropy',
  'dynamic']
 ```
 
-and loop over keys, values, or ``(key, value)`` pairs.
+* and loop over keys, values, or ``(key, value)`` pairs
 
 ```python
 for key in client:
@@ -104,37 +125,49 @@ need to start from the middle.
 
 ```python
 >>> client.keys().first()  # Access the first key.
-'big_image'
+'scalars'
 
 >>> client.keys().head()  # Access the first several keys.
-['big_image',
- 'small_image',
- 'medium_image',
- 'sparse_image',
- 'awkward_array']
+['scalars',
+'nested',
+'tables',
+'structured_data',
+'flat_array']
 
 >>> client.keys().head(3)  # Access the first N keys.
-['big_image',
- 'small_image',
- 'medium_image']
+['scalars',
+'nested',
+'tables']
 
 >>> client.keys()[1:3]  # Access just the keys for entries 1:3.
-['small_image', 'medium_image']
+['nested', 'tables']
 ```
 
-All the same methods work for values
+All the same methods work for values, which return string representations of the
+container contents:
 
 ```python
 >>> client.values()[1:3]  # Access the values (which may be more expensive).
-[<ArrayClient shape=(300, 300) chunks=((300,), (300,)) dtype=float64>, <ArrayClient shape=(1000, 1000) chunks=((1000,), (1000,)) dtype=float64>]
+[<Container {'images', 'cubes', 'complex', 'sparse_image', ...} ~5 entries>,
+ <Container {'short_table', 'long_table', 'wide_table'}>]
+```
+
+or
+
+```python
+>>> client['nested/images'].values()[:2]  # Access the values of a nested container
+[<ArrayClient shape=(50, 50) chunks=((50,), (50,)) dtype=float64>,
+ <ArrayClient shape=(300, 300) chunks=((300,), (300,)) dtype=float64>]
 ```
 
 and `(key, value)` pairs ("items").
 
 ```python
->>> client.items()[1:3]  # Access (key, value) pairs.
-[('small_image', <ArrayClient shape=(300, 300) chunks=((300,), (300,)) dtype=float64>),
-('medium_image', <ArrayClient shape=(1000, 1000) chunks=((1000,), (1000,)) dtype=float64>)]
+>>> client['nested/images'].items()[:2]  # Access (key, value) pairs.
+[('tiny_image',
+  <ArrayClient shape=(50, 50) chunks=((50,), (50,)) dtype=float64>),
+ ('small_image',
+  <ArrayClient shape=(300, 300) chunks=((300,), (300,)) dtype=float64>)]
 ```
 
 Each item has ``metadata``, which is a simple dict.
@@ -145,7 +178,7 @@ space to use or not.
 >>> client.metadata  # happens to be empty
 DictView({})
 
->>> client['short_table'].metadata  # happens to have some stuff
+>>> client['tables/short_table'].metadata  # happens to have some stuff
 DictView({'animal': 'dog', 'color': 'red'})
 ```