_id stringlengths 2 7 | title stringlengths 1 88 | partition stringclasses 3
values | text stringlengths 75 19.8k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q243600 | OsmDownloaderDialog.populate_countries | train | def populate_countries(self):
"""Populate the combobox about countries and levels."""
for i in range(1, 12):
self.admin_level_comboBox.addItem(self.tr('Level %s') % i, i)
# Set current index to admin_level 8, the most common one
self.admin_level_comboBox.setCurrentIndex(7)
... | python | {
"resource": ""
} |
q243601 | OsmDownloaderDialog.update_extent | train | def update_extent(self, extent):
"""Update extent value in GUI based from an extent.
:param extent: A list in the form [xmin, ymin, xmax, ymax] where all
coordinates provided are in Geographic / EPSG:4326.
:type extent: list
"""
self.x_minimum.setValue(extent[0])
... | python | {
"resource": ""
} |
q243602 | OsmDownloaderDialog.update_extent_from_map_canvas | train | def update_extent_from_map_canvas(self):
"""Update extent value in GUI based from value in map.
.. note:: Delegates to update_extent()
"""
self.bounding_box_group.setTitle(
self.tr('Bounding box from the map canvas'))
# Get the extent as [xmin, ymin, xmax, ymax]
... | python | {
"resource": ""
} |
q243603 | OsmDownloaderDialog.update_extent_from_rectangle | train | def update_extent_from_rectangle(self):
"""Update extent value in GUI based from the QgsMapTool rectangle.
.. note:: Delegates to update_extent()
"""
self.show()
self.canvas.unsetMapTool(self.rectangle_map_tool)
self.canvas.setMapTool(self.pan_tool)
rectangle =... | python | {
"resource": ""
} |
q243604 | OsmDownloaderDialog.drag_rectangle_on_map_canvas | train | def drag_rectangle_on_map_canvas(self):
"""Hide the dialog and allow the user to draw a rectangle."""
self.hide()
self.rectangle_map_tool.reset()
self.canvas.unsetMapTool(self.pan_tool)
self.canvas.setMapTool(self.rectangle_map_tool) | python | {
"resource": ""
} |
q243605 | OsmDownloaderDialog.get_checked_features | train | def get_checked_features(self):
"""Create a tab with all checked features.
:return A list with all features which are checked in the UI.
:rtype list
"""
feature_types = []
if self.roads_flag.isChecked():
feature_types.append('roads')
if self.buildings... | python | {
"resource": ""
} |
q243606 | OsmDownloaderDialog.accept | train | def accept(self):
"""Do osm download and display it in QGIS."""
error_dialog_title = self.tr('InaSAFE OpenStreetMap Downloader Error')
# Lock the bounding_box_group
self.bounding_box_group.setDisabled(True)
# Get the extent
y_minimum = self.y_minimum.value()
y_m... | python | {
"resource": ""
} |
q243607 | OsmDownloaderDialog.get_output_base_path | train | def get_output_base_path(
self,
output_directory,
output_prefix,
feature_type,
overwrite):
"""Get a full base name path to save the shapefile.
:param output_directory: The directory where to put results.
:type output_directory: str
... | python | {
"resource": ""
} |
q243608 | OsmDownloaderDialog.require_directory | train | def require_directory(self):
"""Ensure directory path entered in dialog exist.
When the path does not exist, this function will ask the user if he
want to create it or not.
:raises: CanceledImportDialogError - when user choose 'No' in
the question dialog for creating direct... | python | {
"resource": ""
} |
q243609 | OsmDownloaderDialog.reject | train | def reject(self):
"""Redefinition of the method to remove the rectangle selection tool.
It will call the super method.
"""
self.canvas.unsetMapTool(self.rectangle_map_tool)
self.rectangle_map_tool.reset()
super(OsmDownloaderDialog, self).reject() | python | {
"resource": ""
} |
q243610 | MultiExposureImpactFunction.add_exposure | train | def add_exposure(self, layer):
"""Add an exposure layer in the analysis.
:param layer: An exposure layer to be used for the analysis.
:type layer: QgsMapLayer
"""
self._exposures.append(layer)
self._is_ready = False | python | {
"resource": ""
} |
q243611 | ResourceParameterWidget.get_parameter | train | def get_parameter(self):
"""Obtain the parameter object from the current widget state.
:returns: A BooleanParameter from the current state of widget
"""
self._parameter.value = self._input.value()
return self._parameter | python | {
"resource": ""
} |
q243612 | StepFcHazLayerOrigin.set_widgets | train | def set_widgets(self):
"""Set widgets on the Hazard Layer Origin Type tab."""
# First, list available layers in order to check if there are
# any available layers. Note This will be repeated in
# set_widgets_step_fc_hazlayer_from_canvas because we need
# to list them again after ... | python | {
"resource": ""
} |
q243613 | Heading.to_html | train | def to_html(self):
"""Render a Heading MessageElement as html
:returns: The html representation of the Heading MessageElement.
:rtype: str
"""
if self.text is None:
return
level = self.level
if level > 6:
level = 6
return '<h%s%s>... | python | {
"resource": ""
} |
q243614 | Heading.to_text | train | def to_text(self):
"""Render a Heading MessageElement as plain text
:returns: The plain text representation of the Heading MessageElement.
"""
if self.text is None:
return
level = '*' * self.level
return '%s%s\n' % (level, self.text) | python | {
"resource": ""
} |
q243615 | extent_string_to_array | train | def extent_string_to_array(extent_text):
"""Convert an extent string to an array.
.. versionadded: 2.2.0
:param extent_text: String representing an extent e.g.
109.829170982, -8.13333290561, 111.005344795, -7.49226294379
:type extent_text: str
:returns: A list of floats, or None
:rtyp... | python | {
"resource": ""
} |
q243616 | extent_to_array | train | def extent_to_array(extent, source_crs, dest_crs=None):
"""Convert the supplied extent to geographic and return as an array.
:param extent: Rectangle defining a spatial extent in any CRS.
:type extent: QgsRectangle
:param source_crs: Coordinate system used for input extent.
:type source_crs: QgsCo... | python | {
"resource": ""
} |
q243617 | validate_geo_array | train | def validate_geo_array(extent):
"""Validate a geographic extent.
.. versionadded:: 3.2
:param extent: A list in the form [xmin, ymin, xmax, ymax] where all
coordinates provided are in Geographic / EPSG:4326.
:type extent: list
:return: True if the extent is valid, otherwise False
:rty... | python | {
"resource": ""
} |
q243618 | clone_layer | train | def clone_layer(layer, keep_selection=True):
"""Duplicate the layer by taking the same source and copying keywords.
:param keep_selection: If we should keep the selection. Default to true.
:type keep_selection: bool
:param layer: Layer to be duplicated.
:type layer: QgsMapLayer
:return: The n... | python | {
"resource": ""
} |
q243619 | is_raster_y_inverted | train | def is_raster_y_inverted(layer):
"""Check if the raster is upside down, ie Y inverted.
See issue : https://github.com/inasafe/inasafe/issues/4026
:param layer: The layer to test.
:type layer: QgsRasterLayer
:return: A boolean to know if the raster is correct or not.
:rtype: bool
"""
i... | python | {
"resource": ""
} |
q243620 | is_point_layer | train | def is_point_layer(layer):
"""Check if a QGIS layer is vector and its geometries are points.
:param layer: A vector layer.
:type layer: QgsVectorLayer, QgsMapLayer
:returns: True if the layer contains points, otherwise False.
:rtype: bool
"""
try:
return (layer.type() == QgsMapLaye... | python | {
"resource": ""
} |
q243621 | is_line_layer | train | def is_line_layer(layer):
"""Check if a QGIS layer is vector and its geometries are lines.
:param layer: A vector layer.
:type layer: QgsVectorLayer, QgsMapLayer
:returns: True if the layer contains lines, otherwise False.
:rtype: bool
"""
try:
return (layer.type() == QgsMapLayer.... | python | {
"resource": ""
} |
q243622 | is_polygon_layer | train | def is_polygon_layer(layer):
"""Check if a QGIS layer is vector and its geometries are polygons.
:param layer: A vector layer.
:type layer: QgsVectorLayer, QgsMapLayer
:returns: True if the layer contains polygons, otherwise False.
:rtype: bool
"""
try:
return (layer.type() == Qgs... | python | {
"resource": ""
} |
q243623 | layer_icon | train | def layer_icon(layer):
"""Helper to get the layer icon.
:param layer: A layer.
:type layer: QgsMapLayer
:returns: The icon for the given layer.
:rtype: QIcon
"""
if is_raster_layer(layer):
return QgsLayerItem.iconRaster()
elif is_point_layer(layer):
return QgsLayerItem.... | python | {
"resource": ""
} |
q243624 | wkt_to_rectangle | train | def wkt_to_rectangle(extent):
"""Compute the rectangle from a WKT string.
It returns None if the extent is not valid WKT rectangle.
:param extent: The extent.
:type extent: basestring
:return: The rectangle or None if it is not a valid WKT rectangle.
:rtype: QgsRectangle
"""
geometry ... | python | {
"resource": ""
} |
q243625 | qgis_version_detailed | train | def qgis_version_detailed():
"""Get the detailed version of QGIS.
:returns: List containing major, minor and patch.
:rtype: list
"""
version = str(Qgis.QGIS_VERSION_INT)
return [int(version[0]), int(version[1:3]), int(version[3:])] | python | {
"resource": ""
} |
q243626 | MultiExposureDialog._tab_changed | train | def _tab_changed(self):
"""Triggered when the current tab is changed."""
current = self.tab_widget.currentWidget()
if current == self.analysisTab:
self.btn_back.setEnabled(False)
self.btn_next.setEnabled(True)
elif current == self.reportingTab:
if self... | python | {
"resource": ""
} |
q243627 | MultiExposureDialog.ordered_expected_layers | train | def ordered_expected_layers(self):
"""Get an ordered list of layers according to users input.
From top to bottom in the legend:
[
('FromCanvas', layer name, full layer URI, QML),
('FromAnalysis', layer purpose, layer group, None),
...
]
The f... | python | {
"resource": ""
} |
q243628 | MultiExposureDialog._add_layer_clicked | train | def _add_layer_clicked(self):
"""Add layer clicked."""
layer = self.tree.selectedItems()[0]
origin = layer.data(0, LAYER_ORIGIN_ROLE)
if origin == FROM_ANALYSIS['key']:
parent = layer.data(0, LAYER_PARENT_ANALYSIS_ROLE)
key = layer.data(0, LAYER_PURPOSE_KEY_OR_ID_... | python | {
"resource": ""
} |
q243629 | MultiExposureDialog._remove_layer_clicked | train | def _remove_layer_clicked(self):
"""Remove layer clicked."""
layer = self.list_layers_in_map_report.selectedItems()[0]
origin = layer.data(LAYER_ORIGIN_ROLE)
if origin == FROM_ANALYSIS['key']:
key = layer.data(LAYER_PURPOSE_KEY_OR_ID_ROLE)
parent = layer.data(LAYE... | python | {
"resource": ""
} |
q243630 | MultiExposureDialog.move_layer_down | train | def move_layer_down(self):
"""Move the layer down."""
layer = self.list_layers_in_map_report.selectedItems()[0]
index = self.list_layers_in_map_report.indexFromItem(layer).row()
item = self.list_layers_in_map_report.takeItem(index)
self.list_layers_in_map_report.insertItem(index ... | python | {
"resource": ""
} |
q243631 | MultiExposureDialog._list_selection_changed | train | def _list_selection_changed(self):
"""Selection has changed in the list."""
items = self.list_layers_in_map_report.selectedItems()
self.remove_layer.setEnabled(len(items) >= 1)
if len(items) == 1 and self.list_layers_in_map_report.count() >= 2:
index = self.list_layers_in_map... | python | {
"resource": ""
} |
q243632 | MultiExposureDialog._populate_reporting_tab | train | def _populate_reporting_tab(self):
"""Populate trees about layers."""
self.tree.clear()
self.add_layer.setEnabled(False)
self.remove_layer.setEnabled(False)
self.move_up.setEnabled(False)
self.move_down.setEnabled(False)
self.tree.setColumnCount(1)
self.tr... | python | {
"resource": ""
} |
q243633 | MultiExposureDialog._create_exposure_combos | train | def _create_exposure_combos(self):
"""Create one combobox for each exposure and insert them in the UI."""
# Map registry may be invalid if QGIS is shutting down
project = QgsProject.instance()
canvas_layers = self.iface.mapCanvas().layers()
# MapLayers returns a QMap<QString id, ... | python | {
"resource": ""
} |
q243634 | MultiExposureDialog.validate_impact_function | train | def validate_impact_function(self):
"""Check validity of the current impact function."""
# Always set it to False
self.btn_run.setEnabled(False)
for combo in list(self.combos_exposures.values()):
if combo.count() == 1:
combo.setEnabled(False)
hazard ... | python | {
"resource": ""
} |
q243635 | create_section | train | def create_section(
aggregation_summary, analysis_layer, postprocessor_fields,
section_header,
use_aggregation=True,
units_label=None,
use_rounding=True,
extra_component_args=None):
"""Create demographic section context.
:param aggregation_summary: Aggregation su... | python | {
"resource": ""
} |
q243636 | create_section_without_aggregation | train | def create_section_without_aggregation(
aggregation_summary, analysis_layer, postprocessor_fields,
section_header,
units_label=None,
use_rounding=True,
extra_component_args=None):
"""Create demographic section context without aggregation.
:param aggregation_summary: Aggr... | python | {
"resource": ""
} |
q243637 | check_inputs | train | def check_inputs(compulsory_fields, fields):
"""Helper function to check if the layer has every compulsory fields.
:param compulsory_fields: List of compulsory fields.
:type compulsory_fields: list
:param fields: inasafe_field dictionary from the layer.
:type fields: dict
:raises: InvalidKeyw... | python | {
"resource": ""
} |
q243638 | create_absolute_values_structure | train | def create_absolute_values_structure(layer, fields):
"""Helper function to create the structure for absolute values.
:param layer: The vector layer.
:type layer: QgsVectorLayer
:param fields: List of name field on which we want to aggregate.
:type fields: list
:return: The data structure.
... | python | {
"resource": ""
} |
q243639 | add_fields | train | def add_fields(
layer, absolute_values, static_fields, dynamic_structure):
"""Function to add fields needed in the output layer.
:param layer: The vector layer.
:type layer: QgsVectorLayer
:param absolute_values: The absolute value structure.
:type absolute_values: dict
:param static_... | python | {
"resource": ""
} |
q243640 | RectangleMapTool.reset | train | def reset(self):
"""
Clear the rubber band for the analysis extents.
"""
self.start_point = self.end_point = None
self.is_emitting_point = False
self.rubber_band.reset(QgsWkbTypes.PolygonGeometry) | python | {
"resource": ""
} |
q243641 | RectangleMapTool.canvasPressEvent | train | def canvasPressEvent(self, e):
"""
Handle canvas press events so we know when user is capturing the rect.
:param e: A Qt event object.
:type: QEvent
"""
self.start_point = self.toMapCoordinates(e.pos())
self.end_point = self.start_point
self.is_emitting_p... | python | {
"resource": ""
} |
q243642 | RectangleMapTool.canvasReleaseEvent | train | def canvasReleaseEvent(self, e):
"""Handle canvas release events has finished capturing e.
:param e: A Qt event object.
:type: QEvent
"""
_ = e # NOQA
self.is_emitting_point = False
self.rectangle_created.emit() | python | {
"resource": ""
} |
q243643 | RectangleMapTool.show_rectangle | train | def show_rectangle(self, start_point, end_point):
"""Show the rectangle on the canvas.
:param start_point: QGIS Point object representing the origin (
top left).
:type start_point: QgsPoint
:param end_point: QGIS Point object representing the contra-origin (
bot... | python | {
"resource": ""
} |
q243644 | RectangleMapTool.rectangle | train | def rectangle(self):
"""Accessor for the rectangle.
:return: A rectangle showing the designed extent.
:rtype: QgsRectangle
"""
if self.start_point is None or self.end_point is None:
return QgsRectangle()
elif self.start_point.x() == self.end_point.x() or \
... | python | {
"resource": ""
} |
q243645 | RectangleMapTool.deactivate | train | def deactivate(self):
"""
Disable the tool.
"""
self.rubber_band.reset(QgsWkbTypes.PolygonGeometry)
QgsMapTool.deactivate(self)
self.deactivated.emit() | python | {
"resource": ""
} |
q243646 | clean_layer | train | def clean_layer(layer):
"""Clean a vector layer.
:param layer: The vector layer.
:type layer: QgsVectorLayer
:return: The buffered vector layer.
:rtype: QgsVectorLayer
"""
output_layer_name = clean_geometry_steps['output_layer_name']
output_layer_name = output_layer_name % layer.keywor... | python | {
"resource": ""
} |
q243647 | geometry_checker | train | def geometry_checker(geometry):
"""Perform a cleaning if the geometry is not valid.
:param geometry: The geometry to check and clean.
:type geometry: QgsGeometry
:return: Tuple of bool and cleaned geometry. True if the geometry is
already valid, False if the geometry was not valid.
A c... | python | {
"resource": ""
} |
q243648 | remove_provenance_project_variables | train | def remove_provenance_project_variables():
"""Removing variables from provenance data."""
project_context_scope = QgsExpressionContextUtils.projectScope(
QgsProject.instance())
existing_variable_names = project_context_scope.variableNames()
# Save the existing variables that's not provenance va... | python | {
"resource": ""
} |
q243649 | Dock.aggregation | train | def aggregation(self, layer):
"""Setter for the current aggregation layer.
:param layer: The current aggregation layer.
:type layer: QgsVectorLayer
"""
# We need to disconnect first.
if self._aggregation and self.use_selected_features_only:
self._aggregation.... | python | {
"resource": ""
} |
q243650 | Dock._show_organisation_logo | train | def _show_organisation_logo(self):
"""Show the organisation logo in the dock if possible."""
dock_width = float(self.width())
# Don't let the image be more tha 100px height
maximum_height = 100.0 # px
pixmap = QPixmap(self.organisation_logo_path)
if pixmap.height() < 1 o... | python | {
"resource": ""
} |
q243651 | Dock.save_auxiliary_files | train | def save_auxiliary_files(self, layer, destination):
"""Save auxiliary files when using the 'save as' function.
If some auxiliary files (.xml, .json) exist, this function will
copy them when the 'save as' function is used on the layer.
:param layer: The layer which has been saved as.
... | python | {
"resource": ""
} |
q243652 | Dock.index_changed_aggregation_layer_combo | train | def index_changed_aggregation_layer_combo(self, index):
"""Automatic slot executed when the Aggregation combo is changed.
:param index: The index number of the selected exposure layer.
:type index: int
"""
if index == 0:
# No aggregation layer, we should display the ... | python | {
"resource": ""
} |
q243653 | Dock.toggle_aggregation_layer_combo | train | def toggle_aggregation_layer_combo(self):
"""Toggle the aggregation combo enabled status.
Whether the combo is toggled on or off will depend on the current dock
status.
"""
selected_hazard_layer = layer_from_combo(self.hazard_layer_combo)
selected_exposure_layer = layer_... | python | {
"resource": ""
} |
q243654 | Dock.unblock_signals | train | def unblock_signals(self):
"""Let the combos listen for event changes again."""
self.aggregation_layer_combo.blockSignals(False)
self.exposure_layer_combo.blockSignals(False)
self.hazard_layer_combo.blockSignals(False) | python | {
"resource": ""
} |
q243655 | Dock.block_signals | train | def block_signals(self):
"""Prevent the combos and dock listening for event changes."""
self.disconnect_layer_listener()
self.aggregation_layer_combo.blockSignals(True)
self.exposure_layer_combo.blockSignals(True)
self.hazard_layer_combo.blockSignals(True) | python | {
"resource": ""
} |
q243656 | Dock.debug_group_toggled | train | def debug_group_toggled(self):
"""Helper to set a color on the debug button to know if it's debugging.
If debug analysis is true or if rounding is disabled, it will be
orange.
"""
use_debug = self.use_debug_action.isChecked()
set_setting('use_debug_analysis', use_debug)
... | python | {
"resource": ""
} |
q243657 | Dock.get_layers | train | def get_layers(self, *args):
"""Obtain a list of layers currently loaded in QGIS.
On invocation, this method will populate hazard_layer_combo,
exposure_layer_combo and aggregation_layer_combo on the dialog
with a list of available layers.
Only **polygon vector** layers will be ... | python | {
"resource": ""
} |
q243658 | Dock.show_print_dialog | train | def show_print_dialog(self):
"""Open the print dialog"""
if not self.impact_function:
# Now try to read the keywords and show them in the dock
try:
active_layer = self.iface.activeLayer()
keywords = self.keyword_io.read_keywords(active_layer)
... | python | {
"resource": ""
} |
q243659 | Dock.show_busy | train | def show_busy(self):
"""Hide the question group box and enable the busy cursor."""
self.progress_bar.show()
self.question_group.setEnabled(False)
self.question_group.setVisible(False)
enable_busy_cursor()
self.repaint()
qApp.processEvents()
self.busy = Tru... | python | {
"resource": ""
} |
q243660 | Dock.hide_busy | train | def hide_busy(self, check_next_impact=True):
"""A helper function to indicate processing is done.
:param check_next_impact: Flag to check if we can validate the next IF.
:type check_next_impact: bool
"""
self.progress_bar.hide()
self.show_question_button.setVisible(True)... | python | {
"resource": ""
} |
q243661 | Dock.show_impact | train | def show_impact(self, report_path):
"""Show the report.
.. versionadded: 4.0
:param report_path: The path to the report.
:type report_path: basestring
"""
# We can display an impact report.
# We need to open the file in UTF-8, the HTML may have some accents
... | python | {
"resource": ""
} |
q243662 | Dock.show_generic_keywords | train | def show_generic_keywords(self, layer):
"""Show the keywords defined for the active layer.
.. note:: The print button will be disabled if this method is called.
.. versionchanged:: 3.3 - changed parameter from keywords object
to a layer object so that we can show extra stuff like C... | python | {
"resource": ""
} |
q243663 | Dock.layer_changed | train | def layer_changed(self, layer):
"""Handler for when the QGIS active layer is changed.
If the active layer is changed and it has keywords and a report,
show the report.
:param layer: QgsMapLayer instance that is now active.
:type layer: QgsMapLayer, QgsRasterLayer, QgsVectorLaye... | python | {
"resource": ""
} |
q243664 | Dock.save_state | train | def save_state(self):
"""Save the current state of the ui to an internal class member.
The saved state can be restored again easily using
:func:`restore_state`
"""
state = {
'hazard': self.hazard_layer_combo.currentText(),
'exposure': self.exposure_layer_... | python | {
"resource": ""
} |
q243665 | Dock.restore_state | train | def restore_state(self):
"""Restore the state of the dock to the last known state."""
if self.state is None:
return
for myCount in range(0, self.exposure_layer_combo.count()):
item_text = self.exposure_layer_combo.itemText(myCount)
if item_text == self.state['... | python | {
"resource": ""
} |
q243666 | Dock.define_user_analysis_extent | train | def define_user_analysis_extent(self, extent, crs):
"""Slot called when user has defined a custom analysis extent.
.. versionadded: 2.2.0
:param extent: Extent of the user's preferred analysis area.
:type extent: QgsRectangle
:param crs: Coordinate reference system for user de... | python | {
"resource": ""
} |
q243667 | Dock._search_inasafe_layer | train | def _search_inasafe_layer(self):
"""Search for an inasafe layer in an active group.
:returns: A valid layer.
:rtype: QgsMapLayer
.. versionadded:: 4.3
"""
selected_nodes = self.iface.layerTreeView().selectedNodes()
for selected_node in selected_nodes:
... | python | {
"resource": ""
} |
q243668 | Dock._visible_layers_count | train | def _visible_layers_count(self):
"""Calculate the number of visible layers in the legend.
.. versionadded: 3.1
:returns: Count of layers that are actually visible.
:rtype: int
"""
treeroot = QgsProject.instance().layerTreeRoot()
return len([lyr for lyr in treero... | python | {
"resource": ""
} |
q243669 | Dock._validate_question_area | train | def _validate_question_area(self):
"""Helper method to evaluate the current state of the dialog.
This function will determine if it is appropriate for the OK button to
be enabled or not.
.. note:: The enabled state of the OK button on the dialog will
NOT be updated (set True... | python | {
"resource": ""
} |
q243670 | DefaultSelectParameter.default_value | train | def default_value(self, default_value):
"""Setter for default_value.
:param default_value: The default value.
:type default_value: object
"""
# For custom value
if default_value not in self.default_values:
if len(self.default_labels) == len(self.default_value... | python | {
"resource": ""
} |
q243671 | classFactory | train | def classFactory(iface):
"""Load Plugin class from file Plugin."""
# Try to import submodule to check if there are present.
try:
from parameters.generic_parameter import GenericParameter
except ImportError:
# Don't use safe.utilities.i18n.tr as we need to be outside of `safe`.
# ... | python | {
"resource": ""
} |
q243672 | metadata_converter_help | train | def metadata_converter_help():
"""Help message for metadata converter Dialog.
.. versionadded:: 4.3
:returns: A message object containing helpful information.
:rtype: messaging.message.Message
"""
message = m.Message()
message.add(m.Brand())
message.add(heading())
message.add(conte... | python | {
"resource": ""
} |
q243673 | qt_at_least | train | def qt_at_least(needed_version, test_version=None):
"""Check if the installed Qt version is greater than the requested
:param needed_version: minimally needed Qt version in format like 4.8.4
:type needed_version: str
:param test_version: Qt version as returned from Qt.QT_VERSION. As in
0x040100 T... | python | {
"resource": ""
} |
q243674 | disable_busy_cursor | train | def disable_busy_cursor():
"""Disable the hourglass cursor and listen for layer changes."""
while QgsApplication.instance().overrideCursor() is not None and \
QgsApplication.instance().overrideCursor().shape() == \
QtCore.Qt.WaitCursor:
QgsApplication.instance().restoreOverrideCu... | python | {
"resource": ""
} |
q243675 | StepKwSubcategory.subcategories_for_layer | train | def subcategories_for_layer(self):
"""Return a list of valid subcategories for a layer.
Subcategory is hazard type or exposure type.
:returns: A list where each value represents a valid subcategory.
:rtype: list
"""
purpose = self.parent.step_kw_purpose.selected_purpo... | python | {
"resource": ""
} |
q243676 | StepKwSubcategory.on_lstSubcategories_itemSelectionChanged | train | def on_lstSubcategories_itemSelectionChanged(self):
"""Update subcategory description label.
.. note:: This is an automatic Qt slot
executed when the subcategory selection changes.
"""
self.clear_further_steps()
# Set widgets
subcategory = self.selected_subcat... | python | {
"resource": ""
} |
q243677 | StepKwSubcategory.selected_subcategory | train | def selected_subcategory(self):
"""Obtain the subcategory selected by user.
:returns: Metadata of the selected subcategory.
:rtype: dict, None
"""
item = self.lstSubcategories.currentItem()
try:
return definition(item.data(QtCore.Qt.UserRole))
except ... | python | {
"resource": ""
} |
q243678 | StepKwSubcategory.set_widgets | train | def set_widgets(self):
"""Set widgets on the Subcategory tab."""
self.clear_further_steps()
# Set widgets
purpose = self.parent.step_kw_purpose.selected_purpose()
self.lstSubcategories.clear()
self.lblDescribeSubcategory.setText('')
self.lblIconSubcategory.setPixm... | python | {
"resource": ""
} |
q243679 | MetadataConverterDialog.select_output_directory | train | def select_output_directory(self):
"""Select output directory"""
# Input layer
input_layer_path = self.layer.source()
input_file_name = os.path.basename(input_layer_path)
input_extension = os.path.splitext(input_file_name)[1]
# Get current path
current_file_path ... | python | {
"resource": ""
} |
q243680 | MetadataConverterDialog.show_current_metadata | train | def show_current_metadata(self):
"""Show metadata of the current selected layer."""
LOGGER.debug('Showing layer: ' + self.layer.name())
keywords = KeywordIO(self.layer)
content_html = keywords.to_message().to_html()
full_html = html_header() + content_html + html_footer()
... | python | {
"resource": ""
} |
q243681 | get_user_name | train | def get_user_name():
"""Get user name provide by operating system
"""
if sys.platform == 'win32':
#user = os.getenv('USERPROFILE')
user = os.getenv('USERNAME')
else:
user = os.getenv('LOGNAME')
return user | python | {
"resource": ""
} |
q243682 | get_host_name | train | def get_host_name():
"""Get host name provide by operating system
"""
if sys.platform == 'win32':
host = os.getenv('COMPUTERNAME')
else:
host = os.uname()[1]
return host | python | {
"resource": ""
} |
q243683 | compute_checksum | train | def compute_checksum(filename, max_length=2**20):
"""Compute the CRC32 checksum for specified file
Optional parameter max_length sets the maximum number
of bytes used to limit time used with large files.
Default = 2**20 (1MB)
"""
fid = open(filename, 'rb') # Use binary for portability
crcv... | python | {
"resource": ""
} |
q243684 | clean_line | train | def clean_line(str, delimiter):
"""Split string on given delimiter, remove whitespace from each field."""
return [x.strip() for x in str.strip().split(delimiter) if x != ''] | python | {
"resource": ""
} |
q243685 | string_to_char | train | def string_to_char(l):
'''Convert 1-D list of strings to 2-D list of chars.'''
if not l:
return []
if l == ['']:
l = [' ']
maxlen = reduce(max, map(len, l))
ll = [x.ljust(maxlen) for x in l]
result = []
for s in ll:
result.append([x for x in s])
return result | python | {
"resource": ""
} |
q243686 | get_vars_in_expression | train | def get_vars_in_expression(source):
'''Get list of variable names in a python expression.'''
import compiler
from compiler.ast import Node
##
# @brief Internal recursive function.
# @param node An AST parse Node.
# @param var_list Input list of variables.
# @return An updated list of v... | python | {
"resource": ""
} |
q243687 | tar_file | train | def tar_file(files, tarname):
'''Compress a file or directory into a tar file.'''
if isinstance(files, basestring):
files = [files]
o = tarfile.open(tarname, 'w:gz')
for file in files:
o.add(file)
o.close() | python | {
"resource": ""
} |
q243688 | untar_file | train | def untar_file(tarname, target_dir='.'):
'''Uncompress a tar file.'''
o = tarfile.open(tarname, 'r:gz')
members = o.getmembers()
for member in members:
o.extract(member, target_dir)
o.close() | python | {
"resource": ""
} |
q243689 | get_file_hexdigest | train | def get_file_hexdigest(filename, blocksize=1024*1024*10):
'''Get a hex digest of a file.'''
if hashlib.__name__ == 'hashlib':
m = hashlib.md5() # new - 'hashlib' module
else:
m = hashlib.new() # old - 'md5' module - remove once py2.4 gone
fd = open(filename, 'r')
while ... | python | {
"resource": ""
} |
q243690 | make_digest_file | train | def make_digest_file(data_file, digest_file):
'''Create a file containing the hex digest string of a data file.'''
hexdigest = get_file_hexdigest(data_file)
fd = open(digest_file, 'w')
fd.write(hexdigest)
fd.close() | python | {
"resource": ""
} |
q243691 | file_length | train | def file_length(in_file):
'''Function to return the length of a file.'''
fid = open(in_file)
data = fid.readlines()
fid.close()
return len(data) | python | {
"resource": ""
} |
q243692 | convert_geojson_to_shapefile | train | def convert_geojson_to_shapefile(geojson_path):
"""Convert geojson file to shapefile.
It will create a necessary file next to the geojson file. It will not
affect another files (e.g. .xml, .qml, etc).
:param geojson_path: The path to geojson file.
:type geojson_path: basestring
:returns: True... | python | {
"resource": ""
} |
q243693 | peta_bencana_help | train | def peta_bencana_help():
"""Help message for PetaBencana dialog.
.. versionadded:: 3.2.1
:returns: A message object containing helpful information.
:rtype: messaging.message.Message
"""
message = m.Message()
message.add(m.Brand())
message.add(heading())
message.add(content())
... | python | {
"resource": ""
} |
q243694 | Row.add | train | def add(self, item, header_flag=False, align=None):
"""Add a Cell to the row
:param item: An element to add to the Cells can be list or Cell object.
:type item: basestring, QString, list, Cell
:param header_flag: Flag indicating it the item is a header or not.
:type header_flag... | python | {
"resource": ""
} |
q243695 | generate_insufficient_overlap_message | train | def generate_insufficient_overlap_message(
e,
exposure_geoextent,
exposure_layer,
hazard_geoextent,
hazard_layer,
viewport_geoextent):
"""Generate insufficient overlap message.
:param e: An exception.
:type e: Exception
:param exposure_geoextent: Extent ... | python | {
"resource": ""
} |
q243696 | singleton | train | def singleton(class_):
"""Singleton definition.
Method 1 from
https://stackoverflow.com/questions/6760685/creating-a-singleton-in-python
"""
instances = {}
def get_instance(*args, **kwargs):
if class_ not in instances:
instances[class_] = class_(*args, **kwargs)
ret... | python | {
"resource": ""
} |
q243697 | population_chart_legend_extractor | train | def population_chart_legend_extractor(impact_report, component_metadata):
"""Extracting legend of population chart.
:param impact_report: the impact report that acts as a proxy to fetch
all the data that extractor needed
:type impact_report: safe.report.impact_report.ImpactReport
:param compon... | python | {
"resource": ""
} |
q243698 | infographic_people_section_notes_extractor | train | def infographic_people_section_notes_extractor(
impact_report, component_metadata):
"""Extracting notes for people section in the infographic.
:param impact_report: the impact report that acts as a proxy to fetch
all the data that extractor needed
:type impact_report: safe.report.impact_rep... | python | {
"resource": ""
} |
q243699 | StepKwMultiClassifications.is_ready_to_next_step | train | def is_ready_to_next_step(self):
"""Check if the step is complete.
:returns: True if new step may be enabled.
:rtype: bool
"""
# Still editing
if self.mode == EDIT_MODE:
return False
for combo_box in self.exposure_combo_boxes:
# Enable if ... | python | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.