Fix zip calls not being strict

Author: djhoese

pyresample/_formatting_html.py

@@ -104,7 +104,7 @@ def plot_area_def(area: Union['geom.AreaDefinition', 'geom.SwathDefinition'], #
         crs = cartopy.crs.Mercator()
         fig, ax = plt.subplots(subplot_kw=dict(projection=crs))
 
-        poly = Polygon(list(zip(lx[::-1], ly[::-1])))  # make lat/lon counterclockwise for shapely
+        poly = Polygon(list(zip(lx[::-1], ly[::-1], strict=True)))  # make lat/lon counterclockwise for shapely
         ax.add_geometries([poly], crs=cartopy.crs.CRS(area.crs), facecolor="none", edgecolor="red")
         bounds = poly.buffer(5).bounds
         ax.set_extent([bounds[0], bounds[2], bounds[1], bounds[3]], crs=cartopy.crs.CRS(area.crs))

pyresample/boundary/legacy_boundary.py

@@ -67,7 +67,7 @@ def __init__(self, *sides):
         if len(sides) != 4:
             raise ValueError("AreaBoundary expects 4 sides.")
         # Retrieve sides
-        self.sides_lons, self.sides_lats = zip(*sides)
+        self.sides_lons, self.sides_lats = zip(*sides, strict=True)
         self.sides_lons = list(self.sides_lons)
         self.sides_lats = list(self.sides_lats)
 
@@ -82,7 +82,7 @@ def from_lonlat_sides(cls, lon_sides, lat_sides):
                  np.array([vmn, ..., vm1, vm0]),
                  np.array([vm0, ... ,v10, v00])]
         """
-        boundary = cls(*zip(lon_sides, lat_sides))
+        boundary = cls(*zip(lon_sides, lat_sides, strict=True))
         return boundary
 
     def contour(self):
@@ -126,7 +126,7 @@ def __init__(self, area, frequency=1):
                       "Use the Swath/AreaDefinition 'boundary' method instead!.",
                       PendingDeprecationWarning, stacklevel=2)
         AreaBoundary.__init__(self,
-                              *zip(lons, lats))
+                              *zip(lons, lats, strict=True))
 
         if frequency != 1:
             self.decimate(frequency)

pyresample/geometry.py

@@ -348,7 +348,8 @@ def _get_sides(self, coord_fun, vertices_per_side) -> tuple[list[np.ndarray], li
         sides_dim1, sides_dim2 = zip(*[(top_dim1.squeeze(), top_dim2.squeeze()),
                                        (right_dim1.squeeze(), right_dim2.squeeze()),
                                        (bottom_dim1.squeeze(), bottom_dim2.squeeze()),
-                                       (left_dim1.squeeze(), left_dim2.squeeze())])
+                                       (left_dim1.squeeze(), left_dim2.squeeze())],
+                                     strict=True)
         if hasattr(sides_dim1[0], 'compute') and da is not None:
             sides_dim1, sides_dim2 = da.compute(sides_dim1, sides_dim2)
         return self._filter_sides_nans(sides_dim1, sides_dim2)
@@ -361,7 +362,7 @@ def _filter_sides_nans(
         """Remove nan and inf values present in each side."""
         new_dim1_sides = []
         new_dim2_sides = []
-        for dim1_side, dim2_side in zip(dim1_sides, dim2_sides):
+        for dim1_side, dim2_side in zip(dim1_sides, dim2_sides, strict=True):
             # FIXME: ~(~np.isfinite(dim1_side) | ~np.isfinite(dim1_side))
             is_valid_mask = ~(np.isnan(dim1_side) | np.isnan(dim2_side))
             if not is_valid_mask.any():

pyresample/resampler.py

@@ -355,7 +355,7 @@ def crop_source_area(source_geo_def, target_geo_def):
 def _enumerate_dst_area_chunks(dst_area, dst_chunks):
     """Enumerate the chunks in function of the dst_area."""
     for position, slices in _enumerate_chunk_slices(dst_chunks):
-        chunk_shape = tuple(chunk[pos] for pos, chunk in zip(position, dst_chunks))
+        chunk_shape = tuple(chunk[pos] for pos, chunk in zip(position, dst_chunks, strict=True))
         target_geo_def = dst_area[slices[-2:]]
         block_info = {"num-chunks": [len(chunk) for chunk in dst_chunks],
                       "chunk-location": position,

pyresample/slicer.py

@@ -105,7 +105,7 @@ def get_polygon_to_contain(self):
         from shapely.geometry import Polygon
 
         x, y = self.area_to_contain.get_edge_bbox_in_projection_coordinates(10)
-        poly = Polygon(zip(*self._source_transformer.transform(x, y)))
+        poly = Polygon(zip(*self._source_transformer.transform(x, y), strict=True))
         return poly
 
     def get_slices_from_polygon(self, poly):
@@ -121,7 +121,7 @@ def get_slices_from_polygon(self, poly):
     @staticmethod
     def _assemble_slices(chunk_slices):
         """Assemble slices to one slice per dimension."""
-        lines, cols = zip(*chunk_slices)
+        lines, cols = zip(*chunk_slices, strict=True)
         line_slice = slice(min(slc.start for slc in lines), max(slc.stop for slc in lines))
         col_slice = slice(min(slc.start for slc in cols), max(slc.stop for slc in cols))
         slices = col_slice, line_slice
@@ -132,7 +132,7 @@ def _get_chunk_polygons_for_swath_to_crop(self, swath_to_crop):
         from shapely.geometry import Polygon
 
         for (lons, lats), (line_slice, col_slice) in _get_chunk_bboxes_for_swath_to_crop(swath_to_crop):
-            smaller_poly = Polygon(zip(*self._target_transformer.transform(lons, lats)))
+            smaller_poly = Polygon(zip(*self._target_transformer.transform(lons, lats), strict=True))
             yield (smaller_poly, (line_slice, col_slice))
 
 
@@ -176,14 +176,14 @@ def get_polygon_to_contain(self):
         if self.area_to_crop.is_geostationary:
             x_geos, y_geos = get_geostationary_bounding_box_in_proj_coords(self.area_to_crop, 360)
             x_geos, y_geos = self._source_transformer.transform(x_geos, y_geos, direction=TransformDirection.INVERSE)
-            geos_poly = Polygon(zip(x_geos, y_geos))
-            poly = Polygon(zip(x, y))
+            geos_poly = Polygon(zip(x_geos, y_geos, strict=True))
+            poly = Polygon(zip(x, y, strict=True))
             poly = poly.intersection(geos_poly)
             if poly.is_empty:
                 raise IncompatibleAreas("No slice on area.")
-            x, y = zip(*poly.exterior.coords)
+            x, y = zip(*poly.exterior.coords, strict=True)
 
-        return Polygon(zip(*self._source_transformer.transform(x, y)))
+        return Polygon(zip(*self._source_transformer.transform(x, y), strict=True))
 
     def get_slices_from_polygon(self, poly_to_contain):
         """Get the slices based on the polygon."""
@@ -201,7 +201,9 @@ def get_slices_from_polygon(self, poly_to_contain):
             raise InvalidArea("Invalid area") from err
         from shapely.geometry import Polygon
 
-        poly_to_crop = Polygon(zip(*self.area_to_crop.get_edge_bbox_in_projection_coordinates(frequency=10)))
+        poly_to_crop = Polygon(zip(
+            *self.area_to_crop.get_edge_bbox_in_projection_coordinates(frequency=10),
+            strict=True))
         if not poly_to_crop.intersects(buffered_poly):
             raise IncompatibleAreas("Areas not overlapping.")
         bounds = self._sanitize_polygon_bounds(bounds)
@@ -238,7 +240,7 @@ def _enumerate_chunk_slices(chunks):
     """Enumerate chunks with slices."""
     for position in np.ndindex(tuple(map(len, (chunks)))):
         slices = []
-        for pos, chunk in zip(position, chunks):
+        for pos, chunk in zip(position, chunks, strict=True):
             chunk_size = chunk[pos]
             offset = sum(chunk[:pos])
             slices.append(slice(offset, offset + chunk_size))

pyresample/spherical.py

@@ -229,7 +229,7 @@ def __repr__(self):
 
     def __iter__(self):
         """Get iterator over lon/lat pairs."""
-        return zip([self.lon, self.lat]).__iter__()
+        return zip([self.lon, self.lat], strict=True).__iter__()
 
     def plot(self, ax=None,
              projection_crs=None,

pyresample/spherical_utils.py

@@ -82,7 +82,7 @@ def _find_union_pair(self, geoms):
             return None
 
         for id_, komb_pair in zip(itertools.combinations(geoms.keys(), 2),
-                                  itertools.combinations(geoms.values(), 2)):
+                                  itertools.combinations(geoms.values(), 2), strict=True):
             if self._overlaps(komb_pair[0], komb_pair[1]):
                 return id_, komb_pair[0].union(komb_pair[1])
 

pyresample/test/test_boundary/test_legacy_boundary.py

@@ -42,10 +42,10 @@ def test_creation_from_lonlat_sides(self):
         boundary = AreaBoundary.from_lonlat_sides(lon_sides, lat_sides)
 
         # Assert sides coincides
-        for b_lon, src_lon in zip(boundary.sides_lons, lon_sides):
+        for b_lon, src_lon in zip(boundary.sides_lons, lon_sides, strict=True):
             assert np.allclose(b_lon, src_lon)
 
-        for b_lat, src_lat in zip(boundary.sides_lats, lat_sides):
+        for b_lat, src_lat in zip(boundary.sides_lats, lat_sides, strict=True):
             assert np.allclose(b_lat, src_lat)
 
     def test_creation(self):
@@ -61,10 +61,10 @@ def test_creation(self):
         boundary = AreaBoundary(*list_sides)
 
         # Assert sides coincides
-        for b_lon, src_lon in zip(boundary.sides_lons, lon_sides):
+        for b_lon, src_lon in zip(boundary.sides_lons, lon_sides, strict=True):
             assert np.allclose(b_lon, src_lon)
 
-        for b_lat, src_lat in zip(boundary.sides_lats, lat_sides):
+        for b_lat, src_lat in zip(boundary.sides_lats, lat_sides, strict=True):
             assert np.allclose(b_lat, src_lat)
 
     def test_number_sides_required(self):

pyresample/test/test_geometry/test_swath_boundary.py

@@ -138,7 +138,7 @@ def _check_bbox_structure_and_values(bbox_lons, bbox_lats):
     assert not any(np.isnan(side_lat).any() for side_lat in bbox_lats)
     assert len(bbox_lons) == len(bbox_lats)
     assert len(bbox_lons) == 4
-    for side_lons, side_lats in zip(bbox_lons, bbox_lats):
+    for side_lons, side_lats in zip(bbox_lons, bbox_lats, strict=True):
         assert isinstance(side_lons, np.ndarray)
         assert isinstance(side_lats, np.ndarray)
         assert side_lons.shape == side_lats.shape
@@ -163,7 +163,7 @@ def _is_clockwise(lons, lats):
     # https://stackoverflow.com/a/1165943/433202
     prev_point = (lons[0], lats[0])
     edge_sum = 0
-    for point in zip(lons[1:], lats[1:]):
+    for point in zip(lons[1:], lats[1:], strict=True):
         xdiff = point[0] - prev_point[0]
         ysum = point[1] + prev_point[1]
         edge_sum += xdiff * ysum