janim 0.1__py3-none-any.whl

janim/__init__.py

@@ -0,0 +1,3 @@
+'''a library for simple animation effects'''
+
+__version__ = '0.1'

janim/__main__.py

@@ -0,0 +1,270 @@
+import importlib
+import time
+import os
+import platform
+import subprocess as sp
+from argparse import ArgumentParser, Namespace
+
+from janim.anims.timeline import Timeline
+from janim.logger import log
+from janim.utils.config import Config, default_config
+
+
+def main() -> None:
+    parser = ArgumentParser(description='A library for simple animation effects')
+    parser.set_defaults(func=None)
+
+    sp = parser.add_subparsers()
+    run_parser(sp.add_parser('run', help='Run timeline(s) from specific namespace'))
+    write_parser(sp.add_parser('write', help='Generate video file(s) of timeline(s) from specific namesapce'))
+    examples_parser(sp.add_parser('examples', help='Show examples of janim'))
+
+    args = parser.parse_args()
+    if args.func is None:
+        parser.print_help()
+    else:
+        args.func(args)
+
+
+def render_args(parser: ArgumentParser) -> None:
+    parser.add_argument(
+        'namespace',
+        help='Namespace to file holding the python code for the timeline'
+    )
+    parser.add_argument(
+        'timeline_names',
+        nargs='*',
+        help='Name of the Timeline class you want to see'
+    )
+    parser.add_argument(
+        '-a', '--all',
+        action='store_true',
+        help='Render all timelines from a file'
+    )
+    parser.add_argument(
+        '-c', '--config',
+        nargs=2,
+        metavar=('key', 'value'),
+        action='append',
+        help='Override config'
+    )
+
+
+def run_parser(parser: ArgumentParser) -> None:
+    render_args(parser)
+    parser.add_argument(
+        '-i', '--interact',
+        action='store_true',
+        help='Enable the network socket for interacting'
+    )
+    parser.set_defaults(func=run)
+
+
+def write_parser(parser: ArgumentParser) -> None:
+    render_args(parser)
+    parser.add_argument(
+        '-o', '--open',
+        action='store_true',
+        help='Open the file after writing'
+    )
+    parser.add_argument(
+        '--format',
+        choices=['mp4', 'mov'],
+        default='mp4',
+        help='Format of the output file'
+    )
+    parser.set_defaults(func=write)
+
+
+def examples_parser(parser: ArgumentParser) -> None:
+    parser.set_defaults(namespace='janim.examples')
+    parser.add_argument(
+        'timeline_names',
+        nargs='*',
+        help='Name of the example you want to see'
+    )
+    parser.set_defaults(all=None)
+    parser.set_defaults(config=None)
+    parser.set_defaults(func=run)
+    parser.set_defaults(interact=False)
+
+
+def run(args: Namespace) -> None:
+    module = get_module(args.namespace)
+    if module is None:
+        return
+    modify_default_config(args)
+
+    timelines = extract_timelines_from_module(args, module)
+    if not timelines:
+        return
+
+    auto_play = len(timelines) == 1
+
+    from janim.gui.anim_viewer import AnimViewer
+    from janim.gui.application import Application
+    from PySide6.QtCore import QPoint, QTimer
+
+    app = Application()
+
+    log.info('======')
+
+    widgets: list[AnimViewer] = []
+    for timeline in timelines:
+        viewer = AnimViewer(timeline().build(), auto_play, args.interact)
+        widgets.append(viewer)
+
+    log.info('======')
+    log.info('Constructing window')
+
+    t = time.time()
+
+    for i, widget in enumerate(widgets):
+        if i != 0:
+            widget.move(widgets[i - 1].pos() + QPoint(24, 24))
+        widget.show()
+
+    QTimer.singleShot(200, widgets[-1].activateWindow)
+
+    log.info(f'Finished constructing in {time.time() - t:.2f} s')
+    log.info('======')
+
+    app.exec()
+
+
+def write(args: Namespace) -> None:
+    module = get_module(args.namespace)
+    if module is None:
+        return
+    modify_default_config(args)
+
+    timelines = extract_timelines_from_module(args, module)
+    if not timelines:
+        return
+
+    from janim.render.file_writer import FileWriter
+
+    log.info('======')
+
+    built = [timeline().build() for timeline in timelines]
+
+    log.info('======')
+
+    output_dir = os.path.normpath(Config.get.output_dir)
+    if not os.path.exists(output_dir):
+        os.makedirs(output_dir)
+
+    log.info(f'fps={Config.get.fps}')
+    log.info(f'resolution="{Config.get.pixel_width}x{Config.get.pixel_height}"')
+    log.info(f'output_dir="{output_dir}"')
+    log.info(f'format="{args.format}"')
+
+    log.info('======')
+
+    for anim in built:
+        writer = FileWriter(anim)
+        writer.write_all(
+            os.path.join(Config.get.output_dir,
+                         f'{anim.timeline.__class__.__name__}.{args.format}')
+        )
+        if args.open and anim is built[-1]:
+            open_file(writer.final_file_path)
+
+    log.info('======')
+
+
+def modify_default_config(args: Namespace) -> None:
+    if args.config:
+        for key, value in args.config:
+            dtype = type(getattr(default_config, key))
+            setattr(default_config, key, dtype(value))
+
+
+def get_module(namespace: str):
+    try:
+        return importlib.import_module(namespace)
+    except ModuleNotFoundError:
+        log.error(f'No module named "{namespace}"')
+        return None
+
+
+def extract_timelines_from_module(args: Namespace, module) -> list[type[Timeline]]:
+    timelines = []
+    err = False
+
+    if not args.all and args.timeline_names:
+        for name in args.timeline_names:
+            try:
+                timelines.append(module.__dict__[name])
+            except KeyError:
+                log.error(f'No timeline named "{name}"')
+                err = True
+    else:
+        import inspect
+
+        classes = [
+            value
+            for value in module.__dict__.values()
+            if isinstance(value, type) and issubclass(value, Timeline) and value.__module__ == module.__name__
+        ]
+        if len(classes) <= 1:
+            return classes
+        classes.sort(key=lambda x: inspect.getsourcelines(x)[1])
+        if args.all:
+            return classes
+
+        max_digits = len(str(len(classes)))
+
+        name_to_class = {}
+        for idx, timeline_class in enumerate(classes, start=1):
+            name = timeline_class.__name__
+            print(f"{str(idx).zfill(max_digits)}: {name}")
+            name_to_class[name] = timeline_class
+
+        user_input = input(
+            "\nThat module has multiple timelines, "
+            "which ones would you like to render?"
+            "\nTimeline Name or Number: "
+        )
+        for split_str in user_input.replace(' ', '').split(','):
+            if not split_str:
+                continue
+            if split_str.isnumeric():
+                idx = int(split_str) - 1
+                if 0 <= idx < len(classes):
+                    timelines.append(classes[idx])
+                else:
+                    log.error(f'Invaild number {idx + 1}')
+                    err = True
+            else:
+                try:
+                    timelines.append(name_to_class[split_str])
+                except KeyError:
+                    log.error(f'No timeline named {split_str}')
+                    err = True
+
+    return [] if err else timelines
+
+
+def open_file(file_path: str) -> None:
+    current_os = platform.system()
+    if current_os == "Windows":
+        os.startfile(file_path)
+    else:
+        commands = []
+        if current_os == "Linux":
+            commands.append("xdg-open")
+        elif current_os.startswith("CYGWIN"):
+            commands.append("cygstart")
+        else:  # Assume macOS
+            commands.append("open")
+
+        commands.append(file_path)
+
+        FNULL = open(os.devnull, 'w')
+        sp.call(commands, stdout=FNULL, stderr=sp.STDOUT)
+        FNULL.close()
+
+
+if __name__ == '__main__':
+    main()

