cli_ utils:

- fixing  typos and added full docstring
- replace regex with python string split
module_ops:
-  full docstrings, typo fixing
- handling python internal type-madness with exceptions to please mypy
commands:
- docstrings, typos, more descriptive names
-  cleaning version fetch functionality

Author: Oliver Strait

manim/cli/cli_utils.py

@@ -1,18 +1,18 @@
 from __future__ import annotations
 
-import re
 import sys
 
 from manim._config import console
 from manim.constants import CHOOSE_NUMBER_MESSAGE
 
 ESCAPE_CHAR = "CTRL+Z" if sys.platform == "win32" else "CTRL+D"
-NOT_FOUND_IMPORT = "Import statement for Manim was not found. Importing is added."
 
+NOT_FOUND_IMPORT = "Import statement for Manim was not found. Importing is added."
 INPUT_CODE_ENTER = f"Enter the animation code & end with an EOF: {ESCAPE_CHAR}:"
 
 
 def code_input_prompt() -> str:
+    """Little CLI interface in which user can insert code."""
     console.print(INPUT_CODE_ENTER)
     code = sys.stdin.read()
     if len(code.strip()) == 0:
@@ -24,22 +24,27 @@ def code_input_prompt() -> str:
     return code
 
 
-def prompt_user_with_choice(choise_list: list[str]) -> list[int]:
-    """Prompt user with chooses and return indices of choised items"""
-    max_index = len(choise_list)
-    for count, name in enumerate(choise_list, 1):
+def prompt_user_with_list(items: list[str]) -> list[int]:
+    """Prompt user with choices and return indices of chosen items
+
+    Parameters
+    -----------
+    items
+        list of strings representing items to be chosen
+    """
+    max_index = len(items) - 1
+    for count, name in enumerate(items, 1):
         console.print(f"{count}: {name}", style="logging.level.info")
 
     user_input = console.input(CHOOSE_NUMBER_MESSAGE)
-    # CTRL + Z, CTRL + D, Remove common EOF escape chars
-    cleaned = user_input.strip().removesuffix("\x1a").removesuffix("\x04")
-    result = re.split(r"\s*,\s*", cleaned)
+    result = user_input.strip().rstrip(",").split(",")
+    cleaned = [n.strip() for n in result]
 
-    if not all(a.isnumeric() for a in result):
-        raise ValueError("Invalid non-numeric input: ", user_input)
+    if not all(a.isnumeric() for a in cleaned):
+        raise ValueError(f"Invalid non-numeric input(s): {result}")
 
-    indices = [int(i_str.strip()) - 1 for i_str in result]
+    indices = [int(int_str) - 1 for int_str in cleaned]
     if all(a <= max_index >= 0 for a in indices):
         return indices
     else:
-        raise KeyError("One or more chooses is outside of range")
+        raise KeyError("One or more choice is outside of range")

manim/cli/render/commands.py

@@ -26,7 +26,7 @@
     logger,
     tempconfig,
 )
-from manim.cli.cli_utils import code_input_prompt, prompt_user_with_choice
+from manim.cli.cli_utils import code_input_prompt, prompt_user_with_list
 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
