def processAlgorithm(self, parameters, context, feedback):
raw_query = self.parameterAsString(parameters, self.QUERY, context)
server = self.parameterAsString(parameters, self.SERVER, context)
nominatim = self.parameterAsString(parameters, self.AREA, context)
extent = self.parameterAsExtent(parameters, self.EXTENT, context)
crs = self.parameterAsExtentCrs(parameters, self.EXTENT, context)
crs_4326 = QgsCoordinateReferenceSystem(4326)
transform = QgsCoordinateTransform(
crs, crs_4326, QgsProject.instance())
extent = transform.transform(extent)
query_preparation = QueryPreparation(
raw_query,
extent=extent,
area=nominatim,
overpass=server
)
raw_query = query_preparation.prepare_query()
url = query_preparation.prepare_url()
outputs = {
self.OUTPUT_URL: url,
self.OUTPUT_OQL_QUERY: raw_query,
}
return outputs
def process_query(dialog=None,
query=None,
nominatim=None,
bbox=None,
output_dir=None,
prefix_file=None,
output_geometry_types=None,
layer_name="OsmQuery",
white_list_values=None,
config_outputs=None):
"""execute a query and send the result file to open_file."""
# Prepare outputs
dialog.set_progress_text(tr('Prepare outputs'))
# Replace Nominatim or BBOX
query = QueryPreparation(query, bbox, nominatim)
# Getting the default overpass api and running the query
server = get_setting('defaultOAPI')
dialog.set_progress_text(tr('Downloading data from Overpass'))
QApplication.processEvents()
connexion_overpass_api = ConnexionOAPI(url=server, output="xml")
osm_file = connexion_overpass_api.query(query.prepare_query())
return open_file(dialog=dialog,
osm_file=osm_file,
output_geom_types=output_geometry_types,
white_list_column=white_list_values,
layer_name=layer_name,
output_dir=output_dir,
prefix_file=prefix_file,
config_outputs=config_outputs)
def generate_query(self):
query = self.text_query.toPlainText()
area = self.nominatim_value(Panels.Query).text()
bbox = self.get_bounding_box()
query = QueryPreparation(query, bbox, area)
query_string = query.prepare_query()
self.text_query.setPlainText(query_string)
def build_query(self) -> Dict[str, str]:
"""Build the query requested."""
query_factory = QueryFactory(
query_type=self.QUERY_TYPE,
key=self.key,
value=self.value,
area=self.area,
around_distance=self.distance,
timeout=self.timeout)
raw_query = query_factory.make(QueryLanguage.OQL)
self.feedback.pushInfo(query_factory.friendly_message())
query_preparation = QueryPreparation(
raw_query,
area=self.area,
extent=self.extent,
overpass=self.server
)
raw_query = query_preparation.prepare_query()
url = query_preparation.prepare_url()
outputs = {
self.OUTPUT_URL: url,
self.OUTPUT_OQL_QUERY: raw_query,
}
return outputs
def processAlgorithm(self, parameters, context, feedback) -> Dict[str, str]:
"""Run the algorithm."""
self.feedback = feedback
self.fetch_based_parameters(parameters, context)
crs_4326 = QgsCoordinateReferenceSystem(4326)
transform = QgsCoordinateTransform(
self.crs, crs_4326, QgsProject.instance())
self.extent = transform.transform(self.extent)
self.feedback.pushInfo('Prepare the url.')
query_preparation = QueryPreparation(
self.query,
extent=self.extent,
area=self.area,
overpass=self.server
)
raw_query = query_preparation.prepare_query()
url = query_preparation.prepare_url()
outputs = {
self.OUTPUT_URL: url,
self.OUTPUT_OQL_QUERY: raw_query,
}
return outputs
def generate_query(self):
query = self.dialog.text_query.toPlainText()
area = self.dialog.places_edits[Panels.Query].text()
self.write_nominatim_file(Panels.Query)
bbox = self.dialog.get_bounding_box()
query = QueryPreparation(query, bbox, area)
query_string = query.prepare_query()
self.dialog.text_query.setPlainText(query_string)
def generate_query(self):
query = self.dialog.text_query.toPlainText()
area = self.dialog.places_edits[Panels.Query].text()
self.write_nominatim_file(Panels.Query)
properties = self.gather_values()
query = QueryPreparation(query, properties['bbox'], area)
query_string = query.prepare_query()
self.dialog.text_query.setPlainText(query_string)
def generate_query(self):
"""
Transform the template to query "out of the box"
"""
query = self.textEdit_query.toPlainText()
nominatim = self.lineEdit_nominatim.text()
bbox = self.get_bounding_box()
query = QueryPreparation(query, bbox, nominatim)
query_string = query.prepare_query()
self.textEdit_query.setPlainText(query_string)
def generate_query(self):
"""
Transform the template to query "out of the box"
"""
query = self.textEdit_query.toPlainText()
nominatim = self.lineEdit_nominatim.text()
bbox = self.get_bounding_box()
query = QueryPreparation(query, bbox, nominatim)
query_string = query.prepare_query()
self.textEdit_query.setPlainText(query_string)
def build_query(self):
query_factory = QueryFactory(
query_type=self.QUERY_TYPE,
key=self.key,
value=self.value,
area=self.area,
around_distance=self.distance,
timeout=self.timeout)
raw_query = query_factory.make()
query_preparation = QueryPreparation(
raw_query, nominatim_place=self.area, extent=self.extent, overpass=self.server
)
raw_query = query_preparation.prepare_query()
url = query_preparation.prepare_url()
outputs = {
self.OUTPUT_URL: url,
self.OUTPUT_OQL_QUERY: raw_query,
}
return outputs
def process_query(
dialog=None,
query=None,
area=None,
bbox=None,
output_dir=None,
prefix_file=None,
output_geometry_types=None,
layer_name="OsmQuery",
white_list_values=None,
config_outputs=None):
"""execute a query and send the result file to open_file."""
# Prepare outputs
dialog.set_progress_text(tr('Prepare outputs'))
# Getting the default overpass api and running the query
server = get_setting('defaultOAPI', OVERPASS_SERVERS[0]) + 'interpreter'
dialog.set_progress_text(
tr('Downloading data from Overpass {server_name}'.format(
server_name=server)))
# Replace Nominatim or BBOX
query = QueryPreparation(query, bbox, area, server)
QApplication.processEvents()
final_query = query.prepare_query()
url = query.prepare_url()
connexion_overpass_api = ConnexionOAPI(url)
LOGGER.debug('Encoded URL: {}'.format(url))
osm_file = connexion_overpass_api.run()
return open_file(
dialog=dialog,
osm_file=osm_file,
output_geom_types=output_geometry_types,
white_list_column=white_list_values,
layer_name=layer_name,
output_dir=output_dir,
prefix_file=prefix_file,
final_query=final_query,
config_outputs=config_outputs)
def process_query(
dialog=None,
query=None,
nominatim=None,
bbox=None,
output_dir=None,
prefix_file=None,
output_geometry_types=None,
layer_name="OsmQuery",
white_list_values=None,
config_outputs=None):
"""execute a query and send the result file to open_file."""
# Prepare outputs
dialog.set_progress_text(tr('Prepare outputs'))
# Getting the default overpass api and running the query
server = get_setting('defaultOAPI', OVERPASS_SERVERS[0]) + 'interpreter'
dialog.set_progress_text(
tr('Downloading data from Overpass {}').format(server))
# Replace Nominatim or BBOX
query = QueryPreparation(query, bbox, nominatim, server)
QApplication.processEvents()
final_query = query.prepare_query()
url = query.prepare_url()
connexion_overpass_api = ConnexionOAPI(url)
LOGGER.debug('Encoded URL: {}'.format(url))
osm_file = connexion_overpass_api.run()
return open_file(
dialog=dialog,
osm_file=osm_file,
output_geom_types=output_geometry_types,
white_list_column=white_list_values,
layer_name=layer_name,
output_dir=output_dir,
prefix_file=prefix_file,
final_query=final_query,
config_outputs=config_outputs)
def processAlgorithm(self, progress):
progress.setInfo("Preparing the Overpass query")
progress.setPercentage(0)
server = self.getParameterValue(self.SERVER)
query = self.getParameterValue(self.QUERY_STRING)
nominatim = self.getParameterValue(self.NOMINATIM)
# Extent of the layer
extent = self.getParameterValue(self.EXTENT)
if extent != "0,0,0,0":
# x_min, x_max, y_min, y_max
extent = [float(i) for i in extent.split(',')]
# noinspection PyCallByClass
geometry_extent = QgsGeometry.fromRect(
QgsRectangle(extent[0], extent[2], extent[1], extent[3]))
source_crs = iface.mapCanvas().mapRenderer().destinationCrs()
crs_transform = QgsCoordinateTransform(
source_crs, QgsCoordinateReferenceSystem("EPSG:4326"))
geometry_extent.transform(crs_transform)
extent = geometry_extent.boundingBox()
else:
extent = None
if nominatim == "":
nominatim = None
# Make some transformation on the query ({{box}}, Nominatim, ...
query = QueryPreparation(query, extent, nominatim)
overpass_api = ConnexionOAPI(url=server, output="xml")
progress.setInfo("Downloading data from Overpass")
progress.setPercentage(5)
osm_file = overpass_api.get_file_from_query(query.prepare_query())
# Set the output file for Processing
progress.setPercentage(100)
self.setOutputValue(self.OUTPUT_FILE, osm_file)
def processAlgorithm(self, parameters, context, feedback):
raw_query = self.parameterAsString(parameters, self.QUERY, context)
server = self.parameterAsString(parameters, self.SERVER, context)
nominatim = self.parameterAsString(parameters, self.AREA, context)
extent = self.parameterAsExtent(parameters, self.EXTENT, context)
crs = self.parameterAsExtentCrs(parameters, self.EXTENT, context)
crs_4326 = QgsCoordinateReferenceSystem(4326)
transform = QgsCoordinateTransform(
crs, crs_4326, QgsProject.instance())
extent = transform.transform(extent)
query_preparation = QueryPreparation(
raw_query, extent=extent, nominatim_place=nominatim, overpass=server
)
raw_query = query_preparation.prepare_query()
url = query_preparation.prepare_url()
outputs = {
self.OUTPUT_URL: url,
self.OUTPUT_OQL_QUERY: raw_query,
}
return outputs
def build_query(self):
query_factory = QueryFactory(
query_type=self.QUERY_TYPE,
key=self.key,
value=self.value,
area=self.area,
around_distance=self.distance,
timeout=self.timeout)
raw_query = query_factory.make()
query_preparation = QueryPreparation(
raw_query,
area=self.area,
extent=self.extent,
overpass=self.server
)
raw_query = query_preparation.prepare_query()
url = query_preparation.prepare_url()
outputs = {
self.OUTPUT_URL: url,
self.OUTPUT_OQL_QUERY: raw_query,
}
return outputs
def generate_query(self, oql_output: bool = True):
"""Generate the query as final."""
query = self.dialog.text_query.toPlainText()
area = self.dialog.places_edits[Panels.Query].text()
self.write_nominatim_file(Panels.Query)
properties = self.gather_values()
server = get_setting('defaultOAPI', OVERPASS_SERVERS[0]) + 'convert'
query = QueryPreparation(query, properties['bbox'], area, server)
query_string = query.prepare_query()
if (oql_output
and not query.is_oql_query()) or (not oql_output
and query.is_oql_query()):
query.prepare_query()
url = query.prepare_url(
QueryLanguage.OQL if oql_output else QueryLanguage.XML)
connexion_overpass_api = ConnexionOAPI(url)
LOGGER.debug('Encoded URL: {}'.format(url))
query_string = connexion_overpass_api.run_convert()
query_string = html.unescape(query_string)
self.dialog.text_query.setPlainText(query_string)
def reload_query(query: str,
layer_name: str = 'Reloaded_query',
dialog: QDialog = None,
new_file: bool = True):
""" Reload a query with only the query """
# Getting the default overpass api and running the query
server = get_setting('defaultOAPI', OVERPASS_SERVERS[0]) + 'interpreter'
query = QueryPreparation(query, overpass=server)
final_query = query.prepare_query()
url = query.prepare_url()
connexion_overpass_api = ConnexionOAPI(url)
LOGGER.debug('Encoded URL: {}'.format(url))
osm_file = connexion_overpass_api.run()
if new_file:
layer_name += "_reloaded"
return open_file(
dialog=dialog,
osm_file=osm_file,
layer_name=layer_name,
final_query=final_query,
)
def save_final_query(self):
"""
Save the query without any templates, usefull for bbox
"""
# Which geometry at the end ?
output_geometry_types = self.get_output_geometry_types()
white_list_values = self.get_white_list_values()
query = str(self.textEdit_query.toPlainText())
nominatim = str(self.lineEdit_nominatim.text())
bbox = self.get_bounding_box()
# Delete any templates
query = QueryPreparation(query, bbox, nominatim).prepare_query()
# Save the query
save_query_dialog = SaveQueryDialog(
query=query,
output_geometry_types=output_geometry_types,
white_list_values=white_list_values)
save_query_dialog.signal_new_query_successful.connect(
self.signal_new_query_successful.emit)
save_query_dialog.exec_()
def process_query(dialog: QDialog = None,
query: str = None,
description: str = None,
area: Union[str, List[str]] = None,
key: Union[str, List[str]] = None,
value: Union[str, List[str]] = None,
type_multi_request: list = None,
bbox: QgsRectangle = None,
output_dir: str = None,
output_format: Format = None,
prefix_file: str = None,
output_geometry_types: list = None,
layer_name: str = "OsmQuery",
white_list_values: dict = None,
config_outputs: dict = None) -> int:
"""execute a query and send the result file to open_file."""
# Save the query in the historic
q_manage = QueryManagement(query=query,
name=prefix_file if prefix_file else layer_name,
description=description,
advanced=value is None,
type_multi_request=type_multi_request,
keys=key,
values=value,
area=area,
bbox=bbox,
output_geometry_types=output_geometry_types,
white_list_column=white_list_values)
q_manage.write_query_historic()
if dialog.feedback_process.isCanceled():
return None
# Prepare outputs
dialog.set_progress_text(tr('Prepare outputs'))
# Getting the default overpass api and running the query
server = get_setting('defaultOAPI', OVERPASS_SERVERS[0]) + 'interpreter'
dialog.set_progress_text(
tr('Downloading data from Overpass {server_name}'.format(
server_name=server)))
# Replace Nominatim or BBOX
query = QueryPreparation(query, bbox, area, server)
QApplication.processEvents()
final_query = query.prepare_query()
url = query.prepare_url()
connexion_overpass_api = ConnexionOAPI(url)
LOGGER.debug('Encoded URL: {}'.format(url))
osm_file = connexion_overpass_api.run()
return open_file(dialog=dialog,
osm_file=osm_file,
output_geom_types=output_geometry_types,
white_list_column=white_list_values,
key=key,
layer_name=layer_name,
output_dir=output_dir,
output_format=output_format,
prefix_file=prefix_file,
final_query=final_query,
config_outputs=config_outputs,
feedback=dialog.feedback_process)
