Polymorphic! (Errors)

Author: JamesParrott

src/shapefile.py

@@ -844,111 +844,87 @@ def shapeTypeName(self) -> str:
     def __repr__(self):
         return f"Shape #{self.__oid}: {self.shapeTypeName}"
 
+    # pylint: disable=unused-argument
+    def _get_and_set_bbox_from_shp_file(self, f):
+        return None
+
+    @staticmethod
+    def _get_nparts_from_shp_file(f):
+        return None
+
+    @staticmethod
+    def _get_npoints_from_shp_file(f):
+        return None
+
+    def _set_parts_from_shp_file(self, f, nParts):
+        pass
+
+    def _set_part_types_from_shp_file(self, f, nParts):
+        pass
+
+    def _set_points_from_shp_file(self, f, nPoints):
+        pass
+
+    def _set_z_from_shp_file(self, f, nPoints):
+        pass
+
+    def _set_m_from_shp_file(self, f, nPoints, next_shape):
+        pass
+
+    def _get_and_set_2D_point_from_shp_file(self, f):
+        return None
+
+    def _set_single_point_z_from_shp_file(self, f):
+        pass
+
+    def _set_single_point_m_from_shp_file(self, f, next_shape):
+        pass
+
+    # pylint: enable=unused-argument
+
     @classmethod
     def _from_shp_file(cls, f, next_shape, oid=None, bbox=None):
-        # Previously, we also set __zmin = __zmax = __mmin = __mmax = None
-        nParts: Optional[int] = None
-        nPoints: Optional[int] = None
-
         shape = cls(oid=oid)
 
-        # All shape types capable of having a bounding box
-        # elif shapeType in (3, 13, 23, 5, 15, 25, 8, 18, 28, 31):
-        if isinstance(shape, _CanHaveBBox):
-            # record.bbox = tuple(_Array[float]("d", unpack("<4d", f.read(32))))
-            shape.bbox = _Array[float]("d", unpack("<4d", f.read(32)))
-            # if bbox specified and no overlap, skip this shape
-            if bbox is not None and not bbox_overlap(bbox, tuple(shape.bbox)):
-                # because we stop parsing this shape, skip to beginning of
-                # next shape before we return
-                return None
-        # Shape types with parts
-        # if shapeType in (3, 13, 23, 5, 15, 25, 31):
-        if issubclass(cls, (Polyline, Polygon, MultiPatch)):
-            nParts = unpack("<i", f.read(4))[0]
+        bbox = shape._get_and_set_bbox_from_shp_file(f)  # pylint: disable=assignment-from-none
 
-        # Shape types with points
-        # if shapeType in (3, 13, 23, 5, 15, 25, 8, 18, 28, 31):
-        if isinstance(shape, _CanHaveBBox):
-            nPoints = unpack("<i", f.read(4))[0]
-            # Read points - produces a list of [x,y] values
+        # if bbox specified and no overlap, skip this shape
+        if bbox is not None and not bbox_overlap(bbox, tuple(shape.bbox)):  # pylint: disable=no-member
+            # because we stop parsing this shape, skip to beginning of
+            # next shape before we return
+            return None
 
-        if nParts:
-            shape.parts = _Array[int]("i", unpack(f"<{nParts}i", f.read(nParts * 4)))
+        nParts: Optional[int] = shape._get_nparts_from_shp_file(f)
+        nPoints: Optional[int] = shape._get_npoints_from_shp_file(f)
+        # Previously, we also set __zmin = __zmax = __mmin = __mmax = None
 
-            # Read part types for Multipatch - 31
-            # if shapeType == 31:
-            if cls is MultiPatch:
-                shape.partTypes = _Array[int](
-                    "i", unpack(f"<{nParts}i", f.read(nParts * 4))
-                )
+        if nParts:
+            shape._set_parts_from_shp_file(f, nParts)
+            shape._set_part_types_from_shp_file(f, nParts)
 
         if nPoints:
-            flat = unpack(f"<{2 * nPoints}d", f.read(16 * nPoints))
-            shape.points = list(zip(*(iter(flat),) * 2))
-
-            # Read z extremes and values
-            # if shapeType in (13, 15, 18, 31):
-            if isinstance(shape, _HasZ):
-                __zmin, __zmax = unpack("<2d", f.read(16))
-                shape.z = _Array[float](
-                    "d", unpack(f"<{nPoints}d", f.read(nPoints * 8))
-                )
+            shape._set_points_from_shp_file(f, nPoints)
 