@@ -92,15 +92,15 @@ def render(**kwargs: Any) -> ClickArgs | dict[str, Any]:
 
     SCENES is an optional list of scenes in the file.
     """
-    warn_and_change_deprecated_args(kwargs)
+    warn_and_change_deprecated_arguments(kwargs)
 
     click_args = ClickArgs(kwargs)
     if kwargs["jupyter"]:
         return click_args
 
     config.digest_args(click_args)
 
-    scenes = solve_rendrered_scenes(config.input_file)
+    scenes = scenes_from_input(config.input_file)
 
     if config.renderer == RendererType.OPENGL:
         from manim.renderer.opengl_renderer import OpenGLRenderer
@@ -142,33 +142,40 @@ def render(**kwargs: Any) -> ClickArgs | dict[str, Any]:
 
 
 def version_notification() -> None:
-    """Fetch version from Internet or use cache"""
-    file = Path(os.path.dirname(__file__)) / ".version_cache.log"
-    stable = None
-
-    if file.exists():
-        with file.open() as f:
-            last_time = f.readline()
-            if not time.time() - int(last_time) > 86_400:
-                stable = f.readline()
-
-    if stable is None:
-        new_stable = fetch_version()
-        if new_stable:
-            with file.open(mode="w") as f:
-                f.write(str(int(time.time())) + "\n" + str(new_stable))
-            stable = new_stable
-
-    if stable != __version__:
+    """Compare used version to latest version of manim.
+    Version info is fetched from internet once a day and cached into a file.
+    """
+    stable_version = None
+
+    cache_file = Path(os.path.dirname(__file__)) / ".version_cache.log"
+
+    if cache_file.exists():
+        with cache_file.open() as f:
+            cache_lifetime = int(f.readline())
+            if time.time() < cache_lifetime:
+                stable_version = f.readline()
+
+    if stable_version is None:
+        version = fetch_version()
+        if version is None:
+            return None
+
+        with cache_file.open(mode="w") as f:
+            timecode = int(time.time()) + 86_400
+            f.write(str(timecode) + "\n" + str(version))
+        stable_version = version
+
+    if stable_version != __version__:
         console.print(
-            f"You are using manim version [red]v{__version__}[/red], but version [green]v{stable}[/green] is available.",
+            f"You are using manim version [red]v{__version__}[/red], but version [green]v{stable_version}[/green] is available.",
         )
         console.print(
             "You should consider upgrading via [yellow]pip install -U manim[/yellow]",
         )
 
 
 def fetch_version() -> str | None:
+    """Fetch latest manim version from PYPI-database"""
     import http.client
     import urllib.error
     import urllib.request
@@ -185,15 +192,17 @@ def fetch_version() -> str | None:
         logger.debug(f"{e}: {warn_prompt} ")
         return None
     except json.JSONDecodeError:
-        logger.debug(f"Error while decoding JSON from [{manim_info_url}]: warn_prompt")
+        logger.debug(
+            f"Error while decoding JSON from [{manim_info_url}]: {warn_prompt}"
+        )
         return None
     else:
         return str(json_data["info"]["version"])
 
 
-def warn_and_change_deprecated_args(kwargs: dict[str, Any]) -> None:
-    """Helper function to print info about deprecated functions
-    and mutate inserted dict to contain proper format
+def warn_and_change_deprecated_arguments(kwargs: dict[str, Any]) -> None:
+    """Helper function to print info about deprecated arguments
+    and mutate inserted dictionary to use new format
     """
     if kwargs["save_as_gif"]:
         logger.warning("--save_as_gif is deprecated, please use --format=gif instead!")
@@ -210,11 +219,14 @@ def warn_and_change_deprecated_args(kwargs: dict[str, Any]) -> None:
 
 
 def select_scenes(scene_classes: list[type[Scene]]) -> list[type[Scene]]:
-    """Collection of selection checks for inserted scenes"""
-    if not scene_classes:
-        logger.error(NO_SCENE_MESSAGE)
-        return []
-    elif config.write_all:
+    """Assortment of selection functionality in which one or more Scenes are selected from list.
+
+    Parameters
+    ----------
+    scene_classes
+        list of scene classes that
+    """
+    if config.write_all:
         return scene_classes
 
     result = []
@@ -229,13 +241,14 @@ def select_scenes(scene_classes: list[type[Scene]]) -> list[type[Scene]]:
             logger.error(SCENE_NOT_FOUND_MESSAGE.format(scene_name))
     if result:
         return result
+
     if len(scene_classes) == 1:
         config.scene_names = [scene_classes[0].__name__]
         return [scene_classes[0]]
 
     try:
         console.print(f"{MULTIPLE_SCENES}:\n", style="underline white")
-        scene_indices = prompt_user_with_choice([a.__name__ for a in scene_classes])
+        scene_indices = prompt_user_with_list([a.__name__ for a in scene_classes])
     except Exception as e:
         logger.error(f"{e}\n{INVALID_NUMBER_MESSAGE} ")
         sys.exit(2)
@@ -248,22 +261,31 @@ def select_scenes(scene_classes: list[type[Scene]]) -> list[type[Scene]]:
     return classes
 
 
-def solve_rendrered_scenes(file_path_input: str) -> list[type[Scene]]:
-    """Return scenes from file path or create CLI prompt for input"""
+def scenes_from_input(file_path_input: str) -> list[type[Scene]]:
+    """Return scenes from file path or create CLI prompt for input
+
+    Parameters
+    ----------
+    file_path_input
+        file path or '-' that will open a code prompt
+    """
     from ...scene.scene import Scene
 
     if file_path_input == "-":
         try:
             code = code_input_prompt()
             module = module_from_text(code)
         except Exception as e:
