def output(self): """Output object of driver.""" output_params = self._raw["output"] if "path" in output_params: output_params.update( path=os.path.normpath( os.path.join(self.config_dir, output_params["path"]))) output_params.update( type=self.output_pyramid.grid, pixelbuffer=self.output_pyramid.pixelbuffer, metatiling=self.output_pyramid.metatiling) if "format" not in output_params: raise MapcheteConfigError("output format not specified") if output_params["format"] not in available_output_formats(): raise MapcheteConfigError( "format %s not available in %s" % ( output_params["format"], str(available_output_formats()))) writer = load_output_writer(output_params) try: writer.is_valid_with_config(output_params) except Exception as e: logger.exception(e) raise MapcheteConfigError( "driver %s not compatible with configuration: %s" % ( writer.METADATA["driver_name"], e)) return writer
def output(self): """Output object of driver.""" output_params = self.raw["output"] if "format" not in output_params: raise MapcheteConfigError("output format not specified") if output_params["format"] not in available_output_formats(): raise MapcheteConfigError( "format %s not available in %s" % (output_params["format"], str(available_output_formats()))) writer = load_output_writer(output_params) if not writer.is_valid_with_config(output_params): raise MapcheteConfigError( "driver %s not compatible with configuration: %s" % (writer.METADATA["driver_name"], output_params)) return writer
def create(self): """Parse params and run create command.""" parser = argparse.ArgumentParser( description="Creates an empty process and configuration file", formatter_class=argparse.ArgumentDefaultsHelpFormatter, usage=( """mapchete create <mapchete_file> <process_file> """ """<out_format>""") ) parser.add_argument("mapchete_file", type=str, help="Mapchete file") parser.add_argument( "process_file", type=str, help="process (Python) file") parser.add_argument( "out_format", type=str, choices=available_output_formats(), help="process output format") parser.add_argument( "--out_path", "-op", type=str, help="path for process output", metavar="<path>") parser.add_argument( "--pyramid_type", "-pt", type=str, choices=tilematrix._conf.PYRAMID_PARAMS.keys(), default="geodetic", help="output pyramid type") parser.add_argument( "--force", "-f", action="store_true", help="overwrite if Mapchete and process files already exist") args = parser.parse_args(self.args[2:]) create_empty_process(args)
def _output_params(self): """Output params of driver.""" output_params = dict(self._raw["output"], grid=self.output_pyramid.grid, pixelbuffer=self.output_pyramid.pixelbuffer, metatiling=self.output_pyramid.metatiling, delimiters=self._delimiters, mode=self.mode) if "path" in output_params: output_params.update(path=absolute_path(path=output_params["path"], base_dir=self.config_dir)) if "format" not in output_params: raise MapcheteConfigError("output format not specified") if output_params["format"] not in available_output_formats(): raise MapcheteConfigError( "format %s not available in %s" % (output_params["format"], str(available_output_formats()))) return output_params
def list_formats(args): """List input and/or output formats.""" if args.input_formats == args.output_formats: show_inputs, show_outputs = True, True else: show_inputs, show_outputs = args.input_formats, args.output_formats if show_inputs: print "input formats:" for driver in available_input_formats(): print "-", driver if show_outputs: print "output formats:" for driver in available_output_formats(): print "-", driver
def formats(input_formats, output_formats): """List input and/or output formats.""" if input_formats == output_formats: show_inputs, show_outputs = True, True else: show_inputs, show_outputs = input_formats, output_formats if show_inputs: click.echo("input formats:") for driver in available_input_formats(): click.echo("- %s" % driver) if show_outputs: click.echo("output formats:") for driver in available_output_formats(): click.echo("- %s" % driver)
def _setup_logfile(ctx, param, logfile): if logfile: setup_logfile(logfile) return logfile # arguments arg_mapchete_file = click.argument("mapchete_file", type=click.Path(exists=True)) arg_create_mapchete_file = click.argument("mapchete_file", type=click.Path()) arg_mapchete_files = click.argument( "mapchete_files", type=click.Path(exists=True), nargs=-1, callback=_validate_mapchete_files ) arg_process_file = click.argument("process_file", type=click.Path()) arg_out_format = click.argument( "out_format", type=click.Choice(available_output_formats()) ) arg_input_raster = click.argument("input_raster", type=click.Path(exists=True)) arg_out_dir = click.argument("output_dir", type=click.Path()) # options opt_out_path = click.option( "--out_path", "-op", type=click.Path(), default=os.path.join(os.getcwd(), "output"), help="Process output path." ) opt_out_dir = click.option( "--out_dir", "-od", type=click.Path(), help="Index output directory." ) opt_input_file = click.option( "--input_file", "-i", type=click.Path(),
def test_available_output_formats(): """Check if default output formats can be listed.""" assert set(['GTiff', 'PNG', 'PNG_hillshade', 'GeoJSON']).issubset(set(available_output_formats()))
def test_install(): """Mapchete NumPy driver is installed.""" assert "NumPy" in available_output_formats()
from rasterio.rio.options import creation_options from shapely.geometry import box import sys import tilematrix from mapchete.cli import utils from mapchete.config import raw_conf, raw_conf_output_pyramid from mapchete.formats import (driver_from_file, available_output_formats, available_input_formats) from mapchete.io import read_json, get_best_zoom_level from mapchete.io.vector import reproject_geometry from mapchete.tile import BufferedTilePyramid from mapchete.validate import validate_zooms logger = logging.getLogger(__name__) OUTPUT_FORMATS = available_output_formats() def _validate_bidx(ctx, param, bidx): if bidx: try: return list(map(int, bidx.split(","))) except ValueError: raise click.BadParameter( "band indexes must be positive integer values") @click.command(help="Convert outputs or other geodata.") @utils.arg_input @utils.arg_output @utils.opt_zoom
def test_format_available(): """Format can be listed.""" assert "s3" in available_output_formats()