def is_valid_with_config(self, config):
"""
Check if output format is valid with other process parameters.
Parameters
----------
config : dictionary
output configuration parameters
Returns
-------
is_valid : bool
"""
validate_values(config, [("schema", dict), ("path", six.string_types)])
validate_values(
config["schema"], [
("properties", dict), ("geometry", six.string_types)]
)
if config["schema"]["geometry"] not in [
"Geometry", "Point", "MultiPoint", "Line", "MultiLine",
"Polygon", "MultiPolygon"
]:
raise TypeError("invalid geometry type")
if config["type"].type != "geodetic":
raise ValueError("output pyramid has to be geodetic")
return True
def __init__(self, input_params, **kwargs):
"""Initialize."""
super(InputData, self).__init__(input_params, **kwargs)
self._params = input_params["abstract"]
# 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"]
self.path = _absolute_path(
input_params["conf_dir"], self._params["path"])
# 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))
# 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
def is_valid_with_config(self, config):
"""
Check if output format is valid with other process parameters.
Parameters
----------
config : dictionary
output configuration parameters
Returns
-------
is_valid : bool
"""
return all([
validate_values(config, [("profile", dict),
("basekey", six.string_types),
("bucket", six.string_types)]),
validate_values(config["profile"], [("driver", six.string_types),
("bands", int),
("dtype", six.string_types)])
])
def is_valid_with_config(self, config):
"""
Check if output format is valid with other process parameters.
Parameters
----------
config : dictionary
output configuration parameters
Returns
-------
is_valid : bool
"""
validate_values(config, [("schema", dict), ("path", str)])
validate_values(config["schema"], [("properties", dict),
("geometry", str)])
if config["schema"]["geometry"] not in [
"Geometry", "Point", "MultiPoint", "Line", "MultiLine",
"Polygon", "MultiPolygon"
]: # pragma: no cover
raise TypeError("invalid geometry type")
return True
def is_valid_with_config(self, config):
"""
Check if output format is valid with other process parameters.
Parameters
----------
config : dictionary
output configuration parameters
Returns
-------
is_valid : bool
"""
return validate_values(config, [("path", six.string_types)])
def test_validate_values():
with pytest.raises(TypeError):
validate_values(None, 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
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