-            logger.error(f" Failed to create from input code: {e}")
+            logger.error(f"Failed to create from input code: {e}")
             sys.exit(2)
 
         logger.info(INPUT_CODE_RENDER)
     else:
         module = module_from_file(Path(file_path_input))
 
-    scenes = search_classes_from_module(module, Scene)
-
-    return select_scenes(scenes)
+    try:
+        scenes = search_classes_from_module(module, Scene)
+        return select_scenes(scenes)
+    except ValueError:
+        logger.error(NO_SCENE_MESSAGE)
+        return []

manim/utils/module_ops.py

@@ -2,7 +2,6 @@
 
 from __future__ import annotations
 
-import importlib.machinery
 import importlib.util
 import inspect
 import sys
@@ -15,7 +14,13 @@
 
 
 def module_from_text(code: str) -> types.ModuleType:
-    """Creates a input prompt in which user can insert a code that will be asserted and executed."""
+    """Creates a input prompt in which user can insert a code that will be asserted and executed.
+
+    Parameters
+    ----------
+    code
+        code string
+    """
     module = types.ModuleType("RuntimeTEXT")
     try:
         # NOTE Code executer: is needed to resolve imports and other code
@@ -30,25 +35,27 @@ def module_from_file(file_path: Path) -> types.ModuleType:
 
     Parameters
     ----------
-
     file_path
-        location of file as path-object
+        location of python file as path-object
     """
     if not file_path.exists() and file_path.suffix == ".py":
         raise ValueError(f"{file_path} is not a valid python script.")
 
     module_name = "runtimeFile" + ".".join(file_path.with_suffix("").parts)
 
     warnings.filterwarnings("default", category=DeprecationWarning, module=module_name)
+
     try:
         spec = importlib.util.spec_from_file_location(module_name, file_path)
-        if isinstance(spec, importlib.machinery.ModuleSpec):
-            module = importlib.util.module_from_spec(spec)
-            sys.modules[module_name] = module
-            sys.path.insert(0, str(file_path.parent.absolute()))
-            spec.loader.exec_module(module)
-        else:
+        if spec is None:
             raise ValueError("Failed to create ModuleSpec")
+        elif spec.loader is None:
+            raise RuntimeError("ModuleSpec has no loader")
+
+        module = importlib.util.module_from_spec(spec)
+        sys.modules[module_name] = module
+        sys.path.insert(0, str(file_path.parent.absolute()))
+        spec.loader.exec_module(module)
 
     except Exception as e:
         raise RuntimeError("Module creation from file failed") from e
@@ -59,14 +66,14 @@ def module_from_file(file_path: Path) -> types.ModuleType:
 def search_classes_from_module(
     module: types.ModuleType, class_type: type[T]
 ) -> list[type[T]]:
-    """Search and return all occurrence of specified type classes.
+    """Search and return all occurrence of specified class-type.
 
     Parameters
     -----------
     module
         Module object
-    class_type:
-        Type of searched classes
+    class_type
+        Type of class
     """
 
     def is_child_scene(obj: Any) -> bool:
@@ -77,14 +84,22 @@ def is_child_scene(obj: Any) -> bool:
             and obj.__module__.startswith(module.__name__)
         )
 
-    classes = [member[1] for member in inspect.getmembers(module, is_child_scene)]
+    classes = [member for __void, member in inspect.getmembers(module, is_child_scene)]
 
     if len(classes) == 0:
         raise ValueError(f"Could not found any classes of type {class_type.__name__}")
     return classes
 
 
-def scene_classes_for_gui(path: str, class_type: type[T]) -> list[type[T]]:
-    """Specified interface of  dearpyGUI to fetch Scene-class instances"""
-    module = module_from_file(Path(path))
+def scene_classes_for_gui(file_path: str | Path, class_type: type[T]) -> list[type[T]]:
+    """Special interface only for dearpyGUI to fetch Scene-class instances.
+
+    Parameters
+    -----------
+    path
+        file path
+    class_type
+        Type of class
+    """
+    module = module_from_file(Path(file_path))
     return search_classes_from_module(module, class_type)