[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"skill:01M6M0MVMAX3W88TSVKDBH8S00":3,"skill-same:01M6M0MVMAX3W88TSVKDBH8S00":70},{"skillNo":4,"name":5,"nameZh":6,"description":7,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":6,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":15,"categories":16,"keywords":17,"publishedAt":36,"linkOnly":37,"markdownContent":38,"markdownBody":39,"frontMatter":40,"refName":44,"commitSha":45,"skillDirectory":46,"forksCount":13,"repositoryHtmlUrl":47,"repositoryHomepageUrl":6,"ownerHtmlUrl":48,"ownerBlogUrl":6,"ownerDescription":6,"updatedAt":49,"install":50,"resources":63},"01M6M0MVMAX3W88TSVKDBH8S00","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.","endman100\u002Fskill-router-nexus","endman100","https:\u002F\u002Favatars.githubusercontent.com\u002Fu\u002F31997019?v=4","01M6KPDX17BYDWW4RRB0TNGGMX","01M6KPDX64Y2QBEWVFG5W5PWPF",0,"MIT","https:\u002F\u002Fgithub.com\u002Fendman100\u002Fskill-router-nexus\u002Fblob\u002Fmain\u002FScience\u002Fscientific-data-and-ml\u002Fzarr-python\u002FSKILL.md",[],[18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35],"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.\nlicense: MIT license\nmetadata:\n    skill-author: K-Dense Inc.\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\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\n",{"name":5,"license":41,"metadata":42,"description":7},"MIT license",{"skill-author":43},"K-Dense Inc.","main","f19b254e8975d0bfddb394686706106930d7964d","Science\u002Fscientific-data-and-ml\u002Fzarr-python","https:\u002F\u002Fgithub.com\u002Fendman100\u002Fskill-router-nexus","https:\u002F\u002Fgithub.com\u002Fendman100","2026-11-13 20:29:52",{"source":8,"skillName":5,"commands":51,"prompt":61,"zipAvailable":62},[52,55,58],{"tool":53,"command":54},"npx","npx skills add endman100\u002Fskill-router-nexus --skill zarr-python",{"tool":56,"command":57},"bunx","bunx skills add endman100\u002Fskill-router-nexus --skill zarr-python",{"tool":59,"command":60},"pnpm","pnpm dlx skills add endman100\u002Fskill-router-nexus --skill zarr-python","安装技能，技能地址：https:\u002F\u002Fgithub.com\u002Fendman100\u002Fskill-router-nexus\u002Fblob\u002Fmain\u002FScience\u002Fscientific-data-and-ml\u002Fzarr-python\u002FSKILL.md",true,[64],{"path":65,"resourceType":66,"resourceTypeDesc":67,"sizeBytes":68,"sourceHtmlUrl":69},"references\u002Fapi_reference.md","REFERENCE","参考文档",12538,"https:\u002F\u002Fgithub.com\u002Fendman100\u002Fskill-router-nexus\u002Fblob\u002Fmain\u002FScience\u002Fscientific-data-and-ml\u002Fzarr-python\u002Freferences\u002Fapi_reference.md",[71,95,132,155,164,188],{"skillNo":72,"name":73,"nameZh":6,"description":74,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":6,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":75,"sourceHtmlUrl":76,"categories":77,"keywords":83,"publishedAt":36},"01M6MPCT5BXVER8HQZTW3QE9AS","create-master","基于佛教经典文献，生成特定高僧大德的 AI 教学角色","https:\u002F\u002Fgithub.com\u002Fendman100\u002Fskill-router-nexus\u002Fblob\u002Fmain\u002FMetaphysics-and-Spirituality\u002FMaster-skill\u002FLICENSE","https:\u002F\u002Fgithub.com\u002Fendman100\u002Fskill-router-nexus\u002Fblob\u002Fmain\u002FMetaphysics-and-Spirituality\u002FMaster-skill\u002FSKILL.md",[78],{"categoryNo":79,"categoryName":80,"taxonomyType":81,"taxonomyTypeDesc":82},"01JBSEEDCAT000000000000039","教师与教育","PROFESSION","适用职业",[84,85,86,87,88,89,90,91,92,93,94],"create master","master","create","生成","true","webfetch","edit","write","read","grep","Bash",{"skillNo":96,"name":97,"nameZh":6,"description":98,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":6,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":99,"sourceHtmlUrl":100,"categories":101,"keywords":113,"publishedAt":36},"01M6M43AKE95Y64E1JRXEF5QQ3","writing-dna-skill","从至少 20 篇完整文章中蒸馏可复用的写作 DNA，分析语言、文章结构、选题逻辑、素材策略、认知框架和视觉风格，并生成 Writing-DNA.md；按该 DNA 写作时会读取全部蒸馏产物和 5 篇相关原文。用于中英文作者、账号、品牌或出版物的风格分析与一致性写作。 Distill reusable Writing DNA from at least 20 complete articles for Chinese or English authors, publications, brands, and accounts; use for language, structure, topic logic, source strategy, cognitive-frame, and visual-style analysis.","https:\u002F\u002Fgithub.com\u002Fendman100\u002Fskill-router-nexus\u002Fblob\u002Fmain\u002FWriting-and-Content\u002Fwriting-dna-skill\u002FLICENSE","https:\u002F\u002Fgithub.com\u002Fendman100\u002Fskill-router-nexus\u002Fblob\u002Fmain\u002FWriting-and-Content\u002Fwriting-dna-skill\u002FSKILL.md",[102,107,110],{"categoryNo":103,"categoryName":104,"taxonomyType":105,"taxonomyTypeDesc":106},"01JBSEEDCAT000000000000018","写作与文案","SCENARIO","使用场景",{"categoryNo":108,"categoryName":109,"taxonomyType":105,"taxonomyTypeDesc":106},"01JBSEEDCAT000000000000023","Skill与智能体开发",{"categoryNo":111,"categoryName":112,"taxonomyType":81,"taxonomyTypeDesc":82},"01JBSEEDCAT000000000000036","内容创作者",[114,115,116,117,118,119,120,121,122,123,124,125,126,87,127,128,129,22,130,131],"writing dna skill","DNA","writing","strategy","english","logic","visual","structure","chinese","reusable","use","style","distill","analysis","frame","source","at","complete",{"skillNo":133,"name":134,"nameZh":6,"description":135,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":6,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":136,"sourceHtmlUrl":137,"categories":138,"keywords":141,"publishedAt":36},"01M6M428TTCGQ4ME3KY99VN037","stop-slop","Remove AI writing patterns from prose. Use when drafting, editing, or reviewing text to eliminate predictable AI tells.","https:\u002F\u002Fgithub.com\u002Fendman100\u002Fskill-router-nexus\u002Fblob\u002Fmain\u002FWriting-and-Content\u002Fstop-slop\u002FLICENSE","https:\u002F\u002Fgithub.com\u002Fendman100\u002Fskill-router-nexus\u002Fblob\u002Fmain\u002FWriting-and-Content\u002Fstop-slop\u002FSKILL.md",[139,140],{"categoryNo":103,"categoryName":104,"taxonomyType":105,"taxonomyTypeDesc":106},{"categoryNo":111,"categoryName":112,"taxonomyType":81,"taxonomyTypeDesc":82},[142,143,144,145,146,147,148,149,150,124,151,152,153,22,154,116],"slop","stop slop","stop","drafting","when","drafts","https","patterns","prose","remove","editing","text","content",{"skillNo":156,"name":157,"nameZh":6,"description":158,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":6,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":159,"sourceHtmlUrl":160,"categories":161,"keywords":162,"publishedAt":36},"01M6M41X0B7EBX42TK435DMGGR","shuorenhua","检查和清理中英文文本里的 AI 套路，适用于“去 AI 味”“说人话”“自然一点”“别像模板”“先标问题”这类改写和审稿需求；按场景控制力度，同时保留事实、术语、语域和责任主体。","https:\u002F\u002Fgithub.com\u002Fendman100\u002Fskill-router-nexus\u002Fblob\u002Fmain\u002FWriting-and-Content\u002Fshuorenhua\u002FLICENSE","https:\u002F\u002Fgithub.com\u002Fendman100\u002Fskill-router-nexus\u002Fblob\u002Fmain\u002FWriting-and-Content\u002Fshuorenhua\u002FSKILL.md",[],[157,163],"文本",{"skillNo":165,"name":166,"nameZh":6,"description":167,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":6,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":168,"sourceHtmlUrl":169,"categories":170,"keywords":171,"publishedAt":36},"01M6M3ZD12WBEW5KXKDM4N6DFG","naming","Name products, SaaS, brands, open source projects, bots, and apps. Use when the user needs to name something, find a brand name, or pick a product name. Metaphor-driven process that produces memorable, meaningful names and avoids AI slop.","https:\u002F\u002Fgithub.com\u002Fendman100\u002Fskill-router-nexus\u002Fblob\u002Fmain\u002FWriting-and-Content\u002Fnaming-main\u002FLICENSE","https:\u002F\u002Fgithub.com\u002Fendman100\u002Fskill-router-nexus\u002Fblob\u002Fmain\u002FWriting-and-Content\u002Fnaming-main\u002FSKILL.md",[],[166,172,173,174,175,176,124,177,92,129,178,179,180,181,94,182,183,184,185,146,186,187,142],"repo","websearch","product name","apps","bots","view","brand","pick","gh","projects","open","saas","open source","product","describe","ai slop",{"skillNo":189,"name":190,"nameZh":6,"description":191,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":6,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":192,"sourceHtmlUrl":193,"categories":194,"keywords":196,"publishedAt":36},"01M6M3YVXAFAAWJ7F6JMPFREYE","humanizer-zh","去除文本中的 AI 生成痕迹。适用于编辑或审阅文本，使其听起来更自然、更像人类书写。\n基于维基百科的\"AI 写作特征\"综合指南。检测并修复以下模式：夸大的象征意义、\n宣传性语言、以 -ing 结尾的肤浅分析、模糊的归因、破折号过度使用、三段式法则、\nAI 词汇、否定式排比、过多的连接性短语。","https:\u002F\u002Fgithub.com\u002Fendman100\u002Fskill-router-nexus\u002Fblob\u002Fmain\u002FWriting-and-Content\u002Fhumanizer-zh\u002FLICENSE","https:\u002F\u002Fgithub.com\u002Fendman100\u002Fskill-router-nexus\u002Fblob\u002Fmain\u002FWriting-and-Content\u002Fhumanizer-zh\u002FSKILL.md",[195],{"categoryNo":103,"categoryName":104,"taxonomyType":105,"taxonomyTypeDesc":106},[197,198,199,92,91,90,116,87,163,200,142,144],"humanizer","zh","humanizer zh","翻译"]