BUG: avoid soon-to-be-deprecated direct mutations of ndarray.shape attributes

Author: neutrinoceros

CONTRIBUTING.rst

@@ -720,9 +720,7 @@ Source code style guide
 * Do not use nested classes unless you have a very good reason to, such as
   requiring a namespace or class-definition modification.  Classes should live
   at the top level.  ``__metaclass__`` is exempt from this.
-* Avoid copying memory when possible. For example, don't do
-  ``a = a.reshape(3, 4)`` when ``a.shape = (3, 4)`` will do, and ``a = a * 3``
-  should be ``np.multiply(a, 3, a)``.
+* Avoid copying memory when possible.
 * In general, avoid all double-underscore method names: ``__something`` is
   usually unnecessary.
 * When writing a subclass, use the super built-in to access the super class,

yt/data_objects/construction_data_containers.py

@@ -2643,8 +2643,7 @@ def _export_ply(
         f.write(b"end_header\n")
         v.tofile(f)
         arr["ni"][:] = 3
-        vi = np.arange(nv, dtype="<i")
-        vi.shape = (nv // 3, 3)
+        vi = np.arange(nv, dtype="<i").reshape(nv // 3, 3)
         arr["v1"][:] = vi[:, 0]
         arr["v2"][:] = vi[:, 1]
         arr["v3"][:] = vi[:, 2]

yt/fields/field_detector.py

@@ -276,18 +276,19 @@ def fcoords(self):
             np.mgrid[0 : 1 : self.nd * 1j, 0 : 1 : self.nd * 1j, 0 : 1 : self.nd * 1j]
         )
         if self.flat:
-            fc.shape = (self.nd * self.nd * self.nd, 3)
+            fc = fc.reshape(self.nd * self.nd * self.nd, 3)
         else:
             fc = fc.transpose()
         return self.ds.arr(fc, units="code_length")
 
     @property
     def fcoords_vertex(self):
-        rng = np.random.default_rng()
-        fc = rng.random((self.nd, self.nd, self.nd, 8, 3))
         if self.flat:
-            fc.shape = (self.nd * self.nd * self.nd, 8, 3)
-        return self.ds.arr(fc, units="code_length")
+            shape = (self.nd * self.nd * self.nd, 8, 3)
+        else:
+            shape = (self.nd, self.nd, self.nd, 8, 3)
+        rng = np.random.default_rng()
+        return self.ds.arr(rng.random(shape), units="code_length")
 
     @property
     def icoords(self):
@@ -297,21 +298,23 @@ def icoords(self):
             0 : self.nd - 1 : self.nd * 1j,
         ]
         if self.flat:
-            ic.shape = (self.nd * self.nd * self.nd, 3)
+            return ic.reshape(self.nd * self.nd * self.nd, 3)
         else:
-            ic = ic.transpose()
-        return ic
+            return ic.transpose()
 
     @property
     def ires(self):
-        ir = np.ones(self.nd**3, dtype="int64")
-        if not self.flat:
-            ir.shape = (self.nd, self.nd, self.nd)
-        return ir
+        if self.flat:
+            shape = (self.nd**3,)
+        else:
+            shape = (self.nd, self.nd, self.nd)
+        return np.ones(shape, dtype="int64")
 
     @property
     def fwidth(self):
-        fw = np.ones((self.nd**3, 3), dtype="float64") / self.nd
-        if not self.flat:
-            fw.shape = (self.nd, self.nd, self.nd, 3)
+        if self.flat:
+            shape = (self.nd**3, 3)
+        else:
+            shape = (self.nd, self.nd, self.nd, 3)
+        fw = np.full(shape, 1 / self.nd, dtype="float64")
         return self.ds.arr(fw, units="code_length")

yt/fields/geometric_fields.py

@@ -134,8 +134,7 @@ def _morton_index(data):
             data["index", "z"].ravel(),
             LE,
             RE,
-        )
-        morton.shape = data["index", "x"].shape
+        ).reshape(data["index", "x"].shape)
         return morton.view("f8")
 
     registry.add_field(

yt/frontends/amrvac/datfile_utils.py

@@ -152,11 +152,10 @@ def get_single_block_data(istream, byte_offset, block_shape):
 def get_single_block_field_data(istream, byte_offset, block_shape, field_idx):
     """retrieve a specific block (ONE field) from a datfile"""
     # compute byte size of a single field
-    field_shape = block_shape[:-1]
-    fmt = ALIGN + np.prod(field_shape) * "d"
+    field_shape = block_shape[:-1][::-1]
+    count = np.prod(field_shape)
+    fmt = ALIGN + count * "d"
     byte_size_field = struct.calcsize(fmt)
 
     istream.seek(byte_offset + byte_size_field * field_idx)
-    data = np.fromfile(istream, "=f8", count=np.prod(field_shape))
-    data.shape = field_shape[::-1]
-    return data.T
+    return np.fromfile(istream, dtype="=f8", count=count).reshape(field_shape).T

yt/frontends/amrvac/io.py

@@ -103,14 +103,12 @@ def _read_data(self, fid, grid, field):
         offset = grid._index.block_offsets[ileaf]
         field_idx = self.ds.parameters["w_names"].index(field)
 
-        field_shape = self.block_shape[:-1]
+        field_shape = self.block_shape[:-1][::-1]
         count = np.prod(field_shape)
         byte_size_field = count * 8  # size of a double
 
         fid.seek(offset + byte_size_field * field_idx)
-        data = np.fromfile(fid, "=f8", count=count)
-        data.shape = field_shape[::-1]
-        data = data.T
+        data = np.fromfile(fid, dtype="=f8", count=count).reshape(field_shape).T
         # Always convert data to 3D, as grid.ActiveDimensions is always 3D
         while len(data.shape) < 3:
             data = data[..., np.newaxis]

yt/frontends/chimera/data_structures.py

@@ -103,7 +103,7 @@ def _initialize_mesh(self):
                     mylog.warning(
                         "Yin-Yang File Detected; This data is not currently supported."
                     )
-                coords.shape = (nxd * nyd * nzd, 3)
+                coords = coords.reshape(nxd * nyd * nzd, 3)
                 # Connectivity is an array of rows, each of which corresponds to a grid cell.
                 # The 8 elements of each row are integers representing the cell vertices.
                 # These integers reference the numerical index of the element of the

yt/frontends/exodus_ii/data_structures.py

@@ -361,7 +361,7 @@ def _read_connectivity(self):
                         raise NotImplementedError("only equal-size polyhedra supported")
                     q, r = np.divmod(len(conn), npe)
                     assert r == 0
-                    conn.shape = (q, npe)
+                    conn = conn.reshape(q, npe)
                 connectivity.append(conn)
             return connectivity
 

yt/frontends/gadget/io.py

@@ -462,10 +462,11 @@ def _yield_coordinates(self, data_file, needed_ptype=None):
                 if needed_ptype is not None and ptype != needed_ptype:
                     continue
                 # The first total_particles * 3 values are positions
-                pp = np.fromfile(f, dtype=dt, count=count * 3).astype(
-                    dt_native, copy=False
+                pp = (
+                    np.fromfile(f, dtype=dt, count=count * 3)
+                    .reshape(count, 3)
+                    .astype(dt_native, copy=False)
                 )
-                pp.shape = (count, 3)
                 yield ptype, pp
 
     def _get_smoothing_length(self, data_file, position_dtype, position_shape):

yt/frontends/http_stream/io.py

@@ -37,7 +37,7 @@ def _read_particle_coords(self, chunks, ptf):
             for ptype in ptf:
                 s = self._open_stream(data_file, (ptype, "Coordinates"))
                 c = np.frombuffer(s, dtype="float64")
-                c.shape = (c.shape[0] / 3.0, 3)
+                c = c.reshape(c.size // 3, 3)
                 yield ptype, (c[:, 0], c[:, 1], c[:, 2]), 0.0
 
     def _read_particle_fields(self, chunks, ptf, selector):
@@ -46,7 +46,7 @@ def _read_particle_fields(self, chunks, ptf, selector):
             for ptype, field_list in sorted(ptf.items()):
                 s = self._open_stream(data_file, (ptype, "Coordinates"))
                 c = np.frombuffer(s, dtype="float64")
-                c.shape = (c.shape[0] / 3.0, 3)
+                c = c.reshape(c.size // 3, 3)
                 mask = selector.select_points(c[:, 0], c[:, 1], c[:, 2], 0.0)
                 del c
                 if mask is None:
@@ -55,7 +55,7 @@ def _read_particle_fields(self, chunks, ptf, selector):
                     s = self._open_stream(data_file, (ptype, field))
                     c = np.frombuffer(s, dtype="float64")
                     if field in self._vector_fields:
-                        c.shape = (c.shape[0] / 3.0, 3)
+                        c = c.reshape(c.size // 3, 3)
                     data = c[mask, ...]
                     yield (ptype, field), data