manim 0.18.0.post0__py3-none-any.whl → 0.19.0__py3-none-any.whl

manim/cli/render/global_options.py

@@ -1,28 +1,59 @@
 from __future__ import annotations
 
+import logging
 import re
+import sys
 from typing import TYPE_CHECKING
 
-import click
-from cloup import option, option_group
-
-from ... import logger
+from cloup import Choice, option, option_group
 
 if TYPE_CHECKING:
-    from cloup._option_groups import OptionGroupDecorator
+    from click import Context, Option
+
+__all__ = ["global_options"]
+
+logger = logging.getLogger("manim")
+
+
+def validate_gui_location(
+    ctx: Context, param: Option, value: str | None
+) -> tuple[int, int] | None:
+    """If the ``value`` string is given, extract from it the GUI location,
+    which should be in any of these formats: 'x;y', 'x,y' or 'x-y'.
 
+    Parameters
+    ----------
+    ctx
+        The Click context.
+    param
+        A Click option.
+    value
+        The optional string which will be parsed.
 
-def validate_gui_location(ctx, param, value):
-    if value:
-        try:
-            x_offset, y_offset = map(int, re.split(r"[;,\-]", value))
-            return (x_offset, y_offset)
-        except Exception:
-            logger.error("GUI location option is invalid.")
-            exit()
+    Returns
+    -------
+    tuple[int, int] | None
+        If ``value`` is ``None``, the return value is ``None``. Otherwise, it's
+        the ``(x, y)`` location for the GUI.
 
+    Raises
+    ------
+    ValueError
+        If ``value`` has an invalid format.
+    """
+    if value is None:
+        return None
 
-global_options: OptionGroupDecorator = option_group(
+    try:
+        x_offset, y_offset = map(int, re.split(r"[;,\-]", value))
+    except Exception:
+        logger.error("GUI location option is invalid.")
+        sys.exit()
+
+    return (x_offset, y_offset)
+
+
+global_options = option_group(
     "Global options",
     option(
         "-c",
@@ -53,7 +84,7 @@ global_options: OptionGroupDecorator = option_group(
     option(
         "-v",
         "--verbosity",
-        type=click.Choice(
+        type=Choice(
             ["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"],
             case_sensitive=False,
         ),
@@ -108,4 +139,9 @@ global_options: OptionGroupDecorator = option_group(
         help="Prevents deletion of .aux, .dvi, and .log files produced by Tex and MathTex.",
         default=False,
     ),
+    option(
+        "--preview_command",
+        help="The command used to preview the output file (for example vlc for video files)",
+        default="",
+    ),
 )

manim/cli/render/output_options.py

@@ -1,7 +1,8 @@
 from __future__ import annotations
 
-import click
-from cloup import option, option_group
+from cloup import IntRange, Path, option, option_group
+
+__all__ = ["output_options"]
 
 output_options = option_group(
     "Output options",
@@ -15,7 +16,7 @@ output_options = option_group(
     option(
         "-0",
         "--zero_pad",
-        type=click.IntRange(0, 9),
+        type=IntRange(0, 9),
         default=None,
         help="Zero padding for PNG file names.",
     ),
@@ -27,13 +28,13 @@ output_options = option_group(
     ),
     option(
         "--media_dir",
-        type=click.Path(),
+        type=Path(),
         default=None,
         help="Path to store rendered videos and latex.",
     ),
     option(
         "--log_dir",
-        type=click.Path(),
+        type=Path(),
         help="Path to store render logs.",
         default=None,
     ),

manim/cli/render/render_options.py

@@ -1,39 +1,105 @@
 from __future__ import annotations
 
+import logging
 import re
+import sys
+from typing import TYPE_CHECKING
 
-import click
-from cloup import option, option_group
+from cloup import Choice, option, option_group
 
 from manim.constants import QUALITIES, RendererType
 
-from ... import logger
+if TYPE_CHECKING:
+    from click import Context, Option
 
+__all__ = ["render_options"]
+
+logger = logging.getLogger("manim")
+
+
+def validate_scene_range(
+    ctx: Context, param: Option, value: str | None
+) -> tuple[int] | tuple[int, int] | None:
+    """If the ``value`` string is given, extract from it the scene range, which
+    should be in any of these formats: 'start', 'start;end', 'start,end' or
+    'start-end'. Otherwise, return ``None``.
+
+    Parameters
+    ----------
+    ctx
+        The Click context.
+    param
+        A Click option.
+    value
+        The optional string which will be parsed.
+
+    Returns
+    -------
+    tuple[int] | tuple[int, int] | None
+        If ``value`` is ``None``, the return value is ``None``. Otherwise, it's
+        the scene range, given by a tuple which may contain a single value
+        ``start`` or two values ``start`` and ``end``.
+
+    Raises
+    ------
+    ValueError
+        If ``value`` has an invalid format.
+    """
+    if value is None:
+        return None
 
-def validate_scene_range(ctx, param, value):
     try:
         start = int(value)
         return (start,)
     except Exception:
         pass
 
-    if value:
-        try:
-            start, end = map(int, re.split(r"[;,\-]", value))
-            return start, end
-        except Exception:
-            logger.error("Couldn't determine a range for -n option.")
-            exit()
+    try:
+        start, end = map(int, re.split(r"[;,\-]", value))
+    except Exception:
+        logger.error("Couldn't determine a range for -n option.")
+        sys.exit()
+
+    return start, end
+
+
+def validate_resolution(
+    ctx: Context, param: Option, value: str | None
+) -> tuple[int, int] | None:
+    """If the ``value`` string is given, extract from it the resolution, which
+    should be in any of these formats: 'W;H', 'W,H' or 'W-H'. Otherwise, return
+    ``None``.
+
+    Parameters
+    ----------
+    ctx
+        The Click context.
+    param
+        A Click option.
+    value
+        The optional string which will be parsed.
+
+    Returns
+    -------
+    tuple[int, int] | None
+        If ``value`` is ``None``, the return value is ``None``. Otherwise, it's
+        the resolution as a ``(W, H)`` tuple.
+
+    Raises
+    ------
+    ValueError
+        If ``value`` has an invalid format.
+    """
+    if value is None:
+        return None
 
+    try:
+        width, height = map(int, re.split(r"[;,\-]", value))
+    except Exception:
+        logger.error("Resolution option is invalid.")
+        sys.exit()
 
-def validate_resolution(ctx, param, value):
-    if value:
-        try:
-            start, end = map(int, re.split(r"[;,\-]", value))
-            return (start, end)
-        except Exception:
-            logger.error("Resolution option is invalid.")
-            exit()
+    return width, height
 
 
 render_options = option_group(
@@ -55,23 +121,29 @@ render_options = option_group(
     ),
     option(
         "--format",
-        type=click.Choice(["png", "gif", "mp4", "webm", "mov"], case_sensitive=False),
+        type=Choice(["png", "gif", "mp4", "webm", "mov"], case_sensitive=False),
+        default=None,
+    ),
+    option(
+        "-s",
+        "--save_last_frame",
         default=None,
+        is_flag=True,
+        help="Render and save only the last frame of a scene as a PNG image.",
     ),
-    option("-s", "--save_last_frame", is_flag=True, default=None),
     option(
         "-q",
         "--quality",
         default=None,
-        type=click.Choice(
-            list(reversed([q["flag"] for q in QUALITIES.values() if q["flag"]])),  # type: ignore
+        type=Choice(
+            list(reversed([q["flag"] for q in QUALITIES.values() if q["flag"]])),
             case_sensitive=False,
         ),
         help="Render quality at the follow resolution framerates, respectively: "
         + ", ".join(
             reversed(
                 [
-                    f'{q["pixel_width"]}x{q["pixel_height"]} {q["frame_rate"]}FPS'
+                    f"{q['pixel_width']}x{q['pixel_height']} {q['frame_rate']}FPS"
                     for q in QUALITIES.values()
                     if q["flag"]
                 ]
@@ -95,7 +167,7 @@ render_options = option_group(
     ),
     option(
         "--renderer",
-        type=click.Choice(
+        type=Choice(
             [renderer_type.value for renderer_type in RendererType],
             case_sensitive=False,
         ),
@@ -122,13 +194,6 @@ render_options = option_group(
         is_flag=True,
         help="Save section videos in addition to movie file.",
     ),
-    option(
-        "-s",
-        "--save_last_frame",
-        default=None,
-        is_flag=True,
-        help="Save last frame as png (Deprecated).",
-    ),
     option(
         "-t",
         "--transparent",

manim/constants.py

@@ -1,16 +1,15 @@
-"""
-Constant definitions.
-"""
+"""Constant definitions."""
 
 from __future__ import annotations
 
 from enum import Enum
+from typing import TypedDict
 
 import numpy as np
 from cloup import Context
 from PIL.Image import Resampling
 
-from manim.typing import Vector3
+from manim.typing import Vector3D
 
 __all__ = [
     "SCENE_NOT_FOUND_MESSAGE",
@@ -76,6 +75,7 @@ __all__ = [
     "CTRL_VALUE",
     "RendererType",
     "LineJointType",
+    "CapStyleType",
 ]
 # Messages
 
@@ -122,43 +122,43 @@ RESAMPLING_ALGORITHMS = {
 }
 
 # Geometry: directions
-ORIGIN: Vector3 = np.array((0.0, 0.0, 0.0))
+ORIGIN: Vector3D = np.array((0.0, 0.0, 0.0))
 """The center of the coordinate system."""
 
-UP: Vector3 = np.array((0.0, 1.0, 0.0))
+UP: Vector3D = np.array((0.0, 1.0, 0.0))
 """One unit step in the positive Y direction."""
 
-DOWN: Vector3 = np.array((0.0, -1.0, 0.0))
+DOWN: Vector3D = np.array((0.0, -1.0, 0.0))
 """One unit step in the negative Y direction."""
 
-RIGHT: Vector3 = np.array((1.0, 0.0, 0.0))
+RIGHT: Vector3D = np.array((1.0, 0.0, 0.0))
 """One unit step in the positive X direction."""
 
-LEFT: Vector3 = np.array((-1.0, 0.0, 0.0))
+LEFT: Vector3D = np.array((-1.0, 0.0, 0.0))
 """One unit step in the negative X direction."""
 
-IN: Vector3 = np.array((0.0, 0.0, -1.0))
+IN: Vector3D = np.array((0.0, 0.0, -1.0))
 """One unit step in the negative Z direction."""
 
-OUT: Vector3 = np.array((0.0, 0.0, 1.0))
+OUT: Vector3D = np.array((0.0, 0.0, 1.0))
 """One unit step in the positive Z direction."""
 
 # Geometry: axes
-X_AXIS: Vector3 = np.array((1.0, 0.0, 0.0))
-Y_AXIS: Vector3 = np.array((0.0, 1.0, 0.0))
-Z_AXIS: Vector3 = np.array((0.0, 0.0, 1.0))
+X_AXIS: Vector3D = np.array((1.0, 0.0, 0.0))
+Y_AXIS: Vector3D = np.array((0.0, 1.0, 0.0))
+Z_AXIS: Vector3D = np.array((0.0, 0.0, 1.0))
 
 # Geometry: useful abbreviations for diagonals
-UL: Vector3 = UP + LEFT
+UL: Vector3D = UP + LEFT
 """One step up plus one step left."""
 
-UR: Vector3 = UP + RIGHT
+UR: Vector3D = UP + RIGHT
 """One step up plus one step right."""
 
-DL: Vector3 = DOWN + LEFT
+DL: Vector3D = DOWN + LEFT
 """One step down plus one step left."""
 
-DR: Vector3 = DOWN + RIGHT
+DR: Vector3D = DOWN + RIGHT
 """One step down plus one step right."""
 
 # Geometry
@@ -198,8 +198,16 @@ TAU = 2 * PI
 DEGREES = TAU / 360
 """The exchange rate between radians and degrees."""
 
+
+class QualityDict(TypedDict):
+    flag: str | None
+    pixel_height: int
+    pixel_width: int
+    frame_rate: int
+
+
 # Video qualities
-QUALITIES: dict[str, dict[str, str | int | None]] = {
+QUALITIES: dict[str, QualityDict] = {
     "fourk_quality": {
         "flag": "k",
         "pixel_height": 2160,
@@ -305,3 +313,41 @@ class LineJointType(Enum):
     ROUND = 1
     BEVEL = 2
     MITER = 3
+
+
+class CapStyleType(Enum):
+    """Collection of available cap styles.
+
+    See the example below for a visual illustration of the different
+    cap styles.
+
+    Examples
+    --------
+
+    .. manim:: CapStyleVariants
+        :save_last_frame:
+
+        class CapStyleVariants(Scene):
+            def construct(self):
+                arcs = VGroup(*[
+                    Arc(
+                        radius=1,
+                        start_angle=0,
+                        angle=TAU / 4,
+                        stroke_width=20,
+                        color=GREEN,
+                        cap_style=cap_style,
+                    )
+                    for cap_style in CapStyleType
+                ])
+                arcs.arrange(RIGHT, buff=1)
+                self.add(arcs)
+                for arc in arcs:
+                    label = Text(arc.cap_style.name, font_size=24).next_to(arc, DOWN)
+                    self.add(label)
+    """
+
+    AUTO = 0
+    ROUND = 1
+    BUTT = 2
+    SQUARE = 3

manim/gui/gui.py

@@ -13,6 +13,8 @@ except ImportError:
 from .. import __version__, config
 from ..utils.module_ops import scene_classes_from_file
 
+__all__ = ["configure_pygui"]
+
 if dearpygui_imported:
     dpg.create_context()
     window = dpg.generate_uuid()

manim/mobject/frame.py

@@ -24,7 +24,6 @@ class ScreenRectangle(Rectangle):
         When set, the width is stretched to accommodate
         the new aspect ratio.
         """
-
         return self.width / self.height
 
     @aspect_ratio.setter