-            # Read m extremes and values
-            # if shapeType in (13, 23, 15, 25, 18, 28, 31):
-            if isinstance(shape, _HasM):
-                if next_shape - f.tell() >= 16:
-                    __mmin, __mmax = unpack("<2d", f.read(16))
-                # Measure values less than -10e38 are nodata values according to the spec
-                if next_shape - f.tell() >= nPoints * 8:
-                    shape.m = []
-                    for m in _Array[float](
-                        "d", unpack(f"<{nPoints}d", f.read(nPoints * 8))
-                    ):
-                        if m > NODATA:
-                            shape.m.append(m)
-                        else:
-                            shape.m.append(None)
-                else:
-                    shape.m = [None for _ in range(nPoints)]
+            shape._set_z_from_shp_file(f, nPoints)
+
+            shape._set_m_from_shp_file(f, nPoints, next_shape)
 
         # Read a single point
         # if shapeType in (1, 11, 21):
-        if cls is Point:
-            x, y = _Array[float]("d", unpack("<2d", f.read(16)))
-
-            shape.points = [(x, y)]
-            if bbox is not None:
-                # create bounding box for Point by duplicating coordinates
-                # skip shape if no overlap with bounding box
-                if not bbox_overlap(bbox, (x, y, x, y)):
-                    return None
-
-        # Read a single Z value
-        # if shapeType == 11:
-        if cls is PointZ:
-            shape.z = tuple(unpack("<d", f.read(8)))
-
-        # Read a single M value
-        # if shapeType in (21, 11):
-        if cls is PointM:
-            if next_shape - f.tell() >= 8:
-                (m,) = unpack("<d", f.read(8))
-            else:
-                m = NODATA
-            # Measure values less than -10e38 are nodata values according to the spec
-            if m > NODATA:
-                shape.m = (m,)
-            else:
-                shape.m = (None,)
+        point_2D = shape._get_and_set_2D_point_from_shp_file(f)  # pylint: disable=assignment-from-none
 
-        return shape
+        if bbox is not None and point_2D is not None:
+            x, y = point_2D  # pylint: disable=unpacking-non-sequence
+            # create bounding box for Point by duplicating coordinates
+            # skip shape if no overlap with bounding box
+            if not bbox_overlap(bbox, (x, y, x, y)):
+                return None
 
