Added Docstrings to :class:~.Mobject

manim/mobject/mobject.py

@@ -1011,9 +1011,11 @@ def scale(self, scale_factor: float, **kwargs) -> "Mobject":
             return self
 
     def rotate_about_origin(self, angle, axis=OUT, axes=[]):
+        """Rotates the :class:`~.Mobject` about the ORIGIN, which is at [0,0,0]."""
         return self.rotate(angle, axis, about_point=ORIGIN)
 
     def rotate(self, angle, axis=OUT, **kwargs):
+        """Rotates the :class:`~.Mobject` about a certain point."""
         if config["use_opengl_renderer"]:
             rot_matrix_T = rotation_matrix_transpose(angle, axis)
             self.apply_points_function(
@@ -1028,6 +1030,22 @@ def rotate(self, angle, axis=OUT, **kwargs):
             return self
 
     def flip(self, axis=UP, **kwargs):
+        """Flips/Mirrors an mobject about its center.
+
+        Examples
+        --------
+
+        .. manim:: FlipExample
+            :save_last_frame:
+
+            class FlipExample(Scene):
+                def construct(self):
+                    s= Line(LEFT, RIGHT+UP).shift(4*LEFT)
+                    self.add(s)
+                    s2= s.copy().flip()
+                    self.add(s2)
+
+        """
         return self.rotate(TAU / 2, axis, **kwargs)
 
     def stretch(self, factor, dim, **kwargs):
@@ -1398,12 +1416,15 @@ def set_coord(self, value, dim, direction=ORIGIN):
         return self
 
     def set_x(self, x, direction=ORIGIN):
+        """Set x value of the center of the :class:`~.Mobject` (``int`` or ``float``)"""
         return self.set_coord(x, 0, direction)
 
     def set_y(self, y, direction=ORIGIN):
+        """Set y value of the center of the :class:`~.Mobject` (``int`` or ``float``)"""
         return self.set_coord(y, 1, direction)
 
     def set_z(self, z, direction=ORIGIN):
+        """Set z value of the center of the :class:`~.Mobject` (``int`` or ``float``)"""
         return self.set_coord(z, 2, direction)
 
     def space_out_submobjects(self, factor=1.5, **kwargs):
@@ -1415,6 +1436,7 @@ def space_out_submobjects(self, factor=1.5, **kwargs):
     def move_to(
         self, point_or_mobject, aligned_edge=ORIGIN, coor_mask=np.array([1, 1, 1])
     ):
+        """Move center of the :class:`~.Mobject` to certain coordinate."""
         if isinstance(point_or_mobject, Mobject):
             target = point_or_mobject.get_critical_point(aligned_edge)
         else:
@@ -1590,6 +1612,7 @@ def get_color(self):
     ##
 
     def save_state(self):
+        """Save the current state (position, color & size). Can be restored with :meth:`~.Mobject.restore`."""
         if hasattr(self, "saved_state"):
             # Prevent exponential growth of data
             self.saved_state = None
@@ -1598,6 +1621,7 @@ def save_state(self):
         return self
 
     def restore(self):
+        """Restores the state that was previously saved with :meth:`~.Mobject.saved_state`."""
         if not hasattr(self, "saved_state") or self.save_state is None:
             raise Exception("Trying to restore without having saved")
         self.become(self.saved_state)
@@ -1687,6 +1711,7 @@ def get_corner(self, direction):
         return self.get_critical_point(direction)
 
     def get_center(self):
+        """Get center coordinates"""
         return self.get_critical_point(np.zeros(self.dim))
 
     def get_center_of_mass(self):
@@ -1698,15 +1723,19 @@ def get_boundary_point(self, direction):
         return all_points[index]
 
     def get_top(self):
+        """Get top coordinates"""
         return self.get_edge_center(UP)
 
     def get_bottom(self):
+        """Get bottom coordinates"""
         return self.get_edge_center(DOWN)
 
     def get_right(self):
+        """Get right coordinates"""
         return self.get_edge_center(RIGHT)
 
     def get_left(self):
+        """Get left coordinates"""
         return self.get_edge_center(LEFT)
 
     def get_zenith(self):
@@ -1721,33 +1750,39 @@ def length_over_dim(self, dim):
         ) - self.reduce_across_dimension(np.min, np.min, dim)
 
     def get_coord(self, dim, direction=ORIGIN):
-        """Meant to generalize get_x, get_y, get_z"""
+        """Meant to generalize ``get_x``, ``get_y`` and ``get_z``"""
         return self.get_extremum_along_dim(dim=dim, key=direction[dim])
 
     def get_x(self, direction=ORIGIN):
+        """Returns x coordinate of the center of the mobject as ``numpy.float64`` """
         return self.get_coord(0, direction)
 
     def get_y(self, direction=ORIGIN):
+        """Returns y coordinate of the center of the mobject as ``numpy.float64`` """
         return self.get_coord(1, direction)
 
     def get_z(self, direction=ORIGIN):
+        """Returns z coordinate of the center of the mobject as ``numpy.float64`` """
         return self.get_coord(2, direction)
 
     def get_start(self):
+        """Returns the point, where the stroke that surrounds the :class:`~.Mobject` starts. 
         self.throw_error_if_no_points()
         if config["use_opengl_renderer"]:
             return np.array(self.data["points"][0])
         else:
             return np.array(self.points[0])
 
     def get_end(self):
+        """Returns the point, where the stroke that surrounds the :class:`~.Mobject` ends."""
         self.throw_error_if_no_points()
         if config["use_opengl_renderer"]:
             return np.array(self.data["points"][-1])
         else:
             return np.array(self.points[-1])
 
     def get_start_and_end(self):
+        """Returns starting and ending point of a stroke as a ``tuple``. """
         return self.get_start(), self.get_end()
 
     def point_from_proportion(self, alpha):
@@ -1770,6 +1805,7 @@ def get_z_index_reference_point(self):
         return z_index_group.get_center()
 
     def has_points(self):
+         """Check if :class:`~.Mobject` contains points."""
         return len(self.points) > 0
 
     def has_no_points(self):