manim 0.18.0__py3-none-any.whl → 0.18.1__py3-none-any.whl

manim/utils/testing/frames_comparison.py

@@ -214,11 +214,13 @@ def _make_test_comparing_frames(
                 # If you pass a custom renderer to the Scene, the Camera class given as an argument in the Scene
                 # is not passed to the renderer. See __init__ of Scene.
                 # This potentially prevents OpenGL testing.
-                test_renderer=testRenderer(file_writer_class=file_writer_class)
-                if base_scene is not ThreeDScene
-                else testRenderer(
-                    file_writer_class=file_writer_class,
-                    camera_class=ThreeDCamera,
+                test_renderer=(
+                    testRenderer(file_writer_class=file_writer_class)
+                    if base_scene is not ThreeDScene
+                    else testRenderer(
+                        file_writer_class=file_writer_class,
+                        camera_class=ThreeDCamera,
+                    )
                 ),  # testRenderer(file_writer_class=file_writer_class),
             )
             scene_tested = sceneTested(skip_animations=True)

manim/utils/tex.py

@@ -4,162 +4,132 @@ from __future__ import annotations
 
 __all__ = [
     "TexTemplate",
-    "TexTemplateFromFile",
 ]
 
 import copy
-import os
 import re
+import warnings
+from dataclasses import dataclass, field
 from pathlib import Path
+from typing import TYPE_CHECKING, Any
 
+if TYPE_CHECKING:
+    from typing_extensions import Self
 
-class TexTemplate:
-    """TeX templates are used for creating Tex() and MathTex() objects.
-
-    Parameters
-    ----------
-    tex_compiler
-        The TeX compiler to be used, e.g. ``latex``, ``pdflatex`` or ``lualatex``
-    output_format
-        The output format resulting from compilation, e.g. ``.dvi`` or ``.pdf``
-    documentclass
-        The command defining the documentclass, e.g. ``\\documentclass[preview]{standalone}``
-    preamble
-        The document's preamble, i.e. the part between ``\\documentclass`` and ``\\begin{document}``
-    placeholder_text
-        Text in the document that will be replaced by the expression to be rendered
-    post_doc_commands
-        Text (definitions, commands) to be inserted at right after ``\\begin{document}``, e.g. ``\\boldmath``
-
-    Attributes
-    ----------
-    tex_compiler : :class:`str`
-        The TeX compiler to be used, e.g. ``latex``, ``pdflatex`` or ``lualatex``
-    output_format : :class:`str`
-        The output format resulting from compilation, e.g. ``.dvi`` or ``.pdf``
-    documentclass : :class:`str`
-        The command defining the documentclass, e.g. ``\\documentclass[preview]{standalone}``
-    preamble : :class:`str`
-        The document's preamble, i.e. the part between ``\\documentclass`` and ``\\begin{document}``
-    placeholder_text : :class:`str`
-        Text in the document that will be replaced by the expression to be rendered
-    post_doc_commands : :class:`str`
-        Text (definitions, commands) to be inserted at right after ``\\begin{document}``, e.g. ``\\boldmath``
-    """
+    from manim.typing import StrPath
 
-    default_documentclass = r"\documentclass[preview]{standalone}"
-    default_preamble = r"""
-\usepackage[english]{babel}
+_DEFAULT_PREAMBLE = r"""\usepackage[english]{babel}
 \usepackage{amsmath}
-\usepackage{amssymb}
-"""
-    default_placeholder_text = "YourTextHere"
-    default_tex_compiler = "latex"
-    default_output_format = ".dvi"
-    default_post_doc_commands = ""
-
-    def __init__(
-        self,
-        tex_compiler: str | None = None,
-        output_format: str | None = None,
-        documentclass: str | None = None,
-        preamble: str | None = None,
-        placeholder_text: str | None = None,
-        post_doc_commands: str | None = None,
-        **kwargs,
-    ):
-        self.tex_compiler = (
-            tex_compiler
-            if tex_compiler is not None
-            else TexTemplate.default_tex_compiler
-        )
-        self.output_format = (
-            output_format
-            if output_format is not None
-            else TexTemplate.default_output_format
-        )
-        self.documentclass = (
-            documentclass
-            if documentclass is not None
-            else TexTemplate.default_documentclass
-        )
-        self.preamble = (
-            preamble if preamble is not None else TexTemplate.default_preamble
-        )
-        self.placeholder_text = (
-            placeholder_text
-            if placeholder_text is not None
-            else TexTemplate.default_placeholder_text
-        )
-        self.post_doc_commands = (
-            post_doc_commands
-            if post_doc_commands is not None
-            else TexTemplate.default_post_doc_commands
-        )
-        self._rebuild()
-
-    def __eq__(self, other: TexTemplate) -> bool:
-        return (
-            self.body == other.body
-            and self.tex_compiler == other.tex_compiler
-            and self.output_format == other.output_format
-            and self.post_doc_commands == other.post_doc_commands
-        )
+\usepackage{amssymb}"""
+
+_BEGIN_DOCUMENT = r"\begin{document}"
+_END_DOCUMENT = r"\end{document}"
+
 
-    def _rebuild(self):
-        """Rebuilds the entire TeX template text from ``\\documentclass`` to ``\\end{document}`` according to all settings and choices."""
-        self.body = (
-            self.documentclass
-            + "\n"
-            + self.preamble
-            + "\n"
-            + r"\begin{document}"
-            + "\n"
-            + self.post_doc_commands
-            + "\n"
-            + self.placeholder_text
-            + "\n"
-            + "\n"
-            + r"\end{document}"
-            + "\n"
+@dataclass(eq=True)
+class TexTemplate:
+    """TeX templates are used to create ``Tex`` and ``MathTex`` objects."""
+
+    _body: str = field(default="", init=False)
+    """A custom body, can be set from a file."""
+
+    tex_compiler: str = "latex"
+    """The TeX compiler to be used, e.g. ``latex``, ``pdflatex`` or ``lualatex``."""
+
+    output_format: str = ".dvi"
+    """The output format resulting from compilation, e.g. ``.dvi`` or ``.pdf``."""
+
+    documentclass: str = r"\documentclass[preview]{standalone}"
+    r"""The command defining the documentclass, e.g. ``\documentclass[preview]{standalone}``."""
+
+    preamble: str = _DEFAULT_PREAMBLE
+    r"""The document's preamble, i.e. the part between ``\documentclass`` and ``\begin{document}``."""
+
+    placeholder_text: str = "YourTextHere"
+    """Text in the document that will be replaced by the expression to be rendered."""
+
+    post_doc_commands: str = ""
+    r"""Text (definitions, commands) to be inserted at right after ``\begin{document}``, e.g. ``\boldmath``."""
+
+    @property
+    def body(self) -> str:
+        """The entire TeX template."""
+        return self._body or "\n".join(
+            filter(
+                None,
+                [
+                    self.documentclass,
+                    self.preamble,
+                    _BEGIN_DOCUMENT,
+                    self.post_doc_commands,
+                    self.placeholder_text,
+                    _END_DOCUMENT,
+                ],
+            )
         )
 
-    def add_to_preamble(self, txt: str, prepend: bool = False):
-        """Adds stuff to the TeX template's preamble (e.g. definitions, packages). Text can be inserted at the beginning or at the end of the preamble.
+    @body.setter
+    def body(self, value: str) -> None:
+        self._body = value
+
+    @classmethod
+    def from_file(cls, file: StrPath = "tex_template.tex", **kwargs: Any) -> Self:
+        """Create an instance by reading the content of a file.
+
+        Using the ``add_to_preamble`` and ``add_to_document`` methods on this instance
+        will have no effect, as the body is read from the file.
+        """
+        instance = cls(**kwargs)
+        instance.body = Path(file).read_text(encoding="utf-8")
+        return instance
+
+    def add_to_preamble(self, txt: str, prepend: bool = False) -> Self:
+        r"""Adds text to the TeX template's preamble (e.g. definitions, packages). Text can be inserted at the beginning or at the end of the preamble.
 
         Parameters
         ----------
         txt
-            String containing the text to be added, e.g. ``\\usepackage{hyperref}``
+            String containing the text to be added, e.g. ``\usepackage{hyperref}``.
         prepend
-            Whether the text should be added at the beginning of the preamble, i.e. right after ``\\documentclass``. Default is to add it at the end of the preamble, i.e. right before ``\\begin{document}``
+            Whether the text should be added at the beginning of the preamble, i.e. right after ``\documentclass``.
+            Default is to add it at the end of the preamble, i.e. right before ``\begin{document}``.
         """
+        if self._body:
+            warnings.warn(
+                "This TeX template was created with a fixed body, trying to add text the preamble will have no effect.",
+                UserWarning,
+                stacklevel=2,
+            )
         if prepend:
             self.preamble = txt + "\n" + self.preamble
         else:
             self.preamble += "\n" + txt
-        self._rebuild()
         return self
 
-    def add_to_document(self, txt: str):
-        """Adds txt to the TeX template just after \\begin{document}, e.g. ``\\boldmath``
+    def add_to_document(self, txt: str) -> Self:
+        r"""Adds text to the TeX template just after \begin{document}, e.g. ``\boldmath``.
 
         Parameters
         ----------
         txt
             String containing the text to be added.
         """
-        self.post_doc_commands += "\n" + txt + "\n"
-        self._rebuild()
+        if self._body:
+            warnings.warn(
+                "This TeX template was created with a fixed body, trying to add text the document will have no effect.",
+                UserWarning,
+                stacklevel=2,
+            )
+        self.post_doc_commands += txt
         return self
 
-    def get_texcode_for_expression(self, expression: str):
-        """Inserts expression verbatim into TeX template.
+    def get_texcode_for_expression(self, expression: str) -> str:
+        r"""Inserts expression verbatim into TeX template.
 
         Parameters
         ----------
         expression
-            The string containing the expression to be typeset, e.g. ``$\\sqrt{2}$``
+            The string containing the expression to be typeset, e.g. ``$\sqrt{2}$``
 
         Returns
         -------
@@ -168,102 +138,60 @@ class TexTemplate:
         """
         return self.body.replace(self.placeholder_text, expression)
 
-    def _texcode_for_environment(self, environment: str):
-        """Processes the tex_environment string to return the correct ``\\begin{environment}[extra]{extra}`` and
-        ``\\end{environment}`` strings
-
-        Parameters
-        ----------
-        environment
-            The tex_environment as a string. Acceptable formats include:
-            ``{align*}``, ``align*``, ``{tabular}[t]{cccl}``, ``tabular}{cccl``, ``\\begin{tabular}[t]{cccl}``.
-
-        Returns
-        -------
-        Tuple[:class:`str`, :class:`str`]
-            A pair of strings representing the opening and closing of the tex environment, e.g.
-            ``\\begin{tabular}{cccl}`` and ``\\end{tabular}``
-        """
-
-        # If the environment starts with \begin, remove it
-        if environment[0:6] == r"\begin":
-            environment = environment[6:]
-
-        # If environment begins with { strip it
-        if environment[0] == r"{":
-            environment = environment[1:]
-
-        # The \begin command takes everything and closes with a brace
-        begin = r"\begin{" + environment
-        if (
-            begin[-1] != r"}" and begin[-1] != r"]"
-        ):  # If it doesn't end on } or ], assume missing }
-            begin += r"}"
-
-        # While the \end command terminates at the first closing brace
-        split_at_brace = re.split(r"}", environment, 1)
-        end = r"\end{" + split_at_brace[0] + r"}"
-
-        return begin, end
-
-    def get_texcode_for_expression_in_env(self, expression: str, environment: str):
-        r"""Inserts expression into TeX template wrapped in \begin{environment} and \end{environment}
+    def get_texcode_for_expression_in_env(
+        self, expression: str, environment: str
+    ) -> str:
+        r"""Inserts expression into TeX template wrapped in ``\begin{environment}`` and ``\end{environment}``.
 
         Parameters
         ----------
         expression
-            The string containing the expression to be typeset, e.g. ``$\\sqrt{2}$``
+            The string containing the expression to be typeset, e.g. ``$\sqrt{2}$``.
         environment
-            The string containing the environment in which the expression should be typeset, e.g. ``align*``
+            The string containing the environment in which the expression should be typeset, e.g. ``align*``.
 
         Returns
         -------
         :class:`str`
             LaTeX code based on template, containing the given expression inside its environment, ready for typesetting
         """
-        begin, end = self._texcode_for_environment(environment)
-        return self.body.replace(self.placeholder_text, f"{begin}\n{expression}\n{end}")
+        begin, end = _texcode_for_environment(environment)
+        return self.body.replace(
+            self.placeholder_text, "\n".join([begin, expression, end])
+        )
 
-    def copy(self) -> TexTemplate:
+    def copy(self) -> Self:
+        """Create a deep copy of the TeX template instance."""
         return copy.deepcopy(self)
 
 
-class TexTemplateFromFile(TexTemplate):
-    """A TexTemplate object created from a template file (default: tex_template.tex)
+def _texcode_for_environment(environment: str) -> tuple[str, str]:
+    r"""Processes the tex_environment string to return the correct ``\begin{environment}[extra]{extra}`` and
+    ``\end{environment}`` strings.
 
     Parameters
     ----------
-    tex_filename
-        Path to a valid TeX template file
-    kwargs
-        Arguments for :class:`~.TexTemplate`.
-
-    Attributes
-    ----------
-    template_file : :class:`str`
-        Path to a valid TeX template file
-    body : :class:`str`
-        Content of the TeX template file
-    tex_compiler : :class:`str`
-        The TeX compiler to be used, e.g. ``latex``, ``pdflatex`` or ``lualatex``
-    output_format : :class:`str`
-        The output format resulting from compilation, e.g. ``.dvi`` or ``.pdf``
+    environment
+        The tex_environment as a string. Acceptable formats include:
+        ``{align*}``, ``align*``, ``{tabular}[t]{cccl}``, ``tabular}{cccl``, ``\begin{tabular}[t]{cccl}``.
+
+    Returns
+    -------
+    Tuple[:class:`str`, :class:`str`]
+        A pair of strings representing the opening and closing of the tex environment, e.g.
+        ``\begin{tabular}{cccl}`` and ``\end{tabular}``
     """
 
-    def __init__(
-        self, *, tex_filename: str | os.PathLike = "tex_template.tex", **kwargs
-    ):
-        self.template_file = Path(tex_filename)
-        super().__init__(**kwargs)
-
-    def _rebuild(self):
-        self.body = self.template_file.read_text()
+    environment.removeprefix(r"\begin").removeprefix("{")
 
-    def file_not_mutable(self):
-        raise Exception("Cannot modify TexTemplate when using a template file.")
+    # The \begin command takes everything and closes with a brace
+    begin = r"\begin{" + environment
+    # If it doesn't end on } or ], assume missing }
+    if not begin.endswith(("}", "]")):
+        begin += "}"
 
-    def add_to_preamble(self, txt, prepend=False):
-        self.file_not_mutable()
+    # While the \end command terminates at the first closing brace
+    split_at_brace = re.split("}", environment, 1)
+    end = r"\end{" + split_at_brace[0] + "}"
 
-    def add_to_document(self, txt):
-        self.file_not_mutable()
+    return begin, end

manim/utils/tex_file_writing.py

@@ -19,6 +19,8 @@ from manim.utils.tex import TexTemplate
 
 from .. import config, logger
 
+__all__ = ["tex_to_svg_file"]
+
 
 def tex_hash(expression):
     id_str = str(expression)

manim/utils/tex_templates.py

@@ -1,4 +1,5 @@
 """A library of LaTeX templates."""
+
 from __future__ import annotations
 
 __all__ = [

{manim-0.18.0.dist-info → manim-0.18.1.dist-info}/LICENSE.community

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2021, the Manim Community Developers
+Copyright (c) 2024, the Manim Community Developers
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

{manim-0.18.0.dist-info → manim-0.18.1.dist-info}/METADATA

@@ -1,59 +1,53 @@
 Metadata-Version: 2.1
 Name: manim
-Version: 0.18.0
+Version: 0.18.1
 Summary: Animation engine for explanatory math videos.
 Home-page: https://www.manim.community/
 License: MIT
 Author: The Manim Community Developers
 Author-email: contact@manim.community
-Requires-Python: >=3.8,<3.13
+Requires-Python: >=3.9,<3.13
 Classifier: Development Status :: 4 - Beta
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Natural Language :: English
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.8
 Classifier: Topic :: Multimedia :: Graphics
 Classifier: Topic :: Multimedia :: Video
 Classifier: Topic :: Scientific/Engineering
 Provides-Extra: gui
 Provides-Extra: jupyterlab
-Requires-Dist: Pillow (>=9.1,<10.0)
-Requires-Dist: Pygments (>=2.10.0,<3.0.0)
-Requires-Dist: backports.cached-property (>=1.0.1,<2.0.0) ; python_version < "3.8"
-Requires-Dist: click (>=7.2,<=9.0)
-Requires-Dist: click-default-group (>=1.2.2,<2.0.0)
-Requires-Dist: cloup (>=0.13,<2.2)
-Requires-Dist: dearpygui (>=1.3.1,<2.0.0) ; extra == "gui"
-Requires-Dist: decorator (>=5.0.7,<6.0.0)
-Requires-Dist: importlib-metadata (>=4.10.0,<5.0.0) ; python_version < "3.8"
-Requires-Dist: isosurfaces (==0.1.0)
-Requires-Dist: jupyterlab (>=3.0,<4.0) ; extra == "jupyterlab"
+Requires-Dist: Pillow (>=9.1)
+Requires-Dist: Pygments (>=2.0.0)
+Requires-Dist: click (>=8.0)
+Requires-Dist: cloup (>=2.0.0)
+Requires-Dist: dearpygui (>=1.0.0) ; extra == "gui"
+Requires-Dist: decorator (>=4.3.2)
+Requires-Dist: importlib-metadata (>=3.6) ; python_full_version <= "3.9.0"
+Requires-Dist: isosurfaces (>=0.1.0)
+Requires-Dist: jupyterlab (>=3.0.0) ; extra == "jupyterlab"
 Requires-Dist: manimpango (>=0.5.0,<1.0.0)
-Requires-Dist: mapbox-earcut (>=1.0.0,<2.0.0)
-Requires-Dist: moderngl (>=5.6.3,<6.0.0)
-Requires-Dist: moderngl-window (>=2.3.0,<3.0.0)
-Requires-Dist: networkx (>=2.5,<3.3)
-Requires-Dist: notebook (>=6.4,<7.0) ; extra == "jupyterlab"
-Requires-Dist: numpy (>=1.22,<2.0) ; python_version < "3.12"
-Requires-Dist: numpy (>=1.26,<2.0) ; python_version >= "3.12"
-Requires-Dist: pycairo (>=1.21,<2.0)
-Requires-Dist: pydub (>=0.25.1,<0.26.0)
-Requires-Dist: requests (>=2.26.0,<3.0.0)
-Requires-Dist: rich (>=6.0,!=12.0.0)
-Requires-Dist: scipy (>=1.11,<2.0) ; python_version >= "3.12"
-Requires-Dist: scipy (>=1.7.3,<2.0.0) ; python_version < "3.12"
-Requires-Dist: screeninfo (>=0.8,<0.9)
-Requires-Dist: skia-pathops (>=0.7.0,<0.8.0) ; python_version < "3.12"
-Requires-Dist: skia-pathops (>=0.8.0.post1,<0.9.0) ; python_version >= "3.12"
-Requires-Dist: srt (>=3.5.0,<4.0.0)
-Requires-Dist: svgelements (>=1.8.0,<2.0.0)
-Requires-Dist: tqdm (>=4.62.3,<5.0.0)
-Requires-Dist: typing-extensions (>=4.7.1,<5.0.0)
-Requires-Dist: watchdog (>=2.1,<=3.0.0)
+Requires-Dist: mapbox-earcut (>=1.0.0)
+Requires-Dist: moderngl (>=5.0.0,<6.0.0)
+Requires-Dist: moderngl-window (>=2.0.0)
+Requires-Dist: networkx (>=2.6)
+Requires-Dist: notebook (>=6.0.0) ; extra == "jupyterlab"
+Requires-Dist: numpy (>=1.26)
+Requires-Dist: pycairo (>=1.13,<2.0.0)
+Requires-Dist: pydub (>=0.20.0)
+Requires-Dist: rich (>=12.0.0)
+Requires-Dist: scipy (>=1.6.0)
+Requires-Dist: screeninfo (>=0.7)
+Requires-Dist: skia-pathops (>=0.7.0)
+Requires-Dist: srt (>=3.0.0)
+Requires-Dist: svgelements (>=1.8.0)
+Requires-Dist: tqdm (>=4.0.0)
+Requires-Dist: typing-extensions (>=4.0.0)
+Requires-Dist: watchdog (>=2.0.0)
 Project-URL: Bug Tracker, https://github.com/ManimCommunity/manim/issues
 Project-URL: Changelog, https://docs.manim.community/en/stable/changelog.html
 Project-URL: Documentation, https://docs.manim.community/