Metadata-Version: 2.1
Name: up42-blockutils
Version: 0.2.0
Summary: Block development toolkit for UP42
Home-page: https://www.up42.com
Author: UP42
Author-email: support@up42.com
License: MIT
Description: <p align="center">
            <strong>(BETA) Block development toolkit for UP42.</strong>
        </p>
        
        <p align="center">
            <a href="https://pypi.org/project/up42-blockutils/" title="up42-blockutils on pypi"><img src="https://img.shields.io/pypi/v/up42-blockutils"></a>
            <a href="https://twitter.com/UP42_" title="UP42 on Twitter"><img src="https://img.shields.io/twitter/follow/UP42_.svg?style=social"></a>
        </p>
        
        <p align="center">
            <b>
              <a href="https://blockutils.up42.com/"> Documentation</a> &nbsp; • &nbsp;
              <a href="http://www.up42.com">UP42.com</a> &nbsp; • &nbsp;
              <a href="#support">Support</a>
            </b>
        </p>
        
        ## 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.
        - **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.
        - **Synthetic Image**: Image generator, especially useful for mock testing.
        
        See the full code reference [here](https://blockutils.up42.com/blocks/).
        
        ## 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](https://hub.docker.com/r/up42/up42-blockutils-py37)
        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](https://github.com/up42/data-block-template)
        - [Processing block template](https://github.com/up42/processing-block-template)
        
        ## Install
        
        The package requires Python > 3.6.
        
        ```bash
        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.
        
        ```python3
        from pathlib import Path
        import rasterio as rio
        from geojson import FeatureCollection
        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 **[support@up42.com](mailto:support@up42.com)**.
        
Platform: UNKNOWN
Classifier: Programming Language :: Python :: 3
Classifier: License :: OSI Approved :: MIT License
Classifier: Operating System :: OS Independent
Classifier: Development Status :: 4 - Beta
Classifier: Intended Audience :: Developers
Requires-Python: >=3.6, <3.9
Description-Content-Type: text/markdown