janim/anims/animation.py

@@ -0,0 +1,119 @@
+from __future__ import annotations
+
+from contextvars import ContextVar
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Callable
+
+from janim.components.depth import Cmpt_Depth
+from janim.utils.rate_functions import RateFunc, smooth
+
+if TYPE_CHECKING:
+    from janim.anims.composition import AnimGroup
+
+
+@dataclass
+class TimeRange:
+    at: float
+    duration: float
+
+    @property
+    def end(self) -> float:
+        return self.at + self.duration
+
+
+@dataclass
+class RenderCall:
+    '''
+    绘制调用
+
+    - ``depth``: 该绘制的深度
+    - ``func``: 该绘制所调用的函数
+
+    具体机制：
+
+    - 在每个动画对象中，都会使用 :meth:`~.Animation.set_render_call_list` 来设置该动画进行绘制时所执行的函数
+    - 在进行渲染（具体参考 :meth:`~.TimelineAnim.render_all` ）时，会按照深度进行排序，依次对 ``func`` 进行调用，深度越高的越先调用
+
+    例：
+
+    - 在 :class:`~.Display` 中，设置了单个 :class:`RenderCall` ，作用是绘制物件
+    - 在 :class:`~.Transform` 中，对于每个插值物件都设置了 :class:`RenderCall`，绘制所有的插值物件
+    '''
+    depth: Cmpt_Depth
+    func: Callable[[], None]
+
+
+class Animation:
+    '''
+    动画基类
+
+    - 创建一个从 ``at`` 持续至 ``at + duration`` 的动画
+    - 指定 ``rate_func`` 可以设定插值函数，默认为 :meth:`janim.utils.rate_functions.smooth` 即平滑插值
+    '''
+    label_color: tuple[float, float, float] = (128, 132, 137)
+
+    def __init__(
+        self,
+        *,
+        at: float = 0,
+        duration: float = 1.0,
+        rate_func: RateFunc = smooth,
+    ):
+        from janim.anims.timeline import Timeline
+        self.timeline = Timeline.get_context()
+        self.parent: AnimGroup = None
+        self.current_alpha = None
+
+        self.local_range = TimeRange(at, duration)
+        self.global_range = None
+        self.rate_func = rate_func
+
+        self.render_call_list: list[RenderCall] = []
+
+    def set_global_range(self, at: float, duration: float | None = None) -> None:
+        '''
+        设置在 :class:`~.Timeline` 上的时间范围
+
+        不需要手动设置，该方法是被 :meth:`~.AnimGroup.set_global_range` 调用以计算的
+        '''
+        if duration is None:
+            duration = self.local_range.duration
+        self.global_range = TimeRange(at, duration)
+
+    def set_render_call_list(self, lst: list[RenderCall]) -> None:
+        '''
+        设置绘制调用，具体参考 :class:`RenderCall`
+        '''
+        self.render_call_list = sorted(lst, key=lambda x: x.depth, reverse=True)
+
+    def anim_pre_init(self) -> None: '''在 :meth:`~.Timeline.detect_changes_of_all` 执行之前调用的初始化方法'''
+
+    def anim_init(self) -> None: '''在 :meth:`~.Timeline.detect_changes_of_all` 执行之前调用的初始化方法'''
+
+    def anim_on(self, local_t: float) -> None:
+        '''
+        将 ``local_t`` 换算为 ``alpha`` 并调用 :meth:`anim_on_alpha`
+        '''
+        alpha = self.rate_func(local_t / self.local_range.duration)
+        self.anim_on_alpha(alpha)
+
+    def get_alpha_on_global_t(self, global_t: float) -> float:
+        '''
+        传入全局 ``global_t``，得到物件在该时刻应当处于哪个 ``alpha`` 的插值
+        '''
+        if self.parent is None:
+            return self.rate_func((global_t - self.global_range.at) / self.global_range.duration)
+
+        anim_t = self.parent.get_anim_t(self.parent.get_alpha_on_global_t(global_t), self)
+        return self.rate_func(anim_t / self.local_range.duration)
+
+    global_t_ctx: ContextVar[float] = ContextVar('Animation.global_t_ctx')
+    '''
+    对该值进行设置，使得进行 :meth:`anim_on` 和 :meth:`render` 时不需要将 ``global_t`` 作为参数传递也能获取到
+    '''
+
+    def anim_on_alpha(self, alpha: float) -> None:
+        '''
+        动画在 ``alpha`` 处的行为
+        '''
+        pass

