def WebCoverageService(url, version=None, xml=None, cookies=None, timeout=30, auth=None, headers=None):
''' wcs factory function, returns a version specific WebCoverageService object '''
if not auth:
auth = Authentication()
if version is None:
if xml is None:
reader = wcsBase.WCSCapabilitiesReader(auth=auth, headers=headers)
request = reader.capabilities_url(url)
xml = openURL(
request, cookies=cookies, timeout=timeout, auth=auth, headers=headers).read()
capabilities = etree.etree.fromstring(xml)
version = capabilities.get('version')
del capabilities
clean_url = clean_ows_url(url)
if version == '1.0.0':
return wcs100.WebCoverageService_1_0_0.__new__(
wcs100.WebCoverageService_1_0_0, clean_url, xml, cookies, auth=auth, timeout=timeout, headers=headers)
elif version == '1.1.0':
return wcs110.WebCoverageService_1_1_0.__new__(
wcs110.WebCoverageService_1_1_0, url, xml, cookies, auth=auth, timeout=timeout, headers=headers)
elif version == '1.1.1':
return wcs111.WebCoverageService_1_1_1.__new__(
wcs111.WebCoverageService_1_1_1, url, xml, cookies, auth=auth, timeout=timeout, headers=headers)
elif version == '2.0.0':
return wcs200.WebCoverageService_2_0_0.__new__(
wcs200.WebCoverageService_2_0_0, url, xml, cookies, auth=auth, timeout=timeout, headers=headers)
elif version == '2.0.1':
return wcs201.WebCoverageService_2_0_1.__new__(
wcs201.WebCoverageService_2_0_1, url, xml, cookies, auth=auth, timeout=timeout, headers=headers)
def __init__(
self,
url,
version,
xml=None,
parse_remote_metadata=False,
timeout=30,
username=None,
password=None,
auth=None,
):
"""Initialize."""
if auth:
if username:
auth.username = username
if password:
auth.password = password
self.url = url
self.version = version
self.timeout = timeout
self.auth = auth or Authentication(username, password)
self._capabilities = None
reader = WFSCapabilitiesReader(self.version, auth=self.auth)
if xml:
self._capabilities = reader.readString(xml)
else:
self._capabilities = reader.read(self.url)
self._buildMetadata(parse_remote_metadata)
def __init__(
self,
url,
version,
xml=None,
parse_remote_metadata=False,
timeout=30,
headers=None,
username=None,
password=None,
auth=None,
):
"""Initialize."""
if auth:
if username:
auth.username = username
if password:
auth.password = password
else:
auth = Authentication()
super(WebFeatureService_2_0_0, self).__init__(auth)
log.debug("building WFS %s" % url)
self.url = url
self.version = version
self.timeout = timeout
self.headers = headers
self._capabilities = None
reader = WFSCapabilitiesReader(self.version,
headers=self.headers,
auth=self.auth)
if xml:
self._capabilities = reader.readString(xml)
else:
self._capabilities = reader.read(self.url)
self._buildMetadata(parse_remote_metadata)
def __init__(
self,
url,
version,
xml=None,
parse_remote_metadata=False,
timeout=30,
username=None,
password=None,
auth=None,
):
"""Initialize."""
if auth:
if username:
auth.username = username
if password:
auth.password = password
else:
auth = Authentication(username, password)
super(WebFeatureService_1_1_0, self).__init__(auth)
self.url = url
self.version = version
self.timeout = timeout
self._capabilities = None
self.owscommon = OwsCommon("1.0.0")
reader = WFSCapabilitiesReader(self.version, auth=self.auth)
if xml:
self._capabilities = reader.readString(xml)
else:
self._capabilities = reader.read(self.url)
self._buildMetadata(parse_remote_metadata)
def __init__(self, url, version='1.1.1', xml=None, username=None, password=None,
parse_remote_metadata=False, headers=None, timeout=30, auth=None):
"""Initialize."""
if auth:
if username:
auth.username = username
if password:
auth.password = password
self.url = url
self.version = version
self.timeout = timeout
self.headers = headers
self._capabilities = None
self.auth = auth or Authentication(username, password)
# Authentication handled by Reader
reader = WMSCapabilitiesReader(
self.version, url=self.url, headers=headers, auth=self.auth)
if xml: # read from stored xml
self._capabilities = reader.readString(xml)
else: # read from server
self._capabilities = reader.read(self.url, timeout=self.timeout)
self.request = reader.request
# avoid building capabilities metadata if the
# response is a ServiceExceptionReport
se = self._capabilities.find('ServiceException')
if se is not None:
err_message = str(se.text).strip()
raise ServiceException(err_message)
# build metadata objects
self._buildMetadata(parse_remote_metadata)
def get_schema(
url, typename, version="1.0.0", timeout=30, headers=None, username=None, password=None, auth=None
):
"""Parses DescribeFeatureType response and creates schema compatible
with :class:`fiona`
:param str url: url of the service
:param str version: version of the service
:param str typename: name of the layer
:param int timeout: request timeout
:param str username: service authentication username
:param str password: service authentication password
:param Authentication auth: instance of owslib.util.Authentication
"""
if auth:
if username:
auth.username = username
if password:
auth.password = password
else:
auth = Authentication(username, password)
url = _get_describefeaturetype_url(url, version, typename)
root = _get_remote_describefeaturetype(url, timeout=timeout,
headers=headers, auth=auth)
if ":" in typename:
typename = typename.split(":")[1]
type_element = root.find("./{%s}element" % XS_NAMESPACE)
complex_type = type_element.attrib["type"].split(":")[1]
elements = _get_elements(complex_type, root)
nsmap = None
if hasattr(root, "nsmap"):
nsmap = root.nsmap
return _construct_schema(elements, nsmap)
def _get_csw(self):
"""convenience function to init owslib.csw.CatalogueServiceWeb""" # spellok
self.disable_ssl_verification = self.disableSSLVerification.isChecked()
auth = None
if self.disable_ssl_verification:
try:
auth = Authentication(verify=False)
except NameError:
pass
# connect to the server
with OverrideCursor(Qt.WaitCursor):
try:
self.catalog = CatalogueServiceWeb(
self.catalog_url, # spellok
timeout=self.timeout,
username=self.catalog_username,
password=self.catalog_password,
auth=auth)
return True
except ExceptionReport as err:
msg = self.tr('Error connecting to service: {0}').format(err)
except ValueError as err:
msg = self.tr('Value Error: {0}').format(err)
except Exception as err:
msg = self.tr('Unknown Error: {0}').format(err)
QMessageBox.warning(self, self.tr('CSW Connection error'), msg)
return False
def get_layers_for_wms(wms_url):
"""
Retrieve metadata from a WMS service including layers, available styles, and the bounding box.
Args:
wms_url(str): URL to the WMS service endpoint.
Returns:
dict<layer_name:dict<styles,bbox>>: A dictionary with a key for each WMS layer available and a dictionary value containing metadata about the layer.
"""
auth = Authentication(verify=False)
wms = WebMapService(wms_url, auth=auth)
#wms = WebMapService(wms_url)
layers = wms.contents
log.debug('WMS Contents:')
log.debug(layers)
layers_dict = dict()
for layer_name, layer in layers.items():
layer_styles = layer.styles
layer_bbox = layer.boundingBoxWGS84
leaflet_bbox = [[layer_bbox[1], layer_bbox[0]],
[layer_bbox[3], layer_bbox[2]]]
layers_dict.update(
{layer_name: {
'styles': layer_styles,
'bbox': leaflet_bbox
}})
log.debug('Layers Dict:')
log.debug(layers_dict)
return layers_dict
def __init__(self,
url,
version=None,
xml=None,
username=None,
password=None,
parse_remote_metadata=False,
headers=None,
timeout=config_loader(dataset="WMS_request_timeout"),
auth=None):
"""Initialize."""
if auth:
if username:
auth.username = username
if password:
auth.password = password
self.url = url
self.version = version
self.timeout = timeout
self.headers = headers
self._capabilities = None
self.auth = auth or Authentication(username, password)
# Authentication handled by Reader
reader = WMSCapabilitiesReader(self.version,
url=self.url,
headers=headers,
auth=self.auth)
if xml:
# read from stored xml
self._capabilities = reader.readString(xml)
else:
# read from server
self._capabilities = reader.read(self.url, timeout=self.timeout)
self.request = reader.request
if not self.version:
self.version = self._capabilities.attrib["version"]
if self.version not in ["1.1.1", "1.3.0"]:
self.version = "1.1.1"
reader.version = self.version
self.WMS_NAMESPACE = "{http://www.opengis.net/wms}" if self.version == "1.3.0" else ""
self.OGC_NAMESPACE = "{http://www.opengis.net/ogc}" if self.version == "1.3.0" else ""
# avoid building capabilities metadata if the
# response is a ServiceExceptionReport
se = self._capabilities.find('ServiceException')
if se is not None:
err_message = str(se.text).strip()
raise ServiceException(err_message)
# (mss) Store capabilities document.
self.capabilities_document = reader.capabilities_document
# (mss)
# build metadata objects
self._buildMetadata(parse_remote_metadata)
def __init__(self, version=None, cookies=None, auth=None):
"""Initialize
@type version: string
@param version: WCS Version parameter e.g '1.0.0'
"""
self.version = version
self._infoset = None
self.cookies = cookies
self.auth = auth or Authentication()
def __init__(self, version='1.0', username=None, password=None, auth=None):
"""Initialize"""
if auth:
if username:
auth.username = username
if password:
auth.password = password
self.auth = auth or Authentication(username, password)
self.version = version
self._infoset = None
def __init__(self, community, url, schema, fromdate, clean, limit, outdir,
verify):
super().__init__(community, url, fromdate, clean, limit, outdir,
verify)
logging.captureWarnings(True)
self.csw = CatalogueServiceWeb(self.url,
auth=Authentication(verify=self.verify))
self._schema_type = schema
self._schema = None
self._constraints = None
def show_metadata(self):
"""show record metadata"""
if not self.treeRecords.selectedItems():
return
item = self.treeRecords.currentItem()
if not item:
return
identifier = get_item_data(item, 'identifier')
self.disable_ssl_verification = self.disableSSLVerification.isChecked()
auth = None
if self.disable_ssl_verification:
try:
auth = Authentication(verify=False)
except NameError:
pass
try:
with OverrideCursor(Qt.WaitCursor):
cat = CatalogueServiceWeb(
self.catalog_url,
timeout=self.timeout, # spellok
username=self.catalog_username,
password=self.catalog_password,
auth=auth)
cat.getrecordbyid(
[self.catalog.records[identifier].identifier])
except ExceptionReport as err:
QMessageBox.warning(
self, self.tr('GetRecords error'),
self.tr('Error getting response: {0}').format(err))
return
except KeyError as err:
QMessageBox.warning(self, self.tr('Record parsing error'),
self.tr('Unable to locate record identifier'))
return
record = cat.records[identifier]
record.xml_url = cat.request
crd = RecordDialog()
metadata = render_template('en', self.context, record,
'record_metadata_dc.html')
style = QgsApplication.reportStyleSheet()
crd.textMetadata.document().setDefaultStyleSheet(style)
crd.textMetadata.setHtml(metadata)
crd.exec_()
def __init__(self, version='1.1.1', url=None, un=None, pw=None, headers=None, auth=None):
"""Initialize"""
self.version = version
self._infoset = None
self.url = url
if auth:
if un:
auth.username = un
if pw:
auth.password = pw
self.headers = headers
self.request = None
self.auth = auth or Authentication(un, pw)
def load_data(bbox, max_features=1000):
wfs = WebFeatureService(NOVO_FCAMPO_WFS,
version='1.1.0',
auth=Authentication(verify=False))
response = wfs.getfeature(typename='geoquimica:novo-fcampo',
bbox=bbox,
srsname='urn:x-ogc:def:crs:EPSG:4326',
maxfeatures=max_features)
data = gpd.read_file(response)
data.rename(lambda x: str(x).lower(), axis='columns', inplace=True)
return data
def __init__(self,
url,
version,
json_,
timeout=30,
username=None,
password=None,
auth=None):
"""
initializer; implements Requirement 1 (/req/core/root-op)
@type url: string
@param url: url of WFS root document
@type json_: string
@param json_: json object
@param timeout: time (in seconds) after which requests should timeout
@param username: service authentication username
@param password: service authentication password
@param auth: instance of owslib.util.Authentication
@return: initialized WebFeatureService_3_0_0 object
"""
if "?" in url:
self.url, self.url_query_string = url.split("?")
else:
self.url = url.rstrip("/") + "/"
self.url_query_string = None
self.version = version
self.json_ = json_
self.timeout = timeout
if auth:
if username:
auth.username = username
if password:
auth.password = password
self.auth = auth or Authentication(username, password)
if json_ is not None: # static JSON string
self.links = json.loads(json_)["links"]
else:
response = http_get(url, headers=REQUEST_HEADERS,
auth=self.auth).json()
self.links = response["links"]
def __init__(self,
version,
identifier,
cookies,
auth=None,
timeout=30,
headers=None):
"""Initialize
@type version: string
@param version: WCS Version parameter e.g '1.0.0'
"""
self.version = version
self._infoset = None
self.identifier = identifier
self.cookies = cookies
self.headers = headers
self.timeout = timeout
self.auth = auth or Authentication()
def __init__(self, host, **kwargs):
"""Create a WCS client attached to the given host address (an URL).
Args:
host (str): the server URL.
**kwargs: The keyword arguments with credentials to access OGC WCS.
"""
invalid_parameters = set(kwargs) - {"username", "password"}
if invalid_parameters:
raise AttributeError(
'invalid parameter(s): {}'.format(invalid_parameters))
if 'username' in kwargs:
auth = Authentication(username=kwargs['username'],
password=kwargs['password'])
self.wcs_owslib = WebCoverageService(host,
version='1.0.0',
auth=auth)
else:
self.wcs_owslib = WebCoverageService(host, version='1.0.0')
def openURL(url_base,
data=None,
method='Get',
cookies=None,
username=None,
password=None,
timeout=config_loader(dataset="WMS_request_timeout"),
headers=None,
verify=None,
cert=None,
auth=None,
proxies=None):
# (mss) added proxies
# (mss) timeout default of 30secs set by the config_loader
"""
Function to open URLs.
Uses requests library but with additional checks for OGC service exceptions and url formatting.
Also handles cookies and simple user password authentication.
"""
headers = headers if headers is not None else {}
rkwargs = {}
rkwargs['timeout'] = timeout
if auth:
if username:
auth.username = username
if password:
auth.password = password
if cert:
auth.cert = cert
verify = verify and auth.verify
else:
auth = Authentication(username, password, cert, verify)
if auth.username and auth.password:
rkwargs['auth'] = (auth.username, auth.password)
rkwargs['cert'] = auth.cert
rkwargs['verify'] = verify
# FIXUP for WFS in particular, remove xml style namespace
# @TODO does this belong here?
method = method.split("}")[-1]
if method.lower() == 'post':
try:
etree.fromstring(data)
headers['Content-Type'] = 'text/xml'
except (ParseError, UnicodeEncodeError) as error:
# (mss)
logging.debug("ParseError, UnicodeEncodeError %s", error)
rkwargs['data'] = data
elif method.lower() == 'get':
rkwargs['params'] = data
else:
raise ValueError(
f"Unknown method ('{method}'), expected 'get' or 'post'")
if cookies is not None:
rkwargs['cookies'] = cookies
req = requests.request(
method.upper(),
url_base,
headers=headers,
# MSS
proxies=proxies,
**rkwargs)
if req.status_code in [400, 401]:
raise ServiceException(req.text)
if req.status_code in [404, 500, 502, 503, 504]: # add more if needed
req.raise_for_status()
# check for service exceptions without the http header set
if 'Content-Type' in req.headers and req.headers['Content-Type'] in [
'text/xml', 'application/xml', 'application/vnd.ogc.se_xml',
'application/vnd.ogc.wms_xml'
]:
# just in case 400 headers were not set, going to have to read the xml to see if it's an exception report.
se_tree = etree.fromstring(req.content)
# to handle the variety of namespaces and terms across services
# and versions, especially for "legacy" responses like WMS 1.3.0
possible_errors = [
'{http://www.opengis.net/ows}Exception',
'{http://www.opengis.net/ows/1.1}Exception',
'{http://www.opengis.net/ogc}ServiceException', 'ServiceException'
]
for possible_error in possible_errors:
serviceException = se_tree.find(possible_error)
if serviceException is not None:
# and we need to deal with some message nesting
raise ServiceException('\n'.join([
str(t).strip() for t in serviceException.itertext()
if t.strip()
]))
return ResponseWrapper(req)
def __init__(self, auth=None, timeout=30, headers=None):
self.auth = auth or Authentication()
self.headers = headers
self.timeout = timeout
def __init__(self,
url,
lang='en-US',
version='3.0.0',
timeout=10,
skip_caps=False,
username=None,
password=None,
auth=None):
"""
Construct and process a GetCapabilities request
Parameters
----------
- url: the URL of the CSW
- lang: the language (default is 'en-US')
- version: version (default is '3.0.0')
- timeout: timeout in seconds
- skip_caps: whether to skip GetCapabilities processing on init (default is False)
- username: username for HTTP basic authentication
- password: password for HTTP basic authentication
- auth: instance of owslib.util.Authentication
"""
if auth:
if username:
auth.username = username
if password:
auth.password = password
self.url = util.clean_ows_url(url)
self.lang = lang
self.version = version
self.timeout = timeout
self.auth = auth or Authentication(username, password)
self.service = 'CSW'
self.exceptionreport = None
self.owscommon = ows.OwsCommon('2.0.0')
if not skip_caps: # process GetCapabilities
# construct request
data = {
'service': self.service,
'version': self.version,
'request': 'GetCapabilities'
}
self.request = urlencode(data)
self._invoke()
if self.exceptionreport is None:
self.updateSequence = self._exml.getroot().attrib.get(
'updateSequence')
# ServiceIdentification
val = self._exml.find(
util.nspath_eval('ows200:ServiceIdentification',
namespaces))
if val is not None:
self.identification = ows.ServiceIdentification(
val, self.owscommon.namespace)
else:
self.identification = None
# ServiceProvider
val = self._exml.find(
util.nspath_eval('ows200:ServiceProvider', namespaces))
if val is not None:
self.provider = ows.ServiceProvider(
val, self.owscommon.namespace)
else:
self.provider = None
# ServiceOperations metadata
self.operations = []
for elem in self._exml.findall(
util.nspath_eval(
'ows200:OperationsMetadata/ows200:Operation',
namespaces)): # noqa
self.operations.append(
ows.OperationsMetadata(elem, self.owscommon.namespace))
self.constraints = {}
for elem in self._exml.findall(
util.nspath_eval(
'ows200:OperationsMetadata/ows200:Constraint',
namespaces)): # noqa
self.constraints[elem.attrib['name']] = ows.Constraint(
elem, self.owscommon.namespace)
self.parameters = {}
for elem in self._exml.findall(
util.nspath_eval(
'ows200:OperationsMetadata/ows200:Parameter',
namespaces)): # noqa
self.parameters[elem.attrib['name']] = ows.Parameter(
elem, self.owscommon.namespace)
# FilterCapabilities
val = self._exml.find(
util.nspath_eval('fes:Filter_Capabilities', namespaces))
self.filters = fes2.FilterCapabilities(val)
from owslib.wfs import WebFeatureService
from owslib.util import Authentication
from pprint import pprint
import geopandas as gpd
wfs = WebFeatureService(
'https://geoservicos.cprm.gov.br/geoserver/geoquimica/wfs',
version='1.1.0',
auth=Authentication(verify=False))
pprint([operation.name for operation in wfs.operations])
pprint(list(wfs.contents))
pprint(wfs.get_schema('geoquimica:novo-fcampo'))
response = wfs.getfeature(typename='geoquimica:novo-fcampo',
bbox=(-41.26, -12.82, -40.88, -12.52),
srsname='urn:x-ogc:def:crs:EPSG:4326')
#with open('/tmp/geoquimica.gml', 'wb') as output:
# output.write(response.read())
df = gpd.read_file(response)
print(df.head())
def __init__(self, headers=None, auth=None):
self.auth = auth or Authentication()
self.headers = headers
def __init__(self, auth=None):
self.auth = auth or Authentication()
