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 writer class of driver."""
writer = load_output_writer(self._output_params)
try:
writer.is_valid_with_config(self._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 test_output_writer_errors():
"""Test errors when loading output writer."""
with pytest.raises(TypeError):
load_output_writer("not_a_dictionary")
with pytest.raises(errors.MapcheteDriverError):
load_output_writer({"format": "invalid_driver"})
def __init__(self, input_params, **kwargs):
"""Initialize."""
super().__init__(input_params, **kwargs)
if "abstract" in input_params:
self._params = input_params["abstract"]
self.path = absolute_path(path=self._params["path"],
base_dir=input_params["conf_dir"])
logger.debug("InputData params: %s", input_params)
# define pyramid
self.td_pyramid = BufferedTilePyramid(
self._params["grid"],
metatiling=self._params.get("metatiling", 1),
tile_size=self._params.get("tile_size", 256),
pixelbuffer=self._params.get("pixelbuffer", 0))
self._read_as_tiledir_func = base._read_as_tiledir
try:
self._tiledir_metadata_json = read_output_metadata(
os.path.join(self.path, "metadata.json"))
try:
self._data_type = self._tiledir_metadata_json["driver"][
"data_type"]
except KeyError:
self._data_type = driver_metadata(
self._tiledir_metadata_json["driver"]
["format"])["data_type"]
except FileNotFoundError:
# in case no metadata.json is available, try to guess data type via the
# format file extension
self._data_type = data_type_from_extension(
self._params["extension"])
elif "path" in input_params:
self.path = absolute_path(path=input_params["path"],
base_dir=input_params.get("conf_dir"))
try:
self._tiledir_metadata_json = read_output_metadata(
os.path.join(self.path, "metadata.json"))
except FileNotFoundError:
raise MapcheteConfigError(
f"Cannot find metadata.json in {self.path}")
# define pyramid
self.td_pyramid = self._tiledir_metadata_json["pyramid"]
self.output_data = load_output_writer(dict(
self._tiledir_metadata_json["driver"],
metatiling=self.td_pyramid.metatiling,
pixelbuffer=self.td_pyramid.pixelbuffer,
pyramid=self.td_pyramid,
grid=self.td_pyramid.grid,
path=self.path),
readonly=True)
self._params = dict(
path=self.path,
grid=self.td_pyramid.grid.to_dict(),
metatiling=self.td_pyramid.metatiling,
pixelbuffer=self.td_pyramid.pixelbuffer,
tile_size=self.td_pyramid.tile_size,
extension=self.output_data.file_extension.split(".")[-1],
**self._tiledir_metadata_json["driver"])
self._read_as_tiledir_func = self.output_data._read_as_tiledir
self._data_type = driver_metadata(
self._tiledir_metadata_json["driver"]["format"])["data_type"]
# validate parameters
validate_values(self._params, [("path", str), ("grid", (str, dict)),
("extension", str)])
self._ext = self._params["extension"]
# additional params
self._bounds = self._params.get("bounds", self.td_pyramid.bounds)
self.METADATA.update(data_type=self._data_type,
file_extensions=[self._params["extension"]])
if self.METADATA.get("data_type") == "raster":
self._params["count"] = self._params.get(
"count", self._params.get("bands", None))
validate_values(self._params, [("dtype", str), ("count", int)])
self._profile = {
"nodata": self._params.get("nodata", 0),
"dtype": self._params["dtype"],
"count": self._params["count"]
}
else:
self._profile = None
def __init__(self, input_params, **kwargs):
"""Initialize."""
super().__init__(input_params, **kwargs)
if "abstract" in input_params:
self._params = input_params["abstract"]
self.path = absolute_path(
path=self._params["path"],
base_dir=input_params["conf_dir"]
)
logger.debug("InputData params: %s", input_params)
# define pyramid
self.td_pyramid = BufferedTilePyramid(
self._params["grid"],
metatiling=self._params.get("metatiling", 1),
tile_size=self._params.get("tile_size", 256),
pixelbuffer=self._params.get("pixelbuffer", 0)
)
self._read_as_tiledir_func = base._read_as_tiledir
elif "path" in input_params:
self.path = absolute_path(
path=input_params["path"], base_dir=input_params.get("conf_dir")
)
try:
params = read_output_metadata(os.path.join(self.path, "metadata.json"))
except FileNotFoundError:
raise MapcheteConfigError(
"Cannot find metadata.json in %s" % input_params["path"]
)
# define pyramid
self.td_pyramid = params["pyramid"]
self.output_data = load_output_writer(
dict(
params["driver"],
metatiling=self.td_pyramid.metatiling,
pixelbuffer=self.td_pyramid.pixelbuffer,
pyramid=self.td_pyramid,
grid=self.td_pyramid.grid,
path=self.path
),
readonly=True
)
self._params = dict(
path=self.path,
grid=self.td_pyramid.grid.to_dict(),
metatiling=self.td_pyramid.metatiling,
pixelbuffer=self.td_pyramid.pixelbuffer,
tile_size=self.td_pyramid.tile_size,
extension=self.output_data.file_extension.split(".")[-1],
**params["driver"]
)
self._read_as_tiledir_func = self.output_data._read_as_tiledir
# validate parameters
validate_values(
self._params,
[
("path", str),
("grid", (str, dict)),
("extension", str)
]
)
self._ext = self._params["extension"]
# additional params
self._bounds = self._params.get("bounds", self.td_pyramid.bounds)
self._file_type = (
"vector" if self._params["extension"] == "geojson" else "raster"
)
if self._file_type == "raster":
self._params["count"] = self._params.get(
"count", self._params.get("bands", None)
)
validate_values(self._params, [("dtype", str), ("count", int)])
self._profile = {
"nodata": self._params.get("nodata", 0),
"dtype": self._params["dtype"],
"count": self._params["count"]
}
else:
self._profile = None
def __init__(self, input_params, **kwargs):
"""Initialize."""
super(InputData, self).__init__(input_params, **kwargs)
if "abstract" in input_params:
self._params = input_params["abstract"]
self.path = absolute_path(path=self._params["path"],
base_dir=input_params["conf_dir"])
# define pyramid
self.td_pyramid = BufferedTilePyramid(
self._params["type"],
metatiling=self._params.get("metatiling", 1),
tile_size=self._params.get("tile_size", 256),
pixelbuffer=self._params.get("pixelbuffer", 0))
elif "path" in input_params:
self.path = absolute_path(path=input_params["path"],
base_dir=input_params.get("conf_dir"))
try:
params = read_json(os.path.join(self.path, "metadata.json"))
except FileNotFoundError:
raise MapcheteConfigError("Cannot find metadata.json in %s" %
input_params["path"])
# define pyramid
self.td_pyramid = BufferedTilePyramid(
params["pyramid"]["grid"]["type"],
metatiling=params["pyramid"].get("metatiling", 1),
tile_size=params["pyramid"].get("tile_size", 256),
pixelbuffer=params["pyramid"].get("pixelbuffer", 0))
output = load_output_writer(dict(
params["driver"],
metatiling=self.td_pyramid.metatiling,
pixelbuffer=self.td_pyramid.pixelbuffer,
pyramid=self.td_pyramid,
type=self.td_pyramid.type,
path=self.path),
readonly=True)
logger.debug(output)
self._params = dict(
path=self.path,
type=params["pyramid"]["grid"]["type"],
metatiling=params["pyramid"].get("metatiling", 1),
pixelbuffer=params["pyramid"].get("pixelbuffer", 0),
tile_size=params["pyramid"].get("tile_size", 256),
extension=output.file_extension.split(".")[-1],
**params["driver"])
# validate parameters
validate_values(self._params, [("path", six.string_types),
("type", six.string_types),
("extension", six.string_types)])
if not self._params["extension"] in [
"tif", "vrt", "png", "jpg", "mixed", "jp2", "geojson"
]:
raise MapcheteConfigError("invalid file extension given: %s" %
self._params["extension"])
self._ext = self._params["extension"]
# additional params
self._bounds = self._params.get("bounds", self.td_pyramid.bounds)
self._file_type = ("vector" if self._params["extension"] == "geojson"
else "raster")
if self._file_type == "raster":
self._params["count"] = self._params.get(
"count", self._params.get("bands", None))
validate_values(self._params, [("dtype", six.string_types),
("count", int)])
self._profile = {
"nodata": self._params.get("nodata", 0),
"dtype": self._params["dtype"],
"count": self._params["count"]
}
else:
self._profile = None
