[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"skill:01M6AFR1S6Z782PE0W61563CXD":3,"skill-same:01M6AFR1S6Z782PE0W61563CXD":80},{"skillNo":4,"name":5,"nameZh":6,"description":7,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":16,"categories":17,"keywords":18,"publishedAt":37,"linkOnly":38,"markdownContent":39,"markdownBody":40,"frontMatter":41,"refName":42,"commitSha":43,"skillDirectory":44,"forksCount":45,"repositoryHtmlUrl":46,"repositoryHomepageUrl":47,"ownerHtmlUrl":48,"ownerBlogUrl":49,"ownerDescription":50,"updatedAt":51,"install":52,"resources":65},"01M6AFR1S6Z782PE0W61563CXD","zarr-python",null,"Chunked N-D arrays for cloud storage. Compressed arrays, parallel I\u002FO, S3\u002FGCS integration, NumPy\u002FDask\u002FXarray compatible, for large-scale scientific computing pipelines.","davila7\u002Fclaude-code-templates","davila7","https:\u002F\u002Favatars.githubusercontent.com\u002Fu\u002F6216945?v=4","01M6ADEWWFPS191NFM0Y1EX1JH","Daniel Avila","01M6ADJHGM78PHQRD3XZTFDVKK",33481,"MIT","https:\u002F\u002Fgithub.com\u002Fdavila7\u002Fclaude-code-templates\u002Fblob\u002Fmain\u002Fcli-tool\u002Fcomponents\u002Fskills\u002Fscientific\u002Fzarr-python\u002FSKILL.md",[],[19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36],"zarr","zarr python","python","pipelines","for","Cloud Storage","scientific","scale","scientific computing","numpy","arrays","parallel","dask","cloud","gcs","s3","integration","storage","2026-11-10 10:12:30",false,"---\nname: zarr-python\ndescription: \"Chunked N-D arrays for cloud storage. Compressed arrays, parallel I\u002FO, S3\u002FGCS integration, NumPy\u002FDask\u002FXarray compatible, for large-scale scientific computing pipelines.\"\n---\n\n# Zarr Python\n\n## Overview\n\nZarr is a Python library for storing large N-dimensional arrays with chunking and compression. Apply this skill for efficient parallel I\u002FO, cloud-native workflows, and seamless integration with NumPy, Dask, and Xarray.\n\n## Quick Start\n\n### Installation\n\n```bash\nuv pip install zarr\n```\n\nRequires Python 3.11+. For cloud storage support, install additional packages:\n```python\nuv pip install s3fs  # For S3\nuv pip install gcsfs  # For Google Cloud Storage\n```\n\n### Basic Array Creation\n\n```python\nimport zarr\nimport numpy as np\n\n# Create a 2D array with chunking and compression\nz = zarr.create_array(\n    store=\"data\u002Fmy_array.zarr\",\n    shape=(10000, 10000),\n    chunks=(1000, 1000),\n    dtype=\"f4\"\n)\n\n# Write data using NumPy-style indexing\nz[:, :] = np.random.random((10000, 10000))\n\n# Read data\ndata = z[0:100, 0:100]  # Returns NumPy array\n```\n\n## Core Operations\n\n### Creating Arrays\n\nZarr provides multiple convenience functions for array creation:\n\n```python\n# Create empty array\nz = zarr.zeros(shape=(10000, 10000), chunks=(1000, 1000), dtype='f4',\n               store='data.zarr')\n\n# Create filled arrays\nz = zarr.ones((5000, 5000), chunks=(500, 500))\nz = zarr.full((1000, 1000), fill_value=42, chunks=(100, 100))\n\n# Create from existing data\ndata = np.arange(10000).reshape(100, 100)\nz = zarr.array(data, chunks=(10, 10), store='data.zarr')\n\n# Create like another array\nz2 = zarr.zeros_like(z)  # Matches shape, chunks, dtype of z\n```\n\n### Opening Existing Arrays\n\n```python\n# Open array (read\u002Fwrite mode by default)\nz = zarr.open_array('data.zarr', mode='r+')\n\n# Read-only mode\nz = zarr.open_array('data.zarr', mode='r')\n\n# The open() function auto-detects arrays vs groups\nz = zarr.open('data.zarr')  # Returns Array or Group\n```\n\n### Reading and Writing Data\n\nZarr arrays support NumPy-like indexing:\n\n```python\n# Write entire array\nz[:] = 42\n\n# Write slices\nz[0, :] = np.arange(100)\nz[10:20, 50:60] = np.random.random((10, 10))\n\n# Read data (returns NumPy array)\ndata = z[0:100, 0:100]\nrow = z[5, :]\n\n# Advanced indexing\nz.vindex[[0, 5, 10], [2, 8, 15]]  # Coordinate indexing\nz.oindex[0:10, [5, 10, 15]]       # Orthogonal indexing\nz.blocks[0, 0]                     # Block\u002Fchunk indexing\n```\n\n### Resizing and Appending\n\n```python\n# Resize array\nz.resize(15000, 15000)  # Expands or shrinks dimensions\n\n# Append data along an axis\nz.append(np.random.random((1000, 10000)), axis=0)  # Adds rows\n```\n\n## Chunking Strategies\n\nChunking is critical for performance. Choose chunk sizes and shapes based on access patterns.\n\n### Chunk Size Guidelines\n\n- **Minimum chunk size**: 1 MB recommended for optimal performance\n- **Balance**: Larger chunks = fewer metadata operations; smaller chunks = better parallel access\n- **Memory consideration**: Entire chunks must fit in memory during compression\n\n```python\n# Configure chunk size (aim for ~1MB per chunk)\n# For float32 data: 1MB = 262,144 elements = 512×512 array\nz = zarr.zeros(\n    shape=(10000, 10000),\n    chunks=(512, 512),  # ~1MB chunks\n    dtype='f4'\n)\n```\n\n### Aligning Chunks with Access Patterns\n\n**Critical**: Chunk shape dramatically affects performance based on how data is accessed.\n\n```python\n# If accessing rows frequently (first dimension)\nz = zarr.zeros((10000, 10000), chunks=(10, 10000))  # Chunk spans columns\n\n# If accessing columns frequently (second dimension)\nz = zarr.zeros((10000, 10000), chunks=(10000, 10))  # Chunk spans rows\n\n# For mixed access patterns (balanced approach)\nz = zarr.zeros((10000, 10000), chunks=(1000, 1000))  # Square chunks\n```\n\n**Performance example**: For a (200, 200, 200) array, reading along the first dimension:\n- Using chunks (1, 200, 200): ~107ms\n- Using chunks (200, 200, 1): ~1.65ms (65× faster!)\n\n### Sharding for Large-Scale Storage\n\nWhen arrays have millions of small chunks, use sharding to group chunks into larger storage objects:\n\n```python\nfrom zarr.codecs import ShardingCodec, BytesCodec\nfrom zarr.codecs.blosc import BloscCodec\n\n# Create array with sharding\nz = zarr.create_array(\n    store='data.zarr',\n    shape=(100000, 100000),\n    chunks=(100, 100),  # Small chunks for access\n    shards=(1000, 1000),  # Groups 100 chunks per shard\n    dtype='f4'\n)\n```\n\n**Benefits**:\n- Reduces file system overhead from millions of small files\n- Improves cloud storage performance (fewer object requests)\n- Prevents filesystem block size waste\n\n**Important**: Entire shards must fit in memory before writing.\n\n## Compression\n\nZarr applies compression per chunk to reduce storage while maintaining fast access.\n\n### Configuring Compression\n\n```python\nfrom zarr.codecs.blosc import BloscCodec\nfrom zarr.codecs import GzipCodec, ZstdCodec\n\n# Default: Blosc with Zstandard\nz = zarr.zeros((1000, 1000), chunks=(100, 100))  # Uses default compression\n\n# Configure Blosc codec\nz = zarr.create_array(\n    store='data.zarr',\n    shape=(1000, 1000),\n    chunks=(100, 100),\n    dtype='f4',\n    codecs=[BloscCodec(cname='zstd', clevel=5, shuffle='shuffle')]\n)\n\n# Available Blosc compressors: 'blosclz', 'lz4', 'lz4hc', 'snappy', 'zlib', 'zstd'\n\n# Use Gzip compression\nz = zarr.create_array(\n    store='data.zarr',\n    shape=(1000, 1000),\n    chunks=(100, 100),\n    dtype='f4',\n    codecs=[GzipCodec(level=6)]\n)\n\n# Disable compression\nz = zarr.create_array(\n    store='data.zarr',\n    shape=(1000, 1000),\n    chunks=(100, 100),\n    dtype='f4',\n    codecs=[BytesCodec()]  # No compression\n)\n```\n\n### Compression Performance Tips\n\n- **Blosc** (default): Fast compression\u002Fdecompression, good for interactive workloads\n- **Zstandard**: Better compression ratios, slightly slower than LZ4\n- **Gzip**: Maximum compression, slower performance\n- **LZ4**: Fastest compression, lower ratios\n- **Shuffle**: Enable shuffle filter for better compression on numeric data\n\n```python\n# Optimal for numeric scientific data\ncodecs=[BloscCodec(cname='zstd', clevel=5, shuffle='shuffle')]\n\n# Optimal for speed\ncodecs=[BloscCodec(cname='lz4', clevel=1)]\n\n# Optimal for compression ratio\ncodecs=[GzipCodec(level=9)]\n```\n\n## Storage Backends\n\nZarr supports multiple storage backends through a flexible storage interface.\n\n### Local Filesystem (Default)\n\n```python\nfrom zarr.storage import LocalStore\n\n# Explicit store creation\nstore = LocalStore('data\u002Fmy_array.zarr')\nz = zarr.open_array(store=store, mode='w', shape=(1000, 1000), chunks=(100, 100))\n\n# Or use string path (creates LocalStore automatically)\nz = zarr.open_array('data\u002Fmy_array.zarr', mode='w', shape=(1000, 1000),\n                    chunks=(100, 100))\n```\n\n### In-Memory Storage\n\n```python\nfrom zarr.storage import MemoryStore\n\n# Create in-memory store\nstore = MemoryStore()\nz = zarr.open_array(store=store, mode='w', shape=(1000, 1000), chunks=(100, 100))\n\n# Data exists only in memory, not persisted\n```\n\n### ZIP File Storage\n\n```python\nfrom zarr.storage import ZipStore\n\n# Write to ZIP file\nstore = ZipStore('data.zip', mode='w')\nz = zarr.open_array(store=store, mode='w', shape=(1000, 1000), chunks=(100, 100))\nz[:] = np.random.random((1000, 1000))\nstore.close()  # IMPORTANT: Must close ZipStore\n\n# Read from ZIP file\nstore = ZipStore('data.zip', mode='r')\nz = zarr.open_array(store=store)\ndata = z[:]\nstore.close()\n```\n\n### Cloud Storage (S3, GCS)\n\n```python\nimport s3fs\nimport zarr\n\n# S3 storage\ns3 = s3fs.S3FileSystem(anon=False)  # Use credentials\nstore = s3fs.S3Map(root='my-bucket\u002Fpath\u002Fto\u002Farray.zarr', s3=s3)\nz = zarr.open_array(store=store, mode='w', shape=(1000, 1000), chunks=(100, 100))\nz[:] = data\n\n# Google Cloud Storage\nimport gcsfs\ngcs = gcsfs.GCSFileSystem(project='my-project')\nstore = gcsfs.GCSMap(root='my-bucket\u002Fpath\u002Fto\u002Farray.zarr', gcs=gcs)\nz = zarr.open_array(store=store, mode='w', shape=(1000, 1000), chunks=(100, 100))\n```\n\n**Cloud Storage Best Practices**:\n- Use consolidated metadata to reduce latency: `zarr.consolidate_metadata(store)`\n- Align chunk sizes with cloud object sizing (typically 5-100 MB optimal)\n- Enable parallel writes using Dask for large-scale data\n- Consider sharding to reduce number of objects\n\n## Groups and Hierarchies\n\nGroups organize multiple arrays hierarchically, similar to directories or HDF5 groups.\n\n### Creating and Using Groups\n\n```python\n# Create root group\nroot = zarr.group(store='data\u002Fhierarchy.zarr')\n\n# Create sub-groups\ntemperature = root.create_group('temperature')\nprecipitation = root.create_group('precipitation')\n\n# Create arrays within groups\ntemp_array = temperature.create_array(\n    name='t2m',\n    shape=(365, 720, 1440),\n    chunks=(1, 720, 1440),\n    dtype='f4'\n)\n\nprecip_array = precipitation.create_array(\n    name='prcp',\n    shape=(365, 720, 1440),\n    chunks=(1, 720, 1440),\n    dtype='f4'\n)\n\n# Access using paths\narray = root['temperature\u002Ft2m']\n\n# Visualize hierarchy\nprint(root.tree())\n# Output:\n# \u002F\n#  ├── temperature\n#  │   └── t2m (365, 720, 1440) f4\n#  └── precipitation\n#      └── prcp (365, 720, 1440) f4\n```\n\n### H5py-Compatible API\n\nZarr provides an h5py-compatible interface for familiar HDF5 users:\n\n```python\n# Create group with h5py-style methods\nroot = zarr.group('data.zarr')\ndataset = root.create_dataset('my_data', shape=(1000, 1000), chunks=(100, 100),\n                              dtype='f4')\n\n# Access like h5py\ngrp = root.require_group('subgroup')\narr = grp.require_dataset('array', shape=(500, 500), chunks=(50, 50), dtype='i4')\n```\n\n## Attributes and Metadata\n\nAttach custom metadata to arrays and groups using attributes:\n\n```python\n# Add attributes to array\nz = zarr.zeros((1000, 1000), chunks=(100, 100))\nz.attrs['description'] = 'Temperature data in Kelvin'\nz.attrs['units'] = 'K'\nz.attrs['created'] = '2024-01-15'\nz.attrs['processing_version'] = 2.1\n\n# Attributes are stored as JSON\nprint(z.attrs['units'])  # Output: K\n\n# Add attributes to groups\nroot = zarr.group('data.zarr')\nroot.attrs['project'] = 'Climate Analysis'\nroot.attrs['institution'] = 'Research Institute'\n\n# Attributes persist with the array\u002Fgroup\nz2 = zarr.open('data.zarr')\nprint(z2.attrs['description'])\n```\n\n**Important**: Attributes must be JSON-serializable (strings, numbers, lists, dicts, booleans, null).\n\n## Integration with NumPy, Dask, and Xarray\n\n### NumPy Integration\n\nZarr arrays implement the NumPy array interface:\n\n```python\nimport numpy as np\nimport zarr\n\nz = zarr.zeros((1000, 1000), chunks=(100, 100))\n\n# Use NumPy functions directly\nresult = np.sum(z, axis=0)  # NumPy operates on Zarr array\nmean = np.mean(z[:100, :100])\n\n# Convert to NumPy array\nnumpy_array = z[:]  # Loads entire array into memory\n```\n\n### Dask Integration\n\nDask provides lazy, parallel computation on Zarr arrays:\n\n```python\nimport dask.array as da\nimport zarr\n\n# Create large Zarr array\nz = zarr.open('data.zarr', mode='w', shape=(100000, 100000),\n              chunks=(1000, 1000), dtype='f4')\n\n# Load as Dask array (lazy, no data loaded)\ndask_array = da.from_zarr('data.zarr')\n\n# Perform computations (parallel, out-of-core)\nresult = dask_array.mean(axis=0).compute()  # Parallel computation\n\n# Write Dask array to Zarr\nlarge_array = da.random.random((100000, 100000), chunks=(1000, 1000))\nda.to_zarr(large_array, 'output.zarr')\n```\n\n**Benefits**:\n- Process datasets larger than memory\n- Automatic parallel computation across chunks\n- Efficient I\u002FO with chunked storage\n\n### Xarray Integration\n\nXarray provides labeled, multidimensional arrays with Zarr backend:\n\n```python\nimport xarray as xr\nimport zarr\n\n# Open Zarr store as Xarray Dataset (lazy loading)\nds = xr.open_zarr('data.zarr')\n\n# Dataset includes coordinates and metadata\nprint(ds)\n\n# Access variables\ntemperature = ds['temperature']\n\n# Perform labeled operations\nsubset = ds.sel(time='2024-01', lat=slice(30, 60))\n\n# Write Xarray Dataset to Zarr\nds.to_zarr('output.zarr')\n\n# Create from scratch with coordinates\nds = xr.Dataset(\n    {\n        'temperature': (['time', 'lat', 'lon'], data),\n        'precipitation': (['time', 'lat', 'lon'], data2)\n    },\n    coords={\n        'time': pd.date_range('2024-01-01', periods=365),\n        'lat': np.arange(-90, 91, 1),\n        'lon': np.arange(-180, 180, 1)\n    }\n)\nds.to_zarr('climate_data.zarr')\n```\n\n**Benefits**:\n- Named dimensions and coordinates\n- Label-based indexing and selection\n- Integration with pandas for time series\n- NetCDF-like interface familiar to climate\u002Fgeospatial scientists\n\n## Parallel Computing and Synchronization\n\n### Thread-Safe Operations\n\n```python\nfrom zarr import ThreadSynchronizer\nimport zarr\n\n# For multi-threaded writes\nsynchronizer = ThreadSynchronizer()\nz = zarr.open_array('data.zarr', mode='r+', shape=(10000, 10000),\n                    chunks=(1000, 1000), synchronizer=synchronizer)\n\n# Safe for concurrent writes from multiple threads\n# (when writes don't span chunk boundaries)\n```\n\n### Process-Safe Operations\n\n```python\nfrom zarr import ProcessSynchronizer\nimport zarr\n\n# For multi-process writes\nsynchronizer = ProcessSynchronizer('sync_data.sync')\nz = zarr.open_array('data.zarr', mode='r+', shape=(10000, 10000),\n                    chunks=(1000, 1000), synchronizer=synchronizer)\n\n# Safe for concurrent writes from multiple processes\n```\n\n**Note**:\n- Concurrent reads require no synchronization\n- Synchronization only needed for writes that may span chunk boundaries\n- Each process\u002Fthread writing to separate chunks needs no synchronization\n\n## Consolidated Metadata\n\nFor hierarchical stores with many arrays, consolidate metadata into a single file to reduce I\u002FO operations:\n\n```python\nimport zarr\n\n# After creating arrays\u002Fgroups\nroot = zarr.group('data.zarr')\n# ... create multiple arrays\u002Fgroups ...\n\n# Consolidate metadata\nzarr.consolidate_metadata('data.zarr')\n\n# Open with consolidated metadata (faster, especially on cloud storage)\nroot = zarr.open_consolidated('data.zarr')\n```\n\n**Benefits**:\n- Reduces metadata read operations from N (one per array) to 1\n- Critical for cloud storage (reduces latency)\n- Speeds up `tree()` operations and group traversal\n\n**Cautions**:\n- Metadata can become stale if arrays update without re-consolidation\n- Not suitable for frequently-updated datasets\n- Multi-writer scenarios may have inconsistent reads\n\n## Performance Optimization\n\n### Checklist for Optimal Performance\n\n1. **Chunk Size**: Aim for 1-10 MB per chunk\n   ```python\n   # For float32: 1MB = 262,144 elements\n   chunks = (512, 512)  # 512×512×4 bytes = ~1MB\n   ```\n\n2. **Chunk Shape**: Align with access patterns\n   ```python\n   # Row-wise access → chunk spans columns: (small, large)\n   # Column-wise access → chunk spans rows: (large, small)\n   # Random access → balanced: (medium, medium)\n   ```\n\n3. **Compression**: Choose based on workload\n   ```python\n   # Interactive\u002Ffast: BloscCodec(cname='lz4')\n   # Balanced: BloscCodec(cname='zstd', clevel=5)\n   # Maximum compression: GzipCodec(level=9)\n   ```\n\n4. **Storage Backend**: Match to environment\n   ```python\n   # Local: LocalStore (default)\n   # Cloud: S3Map\u002FGCSMap with consolidated metadata\n   # Temporary: MemoryStore\n   ```\n\n5. **Sharding**: Use for large-scale datasets\n   ```python\n   # When you have millions of small chunks\n   shards=(10*chunk_size, 10*chunk_size)\n   ```\n\n6. **Parallel I\u002FO**: Use Dask for large operations\n   ```python\n   import dask.array as da\n   dask_array = da.from_zarr('data.zarr')\n   result = dask_array.compute(scheduler='threads', num_workers=8)\n   ```\n\n### Profiling and Debugging\n\n```python\n# Print detailed array information\nprint(z.info)\n\n# Output includes:\n# - Type, shape, chunks, dtype\n# - Compression codec and level\n# - Storage size (compressed vs uncompressed)\n# - Storage location\n\n# Check storage size\nprint(f\"Compressed size: {z.nbytes_stored \u002F 1e6:.2f} MB\")\nprint(f\"Uncompressed size: {z.nbytes \u002F 1e6:.2f} MB\")\nprint(f\"Compression ratio: {z.nbytes \u002F z.nbytes_stored:.2f}x\")\n```\n\n## Common Patterns and Best Practices\n\n### Pattern: Time Series Data\n\n```python\n# Store time series with time as first dimension\n# This allows efficient appending of new time steps\nz = zarr.open('timeseries.zarr', mode='a',\n              shape=(0, 720, 1440),  # Start with 0 time steps\n              chunks=(1, 720, 1440),  # One time step per chunk\n              dtype='f4')\n\n# Append new time steps\nnew_data = np.random.random((1, 720, 1440))\nz.append(new_data, axis=0)\n```\n\n### Pattern: Large Matrix Operations\n\n```python\nimport dask.array as da\n\n# Create large matrix in Zarr\nz = zarr.open('matrix.zarr', mode='w',\n              shape=(100000, 100000),\n              chunks=(1000, 1000),\n              dtype='f8')\n\n# Use Dask for parallel computation\ndask_z = da.from_zarr('matrix.zarr')\nresult = (dask_z @ dask_z.T).compute()  # Parallel matrix multiply\n```\n\n### Pattern: Cloud-Native Workflow\n\n```python\nimport s3fs\nimport zarr\n\n# Write to S3\ns3 = s3fs.S3FileSystem()\nstore = s3fs.S3Map(root='s3:\u002F\u002Fmy-bucket\u002Fdata.zarr', s3=s3)\n\n# Create array with appropriate chunking for cloud\nz = zarr.open_array(store=store, mode='w',\n                    shape=(10000, 10000),\n                    chunks=(500, 500),  # ~1MB chunks\n                    dtype='f4')\nz[:] = data\n\n# Consolidate metadata for faster reads\nzarr.consolidate_metadata(store)\n\n# Read from S3 (anywhere, anytime)\nstore_read = s3fs.S3Map(root='s3:\u002F\u002Fmy-bucket\u002Fdata.zarr', s3=s3)\nz_read = zarr.open_consolidated(store_read)\nsubset = z_read[0:100, 0:100]\n```\n\n### Pattern: Format Conversion\n\n```python\n# HDF5 to Zarr\nimport h5py\nimport zarr\n\nwith h5py.File('data.h5', 'r') as h5:\n    dataset = h5['dataset_name']\n    z = zarr.array(dataset[:],\n                   chunks=(1000, 1000),\n                   store='data.zarr')\n\n# NumPy to Zarr\nimport numpy as np\ndata = np.load('data.npy')\nz = zarr.array(data, chunks='auto', store='data.zarr')\n\n# Zarr to NetCDF (via Xarray)\nimport xarray as xr\nds = xr.open_zarr('data.zarr')\nds.to_netcdf('data.nc')\n```\n\n## Common Issues and Solutions\n\n### Issue: Slow Performance\n\n**Diagnosis**: Check chunk size and alignment\n```python\nprint(z.chunks)  # Are chunks appropriate size?\nprint(z.info)    # Check compression ratio\n```\n\n**Solutions**:\n- Increase chunk size to 1-10 MB\n- Align chunks with access pattern\n- Try different compression codecs\n- Use Dask for parallel operations\n\n### Issue: High Memory Usage\n\n**Cause**: Loading entire array or large chunks into memory\n\n**Solutions**:\n```python\n# Don't load entire array\n# Bad: data = z[:]\n# Good: Process in chunks\nfor i in range(0, z.shape[0], 1000):\n    chunk = z[i:i+1000, :]\n    process(chunk)\n\n# Or use Dask for automatic chunking\nimport dask.array as da\ndask_z = da.from_zarr('data.zarr')\nresult = dask_z.mean().compute()  # Processes in chunks\n```\n\n### Issue: Cloud Storage Latency\n\n**Solutions**:\n```python\n# 1. Consolidate metadata\nzarr.consolidate_metadata(store)\nz = zarr.open_consolidated(store)\n\n# 2. Use appropriate chunk sizes (5-100 MB for cloud)\nchunks = (2000, 2000)  # Larger chunks for cloud\n\n# 3. Enable sharding\nshards = (10000, 10000)  # Groups many chunks\n```\n\n### Issue: Concurrent Write Conflicts\n\n**Solution**: Use synchronizers or ensure non-overlapping writes\n```python\nfrom zarr import ProcessSynchronizer\n\nsync = ProcessSynchronizer('sync.sync')\nz = zarr.open_array('data.zarr', mode='r+', synchronizer=sync)\n\n# Or design workflow so each process writes to separate chunks\n```\n\n## Additional Resources\n\nFor detailed API documentation, advanced usage, and the latest updates:\n\n- **Official Documentation**: https:\u002F\u002Fzarr.readthedocs.io\u002F\n- **Zarr Specifications**: https:\u002F\u002Fzarr-specs.readthedocs.io\u002F\n- **GitHub Repository**: https:\u002F\u002Fgithub.com\u002Fzarr-developers\u002Fzarr-python\n- **Community Chat**: https:\u002F\u002Fgitter.im\u002Fzarr-developers\u002Fcommunity\n\n**Related Libraries**:\n- **Xarray**: https:\u002F\u002Fdocs.xarray.dev\u002F (labeled arrays)\n- **Dask**: https:\u002F\u002Fdocs.dask.org\u002F (parallel computing)\n- **NumCodecs**: https:\u002F\u002Fnumcodecs.readthedocs.io\u002F (compression codecs)\n","# Zarr Python\n\n## Overview\n\nZarr is a Python library for storing large N-dimensional arrays with chunking and compression. Apply this skill for efficient parallel I\u002FO, cloud-native workflows, and seamless integration with NumPy, Dask, and Xarray.\n\n## Quick Start\n\n### Installation\n\n```bash\nuv pip install zarr\n```\n\nRequires Python 3.11+. For cloud storage support, install additional packages:\n```python\nuv pip install s3fs  # For S3\nuv pip install gcsfs  # For Google Cloud Storage\n```\n\n### Basic Array Creation\n\n```python\nimport zarr\nimport numpy as np\n\n# Create a 2D array with chunking and compression\nz = zarr.create_array(\n    store=\"data\u002Fmy_array.zarr\",\n    shape=(10000, 10000),\n    chunks=(1000, 1000),\n    dtype=\"f4\"\n)\n\n# Write data using NumPy-style indexing\nz[:, :] = np.random.random((10000, 10000))\n\n# Read data\ndata = z[0:100, 0:100]  # Returns NumPy array\n```\n\n## Core Operations\n\n### Creating Arrays\n\nZarr provides multiple convenience functions for array creation:\n\n```python\n# Create empty array\nz = zarr.zeros(shape=(10000, 10000), chunks=(1000, 1000), dtype='f4',\n               store='data.zarr')\n\n# Create filled arrays\nz = zarr.ones((5000, 5000), chunks=(500, 500))\nz = zarr.full((1000, 1000), fill_value=42, chunks=(100, 100))\n\n# Create from existing data\ndata = np.arange(10000).reshape(100, 100)\nz = zarr.array(data, chunks=(10, 10), store='data.zarr')\n\n# Create like another array\nz2 = zarr.zeros_like(z)  # Matches shape, chunks, dtype of z\n```\n\n### Opening Existing Arrays\n\n```python\n# Open array (read\u002Fwrite mode by default)\nz = zarr.open_array('data.zarr', mode='r+')\n\n# Read-only mode\nz = zarr.open_array('data.zarr', mode='r')\n\n# The open() function auto-detects arrays vs groups\nz = zarr.open('data.zarr')  # Returns Array or Group\n```\n\n### Reading and Writing Data\n\nZarr arrays support NumPy-like indexing:\n\n```python\n# Write entire array\nz[:] = 42\n\n# Write slices\nz[0, :] = np.arange(100)\nz[10:20, 50:60] = np.random.random((10, 10))\n\n# Read data (returns NumPy array)\ndata = z[0:100, 0:100]\nrow = z[5, :]\n\n# Advanced indexing\nz.vindex[[0, 5, 10], [2, 8, 15]]  # Coordinate indexing\nz.oindex[0:10, [5, 10, 15]]       # Orthogonal indexing\nz.blocks[0, 0]                     # Block\u002Fchunk indexing\n```\n\n### Resizing and Appending\n\n```python\n# Resize array\nz.resize(15000, 15000)  # Expands or shrinks dimensions\n\n# Append data along an axis\nz.append(np.random.random((1000, 10000)), axis=0)  # Adds rows\n```\n\n## Chunking Strategies\n\nChunking is critical for performance. Choose chunk sizes and shapes based on access patterns.\n\n### Chunk Size Guidelines\n\n- **Minimum chunk size**: 1 MB recommended for optimal performance\n- **Balance**: Larger chunks = fewer metadata operations; smaller chunks = better parallel access\n- **Memory consideration**: Entire chunks must fit in memory during compression\n\n```python\n# Configure chunk size (aim for ~1MB per chunk)\n# For float32 data: 1MB = 262,144 elements = 512×512 array\nz = zarr.zeros(\n    shape=(10000, 10000),\n    chunks=(512, 512),  # ~1MB chunks\n    dtype='f4'\n)\n```\n\n### Aligning Chunks with Access Patterns\n\n**Critical**: Chunk shape dramatically affects performance based on how data is accessed.\n\n```python\n# If accessing rows frequently (first dimension)\nz = zarr.zeros((10000, 10000), chunks=(10, 10000))  # Chunk spans columns\n\n# If accessing columns frequently (second dimension)\nz = zarr.zeros((10000, 10000), chunks=(10000, 10))  # Chunk spans rows\n\n# For mixed access patterns (balanced approach)\nz = zarr.zeros((10000, 10000), chunks=(1000, 1000))  # Square chunks\n```\n\n**Performance example**: For a (200, 200, 200) array, reading along the first dimension:\n- Using chunks (1, 200, 200): ~107ms\n- Using chunks (200, 200, 1): ~1.65ms (65× faster!)\n\n### Sharding for Large-Scale Storage\n\nWhen arrays have millions of small chunks, use sharding to group chunks into larger storage objects:\n\n```python\nfrom zarr.codecs import ShardingCodec, BytesCodec\nfrom zarr.codecs.blosc import BloscCodec\n\n# Create array with sharding\nz = zarr.create_array(\n    store='data.zarr',\n    shape=(100000, 100000),\n    chunks=(100, 100),  # Small chunks for access\n    shards=(1000, 1000),  # Groups 100 chunks per shard\n    dtype='f4'\n)\n```\n\n**Benefits**:\n- Reduces file system overhead from millions of small files\n- Improves cloud storage performance (fewer object requests)\n- Prevents filesystem block size waste\n\n**Important**: Entire shards must fit in memory before writing.\n\n## Compression\n\nZarr applies compression per chunk to reduce storage while maintaining fast access.\n\n### Configuring Compression\n\n```python\nfrom zarr.codecs.blosc import BloscCodec\nfrom zarr.codecs import GzipCodec, ZstdCodec\n\n# Default: Blosc with Zstandard\nz = zarr.zeros((1000, 1000), chunks=(100, 100))  # Uses default compression\n\n# Configure Blosc codec\nz = zarr.create_array(\n    store='data.zarr',\n    shape=(1000, 1000),\n    chunks=(100, 100),\n    dtype='f4',\n    codecs=[BloscCodec(cname='zstd', clevel=5, shuffle='shuffle')]\n)\n\n# Available Blosc compressors: 'blosclz', 'lz4', 'lz4hc', 'snappy', 'zlib', 'zstd'\n\n# Use Gzip compression\nz = zarr.create_array(\n    store='data.zarr',\n    shape=(1000, 1000),\n    chunks=(100, 100),\n    dtype='f4',\n    codecs=[GzipCodec(level=6)]\n)\n\n# Disable compression\nz = zarr.create_array(\n    store='data.zarr',\n    shape=(1000, 1000),\n    chunks=(100, 100),\n    dtype='f4',\n    codecs=[BytesCodec()]  # No compression\n)\n```\n\n### Compression Performance Tips\n\n- **Blosc** (default): Fast compression\u002Fdecompression, good for interactive workloads\n- **Zstandard**: Better compression ratios, slightly slower than LZ4\n- **Gzip**: Maximum compression, slower performance\n- **LZ4**: Fastest compression, lower ratios\n- **Shuffle**: Enable shuffle filter for better compression on numeric data\n\n```python\n# Optimal for numeric scientific data\ncodecs=[BloscCodec(cname='zstd', clevel=5, shuffle='shuffle')]\n\n# Optimal for speed\ncodecs=[BloscCodec(cname='lz4', clevel=1)]\n\n# Optimal for compression ratio\ncodecs=[GzipCodec(level=9)]\n```\n\n## Storage Backends\n\nZarr supports multiple storage backends through a flexible storage interface.\n\n### Local Filesystem (Default)\n\n```python\nfrom zarr.storage import LocalStore\n\n# Explicit store creation\nstore = LocalStore('data\u002Fmy_array.zarr')\nz = zarr.open_array(store=store, mode='w', shape=(1000, 1000), chunks=(100, 100))\n\n# Or use string path (creates LocalStore automatically)\nz = zarr.open_array('data\u002Fmy_array.zarr', mode='w', shape=(1000, 1000),\n                    chunks=(100, 100))\n```\n\n### In-Memory Storage\n\n```python\nfrom zarr.storage import MemoryStore\n\n# Create in-memory store\nstore = MemoryStore()\nz = zarr.open_array(store=store, mode='w', shape=(1000, 1000), chunks=(100, 100))\n\n# Data exists only in memory, not persisted\n```\n\n### ZIP File Storage\n\n```python\nfrom zarr.storage import ZipStore\n\n# Write to ZIP file\nstore = ZipStore('data.zip', mode='w')\nz = zarr.open_array(store=store, mode='w', shape=(1000, 1000), chunks=(100, 100))\nz[:] = np.random.random((1000, 1000))\nstore.close()  # IMPORTANT: Must close ZipStore\n\n# Read from ZIP file\nstore = ZipStore('data.zip', mode='r')\nz = zarr.open_array(store=store)\ndata = z[:]\nstore.close()\n```\n\n### Cloud Storage (S3, GCS)\n\n```python\nimport s3fs\nimport zarr\n\n# S3 storage\ns3 = s3fs.S3FileSystem(anon=False)  # Use credentials\nstore = s3fs.S3Map(root='my-bucket\u002Fpath\u002Fto\u002Farray.zarr', s3=s3)\nz = zarr.open_array(store=store, mode='w', shape=(1000, 1000), chunks=(100, 100))\nz[:] = data\n\n# Google Cloud Storage\nimport gcsfs\ngcs = gcsfs.GCSFileSystem(project='my-project')\nstore = gcsfs.GCSMap(root='my-bucket\u002Fpath\u002Fto\u002Farray.zarr', gcs=gcs)\nz = zarr.open_array(store=store, mode='w', shape=(1000, 1000), chunks=(100, 100))\n```\n\n**Cloud Storage Best Practices**:\n- Use consolidated metadata to reduce latency: `zarr.consolidate_metadata(store)`\n- Align chunk sizes with cloud object sizing (typically 5-100 MB optimal)\n- Enable parallel writes using Dask for large-scale data\n- Consider sharding to reduce number of objects\n\n## Groups and Hierarchies\n\nGroups organize multiple arrays hierarchically, similar to directories or HDF5 groups.\n\n### Creating and Using Groups\n\n```python\n# Create root group\nroot = zarr.group(store='data\u002Fhierarchy.zarr')\n\n# Create sub-groups\ntemperature = root.create_group('temperature')\nprecipitation = root.create_group('precipitation')\n\n# Create arrays within groups\ntemp_array = temperature.create_array(\n    name='t2m',\n    shape=(365, 720, 1440),\n    chunks=(1, 720, 1440),\n    dtype='f4'\n)\n\nprecip_array = precipitation.create_array(\n    name='prcp',\n    shape=(365, 720, 1440),\n    chunks=(1, 720, 1440),\n    dtype='f4'\n)\n\n# Access using paths\narray = root['temperature\u002Ft2m']\n\n# Visualize hierarchy\nprint(root.tree())\n# Output:\n# \u002F\n#  ├── temperature\n#  │   └── t2m (365, 720, 1440) f4\n#  └── precipitation\n#      └── prcp (365, 720, 1440) f4\n```\n\n### H5py-Compatible API\n\nZarr provides an h5py-compatible interface for familiar HDF5 users:\n\n```python\n# Create group with h5py-style methods\nroot = zarr.group('data.zarr')\ndataset = root.create_dataset('my_data', shape=(1000, 1000), chunks=(100, 100),\n                              dtype='f4')\n\n# Access like h5py\ngrp = root.require_group('subgroup')\narr = grp.require_dataset('array', shape=(500, 500), chunks=(50, 50), dtype='i4')\n```\n\n## Attributes and Metadata\n\nAttach custom metadata to arrays and groups using attributes:\n\n```python\n# Add attributes to array\nz = zarr.zeros((1000, 1000), chunks=(100, 100))\nz.attrs['description'] = 'Temperature data in Kelvin'\nz.attrs['units'] = 'K'\nz.attrs['created'] = '2024-01-15'\nz.attrs['processing_version'] = 2.1\n\n# Attributes are stored as JSON\nprint(z.attrs['units'])  # Output: K\n\n# Add attributes to groups\nroot = zarr.group('data.zarr')\nroot.attrs['project'] = 'Climate Analysis'\nroot.attrs['institution'] = 'Research Institute'\n\n# Attributes persist with the array\u002Fgroup\nz2 = zarr.open('data.zarr')\nprint(z2.attrs['description'])\n```\n\n**Important**: Attributes must be JSON-serializable (strings, numbers, lists, dicts, booleans, null).\n\n## Integration with NumPy, Dask, and Xarray\n\n### NumPy Integration\n\nZarr arrays implement the NumPy array interface:\n\n```python\nimport numpy as np\nimport zarr\n\nz = zarr.zeros((1000, 1000), chunks=(100, 100))\n\n# Use NumPy functions directly\nresult = np.sum(z, axis=0)  # NumPy operates on Zarr array\nmean = np.mean(z[:100, :100])\n\n# Convert to NumPy array\nnumpy_array = z[:]  # Loads entire array into memory\n```\n\n### Dask Integration\n\nDask provides lazy, parallel computation on Zarr arrays:\n\n```python\nimport dask.array as da\nimport zarr\n\n# Create large Zarr array\nz = zarr.open('data.zarr', mode='w', shape=(100000, 100000),\n              chunks=(1000, 1000), dtype='f4')\n\n# Load as Dask array (lazy, no data loaded)\ndask_array = da.from_zarr('data.zarr')\n\n# Perform computations (parallel, out-of-core)\nresult = dask_array.mean(axis=0).compute()  # Parallel computation\n\n# Write Dask array to Zarr\nlarge_array = da.random.random((100000, 100000), chunks=(1000, 1000))\nda.to_zarr(large_array, 'output.zarr')\n```\n\n**Benefits**:\n- Process datasets larger than memory\n- Automatic parallel computation across chunks\n- Efficient I\u002FO with chunked storage\n\n### Xarray Integration\n\nXarray provides labeled, multidimensional arrays with Zarr backend:\n\n```python\nimport xarray as xr\nimport zarr\n\n# Open Zarr store as Xarray Dataset (lazy loading)\nds = xr.open_zarr('data.zarr')\n\n# Dataset includes coordinates and metadata\nprint(ds)\n\n# Access variables\ntemperature = ds['temperature']\n\n# Perform labeled operations\nsubset = ds.sel(time='2024-01', lat=slice(30, 60))\n\n# Write Xarray Dataset to Zarr\nds.to_zarr('output.zarr')\n\n# Create from scratch with coordinates\nds = xr.Dataset(\n    {\n        'temperature': (['time', 'lat', 'lon'], data),\n        'precipitation': (['time', 'lat', 'lon'], data2)\n    },\n    coords={\n        'time': pd.date_range('2024-01-01', periods=365),\n        'lat': np.arange(-90, 91, 1),\n        'lon': np.arange(-180, 180, 1)\n    }\n)\nds.to_zarr('climate_data.zarr')\n```\n\n**Benefits**:\n- Named dimensions and coordinates\n- Label-based indexing and selection\n- Integration with pandas for time series\n- NetCDF-like interface familiar to climate\u002Fgeospatial scientists\n\n## Parallel Computing and Synchronization\n\n### Thread-Safe Operations\n\n```python\nfrom zarr import ThreadSynchronizer\nimport zarr\n\n# For multi-threaded writes\nsynchronizer = ThreadSynchronizer()\nz = zarr.open_array('data.zarr', mode='r+', shape=(10000, 10000),\n                    chunks=(1000, 1000), synchronizer=synchronizer)\n\n# Safe for concurrent writes from multiple threads\n# (when writes don't span chunk boundaries)\n```\n\n### Process-Safe Operations\n\n```python\nfrom zarr import ProcessSynchronizer\nimport zarr\n\n# For multi-process writes\nsynchronizer = ProcessSynchronizer('sync_data.sync')\nz = zarr.open_array('data.zarr', mode='r+', shape=(10000, 10000),\n                    chunks=(1000, 1000), synchronizer=synchronizer)\n\n# Safe for concurrent writes from multiple processes\n```\n\n**Note**:\n- Concurrent reads require no synchronization\n- Synchronization only needed for writes that may span chunk boundaries\n- Each process\u002Fthread writing to separate chunks needs no synchronization\n\n## Consolidated Metadata\n\nFor hierarchical stores with many arrays, consolidate metadata into a single file to reduce I\u002FO operations:\n\n```python\nimport zarr\n\n# After creating arrays\u002Fgroups\nroot = zarr.group('data.zarr')\n# ... create multiple arrays\u002Fgroups ...\n\n# Consolidate metadata\nzarr.consolidate_metadata('data.zarr')\n\n# Open with consolidated metadata (faster, especially on cloud storage)\nroot = zarr.open_consolidated('data.zarr')\n```\n\n**Benefits**:\n- Reduces metadata read operations from N (one per array) to 1\n- Critical for cloud storage (reduces latency)\n- Speeds up `tree()` operations and group traversal\n\n**Cautions**:\n- Metadata can become stale if arrays update without re-consolidation\n- Not suitable for frequently-updated datasets\n- Multi-writer scenarios may have inconsistent reads\n\n## Performance Optimization\n\n### Checklist for Optimal Performance\n\n1. **Chunk Size**: Aim for 1-10 MB per chunk\n   ```python\n   # For float32: 1MB = 262,144 elements\n   chunks = (512, 512)  # 512×512×4 bytes = ~1MB\n   ```\n\n2. **Chunk Shape**: Align with access patterns\n   ```python\n   # Row-wise access → chunk spans columns: (small, large)\n   # Column-wise access → chunk spans rows: (large, small)\n   # Random access → balanced: (medium, medium)\n   ```\n\n3. **Compression**: Choose based on workload\n   ```python\n   # Interactive\u002Ffast: BloscCodec(cname='lz4')\n   # Balanced: BloscCodec(cname='zstd', clevel=5)\n   # Maximum compression: GzipCodec(level=9)\n   ```\n\n4. **Storage Backend**: Match to environment\n   ```python\n   # Local: LocalStore (default)\n   # Cloud: S3Map\u002FGCSMap with consolidated metadata\n   # Temporary: MemoryStore\n   ```\n\n5. **Sharding**: Use for large-scale datasets\n   ```python\n   # When you have millions of small chunks\n   shards=(10*chunk_size, 10*chunk_size)\n   ```\n\n6. **Parallel I\u002FO**: Use Dask for large operations\n   ```python\n   import dask.array as da\n   dask_array = da.from_zarr('data.zarr')\n   result = dask_array.compute(scheduler='threads', num_workers=8)\n   ```\n\n### Profiling and Debugging\n\n```python\n# Print detailed array information\nprint(z.info)\n\n# Output includes:\n# - Type, shape, chunks, dtype\n# - Compression codec and level\n# - Storage size (compressed vs uncompressed)\n# - Storage location\n\n# Check storage size\nprint(f\"Compressed size: {z.nbytes_stored \u002F 1e6:.2f} MB\")\nprint(f\"Uncompressed size: {z.nbytes \u002F 1e6:.2f} MB\")\nprint(f\"Compression ratio: {z.nbytes \u002F z.nbytes_stored:.2f}x\")\n```\n\n## Common Patterns and Best Practices\n\n### Pattern: Time Series Data\n\n```python\n# Store time series with time as first dimension\n# This allows efficient appending of new time steps\nz = zarr.open('timeseries.zarr', mode='a',\n              shape=(0, 720, 1440),  # Start with 0 time steps\n              chunks=(1, 720, 1440),  # One time step per chunk\n              dtype='f4')\n\n# Append new time steps\nnew_data = np.random.random((1, 720, 1440))\nz.append(new_data, axis=0)\n```\n\n### Pattern: Large Matrix Operations\n\n```python\nimport dask.array as da\n\n# Create large matrix in Zarr\nz = zarr.open('matrix.zarr', mode='w',\n              shape=(100000, 100000),\n              chunks=(1000, 1000),\n              dtype='f8')\n\n# Use Dask for parallel computation\ndask_z = da.from_zarr('matrix.zarr')\nresult = (dask_z @ dask_z.T).compute()  # Parallel matrix multiply\n```\n\n### Pattern: Cloud-Native Workflow\n\n```python\nimport s3fs\nimport zarr\n\n# Write to S3\ns3 = s3fs.S3FileSystem()\nstore = s3fs.S3Map(root='s3:\u002F\u002Fmy-bucket\u002Fdata.zarr', s3=s3)\n\n# Create array with appropriate chunking for cloud\nz = zarr.open_array(store=store, mode='w',\n                    shape=(10000, 10000),\n                    chunks=(500, 500),  # ~1MB chunks\n                    dtype='f4')\nz[:] = data\n\n# Consolidate metadata for faster reads\nzarr.consolidate_metadata(store)\n\n# Read from S3 (anywhere, anytime)\nstore_read = s3fs.S3Map(root='s3:\u002F\u002Fmy-bucket\u002Fdata.zarr', s3=s3)\nz_read = zarr.open_consolidated(store_read)\nsubset = z_read[0:100, 0:100]\n```\n\n### Pattern: Format Conversion\n\n```python\n# HDF5 to Zarr\nimport h5py\nimport zarr\n\nwith h5py.File('data.h5', 'r') as h5:\n    dataset = h5['dataset_name']\n    z = zarr.array(dataset[:],\n                   chunks=(1000, 1000),\n                   store='data.zarr')\n\n# NumPy to Zarr\nimport numpy as np\ndata = np.load('data.npy')\nz = zarr.array(data, chunks='auto', store='data.zarr')\n\n# Zarr to NetCDF (via Xarray)\nimport xarray as xr\nds = xr.open_zarr('data.zarr')\nds.to_netcdf('data.nc')\n```\n\n## Common Issues and Solutions\n\n### Issue: Slow Performance\n\n**Diagnosis**: Check chunk size and alignment\n```python\nprint(z.chunks)  # Are chunks appropriate size?\nprint(z.info)    # Check compression ratio\n```\n\n**Solutions**:\n- Increase chunk size to 1-10 MB\n- Align chunks with access pattern\n- Try different compression codecs\n- Use Dask for parallel operations\n\n### Issue: High Memory Usage\n\n**Cause**: Loading entire array or large chunks into memory\n\n**Solutions**:\n```python\n# Don't load entire array\n# Bad: data = z[:]\n# Good: Process in chunks\nfor i in range(0, z.shape[0], 1000):\n    chunk = z[i:i+1000, :]\n    process(chunk)\n\n# Or use Dask for automatic chunking\nimport dask.array as da\ndask_z = da.from_zarr('data.zarr')\nresult = dask_z.mean().compute()  # Processes in chunks\n```\n\n### Issue: Cloud Storage Latency\n\n**Solutions**:\n```python\n# 1. Consolidate metadata\nzarr.consolidate_metadata(store)\nz = zarr.open_consolidated(store)\n\n# 2. Use appropriate chunk sizes (5-100 MB for cloud)\nchunks = (2000, 2000)  # Larger chunks for cloud\n\n# 3. Enable sharding\nshards = (10000, 10000)  # Groups many chunks\n```\n\n### Issue: Concurrent Write Conflicts\n\n**Solution**: Use synchronizers or ensure non-overlapping writes\n```python\nfrom zarr import ProcessSynchronizer\n\nsync = ProcessSynchronizer('sync.sync')\nz = zarr.open_array('data.zarr', mode='r+', synchronizer=sync)\n\n# Or design workflow so each process writes to separate chunks\n```\n\n## Additional Resources\n\nFor detailed API documentation, advanced usage, and the latest updates:\n\n- **Official Documentation**: https:\u002F\u002Fzarr.readthedocs.io\u002F\n- **Zarr Specifications**: https:\u002F\u002Fzarr-specs.readthedocs.io\u002F\n- **GitHub Repository**: https:\u002F\u002Fgithub.com\u002Fzarr-developers\u002Fzarr-python\n- **Community Chat**: https:\u002F\u002Fgitter.im\u002Fzarr-developers\u002Fcommunity\n\n**Related Libraries**:\n- **Xarray**: https:\u002F\u002Fdocs.xarray.dev\u002F (labeled arrays)\n- **Dask**: https:\u002F\u002Fdocs.dask.org\u002F (parallel computing)\n- **NumCodecs**: https:\u002F\u002Fnumcodecs.readthedocs.io\u002F (compression codecs)\n",{"name":5,"description":7},"main","2b749c82b5d11fac39d9a6e021ce3f5b8a541bd1","cli-tool\u002Fcomponents\u002Fskills\u002Fscientific\u002Fzarr-python",3931,"https:\u002F\u002Fgithub.com\u002Fdavila7\u002Fclaude-code-templates","https:\u002F\u002Faitmpl.com","https:\u002F\u002Fgithub.com\u002Fdavila7","https:\u002F\u002Fdanielavila.me","Building AI dev tools with LLMs","2026-11-14 06:14:46",{"source":8,"skillName":5,"commands":53,"prompt":63,"zipAvailable":64},[54,57,60],{"tool":55,"command":56},"npx","npx skills add davila7\u002Fclaude-code-templates --skill zarr-python",{"tool":58,"command":59},"bunx","bunx skills add davila7\u002Fclaude-code-templates --skill zarr-python",{"tool":61,"command":62},"pnpm","pnpm dlx skills add davila7\u002Fclaude-code-templates --skill zarr-python","安装技能，技能地址：https:\u002F\u002Fgithub.com\u002Fdavila7\u002Fclaude-code-templates\u002Fblob\u002Fmain\u002Fcli-tool\u002Fcomponents\u002Fskills\u002Fscientific\u002Fzarr-python\u002FSKILL.md",true,[66,72,76],{"path":67,"resourceType":68,"resourceTypeDesc":69,"sizeBytes":70,"sourceHtmlUrl":71},"references\u002Fapi_reference.md","REFERENCE","参考文档",12538,"https:\u002F\u002Fgithub.com\u002Fdavila7\u002Fclaude-code-templates\u002Fblob\u002Fmain\u002Fcli-tool\u002Fcomponents\u002Fskills\u002Fscientific\u002Fzarr-python\u002Freferences\u002Fapi_reference.md",{"path":73,"resourceType":68,"resourceTypeDesc":69,"sizeBytes":74,"sourceHtmlUrl":75},"references\u002Fmcp-setup.md",3847,"https:\u002F\u002Fgithub.com\u002Fdavila7\u002Fclaude-code-templates\u002Fblob\u002Fmain\u002Fcli-tool\u002Fcomponents\u002Fskills\u002Fweb-data\u002Fbright-data-mcp\u002Freferences\u002Fmcp-setup.md",{"path":77,"resourceType":68,"resourceTypeDesc":69,"sizeBytes":78,"sourceHtmlUrl":79},"references\u002Fmcp-tools.md",8883,"https:\u002F\u002Fgithub.com\u002Fdavila7\u002Fclaude-code-templates\u002Fblob\u002Fmain\u002Fcli-tool\u002Fcomponents\u002Fskills\u002Fweb-data\u002Fbright-data-mcp\u002Freferences\u002Fmcp-tools.md",[81,112,139,172,207,231],{"skillNo":82,"name":83,"nameZh":6,"description":84,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":85,"categories":86,"keywords":92,"publishedAt":37},"01M70NHBTQ8BV0A2SCAZXEPHCX","wealthville-pool-scoring","Score DeFi liquidity pools before providing liquidity. Returns a 0-100 pool score and an Enter\u002FHold\u002FExit\u002FReduce\u002FAvoid verdict with calibrated confidence for ~68,800 Solana pools and 575 EVM pools, plus a public miss-inclusive track record. Use when asked whether a pool is worth LPing into, which pools look best right now, or how accurate the scores have actually been.","https:\u002F\u002Fgithub.com\u002Fdavila7\u002Fclaude-code-templates\u002Fblob\u002Fmain\u002Fcli-tool\u002Fcomponents\u002Fskills\u002Fweb-data\u002Fwealthville-pool-scoring\u002FSKILL.md",[87],{"categoryNo":88,"categoryName":89,"taxonomyType":90,"taxonomyTypeDesc":91},"01JBSEEDCAT000000000000023","Skill与智能体开发","SCENARIO","使用场景",[93,94,95,96,97,23,98,99,100,101,102,103,104,105,106,107,108,109,110,111],"scoring","pool","wealthville pool scoring","liquidity","which","exit","now","use","when","reduce","with","record","track","verdict","evm","solana","how","public","look",{"skillNo":113,"name":114,"nameZh":6,"description":115,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":116,"categories":117,"keywords":119,"publishedAt":37},"01M70MB6VR8ERJ4EM8D5KHBMEV","technical-debt-auditor","Scans a codebase and produces a quantified technical debt report with a prioritized remediation plan. Analyzes dead code, TODO\u002FFIXME\u002FHACK markers, dependency staleness, complexity hotspots, code duplication signals, test coverage gaps, unused exports, and outdated patterns. Use this skill when the user asks to audit their codebase for tech debt, wants a health check of their code quality, says things like \"where should I focus refactoring\", \"find code smells\", \"audit my codebase\", \"what technical debt do we have\", \"prioritize cleanup work\", or asks about code quality metrics. Also trigger when the user mentions \"code rot\", \"legacy cleanup\", \"refactoring priorities\", or wants to understand the overall health of a project before a major effort. Trigger even if the user doesn't say \"technical debt\" explicitly — any request to systematically assess code quality and identify improvement priorities belongs here.","https:\u002F\u002Fgithub.com\u002Fdavila7\u002Fclaude-code-templates\u002Fblob\u002Fmain\u002Fcli-tool\u002Fcomponents\u002Fskills\u002Fdevelopment\u002Ftechnical-debt-auditor\u002FSKILL.md",[118],{"categoryNo":88,"categoryName":89,"taxonomyType":90,"taxonomyTypeDesc":91},[120,121,122,123,124,125,126,127,128,129,130,101,131,132,133,134,135,136,137,138],"technical debt","debt","technical","technical debt auditor","auditor","coverage","complexity","markers","project","cleanup","unused","code","todo","work","plan","focus","signals","audit","dependency",{"skillNo":140,"name":141,"nameZh":6,"description":142,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":143,"categories":144,"keywords":154,"publishedAt":37},"01M70KPYH9QNHCNME5GJQGE22K","readonly-sql-guard","Make an agent's database access provably read-only. Use when an agent runs caller-supplied SQL against a production\u002FERP\u002Fanalytics database (a \"query\" MCP tool, text-to-SQL, an admin console), or when reviewing DB-access code for write\u002FDDL\u002Fside-effect\u002Ftransaction-escape risks. Checks what a statement CALLS, not just its shape.","https:\u002F\u002Fgithub.com\u002Fdavila7\u002Fclaude-code-templates\u002Fblob\u002Fmain\u002Fcli-tool\u002Fcomponents\u002Fskills\u002Fdatabase\u002Freadonly-sql-guard\u002FSKILL.md",[145,148,149],{"categoryNo":146,"categoryName":147,"taxonomyType":90,"taxonomyTypeDesc":91},"01JBSEEDCAT000000000000010","后端与接口",{"categoryNo":88,"categoryName":89,"taxonomyType":90,"taxonomyTypeDesc":91},{"categoryNo":150,"categoryName":151,"taxonomyType":152,"taxonomyTypeDesc":153},"01JBSEEDCAT000000000000033","数据分析师","PROFESSION","适用职业",[155,156,157,158,159,160,161,23,162,163,164,165,166,167,168,100,169,170,101,171],"readonly","guard","sql guard","sql","readonly sql guard","erp","effect","read-only","db","just","tool","calls","only","MCP","access","database","query",{"skillNo":173,"name":174,"nameZh":6,"description":175,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":176,"licenseFileUrl":177,"sourceHtmlUrl":178,"categories":179,"keywords":183,"publishedAt":37},"01M6AFY6F7CC2BBZP1QD6VTNVC","web-artifacts-builder","Suite of tools for creating elaborate, multi-component claude.ai HTML artifacts using modern frontend web technologies (React, Tailwind CSS, shadcn\u002Fui). Use for complex artifacts requiring state management, routing, or shadcn\u002Fui components - not for simple single-file HTML\u002FJSX artifacts.","Apache-2.0","https:\u002F\u002Fgithub.com\u002Fdavila7\u002Fclaude-code-templates\u002Fblob\u002Fmain\u002Fcli-tool\u002Fcomponents\u002Fskills\u002Futilities\u002Fweb-artifacts-builder\u002FLICENSE.txt","https:\u002F\u002Fgithub.com\u002Fdavila7\u002Fclaude-code-templates\u002Fblob\u002Fmain\u002Fcli-tool\u002Fcomponents\u002Fskills\u002Futilities\u002Fweb-artifacts-builder\u002FSKILL.md",[180],{"categoryNo":181,"categoryName":182,"taxonomyType":90,"taxonomyTypeDesc":91},"01JBSEEDCAT000000000000009","前端开发",[184,185,186,187,188,189,190,191,192,193,194,195,196,197,198,199,200,201,202,203,204,205,23,206],"artifacts builder","web","web artifacts builder","artifacts","builder","state","routing","state management","component","css","frontend","ui","Tools","file","components","shadcn","react","Tailwind","suite","jsx","html","single-file","ui components",{"skillNo":208,"name":209,"nameZh":6,"description":210,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":176,"licenseFileUrl":211,"sourceHtmlUrl":212,"categories":213,"keywords":218,"publishedAt":37},"01M6AFWF33SFV9Z3SF4PEEE4BF","webapp-testing","Toolkit for interacting with and testing local web applications using Playwright. Supports verifying frontend functionality, debugging UI behavior, capturing browser screenshots, and viewing browser logs.","https:\u002F\u002Fgithub.com\u002Fdavila7\u002Fclaude-code-templates\u002Fblob\u002Fmain\u002Fcli-tool\u002Fcomponents\u002Fskills\u002Fsecurity\u002Fwebapp-testing\u002FLICENSE.txt","https:\u002F\u002Fgithub.com\u002Fdavila7\u002Fclaude-code-templates\u002Fblob\u002Fmain\u002Fcli-tool\u002Fcomponents\u002Fskills\u002Fsecurity\u002Fwebapp-testing\u002FSKILL.md",[214,217],{"categoryNo":215,"categoryName":216,"taxonomyType":90,"taxonomyTypeDesc":91},"01JBSEEDCAT000000000000008","测试与质量",{"categoryNo":181,"categoryName":182,"taxonomyType":90,"taxonomyTypeDesc":91},[219,220,221,222,223,185,224,194,195,225,226,227,228,23,229,103,230],"webapp testing","testing","webapp","browser","playwright","applications","debugging","toolkit","logs","screenshots","local","behavior",{"skillNo":232,"name":233,"nameZh":6,"description":234,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":176,"licenseFileUrl":235,"sourceHtmlUrl":236,"categories":237,"keywords":245,"publishedAt":37},"01M6AF67Q67JJJ5V51JR2P52KA","discernment-nudge","After you give a substantive answer or draft that the user may act on — advice or recommendations, drafted artifacts such as goals, plans, pitches, proposals, or emails, estimates or projections, analysis or interpretation of data, factual claims they may rely on, or a multi-step argument — invoke this skill BEFORE finalizing your reply and then, if it applies, append 2-3 short follow-up questions, each tied to something specific in what you just produced, that help the user check key facts, probe the reasoning or assumptions, and notice missing context. Do this at most once per conversation. Skip it when the user asked a trivial how-to or simple lookup, wants a purely educational explanation, asked you only to format, convert, or assemble a file from content they provided, is writing code they will run, is doing creative writing or casual chat, or already asked you to double-check, cite, or review — the skill file explains these boundaries and the exact output format.","https:\u002F\u002Fgithub.com\u002Fdavila7\u002Fclaude-code-templates\u002Fblob\u002Fmain\u002Fcli-tool\u002Fcomponents\u002Fskills\u002Fproductivity\u002Fdiscernment-nudge\u002FLICENSE.txt","https:\u002F\u002Fgithub.com\u002Fdavila7\u002Fclaude-code-templates\u002Fblob\u002Fmain\u002Fcli-tool\u002Fcomponents\u002Fskills\u002Fproductivity\u002Fdiscernment-nudge\u002FSKILL.md",[238,241,242],{"categoryNo":239,"categoryName":240,"taxonomyType":90,"taxonomyTypeDesc":91},"01JBSEEDCAT000000000000018","写作与文案",{"categoryNo":88,"categoryName":89,"taxonomyType":90,"taxonomyTypeDesc":91},{"categoryNo":243,"categoryName":244,"taxonomyType":152,"taxonomyTypeDesc":153},"01JBSEEDCAT000000000000036","内容创作者",[246,247,248,249,250,251,252,253,187,254,197,131,255,256,257,258,259,167,260,101,261,262,263,264,265,109,266],"discernment nudge","nudge","interpretation","help","run","reasoning","data","writing","lookup","content","review","conversation","short","up","invoke","you","analysis","claims","argument","assemble","recommendations"]