-        # pylint: enable=attribute-defined-outside-init
-        # Seek to the end of this record as defined by the record header because
-        # the shapefile spec doesn't require the actual content to meet the header
-        # definition.  Probably allowed for lazy feature deletion.
+        shape._set_single_point_z_from_shp_file(f)
+
+        shape._set_single_point_m_from_shp_file(f, next_shape)
+
+        return shape
 
 
 def _read_shape_from_shp_file(
@@ -967,6 +943,9 @@ def _read_shape_from_shp_file(
     ShapeClass = SHAPE_CLASS_FROM_SHAPETYPE[shapeType]
     shape = ShapeClass._from_shp_file(f, next_shape, oid=oid, bbox=bbox)
 
+    # Seek to the end of this record as defined by the record header because
+    # the shapefile spec doesn't require the actual content to meet the header
+    # definition.  Probably allowed for lazy feature deletion.
     f.seek(next_shape)
 
     return shape
@@ -983,16 +962,43 @@ class _CanHaveBBox(Shape):
     # Not a BBox because the legacy implementation was a list, not a 4-tuple.
     bbox: Optional[Sequence[float]] = None
 
+    def _get_and_set_bbox_from_shp_file(self, f):
+        # record.bbox = tuple(_Array[float]("d", unpack("<4d", f.read(32))))
+        self.bbox = _Array[float]("d", unpack("<4d", f.read(32)))
+        return self.bbox
+
+    @staticmethod
+    def _get_npoints_from_shp_file(f):
+        return unpack("<i", f.read(4))[0]
+
+    def _set_points_from_shp_file(self, f, nPoints):
+        flat = unpack(f"<{2 * nPoints}d", f.read(16 * nPoints))
+        self.points = list(zip(*(iter(flat),) * 2))
+
+
+class _CanHaveParts(_CanHaveBBox):
+    @staticmethod
+    def _get_nparts_from_shp_file(f):
+        return unpack("<i", f.read(4))[0]
+
+    def _set_parts_from_shp_file(self, f, nParts):
+        self.parts = _Array[int]("i", unpack(f"<{nParts}i", f.read(nParts * 4)))
+
 
 class Point(Shape):
     shapeType = POINT
 
+    def _get_and_set_2D_point_from_shp_file(self, f):
+        x, y = _Array[float]("d", unpack("<2d", f.read(16)))
+
+        self.points = [(x, y)]
+
 
-class Polyline(_CanHaveBBox):
+class Polyline(_CanHaveParts):
     shapeType = POLYLINE
 
 
-class Polygon(_CanHaveBBox):
+class Polygon(_CanHaveParts):
     shapeType = POLYGON
 
 
@@ -1003,21 +1009,53 @@ class MultiPoint(_CanHaveBBox):
 class _HasM(Shape):
     m: Sequence[Optional[float]]
 
+    def _set_m_from_shp_file(self, f, nPoints, next_shape):
+        if next_shape - f.tell() >= 16:
+            __mmin, __mmax = unpack("<2d", f.read(16))
+        # Measure values less than -10e38 are nodata values according to the spec
+        if next_shape - f.tell() >= nPoints * 8:
+            self.m = []
+            for m in _Array[float]("d", unpack(f"<{nPoints}d", f.read(nPoints * 8))):
+                if m > NODATA:
+                    self.m.append(m)
+                else:
+                    self.m.append(None)
+        else:
+            self.m = [None for _ in range(nPoints)]
+
 
 class _HasZ(Shape):
     z: Sequence[float]
 
+    def _set_z_from_shp_file(self, f, nPoints):
+        __zmin, __zmax = unpack("<2d", f.read(16))  # pylint: disable=unused-private-member
+        self.z = _Array[float]("d", unpack(f"<{nPoints}d", f.read(nPoints * 8)))
+
 
-class MultiPatch(_HasM, _HasZ, _CanHaveBBox):
+class MultiPatch(_HasM, _HasZ, _CanHaveParts):
     shapeType = MULTIPATCH
 
+    def _set_part_types_from_shp_file(self, f, nParts):
+        self.partTypes = _Array[int]("i", unpack(f"<{nParts}i", f.read(nParts * 4)))
+
 
 class PointM(Point, _HasM):
     shapeType = POINTM
     # same default as in Writer.__shpRecord (if s.shapeType in (11, 21):)
     # PyShp encodes None m values as NODATA
     m = (None,)
 
+    def _set_single_point_m_from_shp_file(self, f, next_shape):
+        if next_shape - f.tell() >= 8:
+            (m,) = unpack("<d", f.read(8))
+        else:
+            m = NODATA
+        # Measure values less than -10e38 are nodata values according to the spec
+        if m > NODATA:
+            self.m = (m,)
+        else:
+            self.m = (None,)
+
 
 class PolylineM(Polyline, _HasM):
     shapeType = POLYLINEM
@@ -1036,6 +1074,9 @@ class PointZ(PointM, _HasZ):
     # same default as in Writer.__shpRecord (if s.shapeType == 11:)
     z: Sequence[float] = (0.0,)
 
+    def _set_single_point_z_from_shp_file(self, f):
+        self.z = tuple(unpack("<d", f.read(8)))
+
 
 class PolylineZ(PolylineM, _HasZ):
     shapeType = POLYLINEZ
@@ -1735,7 +1776,6 @@ def __shpHeader(self):
                 "Shapefile Reader requires a shapefile or file-like object. (no shp file found"
             )
 
-        # pylint: disable=attribute-defined-outside-init
         shp = self.shp
         # File length (16-bit word * 2 = bytes)
         shp.seek(24)
@@ -1756,14 +1796,11 @@ def __shpHeader(self):
             else:
                 self.mbox.append(None)
 
-        # pylint: enable=attribute-defined-outside-init
-
     def __shape(
         self, oid: Optional[int] = None, bbox: Optional[BBox] = None
     ) -> Optional[Shape]:
         """Returns the header info and geometry for a single shape."""
 
-        # pylint: disable=attribute-defined-outside-init
         f = self.__getFileObj(self.shp)
 
         shape = _read_shape_from_shp_file(f, oid, bbox)
@@ -1901,7 +1938,6 @@ def iterShapes(self, bbox: Optional[BBox] = None) -> Iterator[Optional[Shape]]:
     def __dbfHeader(self):
         """Reads a dbf header. Xbase-related code borrows heavily from ActiveState Python Cookbook Recipe 362715 by Raymond Hettinger"""
 
-        # pylint: disable=attribute-defined-outside-init
         if not self.dbf:
             raise ShapefileException(
                 "Shapefile Reader requires a shapefile or file-like object. (no dbf file found)"
@@ -1948,8 +1984,6 @@ def __dbfHeader(self):
         self.__fullRecStruct = recStruct
         self.__fullRecLookup = recLookup
 
-        # pylint: enable=attribute-defined-outside-init
-
     def __recordFmt(self, fields: Optional[Container[str]] = None) -> tuple[str, int]:
         """Calculates the format and size of a .dbf record. Optional 'fields' arg
         specifies which fieldnames to unpack and which to ignore. Note that this