up42-blockutils 1.2.4

Block development toolkit for UP42

Block development toolkit for UP42.

Documentation   •   UP42.com   •   Support

Highlights

• Python package with utilities to build blocks in UP42.
• For UP42 partners and customers interested in creating blocks!
• Base classes for data and processing blocks.
• Facilities to easily create tests, ensuring production ready blocks.

Overview

The UP42 blockutils package provides several modules with specific concerns:

• Blocks: Base classes for data and processing blocks.
• Common: Directory and query/parameter input handling.
• Logging: Standard logging facility.
• Data Path: Input and output file handling.
• E2E: Utility class to create end-to-end tests.
• Exceptions: Shared exceptions between blocks.
• Format: Exotic file handling (DIMAP and NETCDF).
• Raster: Raster handling methods.
• Geometry: Generic recurrent geometry operations.
• Windows: Raster windowed read and write helper, useful for large file handling.
• STAC: Handling STAC type queries.
• WMTS: Helper for downloading, processing and merging tiles.

See the full code reference here.

Docker image

In order to make development of blocks easier, we have made available a public blockutils base image that you can use in your Dockerfile. Check out the DockerHub page for the up42/up42-blockutils-py37 image.

Template repositories

For your convenience, we have created two template repositories hosted on GitHub that include this package and generic make utilities for building and pushing blocks:

• Data block template
• Processing block template

Install

The package requires Python > 3.6.

pip install up42-blockutils

Quickstart

The example below shows a minimal processing block that takes a raster file and returns the raster values to the power of 2. In this example we make use of the logging, blocks, exceptions, datapath and windows modules.

from pathlib import Path
import rasterio as rio
from geojson import FeatureCollection, Feature
import blockutils

logger = blockutils.logging.get_logger(__name__)


class AProcessingBlock(blockutils.blocks.ProcessingBlock):
    def process(self, input_fc: FeatureCollection) -> FeatureCollection:
        output_fc = FeatureCollection([])

        if not input_fc.features:
            raise blockutils.exceptions.UP42Error(
                blockutils.exceptions.SupportedErrors.NO_INPUT_ERROR
            )

        for feat in input_fc["features"]:
            logger.info(f"Processing {feat}...")
            input_path = Path("/tmp/input/") / Path(blockutils.datapath.get_data_path(feat))
            with rio.open(input_path) as src:
                src_win = blockutils.windows.WindowsUtil(src)
                (
                    output_name,
                    output_path,
                ) = blockutils.datapath.get_output_filename_and_path(
                    input_path.name, postfix="processed"
                )
                dst_meta = src.meta.copy()
                with rio.open(output_path, "w", **dst_meta) as dst:
                    for win in src_win.windows_regular():
                        exp = src.read(window=win) ** 2
                        dst.write(exp, window=win)

                out_feat = Feature(bbox=feat.bbox, geometry=feat.geometry)
                out_feat["properties"] = self.get_metadata(feat)
                out_feat = blockutils.datapath.set_data_path(out_feat, output_name)
                logger.info(f"Processed {out_feat}...")
                output_fc.features.append(out_feat)
            return output_fc


AProcessingBlock().run()

Support

For any issues or help please contact us via Email [e-mail].