refactor and extend use of optimized feature requests

- use LANGUAGE constant, defined in misc_utils for now
- add AdditionalInformationTypeLayer and define get_additional_information_name for it
- add get_attribute_value_by_another_attribute_value for AbstractLayer

Author: nmaarnio

arho_feature_template/core/lambda_service.py

@@ -9,7 +9,8 @@
 from qgis.PyQt.QtNetwork import QNetworkAccessManager, QNetworkProxy, QNetworkReply, QNetworkRequest
 from qgis.PyQt.QtWidgets import QMessageBox
 
-from arho_feature_template.utils.misc_utils import get_active_plan_id, get_plan_name, get_settings
+from arho_feature_template.project.layers.plan_layers import PlanLayer
+from arho_feature_template.utils.misc_utils import get_active_plan_id, get_settings
 
 
 class LambdaService(QObject):
@@ -113,7 +114,7 @@ def _process_json_reply(self, response_json: dict):
         if plan_json:
             geographical_area = plan_json.get("geographicalArea")
             if geographical_area:
-                outline_name = get_plan_name(plan_id, language="fin")
+                outline_name = PlanLayer.get_plan_name(plan_id)
                 outline_json = {
                     "type": "Feature",
                     "properties": {"name": outline_name},

arho_feature_template/core/models.py

@@ -11,11 +11,9 @@
 
 from arho_feature_template.exceptions import ConfigSyntaxError
 from arho_feature_template.qgis_plugin_tools.tools.resources import resources_path
-from arho_feature_template.utils.misc_utils import get_layer_by_name, iface
+from arho_feature_template.utils.misc_utils import LANGUAGE, get_layer_by_name, iface
 
 if TYPE_CHECKING:
-    from typing import Literal
-
     from qgis.core import QgsFeature, QgsGeometry
 
 
@@ -149,7 +147,6 @@ def initialize(
         cls,
         config_path: Path = DEFAULT_PLAN_REGULATIONS_CONFIG_PATH,
         type_of_plan_regulations_layer_name="Kaavamääräyslaji",
-        language: Literal["fin", "eng", "swe"] = "fin",
     ) -> RegulationLibrary:
         # Initialize RegulationLibrary and RegulationConfigs from QGIS layer and config file
 
@@ -165,7 +162,7 @@ def initialize(
 
         # 3. Initialize regulation configs from layer. Storing them by their ID is handy for adding childs later
         id_to_regulation_map: dict[str, RegulationConfig] = {
-            feature["id"]: RegulationConfig.from_feature(feature, language) for feature in layer.getFeatures()
+            feature["id"]: RegulationConfig.from_feature(feature) for feature in layer.getFeatures()
         }
 
         # 4. Add information from config file (value, unit, category only) and link child regulations
@@ -226,7 +223,7 @@ class RegulationConfig:
 
     # NOTE: Perhaps this ("model_from_feature") should be method of PlanTypeLayer class?
     @classmethod
-    def from_feature(cls, feature: QgsFeature, language: str = "fin") -> RegulationConfig:
+    def from_feature(cls, feature: QgsFeature) -> RegulationConfig:
         """
         Initialize PlanRegulationConfig from QgsFeature.
 
@@ -235,8 +232,8 @@ def from_feature(cls, feature: QgsFeature, language: str = "fin") -> RegulationC
         return cls(
             id=feature["id"],
             regulation_code=feature["value"],
-            name=feature["name"][language],
-            description=feature["description"][language],
+            name=feature["name"][LANGUAGE],
+            description=feature["description"][LANGUAGE],
             status=feature["status"],
             level=feature["level"],
             parent_id=feature["parent_id"],

arho_feature_template/core/plan_manager.py

@@ -43,6 +43,7 @@
 from arho_feature_template.resources.libraries.regulation_groups import regulation_group_library_config_files
 from arho_feature_template.utils.db_utils import get_existing_database_connection_names
 from arho_feature_template.utils.misc_utils import (
+    LANGUAGE,
     check_layer_changes,
     get_active_plan_id,
     handle_unsaved_changes,
@@ -346,9 +347,9 @@ def create_new_regulation_group(self):
 
 def regulation_group_library_from_active_plan() -> RegulationGroupLibrary:
     category_features = list(PlanRegulationGroupTypeLayer.get_features())
-    category_id_to_name: dict[str, str] = {category["id"]: category["name"]["fin"] for category in category_features}
+    category_id_to_name: dict[str, str] = {category["id"]: category["name"][LANGUAGE] for category in category_features}
     category_regulation_group_map: dict[str, list[QgsFeature]] = {
-        feature["name"]["fin"]: [] for feature in category_features
+        feature["name"][LANGUAGE]: [] for feature in category_features
     }
 
     for feat in RegulationGroupLayer.get_features():

arho_feature_template/gui/components/code_combobox.py

@@ -7,6 +7,7 @@
 from qgis.PyQt.QtWidgets import QComboBox, QTreeWidget, QTreeWidgetItem
 
 from arho_feature_template.exceptions import LayerNotFoundError
+from arho_feature_template.utils.misc_utils import LANGUAGE
 
 if TYPE_CHECKING:
     from arho_feature_template.project.layers.code_layers import (
@@ -33,7 +34,7 @@ def populate_from_code_layer(self, layer_type: type[AbstractCodeLayer]) -> None:
             return
 
         for i, feature in enumerate(layer.getFeatures(), start=1):
-            self.addItem(feature["name"]["fin"])
+            self.addItem(feature["name"][LANGUAGE])
             self.setItemData(i, feature["id"])
 
     def value(self) -> str:
@@ -83,9 +84,9 @@ def populate_from_code_layer(self, layer_type: type[AbstractCodeLayer]) -> None:
             item = QTreeWidgetItem()
             items[code_feature["id"]] = item
 
-            text = code_feature["name"]["fin"]
+            text = code_feature["name"][LANGUAGE]
             item.setText(0, text)
-            description = code_feature["description"]["fin"]
+            description = code_feature["description"][LANGUAGE]
             item.setToolTip(0, description)
             item.setData(0, Qt.UserRole, code_feature["id"])
 

arho_feature_template/gui/components/plan_proposition_widget.py

@@ -19,9 +19,6 @@
 ui_path = resources.files(__package__) / "plan_proposition_widget.ui"
 FormClass, _ = uic.loadUiType(ui_path)
 
-# TO BE REPLACED
-LANGUAGE = "fin"
-
 
 class PropositionWidget(QWidget, FormClass):  # type: ignore
     """A widget representation of a plan proposition."""

arho_feature_template/gui/components/plan_regulation_widget.py

@@ -24,17 +24,15 @@
     MultilineTextInputWidget,
     SinglelineTextInputWidget,
 )
-from arho_feature_template.utils.misc_utils import get_additional_information_name, get_layer_by_name, iface
+from arho_feature_template.project.layers.code_layers import AdditionalInformationTypeLayer
+from arho_feature_template.utils.misc_utils import LANGUAGE, get_layer_by_name, iface
 
 if TYPE_CHECKING:
     from qgis.PyQt.QtWidgets import QPushButton
 
 ui_path = resources.files(__package__) / "plan_regulation_widget.ui"
 FormClass, _ = uic.loadUiType(ui_path)
 
-# TO BE REPLACED
-LANGUAGE = "fin"
-
 
 class RegulationWidget(QWidget, FormClass):  # type: ignore
     """A widget representation of a plan regulation."""
@@ -218,7 +216,7 @@ def _add_additional_info(self, info_type: str, default_value: str | float | None
 
         # NOTE: Now info type is the name / readable version when this is triggered by user
         # Might need to refactor this later..
-        name = get_additional_information_name(info_type)
+        name = AdditionalInformationTypeLayer.get_additional_information_name(info_type)
         self._add_widgets(QLabel("Lisätiedonlaji"), SinglelineTextInputWidget(name, False))
 
         # NOTE: Does not support multiple instances of same additional information kind,

arho_feature_template/gui/tools/inspect_plan_features_tool.py

@@ -90,9 +90,6 @@ def create_menu(self, click_pos: QPoint, nearby_features: dict[QgsVectorLayer, l
         for layer, features in nearby_features.items():
             for feature in features:
                 menu_text = layer.name()
-                # feat_name = feature["name"]["fin"]
-                # if feat_name:
-                #     menu_text += f" — {feat_name}"
                 action = menu.addAction(menu_text)
                 action.triggered.connect(partial(self.edit_feature_requested.emit, feature, layer.name()))
                 action.hovered.connect(partial(self.highlight_feature, feature, layer))

arho_feature_template/project/layers/__init__.py

@@ -59,3 +59,10 @@ def get_attribute_values_by_another_attribute_value(
         request.setFlags(QgsFeatureRequest.NoGeometry)
         for feature in layer.getFeatures(request):
             yield feature[target_attribute]
+
+    @classmethod
+    def get_attribute_value_by_another_attribute_value(
+        cls, target_attribute: str, filter_attribute: str, filter_value: str
+    ) -> Any | None:
+        gen = cls.get_attribute_values_by_another_attribute_value(target_attribute, filter_attribute, filter_value)
+        return next(gen, None)

arho_feature_template/project/layers/code_layers.py

@@ -1,10 +1,10 @@
 from __future__ import annotations
 
-from typing import ClassVar
-
-from qgis.core import QgsFeatureRequest
+from typing import ClassVar, cast
 
+from arho_feature_template.exceptions import LayerNameNotFoundError
 from arho_feature_template.project.layers import AbstractLayer
+from arho_feature_template.utils.misc_utils import LANGUAGE
 
 
 class AbstractCodeLayer(AbstractLayer): ...
@@ -30,6 +30,15 @@ class PlanThemeLayer(AbstractCodeLayer):
     name = "Kaavoitusteemat"
 
 
+class AdditionalInformationTypeLayer(AbstractCodeLayer):
+    name = "Lisätiedonlaji"
+
+    @classmethod
+    def get_additional_information_name(cls, info_type: str) -> str | None:
+        attribute_value = cls.get_attribute_value_by_another_attribute_value("name", "value", info_type)
+        return cast(str, attribute_value[LANGUAGE]) if attribute_value else None
+
+
 class PlanRegulationGroupTypeLayer(AbstractCodeLayer):
     name = "Kaavamääräysryhmän tyyppi"
 
@@ -45,25 +54,19 @@ class PlanRegulationGroupTypeLayer(AbstractCodeLayer):
     @classmethod
     def get_id_by_feature_layer_name(cls, layer_name: str) -> str | None:
         regulation_group_type = cls.LAYER_NAME_TO_REGULATION_GROUP_TYPE_MAP.get(layer_name)
-
-        request = QgsFeatureRequest().setFilterExpression(f"\"value\"='{regulation_group_type}'")
-        feature = next(cls.get_from_project().getFeatures(request), None)
-        if feature:
-            return feature["id"]
-
-        return None
+        if not regulation_group_type:
+            raise LayerNameNotFoundError(layer_name)
+        attribute_value = cls.get_attribute_value_by_another_attribute_value("id", "value", regulation_group_type)
+        return cast(str, attribute_value) if attribute_value else attribute_value
 
 
 class PlanRegulationTypeLayer(AbstractCodeLayer):
     name = "Kaavamääräyslaji"
 
     @classmethod
     def get_regulation_type_by_id(cls, _id: str) -> str | None:
-        for feature in cls.get_from_project().getFeatures():
-            if feature["id"] == _id:
-                return feature["value"]
-
-        return None
+        attribute_value = cls.get_attribute_value_by_another_attribute_value("value", "id", _id)
+        return cast(str, attribute_value) if attribute_value else attribute_value
 
 
 code_layers = AbstractCodeLayer.__subclasses__()

arho_feature_template/project/layers/plan_layers.py

@@ -21,6 +21,7 @@
 from arho_feature_template.exceptions import FeatureNotFoundError, LayerEditableError, LayerNotFoundError
 from arho_feature_template.project.layers import AbstractLayer
 from arho_feature_template.project.layers.code_layers import PlanRegulationTypeLayer
+from arho_feature_template.utils.misc_utils import LANGUAGE
 
 logger = logging.getLogger(__name__)
 
@@ -75,8 +76,8 @@ def feature_from_model(cls, model: Plan) -> QgsFeature:
             message = "Plan must have a geometry to be added to the layer"
             raise ValueError(message)
 
-        feature["name"] = {"fin": model.name}
-        feature["description"] = {"fin": model.description}
+        feature["name"] = {LANGUAGE: model.name}
+        feature["description"] = {LANGUAGE: model.description}
         feature["permanent_plan_identifier"] = model.permanent_plan_identifier
         feature["record_number"] = model.record_number
         feature["producers_plan_identifier"] = model.producers_plan_identifier
@@ -95,8 +96,8 @@ def model_from_feature(cls, feature: QgsFeature) -> Plan:
         ]
         return Plan(
             geom=feature.geometry(),
-            name=feature["name"]["fin"],
-            description=feature["description"]["fin"],
+            name=feature["name"][LANGUAGE],
+            description=feature["description"][LANGUAGE],
             permanent_plan_identifier=feature["permanent_plan_identifier"],
             record_number=feature["record_number"],
             producers_plan_identifier=feature["producers_plan_identifier"],
@@ -112,6 +113,11 @@ def model_from_feature(cls, feature: QgsFeature) -> Plan:
             id_=feature["id"],
         )
 
+    @classmethod
+    def get_plan_name(cls, plan_id: str) -> str:
+        attribute_value = cls.get_attribute_value_by_another_attribute_value("name", "id", plan_id)
+        return attribute_value[LANGUAGE] if attribute_value else "Nimetön"
+
 
 class PlanFeatureLayer(AbstractPlanLayer):
     @classmethod
@@ -122,9 +128,9 @@ def feature_from_model(cls, model: PlanFeature, plan_id: str | None = None) -> Q
 
         feature = cls.initialize_feature_from_model(model)
         feature.setGeometry(model.geom)
-        feature["name"] = {"fin": model.name if model.name else ""}
+        feature["name"] = {LANGUAGE: model.name if model.name else ""}
         feature["type_of_underground_id"] = model.type_of_underground_id
-        feature["description"] = {"fin": model.description if model.description else ""}
+        feature["description"] = {LANGUAGE: model.description if model.description else ""}
         feature["plan_id"] = (
             plan_id
             if plan_id
@@ -143,8 +149,8 @@ def model_from_feature(cls, feature: QgsFeature) -> PlanFeature:
             geom=feature.geometry(),
             type_of_underground_id=feature["type_of_underground_id"],
             layer_name=cls.get_from_project().name(),
-            name=feature["name"]["fin"],
-            description=feature["description"]["fin"],
+            name=feature["name"][LANGUAGE],
+            description=feature["description"][LANGUAGE],
             regulation_groups=[
                 RegulationGroupLayer.model_from_feature(feat) for feat in regulation_group_features if feat is not None
             ],
@@ -187,7 +193,7 @@ def feature_from_model(cls, model: RegulationGroup, plan_id: str | None = None)
         feature = cls.initialize_feature_from_model(model)
 
         feature["short_name"] = model.short_name if model.short_name else None
-        feature["name"] = {"fin": model.name}
+        feature["name"] = {LANGUAGE: model.name}
         feature["type_of_plan_regulation_group_id"] = model.type_code_id
         feature["plan_id"] = (
             plan_id
@@ -201,7 +207,7 @@ def feature_from_model(cls, model: RegulationGroup, plan_id: str | None = None)
     def model_from_feature(cls, feature: QgsFeature) -> RegulationGroup:
         return RegulationGroup(
             type_code_id=feature["type_of_plan_regulation_group_id"],
-            name=feature["name"]["fin"],
+            name=feature["name"][LANGUAGE],
             short_name=feature["short_name"],
             color_code=None,
             group_number=None,
@@ -309,9 +315,9 @@ def feature_from_model(cls, model: Regulation) -> QgsFeature:
         feature["plan_regulation_group_id"] = model.regulation_group_id_
         feature["type_of_plan_regulation_id"] = model.config.id
         feature["unit"] = model.config.unit
-        feature["text_value"] = {"fin": model.value if isinstance(model.value, str) else ""}
+        feature["text_value"] = {LANGUAGE: model.value if isinstance(model.value, str) else ""}
         feature["numeric_value"] = model.value if isinstance(model.value, Number) else NULL
-        feature["name"] = {"fin": model.topic_tag if model.topic_tag else ""}
+        feature["name"] = {LANGUAGE: model.topic_tag if model.topic_tag else ""}
         feature["id"] = model.id_ if model.id_ else feature["id"]
         # feature["plan_theme_id"]
         # feature["type_of_verbal_plan_regulation_id"]
@@ -331,7 +337,7 @@ def model_from_feature(cls, feature: QgsFeature) -> Regulation:
         return Regulation(
             config=config,
             # Assuming only either text_value or numeric_value is defined
-            value=feature["text_value"]["fin"] if feature["text_value"]["fin"] else feature["numeric_value"],
+            value=feature["text_value"][LANGUAGE] if feature["text_value"][LANGUAGE] else feature["numeric_value"],
             additional_information=None,
             regulation_number=None,
             files=[],
@@ -365,8 +371,8 @@ class PlanPropositionLayer(AbstractPlanLayer):
     def feature_from_model(cls, model: Proposition) -> QgsFeature:
         feature = cls.initialize_feature_from_model(model)
 
-        feature["name"] = {"fin": model.name}
-        feature["text_value"] = {"fin": model.value}
+        feature["name"] = {LANGUAGE: model.name}
+        feature["text_value"] = {LANGUAGE: model.value}
         feature["plan_regulation_group_id"] = model.regulation_group_id_
         feature["ordering"] = model.proposition_number
         feature["plan_theme_id"] = model.theme_id
@@ -377,17 +383,17 @@ def feature_from_model(cls, model: Proposition) -> QgsFeature:
     @classmethod
     def model_from_feature(cls, feature: QgsFeature) -> Proposition:
         return Proposition(
-            name=feature["name"]["fin"],
-            value=feature["text_value"]["fin"],
+            name=feature["name"][LANGUAGE],
+            value=feature["text_value"][LANGUAGE],
             regulation_group_id_=feature["plan_regulation_group_id"],
             proposition_number=feature["ordering"],
             theme_id=feature["plan_theme_id"],
             id_=feature["id"],
         )
 
     @classmethod
-    def propositions_with_group_id(cls, group_id: str) -> list[QgsFeature]:
-        return [feat for feat in cls.get_features() if feat["plan_regulation_group_id"] == group_id]
+    def propositions_with_group_id(cls, group_id: str) -> Generator[QgsFeature]:
+        return cls.get_features_by_attribute_value("plan_regulation_group_id", group_id)
 
 
 class DocumentLayer(AbstractPlanLayer):