janim/anims/composition.py

@@ -0,0 +1,167 @@
+
+from janim.anims.animation import Animation
+from janim.utils.rate_functions import RateFunc, linear
+
+
+class AnimGroup(Animation):
+    '''
+    动画集合（并列执行）
+
+    - 若不传入 ``duration``，则将终止时间（子动画结束时间的最大值）作为该动画集合的 ``duration``
+    - 若传入 ``duration``，则会将子动画的时间进行拉伸，使得终止时间与 ``duration`` 一致
+    - 且可以使用 ``at`` 进行总体偏移（如 ``at=1`` 则是总体延后 1s）
+
+    时间示例：
+
+    .. code-block:: python
+
+        AnimGroup(
+            Anim1(duration=3),
+            Anim2(duration=4)
+        ) # Anim1 在 0~3s 执行，Anim2 在 0~4s 执行
+
+        AnimGroup(
+            Anim1(duration=3),
+            Anim2(duration=4),
+            duration=6
+        ) # Anim1 在 0~4.5s 执行，Anim2 在 0~6s 执行
+
+        AnimGroup(
+            Anim1(duration=3),
+            Anim2(duration=4),
+            at=1,
+            duration=6
+        ) # Anim1 在 1~5.5s 执行，Anim2 在 1~7s 执行
+    '''
+    def __init__(
+        self,
+        *anims: Animation,
+        duration: float | None = None,
+        rate_func: RateFunc = linear,
+        **kwargs
+    ):
+        self.anims = anims
+        self.maxt = 0 if not anims else max(anim.local_range.end for anim in anims)
+        if duration is None:
+            duration = self.maxt
+
+        super().__init__(duration=duration, rate_func=rate_func, **kwargs)
+        for anim in self.anims:
+            anim.parent = self
+
+    def flatten(self) -> list[Animation]:
+        result = [self]
+        for anim in self.anims:
+            if isinstance(anim, AnimGroup):
+                result.extend(anim.flatten())
+            else:
+                result.append(anim)
+
+        return result
+
+    def set_global_range(self, at: float, duration: float | None = None) -> None:
+        '''
+        设置并计算子动画的时间范围
+
+        不需要手动设置，该方法是被 :meth:`~.Timeline.prepare` 调用以计算的
+        '''
+        super().set_global_range(at, duration)
+
+        if duration is None:
+            duration = self.local_range.duration
+
+        factor = duration / self.maxt
+
+        for anim in self.anims:
+            anim.set_global_range(
+                self.global_range.at + anim.local_range.at * factor,
+                anim.local_range.duration * factor
+            )
+
+    def anim_pre_init(self) -> None:
+        for anim in self.anims:
+            anim.anim_pre_init()
+
+    def anim_init(self) -> None:
+        for anim in self.anims:
+            anim.anim_init()
+
+    def get_anim_t(self, alpha: float, anim: Animation) -> float:
+        return alpha * self.maxt - anim.local_range.at
+
+    def anim_on_alpha(self, alpha: float) -> None:
+        '''
+        在该方法中，:class:`AnimGroup` 通过 ``alpha``
+        换算出子动画的 ``local_t`` 并调用子动画的 :meth:`~.Animation.anim_on` 方法
+        '''
+        for anim in self.anims:
+            anim_t = self.get_anim_t(alpha, anim)
+            if 0 <= anim_t < anim.local_range.duration:
+                anim.anim_on(anim_t)
+
+
+class Succession(AnimGroup):
+    '''
+    动画集合（顺序执行）
+
+    - 会将传入的动画依次执行，不并行
+    - 可以传入 `buff` 指定前后动画中间的空白时间
+    - 其余与 `AnimGroup` 相同
+
+    时间示例：
+
+    .. code-block:: python
+
+        Succession(
+            Anim1(duration=3),
+            Anim2(duration=4)
+        ) # Anim1 在 0~3s 执行，Anim2 在 3~7s 执行
+
+        Succession(
+            Anim1(duration=2),
+            Anim2(at=1, duration=2),
+            Anim3(at=0.5, duration=2)
+        ) # Anim1 在 0~2s 执行，Anim2 在 3~5s 执行，Anim3 在 5.5~7.5s 执行
+
+        Succession(
+            Anim1(duration=2),
+            Anim2(duration=2),
+            Anim3(duration=2),
+            buff=0.5
+        ) # Anim1 在 0~2s 执行，Anim2 在 2.5~4.5s 执行，Anim3 在 5~7s 执行
+    '''
+    def __init__(self, *anims: Animation, buff: float = 0, **kwargs):
+        end_time = 0
+        for anim in anims:
+            anim.local_range.at += end_time
+            end_time = anim.local_range.end + buff
+        super().__init__(*anims, **kwargs)
+
+
+class Aligned(AnimGroup):
+    '''
+    动画集合（并列对齐执行）
+
+    时间示例：
+
+    .. code-block:: python
+
+        Aligned(
+            Anim1(duration=1),
+            Anim2(duration=2)
+        ) # Anim1 和 Anim2 都在 0~2s 执行
+
+        Aligned(
+            Anim1(duration=1),
+            Anim2(duration=2),
+            duration=4
+        ) # Anim1 和 Anim2 都在 0~4s 执行
+    '''
+    def __init__(*anims: Animation, **kwargs):
+        maxt = max(anim.local_range.end for anim in anims)
+        for anim in anims:
+            factor = anim.local_range.end / maxt
+            anim.local_range.at *= factor
+            anim.local_range.duration *= factor
+
+        super().__init__(*anims, **kwargs)