qgis-profile-interpreter

fakeqgis.py (10081B)

---

 """
 Minimal fake qgis installed into sys.modules so that profile_interpreter
 can be imported and unit-tested on a QGIS-free Python runtime (e.g. CI).
 """
 import sys
 from types import ModuleType
 
 
 # ── PyQt stubs ────────────────────────────────────────────────────────────
 
 class Qt:
     class MouseButton:
         LeftButton = 1
         RightButton = 2
     LeftButton = 1
     RightButton = 2
 
 
 class QPointF:
     def __init__(self, *args):
         pass
 
 
 class QMetaType:
     class Type:
         Int = 1
         Double = 2
         QString = 3
 
 
 class QIcon:
     def __init__(self, *args, **kwargs):
         pass
 
 
 class QAction:
     def __init__(self, *args, **kwargs):
         self._checkable = False
         self._checked = False
         self._callbacks = []
 
     def setCheckable(self, v):
         self._checkable = v
 
     def setChecked(self, v):
         self._checked = v
 
     def toggled(self):
         pass
 
     def connect(self, cb):
         self._callbacks.append(cb)
 
 
 # ── qgis.core stubs ───────────────────────────────────────────────────────
 
 class Qgis:
     Warning = 1
     Info = 2
     Success = 3
 
 
 class QgsField:
     def __init__(self, name, type_=None):
         self._name = name
 
     def name(self):
         return self._name
 
 
 class _FakeFields:
     def __init__(self, fields):
         self._fields = list(fields)
 
     def __iter__(self):
         return iter(self._fields)
 
 
 class QgsFeature:
     def __init__(self, fields=None):
         self._fields = fields if fields is not None else _FakeFields([])
         self._attrs = {}
         self._geom = None
 
     def fields(self):
         return self._fields
 
     def setGeometry(self, geom):
         self._geom = geom
 
     def __setitem__(self, key, value):
         self._attrs[key] = value
 
     def __getitem__(self, key):
         return self._attrs[key]
 
 
 class _FakeGeometry:
     def __init__(self, empty=False, x=100.0, y=200.0):
         self._empty = empty
         self._x = x
         self._y = y
 
     def isEmpty(self):
         return self._empty
 
     def asPoint(self):
         return _FakeXY(self._x, self._y)
 
     def clone(self):
         return self
 
 
 class _FakeXY:
     def __init__(self, x=100.0, y=200.0):
         self._x = x
         self._y = y
 
     def x(self):
         return self._x
 
     def y(self):
         return self._y
 
 
 class QgsPointXY:
     def __init__(self, x=0.0, y=0.0):
         self._x = x
         self._y = y
 
     def x(self):
         return self._x
 
     def y(self):
         return self._y
 
 
 class QgsGeometry:
     # Set to True in tests to make interpolate() return an empty geometry.
     _next_interpolate_empty = False
 
     def __init__(self, obj=None):
         self._obj = obj
 
     @classmethod
     def set_interpolate_empty(cls, v):
         cls._next_interpolate_empty = v
 
     def interpolate(self, distance):
         empty = QgsGeometry._next_interpolate_empty
         return _FakeGeometry(empty=empty)
 
     def isEmpty(self):
         return False
 
     def asPoint(self):
         return _FakeXY()
 
     def clone(self):
         return self
 
 
 class QgsPoint:
     def __init__(self, x=0.0, y=0.0, z=0.0):
         self._x = x
         self._y = y
         self._z = z
 
 
 class QgsCoordinateTransform:
     _calls = []  # (src_authid, dst_authid, in_x, in_y)
 
     def __init__(self, src, dst, project):
         self._src = src
         self._dst = dst
 
     def transform(self, pt):
         QgsCoordinateTransform._calls.append(
             (self._src.authid(), self._dst.authid(), pt.x(), pt.y())
         )
         return QgsPointXY(pt.x() + 1000.0, pt.y() + 1000.0)
 
     @classmethod
     def reset(cls):
         cls._calls.clear()
 
 
 class QgsMessageLog:
     _log = []
 
     @classmethod
     def logMessage(cls, msg, tag='', level=None):
         cls._log.append((tag, msg, level))
 
     @classmethod
     def reset(cls):
         cls._log.clear()
 
 
 class QgsWkbTypes:
     PointZ = 1001
     Point = 1
     PointGeometry = 0    # PyQt5 style
     LineGeometry = 1
     PolygonGeometry = 2
 
     class GeometryType:  # PyQt6 style
         PointGeometry = 0
         LineGeometry = 1
         PolygonGeometry = 2
 
     @staticmethod
     def hasZ(wkb_type):
         return wkb_type == QgsWkbTypes.PointZ
 
 
 class QgsVectorDataProvider:
     AddFeatures = 1    # PyQt5 style
 
     class Capability:  # PyQt6 style
         AddFeatures = 1
 
 
 class _FakeDataProvider:
     _fail_next = False  # set True in a test to simulate addFeatures failure
 
     def __init__(self, caps, features_store, fields_ref):
         self._caps = caps
         self._features = features_store
         self._fields_ref = fields_ref
 
     def capabilities(self):
         return self._caps
 
     def addFeatures(self, features):
         if _FakeDataProvider._fail_next:
             _FakeDataProvider._fail_next = False
             return (False, [])
         self._features.extend(features)
         return (True, list(features))
 
     def addAttributes(self, attrs):
         self._fields_ref.extend(attrs)
 
 
 class QgsVectorLayer:
     def __init__(self, uri='', name='', provider=''):
         self._name = name
         self._features = []
         self._fields_list = []
         self._geom_type = QgsWkbTypes.PointGeometry
         self._wkb_type = QgsWkbTypes.PointZ
         self._provider = _FakeDataProvider(
             QgsVectorDataProvider.AddFeatures,
             self._features,
             self._fields_list,
         )
 
     def name(self):
         return self._name
 
     def id(self):
         return id(self)
 
     def geometryType(self):
         return self._geom_type
 
     def wkbType(self):
         return self._wkb_type
 
     def dataProvider(self):
         return self._provider
 
     def fields(self):
         return _FakeFields(self._fields_list)
 
     def crs(self):
         return getattr(self, '_crs', _FakeCrs())
 
     def getFeatures(self):
         return iter(self._features)
 
     def updateExtents(self):
         pass
 
     def triggerRepaint(self):
         pass
 
     def updateFields(self):
         pass
 
 
 class QgsProject:
     _instance = None
 
     def __init__(self):
         self._layers = {}
 
     @classmethod
     def instance(cls):
         if cls._instance is None:
             cls._instance = cls()
         return cls._instance
 
     def mapLayer(self, layer_id):
         return self._layers.get(layer_id)
 
     def addMapLayer(self, layer):
         self._layers[layer.id()] = layer
         return layer
 
 
 # ── qgis.gui stubs ────────────────────────────────────────────────────────
 
 class QgsPlotTool:
     def __init__(self, canvas, name):
         self._canvas = canvas
         self._name = name
 
     def plotReleaseEvent(self, event):
         pass
 
 
 class QgsPlotToolPan:
     def __init__(self, canvas):
         self._canvas = canvas
 
 
 class QgsElevationProfileCanvas:
     def __init__(self):
         self._visible = True
         self.refresh_count = 0
         self._tool = None
 
     def isVisible(self):
         return self._visible
 
     def setTool(self, tool):
         self._tool = tool
 
     def refresh(self):
         self.refresh_count += 1
 
     def canvasPointToPlotPoint(self, pt):
         return _FakeProfilePoint()
 
     def profileCurve(self):
         return _FakeCurve()
 
     def crs(self):
         return _FakeCrs()
 
 
 class _FakeProfilePoint:
     def __init__(self, distance=10.0, elevation=5.0):
         self._distance = distance
         self._elevation = elevation
 
     def distance(self):
         return self._distance
 
     def elevation(self):
         return self._elevation
 
 
 class _FakeCurve:
     def clone(self):
         return self
 
 
 class _FakeCrs:
     def __init__(self, authid='EPSG:4326'):
         self._authid = authid
 
     def isValid(self):
         return True
 
     def authid(self):
         return self._authid
 
     def __eq__(self, other):
         if not isinstance(other, _FakeCrs):
             return NotImplemented
         return self._authid == other._authid
 
     def __hash__(self):
         return hash(self._authid)
 
 
 # ── installer ─────────────────────────────────────────────────────────────
 
 def install():
     """Register all fake qgis sub-modules into sys.modules."""
     qgis = ModuleType('qgis')
     qgis_core = ModuleType('qgis.core')
     qgis_gui = ModuleType('qgis.gui')
     qgis_pyqt = ModuleType('qgis.PyQt')
     qgis_pyqt_qtcore = ModuleType('qgis.PyQt.QtCore')
     qgis_pyqt_qtgui = ModuleType('qgis.PyQt.QtGui')
     qgis_pyqt_qtwidgets = ModuleType('qgis.PyQt.QtWidgets')
 
     for name in [
         'Qgis', 'QgsCoordinateTransform', 'QgsFeature', 'QgsField',
         'QgsGeometry', 'QgsMessageLog', 'QgsPoint', 'QgsPointXY',
         'QgsProject', 'QgsVectorDataProvider', 'QgsVectorLayer', 'QgsWkbTypes',
     ]:
         setattr(qgis_core, name, globals()[name])
 
     for name in ['QgsElevationProfileCanvas', 'QgsPlotTool', 'QgsPlotToolPan']:
         setattr(qgis_gui, name, globals()[name])
 
     qgis_pyqt_qtcore.Qt = Qt
     qgis_pyqt_qtcore.QPointF = QPointF
     qgis_pyqt_qtcore.QMetaType = QMetaType
     qgis_pyqt_qtgui.QIcon = QIcon
     qgis_pyqt_qtwidgets.QAction = QAction
 
     sys.modules['qgis'] = qgis
     sys.modules['qgis.core'] = qgis_core
     sys.modules['qgis.gui'] = qgis_gui
     sys.modules['qgis.PyQt'] = qgis_pyqt
     sys.modules['qgis.PyQt.QtCore'] = qgis_pyqt_qtcore
     sys.modules['qgis.PyQt.QtGui'] = qgis_pyqt_qtgui
     sys.modules['qgis.PyQt.QtWidgets'] = qgis_pyqt_qtwidgets
 
     qgis.core = qgis_core
     qgis.gui = qgis_gui
     qgis.PyQt = qgis_pyqt
     qgis_pyqt.QtCore = qgis_pyqt_qtcore
     qgis_pyqt.QtGui = qgis_pyqt_qtgui
     qgis_pyqt.QtWidgets = qgis_pyqt_qtwidgets
 
     # Reset project singleton for each test run.
     QgsProject._instance = None