diff --git a/.github/workflows/docs-preview-comment.yml b/.github/workflows/docs-preview-comment.yml index 32dcac4..e782c2f 100644 --- a/.github/workflows/docs-preview-comment.yml +++ b/.github/workflows/docs-preview-comment.yml @@ -85,7 +85,7 @@ jobs: run: | npm install -g surge - SURGE_DOMAIN="magg-pr-${{ needs.check-comment.outputs.pr_number }}.surge.sh" + SURGE_DOMAIN="zagg-pr-${{ needs.check-comment.outputs.pr_number }}.surge.sh" cd site surge . $SURGE_DOMAIN --token ${{ secrets.SURGE_TOKEN }} || { diff --git a/.github/workflows/docs.yml b/.github/workflows/docs.yml index fc791f5..d4b06dc 100644 --- a/.github/workflows/docs.yml +++ b/.github/workflows/docs.yml @@ -74,7 +74,7 @@ jobs: run: | npm install -g surge - SURGE_DOMAIN="magg-pr-${{ github.event.pull_request.number }}.surge.sh" + SURGE_DOMAIN="zagg-pr-${{ github.event.pull_request.number }}.surge.sh" cd docs-html surge . $SURGE_DOMAIN --token ${{ secrets.SURGE_TOKEN }} || { diff --git a/.github/workflows/lambda-build.yml b/.github/workflows/lambda-build.yml index 4f07a86..549efe8 100644 --- a/.github/workflows/lambda-build.yml +++ b/.github/workflows/lambda-build.yml @@ -4,13 +4,13 @@ on: push: branches: [lambda, main] paths: - - 'src/magg/**' + - 'src/zagg/**' - 'deployment/aws/**' - 'pyproject.toml' - '.github/workflows/lambda-build.yml' pull_request: paths: - - 'src/magg/**' + - 'src/zagg/**' - 'deployment/aws/**' - 'pyproject.toml' - '.github/workflows/lambda-build.yml' diff --git a/.github/workflows/publish.yml b/.github/workflows/publish.yml new file mode 100644 index 0000000..73d7ee5 --- /dev/null +++ b/.github/workflows/publish.yml @@ -0,0 +1,118 @@ +name: Publish + +on: + push: + tags: + - "*.*.*" + workflow_dispatch: + inputs: + tag: + description: 'Tag to publish' + required: true + type: string + +jobs: + test: + uses: ./.github/workflows/test.yml + + build: + name: Build distribution + needs: test + runs-on: ubuntu-latest + + steps: + - uses: actions/checkout@v4 + with: + ref: ${{ github.ref }} + fetch-depth: 0 + - name: Set up Python + uses: actions/setup-python@v5 + with: + python-version: "3.12" + - name: Install build + run: python3 -m pip install build --user + - name: Build sdist and wheel + run: python3 -m build + - name: Store distribution packages + uses: actions/upload-artifact@v4 + with: + name: python-package-distributions + path: dist/ + + publish-to-testpypi: + name: Publish to TestPyPI + needs: build + runs-on: ubuntu-latest + environment: + name: testpypi + url: https://test.pypi.org/p/zagg + permissions: + id-token: write + + steps: + - name: Download dists + uses: actions/download-artifact@v4 + with: + name: python-package-distributions + path: dist/ + - name: Publish to TestPyPI + uses: pypa/gh-action-pypi-publish@release/v1 + with: + repository-url: https://test.pypi.org/legacy/ + verbose: true + + publish-to-pypi: + name: Publish to PyPI + needs: publish-to-testpypi + runs-on: ubuntu-latest + environment: + name: pypi + url: https://pypi.org/p/zagg + permissions: + id-token: write + + steps: + - name: Download dists + uses: actions/download-artifact@v4 + with: + name: python-package-distributions + path: dist/ + - name: Publish to PyPI + uses: pypa/gh-action-pypi-publish@release/v1 + + github-release: + name: Create GitHub Release + needs: publish-to-pypi + runs-on: ubuntu-latest + permissions: + contents: write + + steps: + - uses: actions/checkout@v4 + with: + ref: main + fetch-depth: 0 + - name: Get tag name + id: get_tag + run: | + if [ "${{ github.event_name }}" = "workflow_dispatch" ]; then + echo "tag=${{ inputs.tag }}" >> $GITHUB_OUTPUT + else + echo "tag=${GITHUB_REF#refs/tags/}" >> $GITHUB_OUTPUT + fi + - name: Create GitHub Release + env: + GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} + run: | + TAG_NAME="${{ steps.get_tag.outputs.tag }}" + cat > release_notes.md < Dict[str, Any]: def _handle_setup(event: Dict[str, Any]) -> Dict[str, Any]: """Create the zarr template at ``event['store_path']``.""" - from magg.schema import xdggs_zarr_template + from zagg.schema import xdggs_zarr_template logger.info(f"Setup mode: creating template at {event.get('store_path')}") try: diff --git a/docs/api/auth.md b/docs/api/auth.md index 27a27ed..c408cbd 100644 --- a/docs/api/auth.md +++ b/docs/api/auth.md @@ -1,5 +1,5 @@ # Auth -Authentication helper for NASA Earthdata S3 access. Call [`get_nsidc_s3_credentials`][magg.auth.get_nsidc_s3_credentials] once in your orchestrator before invoking workers --- credentials are valid for approximately 1 hour. +Authentication helper for NASA Earthdata S3 access. Call [`get_nsidc_s3_credentials`][zagg.auth.get_nsidc_s3_credentials] once in your orchestrator before invoking workers --- credentials are valid for approximately 1 hour. -::: magg.auth.get_nsidc_s3_credentials +::: zagg.auth.get_nsidc_s3_credentials diff --git a/docs/api/catalog.md b/docs/api/catalog.md index bafd37c..982cf0a 100644 --- a/docs/api/catalog.md +++ b/docs/api/catalog.md @@ -8,17 +8,17 @@ The catalog CLI accepts date ranges, product names, and spatial polygons: ```bash # ICESat-2 convenience (cycle → date range): -python -m magg.catalog --cycle 22 --parent-order 6 +python -m zagg.catalog --cycle 22 --parent-order 6 # Explicit date range: -python -m magg.catalog --start-date 2024-01-06 --end-date 2024-04-07 --parent-order 6 +python -m zagg.catalog --start-date 2024-01-06 --end-date 2024-04-07 --parent-order 6 # Custom region via GeoJSON polygon: -python -m magg.catalog --start-date 2024-01-01 --end-date 2024-06-01 \ +python -m zagg.catalog --start-date 2024-01-01 --end-date 2024-06-01 \ --polygon my_region.geojson --parent-order 6 # Different product: -python -m magg.catalog --start-date 2024-01-01 --end-date 2024-06-01 \ +python -m zagg.catalog --start-date 2024-01-01 --end-date 2024-06-01 \ --short-name ATL08 --polygon my_region.geojson --parent-order 6 ``` @@ -31,28 +31,28 @@ When no polygon is given, Antarctic drainage basins are used as the default (sui ## Temporal Helpers -::: magg.catalog.cycle_to_dates +::: zagg.catalog.cycle_to_dates ## Spatial Helpers -::: magg.catalog.load_polygon +::: zagg.catalog.load_polygon -::: magg.catalog.polygon_to_bbox +::: zagg.catalog.polygon_to_bbox ## Cell Discovery -::: magg.catalog.load_antarctic_basins +::: zagg.catalog.load_antarctic_basins -::: magg.catalog.discover_cells +::: zagg.catalog.discover_cells ## CMR Query -::: magg.catalog.query_cmr +::: zagg.catalog.query_cmr ## Catalog Builder -::: magg.catalog.build_catalog +::: zagg.catalog.build_catalog ## Granule Parsing -::: magg.catalog.extract_granule_info +::: zagg.catalog.extract_granule_info diff --git a/docs/api/config.md b/docs/api/config.md index 2fe319f..4388a9b 100644 --- a/docs/api/config.md +++ b/docs/api/config.md @@ -1,37 +1,37 @@ # Config -The config module loads YAML pipeline configurations that define what data to read, how to aggregate it, and where to write output. See [configs/atl06.yaml](https://github.com/englacial/magg/blob/main/src/magg/configs/atl06.yaml) for the default configuration. +The config module loads YAML pipeline configurations that define what data to read, how to aggregate it, and where to write output. See [configs/atl06.yaml](https://github.com/englacial/zagg/blob/main/src/zagg/configs/atl06.yaml) for the default configuration. ## Loading -::: magg.config.load_config +::: zagg.config.load_config -::: magg.config.load_config_from_dict +::: zagg.config.load_config_from_dict -::: magg.config.default_config +::: zagg.config.default_config ## Validation -::: magg.config.validate_config +::: zagg.config.validate_config ## Function Resolution -::: magg.config.resolve_function +::: zagg.config.resolve_function -::: magg.config.evaluate_expression +::: zagg.config.evaluate_expression ## Accessors -::: magg.config.get_agg_fields +::: zagg.config.get_agg_fields -::: magg.config.get_coords +::: zagg.config.get_coords -::: magg.config.get_data_vars +::: zagg.config.get_data_vars -::: magg.config.get_child_order +::: zagg.config.get_child_order -::: magg.config.get_store_path +::: zagg.config.get_store_path ## Types -::: magg.config.PipelineConfig +::: zagg.config.PipelineConfig diff --git a/docs/api/processing.md b/docs/api/processing.md index 3586bb7..918a210 100644 --- a/docs/api/processing.md +++ b/docs/api/processing.md @@ -4,12 +4,12 @@ The processing module contains the core aggregation pipeline: reading HDF5 data ## Pipeline -::: magg.processing.process_morton_cell +::: zagg.processing.process_morton_cell ## Statistics -::: magg.processing.calculate_cell_statistics +::: zagg.processing.calculate_cell_statistics ## Zarr I/O -::: magg.processing.write_dataframe_to_zarr +::: zagg.processing.write_dataframe_to_zarr diff --git a/docs/api/schema.md b/docs/api/schema.md index b8ec34a..bd36e49 100644 --- a/docs/api/schema.md +++ b/docs/api/schema.md @@ -4,14 +4,14 @@ The schema module creates Zarr output templates from pipeline configuration. Col ## Zarr Template -::: magg.schema.xdggs_spec +::: zagg.schema.xdggs_spec -::: magg.schema.xdggs_zarr_template +::: zagg.schema.xdggs_zarr_template ## Types -::: magg.schema.ProcessingMetadata +::: zagg.schema.ProcessingMetadata ## Constants -::: magg.schema.HEALPIX_BASE_CELLS +::: zagg.schema.HEALPIX_BASE_CELLS diff --git a/docs/api/store.md b/docs/api/store.md index b0b3ba8..748558f 100644 --- a/docs/api/store.md +++ b/docs/api/store.md @@ -4,8 +4,8 @@ The store module provides a factory for opening Zarr stores from path strings. P ## Factory -::: magg.store.open_store +::: zagg.store.open_store ## Helpers -::: magg.store.parse_s3_path +::: zagg.store.parse_s3_path diff --git a/docs/deployment/arm64.md b/docs/deployment/arm64.md index dca6e02..fba3620 100644 --- a/docs/deployment/arm64.md +++ b/docs/deployment/arm64.md @@ -60,8 +60,8 @@ aws s3 cp deployment/layers/lambda_layer_arm64.zip s3://your-bucket/layers/ # Create/update layer aws lambda publish-layer-version \ - --layer-name magg-layer-arm64 \ - --description "magg dependencies for ARM64/Graviton2" \ + --layer-name zagg-layer-arm64 \ + --description "zagg dependencies for ARM64/Graviton2" \ --content S3Bucket=your-bucket,S3Key=layers/lambda_layer_arm64.zip \ --compatible-runtimes python3.12 \ --compatible-architectures arm64 diff --git a/docs/deployment/lambda.md b/docs/deployment/lambda.md index 530b09d..c74ef34 100644 --- a/docs/deployment/lambda.md +++ b/docs/deployment/lambda.md @@ -23,7 +23,7 @@ The Lambda function processes a single morton cell (order 6) by: │ ────────────────────────────────────────────────────────── │ │ Code (~5 MB): │ │ - deployment/aws/lambda_handler.py (AWS wrapper) │ -│ - src/magg/ package (processing, auth, catalog) │ +│ - src/zagg/ package (processing, auth, catalog) │ │ ────────────────────────────────────────────────────────── │ │ Layer (~70 MB compressed, ~240 MB uncompressed): │ │ - numpy, pandas, h5coro, mortie, healpy │ @@ -37,9 +37,9 @@ The Lambda function processes a single morton cell (order 6) by: | File | Purpose | |------|---------| | `deployment/aws/lambda_handler.py` | AWS Lambda wrapper function | -| `src/magg/processing.py` | Cloud-agnostic core processing logic | -| `src/magg/auth.py` | NASA Earthdata authentication helper | -| `src/magg/catalog.py` | CMR granule catalog builder | +| `src/zagg/processing.py` | Cloud-agnostic core processing logic | +| `src/zagg/auth.py` | NASA Earthdata authentication helper | +| `src/zagg/catalog.py` | CMR granule catalog builder | | `deployment/aws/invoke_lambda.py` | Orchestration script | | `deployment/aws/build_arm64_layer.sh` | ARM64 Lambda layer build script | @@ -79,7 +79,7 @@ The Lambda function processes a single morton cell (order 6) by: Credentials are obtained by the orchestrator once before invoking Lambda functions: ```python -from magg.auth import get_nsidc_s3_credentials +from zagg.auth import get_nsidc_s3_credentials # Get credentials (valid for ~1 hour) s3_creds = get_nsidc_s3_credentials() @@ -102,11 +102,11 @@ This approach avoids rate limiting from 1,872 simultaneous NASA logins and elimi ### Step 1: Create the function package ```bash -cd /path/to/magg +cd /path/to/zagg -# Create function.zip with handler and magg package +# Create function.zip with handler and zagg package zip -j deployment/aws/function.zip deployment/aws/lambda_handler.py && \ - cd src && zip -ur ../deployment/aws/function.zip magg/ -i "*.py" && cd .. + cd src && zip -ur ../deployment/aws/function.zip zagg/ -i "*.py" && cd .. ``` ### Step 2: Build and deploy the Lambda layer @@ -125,7 +125,7 @@ aws lambda create-function \ --zip-file fileb://deployment/aws/function.zip \ --timeout 720 \ --memory-size 2048 \ - --layers arn:aws:lambda:REGION:ACCOUNT_ID:layer:magg-layer-arm64:VERSION + --layers arn:aws:lambda:REGION:ACCOUNT_ID:layer:zagg-layer-arm64:VERSION ``` ### Updating function code @@ -133,7 +133,7 @@ aws lambda create-function \ ```bash # Re-create the zip zip -j deployment/aws/function.zip deployment/aws/lambda_handler.py && \ - cd src && zip -ur ../deployment/aws/function.zip magg/ -i "*.py" && cd .. + cd src && zip -ur ../deployment/aws/function.zip zagg/ -i "*.py" && cd .. # Update the Lambda function aws lambda update-function-code \ @@ -145,10 +145,10 @@ aws lambda update-function-code \ ```bash # Build a granule catalog -uv run python -m magg.catalog --cycle 22 --parent-order 6 +uv run python -m zagg.catalog --cycle 22 --parent-order 6 # Test locally first (no Lambda required) -uv run python -m magg --config atl06.yaml --catalog catalog.json \ +uv run python -m zagg --config atl06.yaml --catalog catalog.json \ --store ./test.zarr --max-cells 1 # Dry run with the Lambda orchestrator @@ -176,7 +176,7 @@ uv run python deployment/aws/invoke_lambda.py \ ## Troubleshooting !!! warning "Missing s3_credentials" - Ensure your orchestrator script calls [`get_nsidc_s3_credentials`][magg.auth.get_nsidc_s3_credentials] and passes the credentials to each Lambda invocation. + Ensure your orchestrator script calls [`get_nsidc_s3_credentials`][zagg.auth.get_nsidc_s3_credentials] and passes the credentials to each Lambda invocation. !!! info "No granules found" This is normal for cells outside the data coverage area. The function returns gracefully with `error: "No granules found"`. diff --git a/docs/design/architecture.md b/docs/design/architecture.md index ba38f21..d12fa22 100644 --- a/docs/design/architecture.md +++ b/docs/design/architecture.md @@ -12,7 +12,7 @@ When casting point data (ATL06, OPR, etc) to a grid, we encounter two issues: 1. **Too dense** --- multiple points per cell 2. **Too sparse** --- no points for many cells -The sparsity is annoying but workable. The density is the real problem: xarray doesn't handle collisions natively, so we must define what to do with overlapping observations. Hence the "agg" in magg. +The sparsity is annoying but workable. The density is the real problem: xarray doesn't handle collisions natively, so we must define what to do with overlapping observations. Hence the "agg" in zagg. ## Prior Art @@ -248,6 +248,6 @@ Target coverage: ~1,300 cells covering Antarctic grounded ice drainage basins (e ## Output Format -Results are written to a [Zarr v3](https://zarr-specs.readthedocs.io/en/latest/v3/core/v3.0.html) store following the [DGGS convention](https://github.com/zarr-conventions/dggs). The template is generated by [`xdggs_zarr_template`][magg.schema.xdggs_zarr_template] from the pipeline config, with one chunk per parent shard cell. +Results are written to a [Zarr v3](https://zarr-specs.readthedocs.io/en/latest/v3/core/v3.0.html) store following the [DGGS convention](https://github.com/zarr-conventions/dggs). The template is generated by [`xdggs_zarr_template`][zagg.schema.xdggs_zarr_template] from the pipeline config, with one chunk per parent shard cell. See [Schema](schema.md) for details on the output schema and aggregation dispatch. diff --git a/docs/design/schema.md b/docs/design/schema.md index 8f61d52..184098b 100644 --- a/docs/design/schema.md +++ b/docs/design/schema.md @@ -6,7 +6,7 @@ The YAML pipeline config (`configs/atl06.yaml`) is the single source of truth fo - **Column definitions and types** --- coordinate columns (`cell_ids`, `morton`) and data variables (`count`, `h_mean`, etc.) - **Aggregation recipes** --- each data variable specifies a `function` (resolved via `resolve_function()`) or an `expression` (evaluated at runtime), plus `source` column and `params` -- **Zarr array configuration** --- dtype and fill value per column, used by [`xdggs_spec`][magg.schema.xdggs_spec] to generate the Zarr template +- **Zarr array configuration** --- dtype and fill value per column, used by [`xdggs_spec`][zagg.schema.xdggs_spec] to generate the Zarr template Coordinate and data variable column names are derived from the config via `get_coords()` and `get_data_vars()`, not hardcoded. @@ -27,7 +27,7 @@ Each variable in `aggregation.variables` carries metadata describing its behavio ## Aggregation Dispatch -[`calculate_cell_statistics`][magg.processing.calculate_cell_statistics] is config-driven: it iterates the aggregation variable metadata and dispatches via `resolve_function()` (for `function`-based fields) or `evaluate_expression()` (for `expression`-based fields). +[`calculate_cell_statistics`][zagg.processing.calculate_cell_statistics] is config-driven: it iterates the aggregation variable metadata and dispatches via `resolve_function()` (for `function`-based fields) or `evaluate_expression()` (for `expression`-based fields). Available aggregation functions (via numpy or dotted import paths): diff --git a/docs/index.md b/docs/index.md index 543e478..8cb98b0 100644 --- a/docs/index.md +++ b/docs/index.md @@ -1,10 +1,10 @@ -# magg +# zagg Multi-resolution aggregation for point observations using morton/healpix indexing. ## Overview -`magg` aggregates sparse point data (e.g., ICESat-2 ATL06 elevation measurements) into gridded products using HEALPix/morton spatial indexing. It is designed for massively parallel execution on commodity cloud workers (e.g., AWS Lambda), producing [Zarr v3](https://zarr-specs.readthedocs.io/en/latest/v3/core/v3.0.html) output following the [DGGS convention](https://github.com/zarr-conventions/dggs). +`zagg` aggregates sparse point data (e.g., ICESat-2 ATL06 elevation measurements) into gridded products using HEALPix/morton spatial indexing. It is designed for massively parallel execution on commodity cloud workers (e.g., AWS Lambda), producing [Zarr v3](https://zarr-specs.readthedocs.io/en/latest/v3/core/v3.0.html) output following the [DGGS convention](https://github.com/zarr-conventions/dggs). Spatial filtering happens at two levels: a **bounding box** narrows the CMR granule query (which granule files to fetch), while a **polygon** controls @@ -13,12 +13,12 @@ omitting them defaults to all Antarctic drainage basins. The library is organized into six modules: -- **`magg.config`**: YAML-driven pipeline configuration — data source, aggregation, output grid, and optional store/catalog/bounds -- **`magg.store`**: Store factory — opens local or S3 Zarr stores from path strings (`./output.zarr` or `s3://bucket/prefix`) -- **`magg.catalog`**: CMR granule catalog builder — queries NASA CMR with date ranges, product names, and spatial polygons, then maps parent morton cells to S3 granule URLs -- **`magg.schema`**: Zarr template creation from pipeline configuration -- **`magg.processing`**: Core aggregation pipeline — reading HDF5, spatial filtering, statistics calculation, and Zarr writing -- **`magg.auth`**: NASA Earthdata authentication for S3 access to NSIDC data +- **`zagg.config`**: YAML-driven pipeline configuration — data source, aggregation, output grid, and optional store/catalog/bounds +- **`zagg.store`**: Store factory — opens local or S3 Zarr stores from path strings (`./output.zarr` or `s3://bucket/prefix`) +- **`zagg.catalog`**: CMR granule catalog builder — queries NASA CMR with date ranges, product names, and spatial polygons, then maps parent morton cells to S3 granule URLs +- **`zagg.schema`**: Zarr template creation from pipeline configuration +- **`zagg.processing`**: Core aggregation pipeline — reading HDF5, spatial filtering, statistics calculation, and Zarr writing +- **`zagg.auth`**: NASA Earthdata authentication for S3 access to NSIDC data ## End-to-End Workflow @@ -26,15 +26,15 @@ The library is organized into six modules: ```bash # ICESat-2 cycle (convenience): -uv run python -m magg.catalog --cycle 22 --parent-order 6 +uv run python -m zagg.catalog --cycle 22 --parent-order 6 # Date range, bbox-filtered to everything south of 60°S: -uv run python -m magg.catalog \ +uv run python -m zagg.catalog \ --start-date 2024-01-06 --end-date 2024-04-07 \ --bbox -180,-90,180,-60 --parent-order 6 # Custom region via GeoJSON polygon: -uv run python -m magg.catalog \ +uv run python -m zagg.catalog \ --start-date 2024-01-01 --end-date 2024-06-01 \ --polygon my_region.geojson --parent-order 6 ``` @@ -45,7 +45,7 @@ See [Catalog API](api/catalog.md) for full options. ```bash # Local processing: -uv run python -m magg --config atl06.yaml --catalog catalog.json --store ./output.zarr +uv run python -m zagg --config atl06.yaml --catalog catalog.json --store ./output.zarr # Lambda dispatch: uv run python deployment/aws/invoke_lambda.py --config atl06.yaml --catalog catalog.json @@ -68,9 +68,9 @@ uv run jupyter notebook notebooks/rasterized_zarr.ipynb ## Quick example ```python -from magg import default_config, get_child_order, open_store -from magg.processing import process_morton_cell, write_dataframe_to_zarr -from magg.auth import get_nsidc_s3_credentials +from zagg import default_config, get_child_order, open_store +from zagg.processing import process_morton_cell, write_dataframe_to_zarr +from zagg.auth import get_nsidc_s3_credentials config = default_config("atl06") child_order = get_child_order(config) # 12 @@ -94,10 +94,10 @@ write_dataframe_to_zarr(df_out, store, chunk_idx=0, ## Contributing -1. Clone the repository: `git clone https://github.com/englacial/magg.git` +1. Clone the repository: `git clone https://github.com/englacial/zagg.git` 2. Install development dependencies: `uv sync --all-groups` 3. Run the test suite: `uv run pytest` ## License -`magg` is distributed under the terms of the [MIT](https://spdx.org/licenses/MIT.html) license. +`zagg` is distributed under the terms of the [MIT](https://spdx.org/licenses/MIT.html) license. diff --git a/docs/quickstart.md b/docs/quickstart.md index 711d50c..e1db29e 100644 --- a/docs/quickstart.md +++ b/docs/quickstart.md @@ -1,6 +1,6 @@ # Quickstart -Zero-to-working setup for `magg`. +Zero-to-working setup for `zagg`. ## Prerequisites @@ -12,14 +12,14 @@ Zero-to-working setup for `magg`. ## Installation ```bash -git clone https://github.com/englacial/magg.git -cd magg +git clone https://github.com/englacial/zagg.git +cd zagg uv sync --all-groups ``` ## NASA Earthdata Authentication -`magg` reads ICESat-2 ATL06 data from NSIDC's S3 buckets in AWS `us-west-2`. +`zagg` reads ICESat-2 ATL06 data from NSIDC's S3 buckets in AWS `us-west-2`. This requires NASA Earthdata credentials. Three methods, in order of precedence: **1. Environment variables** @@ -53,7 +53,7 @@ The catalog step queries NASA's CMR API (public, no auth needed) and builds a morton-cell-to-granule mapping: ```bash -uv run python -m magg.catalog --cycle 22 --parent-order 6 +uv run python -m zagg.catalog --cycle 22 --parent-order 6 ``` This produces a JSON file (e.g., `catalog_ATL06_cycle22_order6.json`) that maps @@ -66,12 +66,12 @@ The simplest path -- no AWS Lambda needed: ```bash # Process one cell, write to local Zarr: -uv run python -m magg --config src/magg/configs/atl06.yaml \ +uv run python -m zagg --config src/zagg/configs/atl06.yaml \ --catalog catalog_ATL06_cycle22_order6.json \ --store ./output.zarr --max-cells 1 # Dry run (shows what would happen, no processing): -uv run python -m magg --config src/magg/configs/atl06.yaml \ +uv run python -m zagg --config src/zagg/configs/atl06.yaml \ --catalog catalog_ATL06_cycle22_order6.json --dry-run ``` @@ -80,7 +80,7 @@ uv run python -m magg --config src/magg/configs/atl06.yaml \ To write output to S3, set the store path to an S3 URI: ```bash -uv run python -m magg --config src/magg/configs/atl06.yaml \ +uv run python -m zagg --config src/zagg/configs/atl06.yaml \ --catalog catalog_ATL06_cycle22_order6.json \ --store s3://my-bucket/output.zarr ``` @@ -93,7 +93,7 @@ This requires AWS credentials configured via one of: ## Lambda Deployment (Optional) -For full-scale processing, `magg` dispatches work to AWS Lambda. See +For full-scale processing, `zagg` dispatches work to AWS Lambda. See [Lambda Deployment](deployment/lambda.md) for details. The short version: 1. **AWS prerequisites**: IAM role with S3 + Lambda permissions, S3 bucket for output @@ -105,7 +105,7 @@ python deployment/aws/invoke_lambda.py --config atl06.yaml --catalog catalog.jso ``` The function name defaults to `process-morton-cell` but is configurable via -the `MAGG_LAMBDA_FUNCTION_NAME` environment variable. +the `ZAGG_LAMBDA_FUNCTION_NAME` environment variable. ## Configuration @@ -144,6 +144,6 @@ catalog: catalog_ATL06_cycle22_order6.json store: ./output.zarr ``` -See `src/magg/configs/atl06.yaml` for a complete example and the -[custom aggregations notebook](https://github.com/englacial/magg/blob/main/notebooks/custom_aggregations.ipynb) +See `src/zagg/configs/atl06.yaml` for a complete example and the +[custom aggregations notebook](https://github.com/englacial/zagg/blob/main/notebooks/custom_aggregations.ipynb) for customization examples. diff --git a/mkdocs.yml b/mkdocs.yml index 817a0fa..ac285fa 100644 --- a/mkdocs.yml +++ b/mkdocs.yml @@ -1,6 +1,6 @@ -site_name: magg -repo_name: englacial/magg -repo_url: https://github.com/englacial/magg +site_name: zagg +repo_name: englacial/zagg +repo_url: https://github.com/englacial/zagg site_description: Multi-resolution aggregation for ICESat-2 ATL06 data using morton/healpix indexing. site_author: Shane Grisby docs_dir: docs @@ -28,7 +28,7 @@ nav: - "ARM64 Layer": "deployment/arm64.md" watch: - - src/magg + - src/zagg - docs theme: @@ -79,7 +79,7 @@ plugins: enable_inventory: true handlers: python: - paths: [src/magg] + paths: [src/zagg] options: allow_inspection: true docstring_section_style: list diff --git a/notebooks/cryocloud_example.ipynb b/notebooks/cryocloud_example.ipynb index 607bbea..7359932 100644 --- a/notebooks/cryocloud_example.ipynb +++ b/notebooks/cryocloud_example.ipynb @@ -4,11 +4,11 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# magg on CryoCloud: end-to-end example\n", + "# zagg on CryoCloud: end-to-end example\n", "\n", - "This notebook demonstrates running the [`magg`](https://github.com/englacial/xagg) library on CryoCloud, including:\n", + "This notebook demonstrates running the [`zagg`](https://github.com/englacial/xagg) library on CryoCloud, including:\n", "\n", - "1. **Installing** `magg` and its dependencies into the CryoCloud user environment\n", + "1. **Installing** `zagg` and its dependencies into the CryoCloud user environment\n", "2. **Reading ISMIP6 data** from a virtualizarr / icechunk repository (single variable, DataTree, and inter-model variance with a time slider)\n", "3. **Local processing** of ICESat-2 ATL06 data with a custom aggregation\n", "4. **Lambda processing** of the full ATL06 dataset against an AWS Lambda function in account `429435741471`\n", @@ -21,11 +21,11 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## 0. Install magg and configure the Lambda target\n", + "## 0. Install zagg and configure the Lambda target\n", "\n", - "On CryoCloud, the bare function name `process-morton-cell` would resolve in CryoCloud's own AWS account (574251165169) and fail with `AccessDeniedException`. We point boto3 at the full cross-account ARN via the `MAGG_LAMBDA_FUNCTION_NAME` env var that `magg.runner` reads.\n", + "On CryoCloud, the bare function name `process-morton-cell` would resolve in CryoCloud's own AWS account (574251165169) and fail with `AccessDeniedException`. We point boto3 at the full cross-account ARN via the `ZAGG_LAMBDA_FUNCTION_NAME` env var that `zagg.runner` reads.\n", "\n", - "Lambda output is written to the public `xagg` bucket in the magg owner's account -- the function's execution role already has write permission there, and the result stays colocated with the code that produced it." + "Lambda output is written to the public `xagg` bucket in the zagg owner's account -- the function's execution role already has write permission there, and the result stays colocated with the code that produced it." ] }, { @@ -34,7 +34,7 @@ "metadata": {}, "outputs": [], "source": [ - "%pip install --quiet 'magg[analysis] @ git+https://github.com/englacial/xagg.git'\n", + "%pip install --quiet 'zagg[analysis] @ git+https://github.com/englacial/xagg.git'\n", "%pip install --quiet icechunk 'cubed-xarray>=0.0.9' hvplot" ] }, @@ -47,11 +47,11 @@ "import logging\n", "import os\n", "\n", - "# Show INFO-level magg messages (per-cell progress, summary lines).\n", + "# Show INFO-level zagg messages (per-cell progress, summary lines).\n", "# Without this, only WARNING+ surfaces and runs look silent.\n", "logging.basicConfig(level=logging.INFO, format='%(message)s')\n", "\n", - "os.environ['MAGG_LAMBDA_FUNCTION_NAME'] = (\n", + "os.environ['ZAGG_LAMBDA_FUNCTION_NAME'] = (\n", " 'arn:aws:lambda:us-west-2:429435741471:function:process-morton-cell'\n", ")\n", "os.environ.setdefault('AWS_DEFAULT_REGION', 'us-west-2')\n", @@ -291,7 +291,7 @@ "source": [ "# Generate catalog: ICESat-2 ATL06, cycle 22, parent morton order 6\n", "# Output: catalog_ATL06_cycle22_order6.json in the cwd\n", - "!python -m magg.catalog --cycle 22 --parent-order 6" + "!python -m zagg.catalog --cycle 22 --parent-order 6" ] }, { @@ -301,8 +301,8 @@ "outputs": [], "source": [ "import yaml\n", - "from magg import agg\n", - "from magg.config import load_config_from_dict, get_agg_fields\n", + "from zagg import agg\n", + "from zagg.config import load_config_from_dict, get_agg_fields\n", "\n", "custom_yaml = \"\"\"\n", "data_source:\n", @@ -374,7 +374,7 @@ "\n", "With the pipeline validated, we now use the default `atl06` config (which produces the richer set of variables expected by the existing rasterized output) and dispatch every parent cell in the catalog to the Lambda function. The function runs in *your* AWS account (`429435741471`), so all compute and S3 PUT charges bill there -- not to CryoCloud.\n", "\n", - "Output is written to `s3://xagg/...`. The Lambda's execution role (`magg-lambda-execution`) is already scoped to that bucket, so writes work without any cross-account bucket-policy work.\n", + "Output is written to `s3://xagg/...`. The Lambda's execution role (`zagg-lambda-execution`) is already scoped to that bucket, so writes work without any cross-account bucket-policy work.\n", "\n", "The IRSA role `nasa-cryo-prod` was granted `lambda:InvokeFunction` on the function ARN via the merged 2i2c PR; the Lambda's resource-based policy was extended to trust that role via `aws lambda add-permission`." ] @@ -385,7 +385,7 @@ "metadata": {}, "outputs": [], "source": [ - "from magg import default_config\n", + "from zagg import default_config\n", "\n", "cfg_full = default_config('atl06')\n", "\n", diff --git a/notebooks/custom_aggregations.ipynb b/notebooks/custom_aggregations.ipynb index 344d0fa..1e4da69 100644 --- a/notebooks/custom_aggregations.ipynb +++ b/notebooks/custom_aggregations.ipynb @@ -5,7 +5,7 @@ "id": "intro-md", "metadata": {}, "source": [ - "# Customizing Aggregations in magg\n", + "# Customizing Aggregations in zagg\n", "\n", "The aggregation pipeline is driven by a single YAML config file with three\n", "required sections, plus optional fields:\n", @@ -51,13 +51,13 @@ "name": "stdout", "output_type": "stream", "text": [ - "\n", + "\n", "Sections: data_source, aggregation, output\n" ] } ], "source": [ - "from magg.config import default_config\n", + "from zagg.config import default_config\n", "\n", "cfg = default_config()\n", "print(type(cfg))\n", @@ -241,7 +241,7 @@ "source": [ "### The YAML source\n", "\n", - "The config above comes from `src/magg/configs/atl06.yaml`. Here is its\n", + "The config above comes from `src/zagg/configs/atl06.yaml`. Here is its\n", "content verbatim:" ] }, @@ -333,9 +333,9 @@ ], "source": [ "from importlib import resources\n", - "import magg.configs\n", + "import zagg.configs\n", "\n", - "yaml_text = resources.files(magg.configs).joinpath(\"atl06.yaml\").read_text()\n", + "yaml_text = resources.files(zagg.configs).joinpath(\"atl06.yaml\").read_text()\n", "print(yaml_text)" ] }, @@ -373,7 +373,7 @@ } ], "source": [ - "from magg.config import resolve_function\n", + "from zagg.config import resolve_function\n", "import numpy as np\n", "\n", "for name in [\"len\", \"min\", \"max\", \"average\", \"var\", \"quantile\", \"np.median\"]:\n", @@ -421,7 +421,7 @@ ], "source": [ "import numpy as np\n", - "from magg.config import evaluate_expression\n", + "from zagg.config import evaluate_expression\n", "\n", "columns = {\n", " \"h_li\": np.array([120.5, 118.3, 122.1, 119.7, 121.0], dtype=np.float32),\n", @@ -476,7 +476,7 @@ ], "source": [ "import pandas as pd\n", - "from magg.processing import calculate_cell_statistics\n", + "from zagg.processing import calculate_cell_statistics\n", "\n", "# Five synthetic ICESat-2 observations: elevation (h_li) and uncertainty (s_li)\n", "df = pd.DataFrame({\n", @@ -540,7 +540,7 @@ ], "source": [ "import yaml\n", - "from magg.config import load_config_from_dict, validate_config, get_agg_fields\n", + "from zagg.config import load_config_from_dict, validate_config, get_agg_fields\n", "\n", "simple_yaml = \"\"\"\n", "data_source:\n", @@ -658,7 +658,7 @@ } ], "source": [ - "from magg.schema import xdggs_spec\n", + "from zagg.schema import xdggs_spec\n", "\n", "# Default config -> 9 data vars + 2 coords = 11 arrays\n", "spec_default = xdggs_spec(parent_order=6, child_order=12)\n", diff --git a/notebooks/jupyterhub_example.ipynb b/notebooks/jupyterhub_example.ipynb index ba2c0f1..29d20d3 100644 --- a/notebooks/jupyterhub_example.ipynb +++ b/notebooks/jupyterhub_example.ipynb @@ -5,9 +5,9 @@ "id": "intro", "metadata": {}, "source": [ - "# Running magg from a JupyterHub\n", + "# Running zagg from a JupyterHub\n", "\n", - "This notebook demonstrates how to use the `magg` Python API from a Jupyter\n", + "This notebook demonstrates how to use the `zagg` Python API from a Jupyter\n", "notebook, covering two deployment scenarios:\n", "\n", "1. **Local processing** -- no AWS Lambda needed, runs on the hub itself\n", @@ -23,7 +23,7 @@ "source": [ "## 1. Authentication\n", "\n", - "magg needs two sets of credentials:\n", + "zagg needs two sets of credentials:\n", "\n", "- **NASA Earthdata** -- for reading source data (ICESat-2 HDF5 on NSIDC S3)\n", "- **AWS** (optional) -- for writing output to S3 or invoking Lambda\n", @@ -102,7 +102,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "/home/espg/software/magg_deployment/.venv/lib64/python3.13/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", + "/home/espg/software/zagg_deployment/.venv/lib64/python3.13/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", " from .autonotebook import tqdm as notebook_tqdm\n" ] }, @@ -118,7 +118,7 @@ } ], "source": [ - "from magg import default_config, get_child_order\n", + "from zagg import default_config, get_child_order\n", "\n", "config = default_config(\"atl06\")\n", "\n", @@ -270,7 +270,7 @@ ], "source": [ "# Option A: Build a catalog (queries NASA CMR, takes ~30s)\n", - "!uv run python -m magg.catalog --cycle 22 --parent-order 6" + "!uv run python -m zagg.catalog --cycle 22 --parent-order 6" ] }, { @@ -350,7 +350,7 @@ } ], "source": [ - "from magg import agg\n", + "from zagg import agg\n", "\n", "# Dry run -- preview without processing\n", "preview = agg(\n", @@ -513,7 +513,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "/home/espg/software/magg_deployment/.venv/lib64/python3.13/site-packages/zarr/api/asynchronous.py:247: ZarrUserWarning: Consolidated metadata is currently not part in the Zarr format 3 specification. It may not be supported by other zarr implementations and may change in the future.\n", + "/home/espg/software/zagg_deployment/.venv/lib64/python3.13/site-packages/zarr/api/asynchronous.py:247: ZarrUserWarning: Consolidated metadata is currently not part in the Zarr format 3 specification. It may not be supported by other zarr implementations and may change in the future.\n", " warnings.warn(\n", "Done: 2 cells, 167,846 obs, 0 errors, 214.2s\n" ] @@ -627,7 +627,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -727,7 +727,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "/home/espg/software/magg_deployment/.venv/lib64/python3.13/site-packages/zarr/api/asynchronous.py:247: ZarrUserWarning: Consolidated metadata is currently not part in the Zarr format 3 specification. It may not be supported by other zarr implementations and may change in the future.\n", + "/home/espg/software/zagg_deployment/.venv/lib64/python3.13/site-packages/zarr/api/asynchronous.py:247: ZarrUserWarning: Consolidated metadata is currently not part in the Zarr format 3 specification. It may not be supported by other zarr implementations and may change in the future.\n", " warnings.warn(\n", "Done: 10 cells, 1,065,391 obs, 0 errors, 30.4s\n" ] @@ -827,7 +827,7 @@ }, "outputs": [], "source": [ - "from magg import load_config\n", + "from zagg import load_config\n", "\n", "# Load from a custom YAML file:\n", "# config = load_config(\"my_custom_config.yaml\")\n", @@ -851,9 +851,9 @@ ], "metadata": { "kernelspec": { - "display_name": "magg (dev)", + "display_name": "zagg (dev)", "language": "python", - "name": "magg-dev" + "name": "zagg-dev" }, "language_info": { "codemirror_mode": { diff --git a/pyproject.toml b/pyproject.toml index 00c3ecd..6d66419 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,25 +1,30 @@ +[build-system] +requires = ["hatchling", "hatch-vcs"] +build-backend = "hatchling.build" + [project] -name = "magg" -version = "0.1.0" +name = "zagg" +dynamic = ["version"] description = "Multi-resolution aggregation for ICESat-2 ATL06 data using morton/healpix indexing" readme = "README.md" requires-python = ">=3.12" license = {file = "LICENSE"} authors = [ - {name = "Shane Grisby"} + {name = "Shane Grigsby", email = "refuge@rocktalus.com"}, ] classifiers = [ "Development Status :: 3 - Alpha", "Intended Audience :: Science/Research", "License :: OSI Approved :: MIT License", "Programming Language :: Python :: 3.12", + "Programming Language :: Python :: 3.13", "Topic :: Scientific/Engineering :: GIS", ] dependencies = [ - "numpy==2.2.6", - "pandas==2.2.3", - "h5coro==0.0.8", + "numpy>=2.0", + "pandas>=2.2", + "h5coro>=0.0.8", "mortie>=0.6.3", "healpy", "earthaccess", @@ -36,6 +41,9 @@ dependencies = [ [project.optional-dependencies] lambda = [ + "numpy==2.2.6", + "pandas==2.2.3", + "h5coro==0.0.8", "cramjam", "astropy", ] @@ -43,7 +51,7 @@ analysis = [ "cubed>=0.24.0", "cubed-xarray>=0.0.9", "xarray[io]", - "xdggs @ git+https://github.com/xarray-contrib/xdggs.git@main", + "xdggs", "geopandas", "cartopy>=0.25.0", "matplotlib>=3.10.8", @@ -53,18 +61,31 @@ test = [ "pytest>=8.0", ] -[build-system] -requires = ["setuptools>=68", "wheel"] -build-backend = "setuptools.build_meta" +[project.urls] +Homepage = "https://github.com/englacial/zagg" +Repository = "https://github.com/englacial/zagg" +Issues = "https://github.com/englacial/zagg/issues" -[tool.setuptools] -packages = ["magg"] +[project.scripts] +zagg = "zagg.__main__:main" -[tool.setuptools.package-data] -magg = ["configs/*.yaml"] +[tool.hatch.version] +source = "vcs" -[tool.setuptools.package-dir] -magg = "src/magg" +[tool.hatch.build.hooks.vcs] +version-file = "src/zagg/_version.py" + +[tool.hatch.build.targets.wheel] +packages = ["src/zagg"] + +[tool.hatch.build.targets.sdist] +only-include = [ + "src/zagg", + "tests", + "README.md", + "LICENSE", + "pyproject.toml", +] [tool.pytest.ini_options] testpaths = ["tests"] @@ -80,7 +101,7 @@ lint.select = ["E", "F", "W", "I", "N"] lint.ignore = ["E501"] [tool.ruff.lint.isort] -known-first-party = ["magg"] +known-first-party = ["zagg"] [dependency-groups] dev = [ diff --git a/src/magg/__init__.py b/src/zagg/__init__.py similarity index 88% rename from src/magg/__init__.py rename to src/zagg/__init__.py index 898753c..eba0940 100644 --- a/src/magg/__init__.py +++ b/src/zagg/__init__.py @@ -1,5 +1,5 @@ """ -magg - Multi-resolution Aggregation +zagg - Multi-resolution Aggregation Multi-resolution aggregation using morton/healpix indexing. @@ -8,9 +8,11 @@ or used for local processing. """ -__version__ = "0.1.0" +try: + from ._version import __version__ +except ImportError: + __version__ = "0.0.0+unknown" -# Export main processing functions from .auth import get_edl_token, get_nsidc_s3_credentials from .config import ( PipelineConfig, diff --git a/src/magg/__main__.py b/src/zagg/__main__.py similarity index 79% rename from src/magg/__main__.py rename to src/zagg/__main__.py index b50f80e..2471e6b 100644 --- a/src/magg/__main__.py +++ b/src/zagg/__main__.py @@ -1,30 +1,30 @@ -"""CLI entry point for magg processing. +"""CLI entry point for zagg processing. Usage: - python -m magg --config atl06.yaml --catalog catalog.json - python -m magg --config atl06.yaml --catalog catalog.json --store ./test.zarr - python -m magg --config atl06.yaml --catalog catalog.json --max-cells 5 - python -m magg --config atl06.yaml --catalog catalog.json --backend lambda + python -m zagg --config atl06.yaml --catalog catalog.json + python -m zagg --config atl06.yaml --catalog catalog.json --store ./test.zarr + python -m zagg --config atl06.yaml --catalog catalog.json --max-cells 5 + python -m zagg --config atl06.yaml --catalog catalog.json --backend lambda """ import argparse import logging import os -from magg.config import load_config -from magg.runner import agg +from zagg.config import load_config +from zagg.runner import agg def main(): parser = argparse.ArgumentParser( - description="magg processing runner", + description="zagg processing runner", formatter_class=argparse.RawDescriptionHelpFormatter, epilog=""" examples: - python -m magg --config atl06.yaml --catalog catalog.json - python -m magg --config atl06.yaml --catalog catalog.json --store ./test.zarr - python -m magg --config atl06.yaml --catalog catalog.json --max-cells 5 - python -m magg --config atl06.yaml --catalog catalog.json --backend lambda + python -m zagg --config atl06.yaml --catalog catalog.json + python -m zagg --config atl06.yaml --catalog catalog.json --store ./test.zarr + python -m zagg --config atl06.yaml --catalog catalog.json --max-cells 5 + python -m zagg --config atl06.yaml --catalog catalog.json --backend lambda """, ) parser.add_argument("--config", required=True, help="Path to pipeline config YAML") @@ -42,8 +42,8 @@ def main(): parser.add_argument("--region", default="us-west-2", help="AWS region (default: us-west-2)") parser.add_argument( "--function-name", - default=os.environ.get("MAGG_LAMBDA_FUNCTION_NAME", "process-morton-cell"), - help="Lambda function name (default: env MAGG_LAMBDA_FUNCTION_NAME or 'process-morton-cell')", + default=os.environ.get("ZAGG_LAMBDA_FUNCTION_NAME", "process-morton-cell"), + help="Lambda function name (default: env ZAGG_LAMBDA_FUNCTION_NAME or 'process-morton-cell')", ) args = parser.parse_args() diff --git a/src/magg/auth.py b/src/zagg/auth.py similarity index 100% rename from src/magg/auth.py rename to src/zagg/auth.py diff --git a/src/magg/catalog.py b/src/zagg/catalog.py similarity index 98% rename from src/magg/catalog.py rename to src/zagg/catalog.py index 1b09b15..9b8bce9 100644 --- a/src/magg/catalog.py +++ b/src/zagg/catalog.py @@ -10,14 +10,14 @@ Usage: # General (date range + polygon): - python -m magg.catalog --start-date 2024-01-06 --end-date 2024-04-07 \\ + python -m zagg.catalog --start-date 2024-01-06 --end-date 2024-04-07 \\ --polygon antarctica.geojson --parent-order 6 # ICESat-2 convenience (cycle computes dates automatically): - python -m magg.catalog --cycle 22 --parent-order 6 + python -m zagg.catalog --cycle 22 --parent-order 6 # Custom product: - python -m magg.catalog --start-date 2024-01-01 --end-date 2024-06-01 \\ + python -m zagg.catalog --start-date 2024-01-01 --end-date 2024-06-01 \\ --short-name ATL08 --polygon my_region.geojson --parent-order 6 """ @@ -476,13 +476,13 @@ def main(): epilog=""" examples: # ICESat-2 cycle (convenience): - python -m magg.catalog --cycle 22 --parent-order 6 + python -m zagg.catalog --cycle 22 --parent-order 6 # Explicit date range: - python -m magg.catalog --start-date 2024-01-06 --end-date 2024-04-07 --parent-order 6 + python -m zagg.catalog --start-date 2024-01-06 --end-date 2024-04-07 --parent-order 6 # Custom region and product: - python -m magg.catalog --start-date 2024-01-01 --end-date 2024-06-01 \\ + python -m zagg.catalog --start-date 2024-01-01 --end-date 2024-06-01 \\ --short-name ATL08 --polygon my_region.geojson --parent-order 6 """, ) diff --git a/src/magg/config.py b/src/zagg/config.py similarity index 98% rename from src/magg/config.py rename to src/zagg/config.py index b1aac48..8cc8c37 100644 --- a/src/magg/config.py +++ b/src/zagg/config.py @@ -1,4 +1,4 @@ -"""YAML-driven pipeline configuration for magg.""" +"""YAML-driven pipeline configuration for zagg.""" import importlib import re @@ -10,7 +10,7 @@ import numpy as np import yaml -import magg.configs +import zagg.configs class DataSourceDict(TypedDict): @@ -105,7 +105,7 @@ def default_config(name: str = "atl06") -> PipelineConfig: FileNotFoundError If the named config does not exist. """ - ref = resources.files(magg.configs).joinpath(f"{name}.yaml") + ref = resources.files(zagg.configs).joinpath(f"{name}.yaml") if not ref.is_file(): raise FileNotFoundError(f"No built-in config named '{name}'") text = ref.read_text(encoding="utf-8") diff --git a/src/magg/configs/__init__.py b/src/zagg/configs/__init__.py similarity index 100% rename from src/magg/configs/__init__.py rename to src/zagg/configs/__init__.py diff --git a/src/magg/configs/atl06.yaml b/src/zagg/configs/atl06.yaml similarity index 100% rename from src/magg/configs/atl06.yaml rename to src/zagg/configs/atl06.yaml diff --git a/src/magg/processing.py b/src/zagg/processing.py similarity index 98% rename from src/magg/processing.py rename to src/zagg/processing.py index 907364a..6937d70 100644 --- a/src/magg/processing.py +++ b/src/zagg/processing.py @@ -15,8 +15,8 @@ from zarr import config, open_array from zarr.abc.store import Store -from magg.config import PipelineConfig, default_config, get_agg_fields, get_data_vars -from magg.schema import ProcessingMetadata +from zagg.config import PipelineConfig, default_config, get_agg_fields, get_data_vars +from zagg.schema import ProcessingMetadata logger = logging.getLogger(__name__) @@ -32,7 +32,7 @@ def _rewrite(url): return _rewrite raise ValueError( "driver='https' requires catalog metadata with s3_base/https_base. " - "Rebuild the catalog with the latest magg to populate these fields." + "Rebuild the catalog with the latest zagg to populate these fields." ) # S3 driver: strip s3:// prefix (h5coro expects bucket/key) def _rewrite_s3(url): @@ -116,7 +116,7 @@ def calculate_cell_statistics( dict Dictionary of statistics keyed by aggregation variable name """ - from magg.config import evaluate_expression, resolve_function + from zagg.config import evaluate_expression, resolve_function if config is None: config = default_config() diff --git a/src/magg/runner.py b/src/zagg/runner.py similarity index 97% rename from src/magg/runner.py rename to src/zagg/runner.py index cbbcdd9..ec491cd 100644 --- a/src/magg/runner.py +++ b/src/zagg/runner.py @@ -2,7 +2,7 @@ Usage from Python (e.g., Jupyter notebook):: - from magg import load_config, agg + from zagg import load_config, agg config = load_config("atl06.yaml") results = agg(config, catalog="catalog.json", store="./output.zarr", max_cells=5) @@ -19,11 +19,11 @@ from zarr import consolidate_metadata -from magg.auth import get_edl_token, get_nsidc_s3_credentials -from magg.config import PipelineConfig, get_child_order, get_driver, get_store_path -from magg.processing import process_morton_cell, write_dataframe_to_zarr -from magg.schema import xdggs_zarr_template -from magg.store import open_store +from zagg.auth import get_edl_token, get_nsidc_s3_credentials +from zagg.config import PipelineConfig, get_child_order, get_driver, get_store_path +from zagg.processing import process_morton_cell, write_dataframe_to_zarr +from zagg.schema import xdggs_zarr_template +from zagg.store import open_store logger = logging.getLogger(__name__) @@ -71,7 +71,7 @@ def agg( dry_run : bool Preview what would be processed without running. function_name : str, optional - Lambda function name. Defaults to env ``MAGG_LAMBDA_FUNCTION_NAME`` + Lambda function name. Defaults to env ``ZAGG_LAMBDA_FUNCTION_NAME`` or ``"process-morton-cell"``. Only used with ``backend="lambda"``. region : str AWS region for S3 and Lambda. Default ``"us-west-2"``. @@ -118,7 +118,7 @@ def agg( if not store_path.startswith("s3://"): raise ValueError(f"Lambda backend requires s3:// store path, got: {store_path}") if function_name is None: - function_name = os.environ.get("MAGG_LAMBDA_FUNCTION_NAME", "process-morton-cell") + function_name = os.environ.get("ZAGG_LAMBDA_FUNCTION_NAME", "process-morton-cell") return _run_lambda( config, catalog_data, store_path, child_order, max_cells=max_cells, morton_cell=morton_cell, diff --git a/src/magg/schema.py b/src/zagg/schema.py similarity index 98% rename from src/magg/schema.py rename to src/zagg/schema.py index 4aac264..f583db8 100644 --- a/src/magg/schema.py +++ b/src/zagg/schema.py @@ -5,7 +5,7 @@ from zarr import config as zarr_config from zarr.abc.store import Store -from magg.config import PipelineConfig, default_config, get_agg_fields +from zagg.config import PipelineConfig, default_config, get_agg_fields HEALPIX_BASE_CELLS: int = 12 # Number of base cells in HEALPix tessellation diff --git a/src/magg/store.py b/src/zagg/store.py similarity index 100% rename from src/magg/store.py rename to src/zagg/store.py diff --git a/tests/conftest.py b/tests/conftest.py index 74c3cf8..7acf5c6 100644 --- a/tests/conftest.py +++ b/tests/conftest.py @@ -3,7 +3,7 @@ import pytest from zarr.storage import MemoryStore -from magg.config import default_config, get_data_vars +from zagg.config import default_config, get_data_vars @pytest.fixture diff --git a/tests/test_catalog.py b/tests/test_catalog.py index ab2f53d..2fc5c95 100644 --- a/tests/test_catalog.py +++ b/tests/test_catalog.py @@ -1,4 +1,4 @@ -"""Tests for magg.catalog — CMR query, polygon loading, cell discovery, catalog building.""" +"""Tests for zagg.catalog — CMR query, polygon loading, cell discovery, catalog building.""" import json from datetime import datetime @@ -7,7 +7,7 @@ import numpy as np import pytest -from magg.catalog import ( +from zagg.catalog import ( build_catalog, cycle_to_dates, discover_cells, @@ -278,7 +278,7 @@ def _mock_response(self, items, total_hits=None): resp.raise_for_status = MagicMock() return resp - @patch("magg.catalog.requests.get") + @patch("zagg.catalog.requests.get") def test_basic_query(self, mock_get): mock_get.return_value = self._mock_response([{"id": "1"}, {"id": "2"}]) result = query_cmr("2024-01-01", "2024-04-01") @@ -290,28 +290,28 @@ def test_basic_query(self, mock_get): assert "2024-01-01" in params["temporal"] assert "2024-04-01" in params["temporal"] - @patch("magg.catalog.requests.get") + @patch("zagg.catalog.requests.get") def test_custom_short_name(self, mock_get): mock_get.return_value = self._mock_response([]) query_cmr("2024-01-01", "2024-04-01", short_name="ATL08") params = mock_get.call_args.kwargs.get("params") or mock_get.call_args[1]["params"] assert params["short_name"] == "ATL08" - @patch("magg.catalog.requests.get") + @patch("zagg.catalog.requests.get") def test_bbox_passed(self, mock_get): mock_get.return_value = self._mock_response([]) query_cmr("2024-01-01", "2024-04-01", bbox=(-180, -90, 180, -60)) params = mock_get.call_args.kwargs.get("params") or mock_get.call_args[1]["params"] assert params["bounding_box"] == "-180,-90,180,-60" - @patch("magg.catalog.requests.get") + @patch("zagg.catalog.requests.get") def test_no_bbox(self, mock_get): mock_get.return_value = self._mock_response([]) query_cmr("2024-01-01", "2024-04-01") params = mock_get.call_args.kwargs.get("params") or mock_get.call_args[1]["params"] assert "bounding_box" not in params - @patch("magg.catalog.requests.get") + @patch("zagg.catalog.requests.get") def test_pagination(self, mock_get): page1 = self._mock_response([{"id": str(i)} for i in range(2000)], total_hits=3000) page2 = self._mock_response([{"id": str(i)} for i in range(1000)], total_hits=3000) diff --git a/tests/test_config.py b/tests/test_config.py index 8d91de9..dd08c2b 100644 --- a/tests/test_config.py +++ b/tests/test_config.py @@ -6,7 +6,7 @@ import pandas as pd import pytest -from magg.config import ( +from zagg.config import ( PipelineConfig, default_config, evaluate_expression, @@ -20,7 +20,7 @@ resolve_function, validate_config, ) -from magg.processing import calculate_cell_statistics +from zagg.processing import calculate_cell_statistics # --------------------------------------------------------------------------- # Fixtures @@ -31,8 +31,8 @@ def atl06_yaml(tmp_path): """Path to the built-in atl06.yaml (copied to tmp for load_config tests).""" from importlib import resources - import magg.configs - ref = resources.files(magg.configs).joinpath("atl06.yaml") + import zagg.configs + ref = resources.files(zagg.configs).joinpath("atl06.yaml") text = ref.read_text(encoding="utf-8") p = tmp_path / "atl06.yaml" p.write_text(text) diff --git a/tests/test_integration.py b/tests/test_integration.py index a701ebb..1f71ea8 100644 --- a/tests/test_integration.py +++ b/tests/test_integration.py @@ -1,9 +1,9 @@ import numpy as np import zarr -from magg.config import default_config, get_coords, get_data_vars -from magg.processing import write_dataframe_to_zarr -from magg.schema import xdggs_zarr_template +from zagg.config import default_config, get_coords, get_data_vars +from zagg.processing import write_dataframe_to_zarr +from zagg.schema import xdggs_zarr_template def test_full_integration(zarr_store, mock_dataframe_factory): diff --git a/tests/test_lambda_build.py b/tests/test_lambda_build.py index 67e7357..420d1ab 100644 --- a/tests/test_lambda_build.py +++ b/tests/test_lambda_build.py @@ -3,7 +3,7 @@ These tests verify that: 1. All imports needed by lambda_handler.py are available 2. The function code build script works and produces output within size budget -3. The magg package can be imported as Lambda would see it +3. The zagg package can be imported as Lambda would see it """ import subprocess @@ -34,13 +34,13 @@ def test_handler_direct_imports(self): from obstore.store import S3Store # noqa: F401 from zarr.storage import ObjectStore # noqa: F401 - def test_handler_magg_imports(self): - """magg.processing imports used by lambda_handler must resolve.""" - from magg.processing import process_morton_cell, write_dataframe_to_zarr # noqa: F401 + def test_handler_zagg_imports(self): + """zagg.processing imports used by lambda_handler must resolve.""" + from zagg.processing import process_morton_cell, write_dataframe_to_zarr # noqa: F401 - def test_magg_schema_imports(self): - """magg.schema imports used transitively must resolve.""" - from magg.schema import xdggs_spec, xdggs_zarr_template # noqa: F401 + def test_zagg_schema_imports(self): + """zagg.schema imports used transitively must resolve.""" + from zagg.schema import xdggs_spec, xdggs_zarr_template # noqa: F401 def test_zarr_codecs_available(self): """Zarr codecs (numcodecs/blosc) must be importable for data writing.""" @@ -159,58 +159,40 @@ def test_invoke_script_parses(self): class TestPackageConsistency: """Verify dependency specifications are consistent across build scripts.""" - def test_numpy_version_consistent(self): - """numpy version must match between pyproject.toml and build scripts.""" + @staticmethod + def _lambda_extra_pin(pkg): import tomllib - pyproject = REPO_ROOT / "pyproject.toml" - config = tomllib.loads(pyproject.read_text()) - deps = config["project"]["dependencies"] - numpy_dep = [d for d in deps if d.startswith("numpy")][0] + config = tomllib.loads((REPO_ROOT / "pyproject.toml").read_text()) + dep = next(d for d in config["project"]["optional-dependencies"]["lambda"] + if d.startswith(f"{pkg}==")) + return dep.split("==", 1)[1] - # Extract version from pyproject (e.g., "numpy==2.2.6" → "2.2.6") - numpy_version = numpy_dep.split("==")[1] + @staticmethod + def _pinned_in_script(pkg, script_path): + import re - # Check build scripts reference same version - layer_script = (REPO_ROOT / "deployment" / "aws" / "build_layer_v14.sh").read_text() - arm64_script = (REPO_ROOT / "deployment" / "aws" / "build_arm64_layer.sh").read_text() + match = re.search(rf'{re.escape(pkg)}==([0-9][^\s"\']+)', script_path.read_text()) + return match.group(1) if match else None - assert f"numpy=={numpy_version}" in arm64_script or "numpy>=" in layer_script, ( - f"ARM64 build script doesn't pin numpy=={numpy_version}" + def _assert_lockstep(self, pkg, script_name): + extra_pin = self._lambda_extra_pin(pkg) + script_pin = self._pinned_in_script(pkg, REPO_ROOT / "deployment" / "aws" / script_name) + assert script_pin, f"{script_name} does not pin {pkg}" + assert script_pin == extra_pin, ( + f"{script_name} pins {pkg}=={script_pin} but [lambda] extra pins {pkg}=={extra_pin}" ) - def test_pandas_version_consistent(self): - """pandas version must match between pyproject.toml and build scripts.""" - import tomllib - - pyproject = REPO_ROOT / "pyproject.toml" - config = tomllib.loads(pyproject.read_text()) - deps = config["project"]["dependencies"] - pandas_dep = [d for d in deps if d.startswith("pandas")][0] - pandas_version = pandas_dep.split("==")[1] - - layer_script = (REPO_ROOT / "deployment" / "aws" / "build_layer_v14.sh").read_text() - arm64_script = (REPO_ROOT / "deployment" / "aws" / "build_arm64_layer.sh").read_text() + def test_numpy_version_consistent(self): + """Lambda [extra] and ARM64 build script must pin the same numpy version.""" + self._assert_lockstep("numpy", "build_arm64_layer.sh") - assert f"pandas=={pandas_version}" in layer_script, ( - f"x86_64 build script doesn't pin pandas=={pandas_version}" - ) - assert f"pandas=={pandas_version}" in arm64_script, ( - f"ARM64 build script doesn't pin pandas=={pandas_version}" - ) + def test_pandas_version_consistent(self): + """Lambda [extra] and both build scripts must pin the same pandas version.""" + self._assert_lockstep("pandas", "build_layer_v14.sh") + self._assert_lockstep("pandas", "build_arm64_layer.sh") def test_h5coro_version_consistent(self): - """h5coro version must match between pyproject.toml and build scripts.""" - import tomllib - - pyproject = REPO_ROOT / "pyproject.toml" - config = tomllib.loads(pyproject.read_text()) - deps = config["project"]["dependencies"] - h5coro_dep = [d for d in deps if d.startswith("h5coro")][0] - h5coro_version = h5coro_dep.split("==")[1] - - layer_script = (REPO_ROOT / "deployment" / "aws" / "build_layer_v14.sh").read_text() - arm64_script = (REPO_ROOT / "deployment" / "aws" / "build_arm64_layer.sh").read_text() - - assert f"h5coro=={h5coro_version}" in layer_script - assert f"h5coro=={h5coro_version}" in arm64_script + """Lambda [extra] and both build scripts must pin the same h5coro version.""" + self._assert_lockstep("h5coro", "build_layer_v14.sh") + self._assert_lockstep("h5coro", "build_arm64_layer.sh") diff --git a/tests/test_processing.py b/tests/test_processing.py index 16574fb..46bfcba 100644 --- a/tests/test_processing.py +++ b/tests/test_processing.py @@ -4,12 +4,12 @@ from zarr import open_group from zarr.storage import MemoryStore -from magg.config import default_config, get_agg_fields, get_coords, get_data_vars -from magg.processing import ( +from zagg.config import default_config, get_agg_fields, get_coords, get_data_vars +from zagg.processing import ( calculate_cell_statistics, write_dataframe_to_zarr, ) -from magg.schema import xdggs_zarr_template +from zagg.schema import xdggs_zarr_template class TestWriteDataframeToZarr: diff --git a/tests/test_runner.py b/tests/test_runner.py index a480d0b..16c407e 100644 --- a/tests/test_runner.py +++ b/tests/test_runner.py @@ -4,8 +4,8 @@ import pytest -from magg.config import default_config -from magg.runner import _load_catalog, _select_cells, agg +from zagg.config import default_config +from zagg.runner import _load_catalog, _select_cells, agg @pytest.fixture diff --git a/tests/test_schema.py b/tests/test_schema.py index c460b42..6d30dcf 100644 --- a/tests/test_schema.py +++ b/tests/test_schema.py @@ -3,8 +3,8 @@ from zarr import open_array, open_group from zarr.storage import MemoryStore -from magg.config import default_config, get_agg_fields, get_coords, get_data_vars -from magg.schema import ( +from zagg.config import default_config, get_agg_fields, get_coords, get_data_vars +from zagg.schema import ( HEALPIX_BASE_CELLS, xdggs_zarr_template, ) diff --git a/tests/test_store.py b/tests/test_store.py index a5df930..328109a 100644 --- a/tests/test_store.py +++ b/tests/test_store.py @@ -5,7 +5,7 @@ import pytest from zarr.storage import LocalStore -from magg.store import open_store, parse_s3_path +from zagg.store import open_store, parse_s3_path class TestOpenStore: