manim 0.17.0__py3-none-any.whl → 0.19.1__py3-none-any.whl

manim/cli/plugins/commands.py

@@ -5,12 +5,15 @@ plugin``. Here you can specify options, subcommands, and subgroups for the plugi
 group.
 
 """
+
 from __future__ import annotations
 
 import cloup
 
-from ...constants import CONTEXT_SETTINGS, EPILOG
-from ...plugins.plugins_flags import list_plugins
+from manim.constants import CONTEXT_SETTINGS, EPILOG
+from manim.plugins.plugins_flags import list_plugins
+
+__all__ = ["plugins"]
 
 
 @cloup.command(
@@ -26,6 +29,16 @@ from ...plugins.plugins_flags import list_plugins
     is_flag=True,
     help="List available plugins.",
 )
-def plugins(list_available):
+def plugins(list_available: bool) -> None:
+    """Print a list of all available plugins when calling ``manim plugins -l``
+    or ``manim plugins --list``.
+
+    Parameters
+    ----------
+    list_available
+        If the ``-l`` or ``-list`` option is passed to ``manim plugins``, this
+        parameter will be set to ``True``, which will print a list of all
+        available plugins.
+    """
     if list_available:
         list_plugins()

manim/cli/render/commands.py

@@ -5,24 +5,56 @@ Manim's render subcommand is accessed in the command-line interface via
 can specify options, and arguments for the render command.
 
 """
+
 from __future__ import annotations
 
+import http.client
 import json
 import sys
+import urllib.error
+import urllib.request
+from argparse import Namespace
 from pathlib import Path
+from typing import Any, cast
 
-import click
 import cloup
-import requests
 
-from ... import __version__, config, console, error_console, logger
-from ..._config import tempconfig
-from ...constants import EPILOG, RendererType
-from ...utils.module_ops import scene_classes_from_file
-from .ease_of_access_options import ease_of_access_options
-from .global_options import global_options
-from .output_options import output_options
-from .render_options import render_options
+from manim import __version__
+from manim._config import (
+    config,
+    console,
+    error_console,
+    logger,
+    tempconfig,
+)
+from manim.cli.render.ease_of_access_options import ease_of_access_options
+from manim.cli.render.global_options import global_options
+from manim.cli.render.output_options import output_options
+from manim.cli.render.render_options import render_options
+from manim.constants import EPILOG, RendererType
+from manim.utils.module_ops import scene_classes_from_file
+
+__all__ = ["render"]
+
+
+class ClickArgs(Namespace):
+    def __init__(self, args: dict[str, Any]) -> None:
+        for name in args:
+            setattr(self, name, args[name])
+
+    def _get_kwargs(self) -> list[tuple[str, Any]]:
+        return list(self.__dict__.items())
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, ClickArgs):
+            return NotImplemented
+        return vars(self) == vars(other)
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.__dict__
+
+    def __repr__(self) -> str:
+        return str(self.__dict__)
 
 
 @cloup.command(
@@ -30,56 +62,34 @@ from .render_options import render_options
     no_args_is_help=True,
     epilog=EPILOG,
 )
-@click.argument("file", type=Path, required=True)
-@click.argument("scene_names", required=False, nargs=-1)
+@cloup.argument("file", type=cloup.Path(path_type=Path), required=True)
+@cloup.argument("scene_names", required=False, nargs=-1)
 @global_options
 @output_options
-@render_options  # type: ignore
+@render_options
 @ease_of_access_options
-def render(
-    **args,
-):
+def render(**kwargs: Any) -> ClickArgs | dict[str, Any]:
     """Render SCENE(S) from the input FILE.
 
     FILE is the file path of the script or a config file.
 
     SCENES is an optional list of scenes in the file.
     """
-
-    if args["save_as_gif"]:
+    if kwargs["save_as_gif"]:
         logger.warning("--save_as_gif is deprecated, please use --format=gif instead!")
-        args["format"] = "gif"
+        kwargs["format"] = "gif"
 
-    if args["save_pngs"]:
+    if kwargs["save_pngs"]:
         logger.warning("--save_pngs is deprecated, please use --format=png instead!")
-        args["format"] = "png"
+        kwargs["format"] = "png"
 
-    if args["show_in_file_browser"]:
+    if kwargs["show_in_file_browser"]:
         logger.warning(
             "The short form of show_in_file_browser is deprecated and will be moved to support --format.",
         )
 
-    class ClickArgs:
-        def __init__(self, args):
-            for name in args:
-                setattr(self, name, args[name])
-
-        def _get_kwargs(self):
-            return list(self.__dict__.items())
-
-        def __eq__(self, other):
-            if not isinstance(other, ClickArgs):
-                return NotImplemented
-            return vars(self) == vars(other)
-
-        def __contains__(self, key):
-            return key in self.__dict__
-
-        def __repr__(self):
-            return str(self.__dict__)
-
-    click_args = ClickArgs(args)
-    if args["jupyter"]:
+    click_args = ClickArgs(kwargs)
+    if kwargs["jupyter"]:
         return click_args
 
     config.digest_args(click_args)
@@ -120,13 +130,26 @@ def render(
     if config.notify_outdated_version:
         manim_info_url = "https://pypi.org/pypi/manim/json"
         warn_prompt = "Cannot check if latest release of manim is installed"
-        req_info = {}
 
         try:
-            req_info = requests.get(manim_info_url, timeout=10)
-            req_info.raise_for_status()
-
-            stable = req_info.json()["info"]["version"]
+            with urllib.request.urlopen(
+                urllib.request.Request(manim_info_url),
+                timeout=10,
+            ) as response:
+                response = cast(http.client.HTTPResponse, response)
+                json_data = json.loads(response.read())
+        except urllib.error.HTTPError:
+            logger.debug("HTTP Error: %s", warn_prompt)
+        except urllib.error.URLError:
+            logger.debug("URL Error: %s", warn_prompt)
+        except json.JSONDecodeError:
+            logger.debug(
+                "Error while decoding JSON from %r: %s", manim_info_url, warn_prompt
+            )
+        except Exception:
+            logger.debug("Something went wrong: %s", warn_prompt)
+        else:
+            stable = json_data["info"]["version"]
             if stable != __version__:
                 console.print(
                     f"You are using manim version [red]v{__version__}[/red], but version [green]v{stable}[/green] is available.",
@@ -134,16 +157,5 @@ def render(
                 console.print(
                     "You should consider upgrading via [yellow]pip install -U manim[/yellow]",
                 )
-        except requests.exceptions.HTTPError:
-            logger.debug(f"HTTP Error: {warn_prompt}")
-        except requests.exceptions.ConnectionError:
-            logger.debug(f"Connection Error: {warn_prompt}")
-        except requests.exceptions.Timeout:
-            logger.debug(f"Timed Out: {warn_prompt}")
-        except json.JSONDecodeError:
-            logger.debug(warn_prompt)
-            logger.debug(f"Error decoding JSON from {manim_info_url}")
-        except Exception:
-            logger.debug(f"Something went wrong: {warn_prompt}")
 
-    return args
+    return kwargs

manim/cli/render/ease_of_access_options.py

@@ -1,7 +1,8 @@
 from __future__ import annotations
 
-import click
-from cloup import option, option_group
+from cloup import Choice, option, option_group
+
+__all__ = ["ease_of_access_options"]
 
 ease_of_access_options = option_group(
     "Ease of access options",
@@ -9,7 +10,7 @@ ease_of_access_options = option_group(
         "--progress_bar",
         default=None,
         show_default=False,
-        type=click.Choice(
+        type=Choice(
             ["display", "leave", "none"],
             case_sensitive=False,
         ),

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,
         ),
@@ -94,12 +125,23 @@ global_options: OptionGroupDecorator = option_group(
         "--force_window",
         is_flag=True,
         help="Force window to open when using the opengl renderer, intended for debugging as it may impact performance",
-        default=False,
+        default=None,
     ),
     option(
         "--dry_run",
         is_flag=True,
         help="Renders animations without outputting image or video files and disables the window",
-        default=False,
+        default=None,
+    ),
+    option(
+        "--no_latex_cleanup",
+        is_flag=True,
+        help="Prevents deletion of .aux, .dvi, and .log files produced by Tex and MathTex.",
+        default=None,
+    ),
+    option(
+        "--preview_command",
+        help="The command used to preview the output file (for example vlc for video files)",
+        default=None,
     ),
 )

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"]
                 ]
@@ -83,7 +155,7 @@ render_options = option_group(
         "--resolution",
         callback=validate_resolution,
         default=None,
-        help="Resolution in (W,H) for when 16:9 aspect ratio isn't possible.",
+        help='Resolution in "W,H" for when 16:9 aspect ratio isn\'t possible.',
     ),
     option(
         "--fps",
@@ -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",