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()
