def __init__(self, provider_def):
"""
Initialize object
:param provider_def: provider definition
:returns: pygeoapi.provider.xarray_.XarrayProvider
"""
BaseProvider.__init__(self, provider_def)
try:
self._data = open_data(self.data)
self._coverage_properties = self._get_coverage_properties()
self.axes = [
self._coverage_properties['x_axis_label'],
self._coverage_properties['y_axis_label'],
self._coverage_properties['time_axis_label'], 'percentile'
]
if 'RCP' in self.data:
self.axes.append('scenario')
self.fields = self._coverage_properties['fields']
except Exception as err:
LOGGER.warning(err)
raise ProviderConnectionError(err)
def __init__(self, definition):
"""initializer"""
BaseProvider.__init__(self, definition)
with open(self.url) as ff:
self.data = csv.DictReader(ff)
def __init__(self, provider_def):
"""
GeoPackageProvider Class constructor
:param provider_def: provider definitions from yml pygeoapi-config.
data,id_field, name set in parent class
:returns: pygeoapi.providers.base.GeoPackageProvider
"""
BaseProvider.__init__(self, provider_def)
self.table = provider_def['table']
self.view = "vgpkg_" + provider_def['table']
self.dataDB = None
LOGGER.debug('Setting GPKG properties:')
LOGGER.debug('Data source:{}'.format(self.data))
LOGGER.debug('Name:{}'.format(self.name))
LOGGER.debug('ID_field:{}'.format(self.id_field))
LOGGER.debug('Table:{}'.format(self.table))
self.cursor = self.__load()
LOGGER.debug('Got cursor from GeoPackage')
def __init__(self, provider_def):
"""
Initialize object
:param provider_def: provider definition
:returns: pygeoapi.provider.tinydb_.TinyDBCatalogueProvider
"""
self.excludes = [
'_metadata-anytext',
]
BaseProvider.__init__(self, provider_def)
LOGGER.debug('Connecting to TinyDB db at {}'.format(self.data))
if not os.path.exists(self.data):
msg = 'TinyDB does not exist'
LOGGER.error(msg)
raise ProviderConnectionError(msg)
self.db = TinyDB(self.data)
self.fields = self.get_fields()
def __init__(self, provider_def):
"""
PostgreSQLProvider Class constructor
:param provider_def: provider definitions from yml pygeoapi-config.
data,id_field, name set in parent class
data contains the connection information
for class DatabaseCursor
:returns: pygeoapi.providers.base.PostgreSQLProvider
"""
BaseProvider.__init__(self, provider_def)
self.table = provider_def['table']
self.id_field = provider_def['id_field']
self.conn_dic = provider_def['data']
self.geom = provider_def.get('geom_field', 'geom')
LOGGER.debug('Setting Postgresql properties:')
LOGGER.debug('Connection String:{}'.format(",".join(
("{}={}".format(*i) for i in self.conn_dic.items()))))
LOGGER.debug('Name:{}'.format(self.name))
LOGGER.debug('ID_field:{}'.format(self.id_field))
LOGGER.debug('Table:{}'.format(self.table))
LOGGER.debug('Get available fields/properties')
self.get_fields()
def __init__(self, provider_def):
"""
Initialize object
:param provider_def: provider definition
:returns: pygeoapi.providers.elasticsearch_.ElasticsearchProvider
"""
BaseProvider.__init__(self, provider_def)
url_tokens = self.data.split('/')
LOGGER.debug('Setting Elasticsearch properties')
self.es_host = url_tokens[2]
self.index_name = url_tokens[-2]
self.type_name = url_tokens[-1]
LOGGER.debug('host: {}'.format(self.es_host))
LOGGER.debug('index: {}'.format(self.index_name))
LOGGER.debug('type: {}'.format(self.type_name))
LOGGER.debug('Connecting to Elasticsearch')
self.es = Elasticsearch(self.es_host)
if not self.es.ping():
msg = 'Cannot connect to Elasticsearch'
LOGGER.error(msg)
raise ProviderConnectionError(msg)
LOGGER.debug('Grabbing field information')
try:
self.fields = self.get_fields()
except exceptions.NotFoundError as err:
LOGGER.error(err)
raise ProviderQueryError(err)
def __init__(self, provider_def):
"""
Initialize object
:param provider_def: provider definition
:returns: pygeoapi.providers.xarray_.XarrayProvider
"""
BaseProvider.__init__(self, provider_def)
try:
if provider_def['format']['name'] == 'zarr':
open_func = xarray.open_zarr
else:
open_func = xarray.open_dataset
self._data = open_func(self.data)
self._data = _convert_float32_to_float64(self._data)
self._coverage_properties = self._get_coverage_properties()
self.axes = [self._coverage_properties['x_axis_label'],
self._coverage_properties['y_axis_label'],
self._coverage_properties['time_axis_label']]
self.fields = self._coverage_properties['fields']
except Exception as err:
LOGGER.warning(err)
raise ProviderConnectionError(err)
def __init__(self, provider_def):
"""
SQLiteGPKGProvider Class constructor
:param provider_def: provider definitions from yml pygeoapi-config.
data,id_field, name set in parent class
:returns: pygeoapi.providers.base.SQLiteProvider
"""
BaseProvider.__init__(self, provider_def)
self.table = provider_def['table']
self.application_id = None
self.geom_col = None
LOGGER.debug('Setting SQLite properties:')
LOGGER.debug('Data source: {}'.format(self.data))
LOGGER.debug('Name: {}'.format(self.name))
LOGGER.debug('ID_field: {}'.format(self.id_field))
LOGGER.debug('Table: {}'.format(self.table))
self.cursor = self.__load()
LOGGER.debug('Got cursor from DB')
LOGGER.debug('Get available fields/properties')
self.get_fields()
def __init__(self, definition):
"""initializer"""
BaseProvider.__init__(self, definition)
# url is a file path, TODO use urlparse or support local paths
self.path = self.url.replace("file://", '')
self._validate_or_create(self.path)
def __init__(self, provider_def):
"""
PostgreSQLProvider Class constructor
:param provider_def: provider definitions from yml pygeoapi-config.
data, name, id_field and query set in parent class
data contains the connection information
for class DatabaseCursor
:returns: pygeoapi.providers.base.PostgreSQLProvider
"""
BaseProvider.__init__(self, provider_def)
self.name = provider_def['name']
self.table = provider_def['table']
self.id_field = provider_def['id_field']
self.conn_dic = provider_def['data']
self.geom = provider_def.get('geom_field', 'geom')
if 'column_property_mapping' in provider_def:
self.columns_to_properties = \
provider_def.get('column_property_mapping')
else:
# Getting columns
query_cols = \
"SELECT column_name, udt_name FROM information_schema.columns \
WHERE table_name = '{}' and udt_name != 'geometry';" .format(
self.table)
with DatabaseConnection(self.conn_dic) as db:
cursor = db.conn.cursor(cursor_factory=RealDictCursor)
cursor.execute(query_cols)
result = cursor.fetchall()
self.columns_to_properties = \
dict(zip([item['column_name'] for item in result],
[item['column_name'] for item in result]))
self.columns = SQL(', ').join([
SQL('{} {}').format(Identifier(col), Identifier(prop))
for (col, prop) in self.columns_to_properties.items()
])
self.properties_to_cols = dict(
zip(self.columns_to_properties.values(),
self.columns_to_properties.keys()))
LOGGER.debug('Setting Postgresql properties:')
LOGGER.debug('Connection String:{}'.format(','.join(
('{}={}'.format(*i) for i in self.conn_dic.items()))))
LOGGER.debug('Name:{}'.format(self.name))
LOGGER.debug('ID_field:{}'.format(self.id_field))
LOGGER.debug('Query_table:{}'.format(self.table))
LOGGER.debug('Get available fields/properties')
self.get_fields()
def __init__(self, provider_def):
"""
Initialize object
:param provider_def: provider definition
:returns: pygeoapi.providers.csv_.CSVProvider
"""
BaseProvider.__init__(self, provider_def)
self.geometry_x = provider_def['geometry']['x_field']
self.geometry_y = provider_def['geometry']['y_field']
def __init__(self, definition):
"""initializer"""
BaseProvider.__init__(self, definition)
url_tokens = self.url.split('/')
self.index_name = url_tokens[-2]
self.type_name = url_tokens[-1]
self.es_host = url_tokens[2]
self.es = Elasticsearch(self.es_host)
def __init__(self, provider_def):
"""
Initialize object
:param provider_def: provider definition
:returns: pygeoapi.provider.filesystem.FileSystemProvider
"""
BaseProvider.__init__(self, provider_def)
if not os.path.exists(self.data):
msg = 'Directory does not exist: {}'.format(self.data)
LOGGER.error(msg)
raise ProviderConnectionError(msg)
def __init__(self, provider_def):
"""
SQLiteProvider Class constructor
:param provider_def: provider definitions from yml pygeoapi-config.
data,id_field, name set in parent class
:returns: pygeoapi.providers.base.SQLiteProvider
"""
BaseProvider.__init__(self, provider_def)
self.table = provider_def['table']
LOGGER.debug('Setting SQLite properties:')
LOGGER.debug('Data source: {}'.format(self.data))
LOGGER.debug('Name: {}'.format(self.name))
LOGGER.debug('ID_field: {}'.format(self.id_field))
LOGGER.debug('Table: {}'.format(self.table))
def __init__(self, provider_def):
"""
Initialize object
:param provider_def: provider definition
:returns: pygeoapi.providers.rasterio_.RasterioProvider
"""
BaseProvider.__init__(self, provider_def)
try:
self._data = rasterio.open(self.data)
self._coverage_properties = self._get_coverage_properties()
self.axes = self._coverage_properties['axes']
self.crs = self._coverage_properties['bbox_crs']
self.num_bands = self._coverage_properties['num_bands']
self.fields = [str(num) for num in range(1, self.num_bands + 1)]
self.native_format = provider_def['format']['name']
except Exception as err:
LOGGER.warning(err)
raise ProviderConnectionError(err)
def __init__(self, provider_def):
"""
Initialize object
:param provider_def: provider definition
:returns: pygeoapi.providers.elasticsearch_.ElasticsearchProvider
"""
BaseProvider.__init__(self, provider_def)
url_tokens = self.data.split('/')
LOGGER.debug('Setting Elasticsearch properties')
self.es_host = url_tokens[2]
self.index_name = url_tokens[-1]
self.is_gdal = False
LOGGER.debug('host: {}'.format(self.es_host))
LOGGER.debug('index: {}'.format(self.index_name))
LOGGER.debug('Connecting to Elasticsearch')
self.es = Elasticsearch(self.es_host)
if not self.es.ping():
msg = 'Cannot connect to Elasticsearch'
LOGGER.error(msg)
raise ProviderConnectionError(msg)
LOGGER.debug('Determining ES version')
v = self.es.info()['version']['number'][:3]
if float(v) < 7:
msg = 'only ES 7+ supported'
LOGGER.error(msg)
raise ProviderConnectionError(msg)
LOGGER.debug('Grabbing field information')
try:
self.fields = self.get_fields()
except exceptions.NotFoundError as err:
LOGGER.error(err)
raise ProviderQueryError(err)
def __init__(self, provider_def):
"""
MongoProvider Class constructor
:param provider_def: provider definitions from yml pygeoapi-config.
data,id_field, name set in parent class
:returns: pygeoapi.providers.mongo.MongoProvider
"""
# this is dummy value never used in case of Mongo.
# Mongo id field is _id
provider_def.setdefault('id_field', '_id')
BaseProvider.__init__(self, provider_def)
LOGGER.info('Mongo source config: {}'.format(self.data))
dbclient = MongoClient(self.data)
self.featuredb = dbclient.get_default_database()
self.collection = provider_def['collection']
self.featuredb[self.collection].create_index([("geometry", GEOSPHERE)])
def __init__(self, provider_def):
"""initializer"""
BaseProvider.__init__(self, provider_def)
self.fields = self.get_fields()
def __init__(self, provider_def):
"""
Initialize object
# Typical OGRProvider YAML config:
provider:
name: OGR
data:
source_type: WFS
source: WFS:http://geodata.nationaalgeoregister.nl/rdinfo/wfs?
source_srs: EPSG:28992
target_srs: EPSG:4326
source_capabilities:
paging: True
source_options:
OGR_WFS_LOAD_MULTIPLE_LAYER_DEFN: NO
# open_options:
# EXPOSE_GML_ID: NO
gdal_ogr_options:
EMPTY_AS_NULL: NO
GDAL_CACHEMAX: 64
# GDAL_HTTP_PROXY: (optional proxy)
# GDAL_PROXY_AUTH: (optional auth for remote WFS)
CPL_DEBUG: NO
id_field: gml_id
layer: rdinfo:stations
:param provider_def: provider definition
:returns: pygeoapi.providers.ogr.OGRProvider
"""
BaseProvider.__init__(self, provider_def)
self.ogr = osgeo_ogr
# http://trac.osgeo.org/gdal/wiki/PythonGotchas
self.gdal = osgeo_gdal
self.gdal.UseExceptions()
LOGGER.info("Using GDAL/OGR version: %d"
% int(osgeo_gdal.VersionInfo('VERSION_NUM')))
# GDAL error handler function
# http://pcjericks.github.io/py-gdalogr-cookbook/gdal_general.html
def gdal_error_handler(err_class, err_num, err_msg):
err_type = {
osgeo_gdal.CE_None: 'None',
osgeo_gdal.CE_Debug: 'Debug',
osgeo_gdal.CE_Warning: 'Warning',
osgeo_gdal.CE_Failure: 'Failure',
osgeo_gdal.CE_Fatal: 'Fatal'
}
err_msg = err_msg.replace('\n', ' ')
err_class = err_type.get(err_class, 'None')
LOGGER.error('Error Number: %s, Type: %s, Msg: %s'
% (err_num, err_class, err_msg))
# install error handler
self.gdal.PushErrorHandler(gdal_error_handler)
LOGGER.debug('Setting OGR properties')
self.data_def = provider_def['data']
# Generic GDAL/OGR options (optional)
gdal_ogr_options = self.data_def.get('gdal_ogr_options', {})
for key in gdal_ogr_options:
self.gdal.SetConfigOption(key, str(gdal_ogr_options[key]))
# Driver-specific options (optional)
source_options = self.data_def.get('source_options', {})
for key in source_options:
self.gdal.SetConfigOption(key, str(source_options[key]))
# Open options
self.open_options = self.data_def.get('open_options', {})
self.source_capabilities = self.data_def.get('source_capabilities',
{'paging': False})
self.source_srs = int(self.data_def.get('source_srs',
'EPSG:4326').split(':')[1])
self.target_srs = int(self.data_def.get('target_srs',
'EPSG:4326').split(':')[1])
# Optional coordinate transformation inward (requests) and
# outward (responses) when the source layers and WFS3 collections
# differ in EPSG-codes.
self.transform_in = None
self.transform_out = None
if self.source_srs != self.target_srs:
source = osgeo_osr.SpatialReference()
source.ImportFromEPSG(self.source_srs)
target = osgeo_osr.SpatialReference()
target.ImportFromEPSG(self.target_srs)
self.transform_in = \
osgeo_osr.CoordinateTransformation(target, source)
self.transform_out = \
osgeo_osr.CoordinateTransformation(source, target)
self._load_source_helper(self.data_def['source_type'])
# Layer name is required
self.layer_name = provider_def.get('layer', None)
if not self.layer_name:
msg = 'Need explicit \'layer\' attr in provider config'
LOGGER.error(msg)
raise Exception(msg)
# Init driver and Source connection
self.driver = None
self.conn = None
def __init__(self, provider_def):
"""initializer"""
BaseProvider.__init__(self, provider_def)
def __init__(self, definition):
"""initializer"""
BaseProvider.__init__(self, definition)
self.path = self.url.replace("file://", '')
def __init__(self, provider_def):
"""
Initialize object
# Typical OGRProvider YAML config:
provider:
name: OGR
data:
source_type: WFS
source: WFS:http://geodata.nationaalgeoregister.nl/rdinfo/wfs?
source_srs: EPSG:28992
target_srs: EPSG:4326
source_capabilities:
paging: True
source_options:
OGR_WFS_LOAD_MULTIPLE_LAYER_DEFN: NO
# open_options:
# EXPOSE_GML_ID: NO
gdal_ogr_options:
EMPTY_AS_NULL: NO
GDAL_CACHEMAX: 64
# GDAL_HTTP_PROXY: (optional proxy)
# GDAL_PROXY_AUTH: (optional auth for remote WFS)
CPL_DEBUG: NO
id_field: gml_id
layer: rdinfo:stations
:param provider_def: provider definition
:returns: pygeoapi.providers.ogr.OGRProvider
"""
BaseProvider.__init__(self, provider_def)
self.ogr = osgeo_ogr
# http://trac.osgeo.org/gdal/wiki/PythonGotchas
self.gdal = osgeo_gdal
LOGGER.info("Using GDAL/OGR version: %d" %
int(osgeo_gdal.VersionInfo('VERSION_NUM')))
# install error handler
err = GdalErrorHandler()
self.handler = err.handler
self.gdal.PushErrorHandler(self.handler)
# Exceptions will get raised on anything >= gdal.CE_Failure
self.gdal.UseExceptions()
LOGGER.debug('Setting OGR properties')
self.data_def = provider_def['data']
# Generic GDAL/OGR options (optional)
gdal_ogr_options = self.data_def.get('gdal_ogr_options', {})
for key in gdal_ogr_options:
self.gdal.SetConfigOption(key, str(gdal_ogr_options[key]))
# Driver-specific options (optional)
source_options = self.data_def.get('source_options', {})
for key in source_options:
self.gdal.SetConfigOption(key, str(source_options[key]))
# Open options
self.open_options = self.data_def.get('open_options', {})
self.source_capabilities = self.data_def.get('source_capabilities',
{'paging': False})
self.source_srs = int(
self.data_def.get('source_srs', 'EPSG:4326').split(':')[1])
self.target_srs = int(
self.data_def.get('target_srs', 'EPSG:4326').split(':')[1])
# Optional coordinate transformation inward (requests) and
# outward (responses) when the source layers and WFS3 collections
# differ in EPSG-codes.
self.transform_in = None
self.transform_out = None
if self.source_srs != self.target_srs:
source = osgeo_osr.SpatialReference()
source.SetAxisMappingStrategy(
OGRProvider.OAMS_TRADITIONAL_GIS_ORDER)
source.ImportFromEPSG(self.source_srs)
target = osgeo_osr.SpatialReference()
target.SetAxisMappingStrategy(
OGRProvider.OAMS_TRADITIONAL_GIS_ORDER)
target.ImportFromEPSG(self.target_srs)
self.transform_in = \
osgeo_osr.CoordinateTransformation(target, source)
self.transform_out = \
osgeo_osr.CoordinateTransformation(source, target)
self._load_source_helper(self.data_def['source_type'])
# Layer name is required
self.layer_name = provider_def.get('layer', None)
if not self.layer_name:
msg = 'Need explicit \'layer\' attr in provider config'
LOGGER.error(msg)
raise Exception(msg)
# Init driver and Source connection
self.driver = None
self.conn = None
LOGGER.debug('Grabbing field information')
self.fields = self.get_fields()