Auf Wrapper umgestellt, Prüfarchitektur QT6-kompatibel gemacht (Nicht lauffähig)

functions/qgisqt_wrapper.py

@@ -0,0 +1,880 @@
+"""
+sn_basis/functions/qgisqt_wrapper.py – zentrale QGIS/Qt-Abstraktion
+"""
+
+from typing import Optional, Type, Any
+
+
+# ---------------------------------------------------------
+# Hilfsfunktionen
+# ---------------------------------------------------------
+
+def getattr_safe(obj: Any, name: str, default: Any = None) -> Any:
+    """
+    Sichere getattr-Variante:
+    - fängt Exceptions beim Attributzugriff ab
+    - liefert default zurück, wenn Attribut fehlt oder fehlschlägt
+    """
+    try:
+        return getattr(obj, name)
+    except Exception:
+        return default
+
+
+# ---------------------------------------------------------
+# Qt‑Symbole (werden später dynamisch importiert)
+# ---------------------------------------------------------
+
+QMessageBox: Optional[Type[Any]] = None
+QFileDialog: Optional[Type[Any]] = None
+QEventLoop: Optional[Type[Any]] = None
+QUrl: Optional[Type[Any]] = None
+QNetworkRequest: Optional[Type[Any]] = None
+QNetworkReply: Optional[Type[Any]] = None
+QCoreApplication: Optional[Type[Any]] = None
+
+QWidget: Type[Any] 
+QGridLayout: Type[Any]
+QLabel: Type[Any]
+QLineEdit: Type[Any]
+QGroupBox: Type[Any]
+QVBoxLayout: Type[Any]
+QPushButton: Type[Any]
+
+YES: Optional[Any] = None
+NO: Optional[Any] = None
+CANCEL: Optional[Any] = None
+ICON_QUESTION: Optional[Any] = None
+
+
+def exec_dialog(dialog: Any) -> Any:
+    raise NotImplementedError
+
+
+# ---------------------------------------------------------
+# QGIS‑Symbole (werden später dynamisch importiert)
+# ---------------------------------------------------------
+
+QgsProject: Optional[Type[Any]] = None
+QgsVectorLayer: Optional[Type[Any]] = None
+QgsNetworkAccessManager: Optional[Type[Any]] = None
+Qgis: Optional[Type[Any]] = None
+iface: Optional[Any] = None
+
+
+# ---------------------------------------------------------
+# Qt‑Versionserkennung
+# ---------------------------------------------------------
+
+QT_VERSION = 0  # 0 = Mock, 5 = PyQt5, 6 = PyQt6
+
+
+# ---------------------------------------------------------
+# Versuch: PyQt6 importieren
+# ---------------------------------------------------------
+
+try:
+    from PyQt6.QtWidgets import ( #type: ignore
+        QMessageBox as _QMessageBox,
+        QFileDialog as _QFileDialog,
+        QWidget as _QWidget,
+        QGridLayout as _QGridLayout,
+        QLabel as _QLabel,
+        QLineEdit as _QLineEdit,
+        QGroupBox as _QGroupBox,
+        QVBoxLayout as _QVBoxLayout,
+        QPushButton as _QPushButton,
+    )
+    from PyQt6.QtCore import ( #type: ignore
+        Qt,
+        QEventLoop as _QEventLoop,
+        QUrl as _QUrl,
+        QCoreApplication as _QCoreApplication,
+    )
+    from PyQt6.QtNetwork import ( #type: ignore
+        QNetworkRequest as _QNetworkRequest,
+        QNetworkReply as _QNetworkReply,
+    )
+
+    QMessageBox = _QMessageBox
+    QFileDialog = _QFileDialog
+    QEventLoop = _QEventLoop
+    QUrl = _QUrl
+    QNetworkRequest = _QNetworkRequest
+    QNetworkReply = _QNetworkReply
+    QCoreApplication = _QCoreApplication
+
+    QWidget = _QWidget
+    QGridLayout = _QGridLayout
+    QLabel = _QLabel
+    QLineEdit = _QLineEdit
+    QGroupBox = _QGroupBox
+    QVBoxLayout = _QVBoxLayout
+    QPushButton = _QPushButton
+
+    if QMessageBox is not None:
+        YES = QMessageBox.StandardButton.Yes
+        NO = QMessageBox.StandardButton.No
+        CANCEL = QMessageBox.StandardButton.Cancel
+        ICON_QUESTION = QMessageBox.Icon.Question
+
+    QT_VERSION = 6
+
+    def exec_dialog(dialog: Any) -> Any:
+        return dialog.exec()
+
+# ---------------------------------------------------------
+# Versuch: PyQt5 importieren
+# ---------------------------------------------------------
+
+except Exception:
+    try:
+        from PyQt5.QtWidgets import (
+            QMessageBox as _QMessageBox,
+            QFileDialog as _QFileDialog,
+            QWidget as _QWidget,
+            QGridLayout as _QGridLayout,
+            QLabel as _QLabel,
+            QLineEdit as _QLineEdit,
+            QGroupBox as _QGroupBox,
+            QVBoxLayout as _QVBoxLayout,
+            QPushButton as _QPushButton,
+        )
+        from PyQt5.QtCore import (
+            Qt,
+            QEventLoop as _QEventLoop,
+            QUrl as _QUrl,
+            QCoreApplication as _QCoreApplication,
+        )
+        from PyQt5.QtNetwork import (
+            QNetworkRequest as _QNetworkRequest,
+            QNetworkReply as _QNetworkReply,
+        )
+
+        QMessageBox = _QMessageBox
+        QFileDialog = _QFileDialog
+        QEventLoop = _QEventLoop
+        QUrl = _QUrl
+        QNetworkRequest = _QNetworkRequest
+        QNetworkReply = _QNetworkReply
+        QCoreApplication = _QCoreApplication
+
+        QWidget = _QWidget
+        QGridLayout = _QGridLayout
+        QLabel = _QLabel
+        QLineEdit = _QLineEdit
+        QGroupBox = _QGroupBox
+        QVBoxLayout = _QVBoxLayout
+        QPushButton = _QPushButton
+
+        if QMessageBox is not None:
+            YES = QMessageBox.Yes
+            NO = QMessageBox.No
+            CANCEL = QMessageBox.Cancel
+            ICON_QUESTION = QMessageBox.Question
+
+        QT_VERSION = 5
+
+        def exec_dialog(dialog: Any) -> Any:
+            return dialog.exec_()
+
+    # ---------------------------------------------------------
+    # Mock‑Modus (kein Qt verfügbar)
+    # ---------------------------------------------------------
+
+    except Exception:
+        QT_VERSION = 0
+
+        class FakeEnum(int):
+            """OR‑fähiger Enum‑Ersatz für Mock‑Modus."""
+
+            def __new__(cls, value: int):
+                return int.__new__(cls, value)
+
+            def __or__(self, other: "FakeEnum") -> "FakeEnum":
+                return FakeEnum(int(self) | int(other))
+
+        class _MockQMessageBox:
+            Yes = FakeEnum(1)
+            No = FakeEnum(2)
+            Cancel = FakeEnum(4)
+            Question = FakeEnum(8)
+
+        QMessageBox = _MockQMessageBox
+
+        class _MockQFileDialog:
+            @staticmethod
+            def getOpenFileName(*args, **kwargs):
+                return ("", "")
+
+            @staticmethod
+            def getSaveFileName(*args, **kwargs):
+                return ("", "")
+
+        QFileDialog = _MockQFileDialog
+
+        class _MockQEventLoop:
+            def exec(self) -> int:
+                return 0
+
+            def quit(self) -> None:
+                pass
+
+        QEventLoop = _MockQEventLoop
+
+        class _MockQUrl(str):
+            def isValid(self) -> bool:
+                return True
+
+        QUrl = _MockQUrl
+
+        class _MockQNetworkRequest:
+            def __init__(self, url: Any):
+                self.url = url
+
+        QNetworkRequest = _MockQNetworkRequest
+
+        class _MockQNetworkReply:
+            class NetworkError:
+                NoError = 0
+
+            def __init__(self):
+                self._data = b""
+
+            def error(self) -> int:
+                return 0
+
+            def errorString(self) -> str:
+                return ""
+
+            def attribute(self, *args, **kwargs) -> Any:
+                return 200
+
+            def readAll(self) -> bytes:
+                return self._data
+
+            def deleteLater(self) -> None:
+                pass
+
+        QNetworkReply = _MockQNetworkReply
+
+        YES = FakeEnum(1)
+        NO = FakeEnum(2)
+        CANCEL = FakeEnum(4)
+        ICON_QUESTION = FakeEnum(8)
+
+        def exec_dialog(dialog: Any) -> Any:
+            return YES
+
+        class _MockWidget:
+            def __init__(self, *args, **kwargs):
+                pass
+
+        class _MockLayout:
+            def __init__(self, *args, **kwargs):
+                pass
+
+            def addWidget(self, *args, **kwargs):
+                pass
+
+            def addLayout(self, *args, **kwargs):
+                pass
+
+            def addStretch(self, *args, **kwargs):
+                pass
+
+            def setLayout(self, *args, **kwargs):
+                pass
+
+        class _MockLabel:
+            def __init__(self, text: str = ""):
+                self._text = text
+
+        class _MockLineEdit:
+            def __init__(self, *args, **kwargs):
+                self._text = ""
+
+            def text(self) -> str:
+                return self._text
+
+            def setText(self, value: str) -> None:
+                self._text = value
+
+        class _MockButton:
+            def __init__(self, *args, **kwargs):
+                # einfache Attr für Kompatibilität mit Qt-Signal-Syntax
+                self.clicked = lambda *a, **k: None
+
+            def connect(self, *args, **kwargs):
+                pass
+
+        QWidget = _MockWidget
+        QGridLayout = _MockLayout
+        QLabel = _MockLabel
+        QLineEdit = _MockLineEdit
+        QGroupBox = _MockWidget
+        QVBoxLayout = _MockLayout
+        QPushButton = _MockButton
+
+        # Kein echtes QCoreApplication im Mock
+        QCoreApplication = None
+
+
+# ---------------------------------------------------------
+# QGIS‑Imports
+# ---------------------------------------------------------
+
+try:
+    from qgis.core import (
+        QgsProject as _QgsProject,
+        QgsVectorLayer as _QgsVectorLayer,
+        QgsNetworkAccessManager as _QgsNetworkAccessManager,
+        Qgis as _Qgis,
+    )
+    from qgis.utils import iface as _iface
+
+    QgsProject = _QgsProject
+    QgsVectorLayer = _QgsVectorLayer
+    QgsNetworkAccessManager = _QgsNetworkAccessManager
+    Qgis = _Qgis
+    iface = _iface
+
+    QGIS_AVAILABLE = True
+
+except Exception:
+    QGIS_AVAILABLE = False
+
+    class _MockQgsProject:
+        @staticmethod
+        def instance() -> "_MockQgsProject":
+            return _MockQgsProject()
+
+        def __init__(self):
+            self._variables = {}
+
+        def read(self) -> bool:
+            return True
+
+    QgsProject = _MockQgsProject
+
+    class _MockQgsVectorLayer:
+        def __init__(self, *args, **kwargs):
+            self._valid = True
+
+        def isValid(self) -> bool:
+            return self._valid
+
+        def loadNamedStyle(self, path: str):
+            return True, ""
+
+        def triggerRepaint(self) -> None:
+            pass
+
+    QgsVectorLayer = _MockQgsVectorLayer
+
+    class _MockQgsNetworkAccessManager:
+        def head(self, request: Any) -> _MockQNetworkReply:
+            return _MockQNetworkReply()
+
+    QgsNetworkAccessManager = _MockQgsNetworkAccessManager
+
+    class _MockQgis:
+        class MessageLevel:
+            Success = 0
+            Info = 1
+            Warning = 2
+            Critical = 3
+
+    Qgis = _MockQgis
+
+    class FakeIface:
+        class FakeMessageBar:
+            def pushMessage(self, title, text, level=0, duration=5):
+                return {"title": title, "text": text, "level": level, "duration": duration}
+
+        def messageBar(self):
+            return self.FakeMessageBar()
+
+        def mainWindow(self):
+            return None
+
+    iface = FakeIface()
+
+
+# ---------------------------------------------------------
+# Message‑Funktionen
+# ---------------------------------------------------------
+
+def _get_message_bar():
+    if iface is not None:
+        bar_attr = getattr_safe(iface, "messageBar")
+        if callable(bar_attr):
+            try:
+                return bar_attr()
+            except Exception:
+                pass
+
+    class _MockMessageBar:
+        def pushMessage(self, title, text, level=0, duration=5):
+            return {
+                "title": title,
+                "text": text,
+                "level": level,
+                "duration": duration,
+            }
+
+    return _MockMessageBar()
+
+
+def push_message(level, title, text, duration=5, parent=None):
+    bar = _get_message_bar()
+    push = getattr_safe(bar, "pushMessage")
+    if callable(push):
+        return push(title, text, level=level, duration=duration)
+    return None
+
+
+def info(title, text, duration=5):
+    level = Qgis.MessageLevel.Info if Qgis is not None else 1
+    return push_message(level, title, text, duration)
+
+
+def warning(title, text, duration=5):
+    level = Qgis.MessageLevel.Warning if Qgis is not None else 2
+    return push_message(level, title, text, duration)
+
+
+def error(title, text, duration=5):
+    level = Qgis.MessageLevel.Critical if Qgis is not None else 3
+    return push_message(level, title, text, duration)
+
+
+def success(title, text, duration=5):
+    level = Qgis.MessageLevel.Success if Qgis is not None else 0
+    return push_message(level, title, text, duration)
+
+# ---------------------------------------------------------
+# Dialog‑Interaktionen
+# ---------------------------------------------------------
+
+def ask_yes_no(
+    title: str,
+    message: str,
+    default: bool = False,
+    parent: Any = None,
+) -> bool:
+    """
+    Fragt den Benutzer eine Ja/Nein‑Frage.
+
+    - In QGIS/Qt: zeigt einen QMessageBox‑Dialog
+    - Im Mock/Test‑Modus: gibt default zurück
+    """
+    if QMessageBox is None:
+        return default
+
+    try:
+        buttons = YES | NO
+        result = QMessageBox.question(
+            parent,
+            title,
+            message,
+            buttons,
+            YES if default else NO,
+        )
+        return result == YES
+    except Exception:
+        return default
+
+
+# ---------------------------------------------------------
+# Variablen‑Wrapper
+# ---------------------------------------------------------
+
+try:
+    from qgis.core import QgsExpressionContextUtils
+
+    _HAS_QGIS_VARIABLES = True
+except Exception:
+    _HAS_QGIS_VARIABLES = False
+
+    class _MockVariableStore:
+        global_vars: dict[str, str] = {}
+        project_vars: dict[str, str] = {}
+
+    class QgsExpressionContextUtils:
+        @staticmethod
+        def setGlobalVariable(name: str, value: str) -> None:
+            _MockVariableStore.global_vars[name] = value
+
+        @staticmethod
+        def globalScope():
+            class _Scope:
+                def variable(self, name: str) -> str:
+                    return _MockVariableStore.global_vars.get(name, "")
+
+            return _Scope()
+
+        @staticmethod
+        def setProjectVariable(project: Any, name: str, value: str) -> None:
+            _MockVariableStore.project_vars[name] = value
+
+        @staticmethod
+        def projectScope(project: Any):
+            class _Scope:
+                def variable(self, name: str) -> str:
+                    return _MockVariableStore.project_vars.get(name, "")
+
+            return _Scope()
+
+
+def get_variable(key: str, scope: str = "project") -> str:
+    var_name = f"sn_{key}"
+
+    if scope == "project":
+        if QgsProject is not None:
+            projekt = QgsProject.instance()
+        else:
+            projekt = None  # type: ignore[assignment]
+        return QgsExpressionContextUtils.projectScope(projekt).variable(var_name) or ""
+
+    if scope == "global":
+        return QgsExpressionContextUtils.globalScope().variable(var_name) or ""
+
+    raise ValueError("Scope muss 'project' oder 'global' sein.")
+
+
+def set_variable(key: str, value: str, scope: str = "project") -> None:
+    var_name = f"sn_{key}"
+
+    if scope == "project":
+        if QgsProject is not None:
+            projekt = QgsProject.instance()
+        else:
+            projekt = None  # type: ignore[assignment]
+        QgsExpressionContextUtils.setProjectVariable(projekt, var_name, value)
+        return
+
+    if scope == "global":
+        QgsExpressionContextUtils.setGlobalVariable(var_name, value)
+        return
+
+    raise ValueError("Scope muss 'project' oder 'global' sein.")
+
+
+# ---------------------------------------------------------
+# syswrapper Lazy‑Import
+# ---------------------------------------------------------
+
+def _sys():
+    from sn_basis.functions import syswrapper
+    return syswrapper
+
+
+# ---------------------------------------------------------
+# Style‑Funktion
+# ---------------------------------------------------------
+
+def apply_style(layer, style_name: str) -> bool:
+    if layer is None:
+        return False
+
+    is_valid_attr = getattr_safe(layer, "isValid")
+    if not callable(is_valid_attr) or not is_valid_attr():
+        return False
+
+    sys = _sys()
+    base_dir = sys.get_plugin_root()
+    style_path = sys.join_path(base_dir, "styles", style_name)
+
+    if not sys.file_exists(style_path):
+        return False
+
+    try:
+        ok, error_msg = layer.loadNamedStyle(style_path)
+    except Exception:
+        return False
+
+    if not ok:
+        return False
+
+    try:
+        trigger = getattr_safe(layer, "triggerRepaint")
+        if callable(trigger):
+            trigger()
+    except Exception:
+        pass
+
+    return True
+
+
+# ---------------------------------------------------------
+# Layer‑Wrapper
+# ---------------------------------------------------------
+
+def layer_exists(layer) -> bool:
+    if layer is None:
+        return False
+
+    # Mock/Wrapper-Attribut
+    is_valid_flag = getattr_safe(layer, "is_valid")
+    if is_valid_flag is not None:
+        try:
+            return bool(is_valid_flag)
+        except Exception:
+            return False
+
+    try:
+        is_valid_attr = getattr_safe(layer, "isValid")
+        if callable(is_valid_attr):
+            return bool(is_valid_attr())
+        return True
+    except Exception:
+        return False
+
+
+def get_layer_geometry_type(layer) -> str:
+    if layer is None:
+        return "None"
+
+    geometry_type_attr = getattr_safe(layer, "geometry_type")
+    if geometry_type_attr is not None:
+        return str(geometry_type_attr)
+
+    try:
+        is_spatial_attr = getattr_safe(layer, "isSpatial")
+        if callable(is_spatial_attr) and not is_spatial_attr():
+            return "None"
+
+        geometry_type_qgis = getattr_safe(layer, "geometryType")
+        if callable(geometry_type_qgis):
+            gtype = geometry_type_qgis()
+            if gtype == 0:
+                return "Point"
+            if gtype == 1:
+                return "LineString"
+            if gtype == 2:
+                return "Polygon"
+            return "None"
+
+        return "None"
+    except Exception:
+        return "None"
+
+
+def get_layer_feature_count(layer) -> int:
+    if layer is None:
+        return 0
+
+    feature_count_attr = getattr_safe(layer, "feature_count")
+    if feature_count_attr is not None:
+        try:
+            return int(feature_count_attr)
+        except Exception:
+            return 0
+
+    try:
+        is_spatial_attr = getattr_safe(layer, "isSpatial")
+        if callable(is_spatial_attr) and not is_spatial_attr():
+            return 0
+
+        feature_count_qgis = getattr_safe(layer, "featureCount")
+        if callable(feature_count_qgis):
+            return int(feature_count_qgis())
+
+        return 0
+    except Exception:
+        return 0
+
+
+def is_layer_visible(layer) -> bool:
+    if layer is None:
+        return False
+
+    visible_attr = getattr_safe(layer, "visible")
+    if visible_attr is not None:
+        try:
+            return bool(visible_attr)
+        except Exception:
+            return False
+
+    try:
+        is_visible_attr = getattr_safe(layer, "isVisible")
+        if callable(is_visible_attr):
+            return bool(is_visible_attr())
+
+        tree_layer_attr = getattr_safe(layer, "treeLayer")
+        if callable(tree_layer_attr):
+            node = tree_layer_attr()
+        else:
+            node = tree_layer_attr
+
+        if node is not None:
+            node_visible_attr = getattr_safe(node, "isVisible")
+            if callable(node_visible_attr):
+                return bool(node_visible_attr())
+
+        return False
+    except Exception:
+        return False
+
+def set_layer_visible(layer, visible: bool) -> bool:
+    """
+    Setzt die Sichtbarkeit eines Layers.
+
+    Unterstützt:
+    - Mock-/Wrapper-Attribute (layer.visible)
+    - QGIS-LayerTreeNode (treeLayer().setItemVisibilityChecked)
+    - Fallbacks ohne Exception-Wurf
+
+    Gibt True zurück, wenn die Sichtbarkeit gesetzt werden konnte.
+    """
+    if layer is None:
+        return False
+
+    # 1️⃣ Mock / Wrapper-Attribut
+    try:
+        if hasattr(layer, "visible"):
+            layer.visible = bool(visible)
+            return True
+    except Exception:
+        pass
+
+    # 2️⃣ QGIS: LayerTreeNode
+    try:
+        tree_layer_attr = getattr_safe(layer, "treeLayer")
+        node = tree_layer_attr() if callable(tree_layer_attr) else tree_layer_attr
+
+        if node is not None:
+            set_visible = getattr_safe(node, "setItemVisibilityChecked")
+            if callable(set_visible):
+                set_visible(bool(visible))
+                return True
+    except Exception:
+        pass
+
+    # 3️⃣ QGIS-Fallback: setVisible (selten, aber vorhanden)
+    try:
+        set_visible_attr = getattr_safe(layer, "setVisible")
+        if callable(set_visible_attr):
+            set_visible_attr(bool(visible))
+            return True
+    except Exception:
+        pass
+
+    return False
+
+
+def get_layer_type(layer) -> str:
+    if layer is None:
+        return "unknown"
+
+    layer_type_attr = getattr_safe(layer, "layer_type")
+    if layer_type_attr is not None:
+        return str(layer_type_attr)
+
+    try:
+        is_spatial_attr = getattr_safe(layer, "isSpatial")
+        if callable(is_spatial_attr):
+            return "vector" if is_spatial_attr() else "table"
+
+        data_provider_attr = getattr_safe(layer, "dataProvider")
+        raster_type_attr = getattr_safe(layer, "rasterType")
+        if data_provider_attr is not None and raster_type_attr is not None:
+            return "raster"
+
+        return "unknown"
+    except Exception:
+        return "unknown"
+
+
+def get_layer_crs(layer) -> str:
+    if layer is None:
+        return "None"
+
+    crs_attr_direct = getattr_safe(layer, "crs")
+    if crs_attr_direct is not None and not callable(crs_attr_direct):
+        # direkter Attributzugriff (z. B. im Mock)
+        return str(crs_attr_direct)
+
+    try:
+        crs_callable = getattr_safe(layer, "crs")
+        if callable(crs_callable):
+            crs = crs_callable()
+            authid_attr = getattr_safe(crs, "authid")
+            if callable(authid_attr):
+                return authid_attr() or "None"
+        return "None"
+    except Exception:
+        return "None"
+
+
+def get_layer_fields(layer) -> list[str]:
+    if layer is None:
+        return []
+
+    # direkter Attributzugriff (Mock / Wrapper)
+    fields_attr_direct = getattr_safe(layer, "fields")
+    if fields_attr_direct is not None and not callable(fields_attr_direct):
+        try:
+            # direkter Iterable oder Mapping von Namen
+            if hasattr(fields_attr_direct, "__iter__") and not isinstance(
+                fields_attr_direct, (str, bytes)
+            ):
+                return list(fields_attr_direct)
+        except Exception:
+            return []
+
+    try:
+        fields_callable = getattr_safe(layer, "fields")
+        if callable(fields_callable):
+            fields = fields_callable()
+
+            # QGIS: QgsFields.names()
+            names_attr = getattr_safe(fields, "names")
+            if callable(names_attr):
+                return list(names_attr())
+
+            # Fallback: iterierbar?
+            if hasattr(fields, "__iter__") and not isinstance(fields, (str, bytes)):
+                return list(fields)
+
+        return []
+    except Exception:
+        return []
+
+
+def get_layer_source(layer) -> str:
+    if layer is None:
+        return "None"
+
+    source_attr_direct = getattr_safe(layer, "source")
+    if source_attr_direct is not None and not callable(source_attr_direct):
+        return str(source_attr_direct)
+
+    try:
+        source_callable = getattr_safe(layer, "source")
+        if callable(source_callable):
+            return source_callable() or "None"
+        return "None"
+    except Exception:
+        return "None"
+
+
+def is_layer_editable(layer) -> bool:
+    if layer is None:
+        return False
+
+    editable_attr = getattr_safe(layer, "editable")
+    if editable_attr is not None:
+        try:
+            return bool(editable_attr)
+        except Exception:
+            return False
+
+    try:
+        editable_callable = getattr_safe(layer, "isEditable")
+        if callable(editable_callable):
+            return bool(editable_callable())
+        return False
+    except Exception:
+        return False