yerba 0.0.3a0.dev0__tar.gz → 0.0.3a0.dev2__tar.gz

{yerba-0.0.3a0.dev0/yerba.egg-info → yerba-0.0.3a0.dev2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: yerba
-Version: 0.0.3a0.dev0
+Version: 0.0.3a0.dev2
 Author-email: "Bernardo L. Español" <esp.bernardo@gmail.com>
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown

yerba-0.0.3a0.dev2/pyproject.toml

@@ -0,0 +1,32 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "yerba"
+version = "0.0.3-alpha-dev2"
+requires-python = ">=3.8"
+dependencies = [
+  "manim",
+  "manim-mobject-svg",
+  "markdown-it-py",
+  "mdformat",
+  "mdit-py-plugins",
+  "numpy",
+  "pillow",
+  "pyyaml"
+]
+authors = [
+  {name = "Bernardo L. Español", email = "esp.bernardo@gmail.com"},
+]
+readme = "README.md"
+license = {file = "LICENSE.txt"}
+
+[project.scripts]
+yerba = "yerba.__main__:cli_entry"
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["yerba*"]
+exclude = []
+namespaces = false

yerba-0.0.3a0.dev2/yerba/__main__.py

@@ -0,0 +1,30 @@
+import sys
+import os
+
+from .logger_setup import logger
+from .main_rutine import MainRutine
+
+
+def cli_entry():
+    if len(sys.argv) == 1:
+        logger.info("You should specify an input filename")
+        quit()
+    elif len(sys.argv) == 2:
+        filename = sys.argv[1]
+        if os.path.exists(filename):
+            pass
+        elif os.path.exists(filename+".md"):
+            filename = filename+".md"
+        else:
+            logger.error(f"File '{filename}' not found")
+            quit()
+    else:
+        logger.error("Too many args")
+        quit()
+
+    main_rutine = MainRutine(filename)
+    main_rutine.run()
+
+
+if __name__ == "__main__":
+    cli_entry()

yerba-0.0.3a0.dev2/yerba/base/box.py

@@ -0,0 +1,385 @@
+from __future__ import annotations
+import numpy as np
+from manim import VMobject, VGroup, Rectangle
+
+from ..defaults import box_params
+from ..managers.color_manager import ColorManager
+from ..utils.constants import (
+    UP, DOWN, LEFT, RIGHT, ORIGIN, SLIDE_HEIGHT, SLIDE_WIDTH, LEFT_EDGE,
+    RIGHT_EDGE, SLIDE_X_RAD, SLIDE_Y_RAD, TOP_EDGE, BOTTOM_EDGE, UL, DR
+)
+from ..utils.aux_functions import (
+    restructure_list_to_exclude_certain_family_members,
+    replace_in_list
+)
+
+
+class Box():
+    def __init__(self, center: np.ndarray,
+                 width: float, height: float, arrange: str | None = "top left",
+                 arrange_buff: float = box_params["arrange_buff"],
+                 is_null: bool = False, is_unique=False):
+
+        self.center = center
+        self.width = width
+        self.height = height
+        self.arrange = None if arrange == "none" else arrange
+        self.arrange_buff = arrange_buff
+        self.is_null = is_null
+        self.is_unique = is_unique
+
+        self.grid: dict[str, Box] | None = None
+        self.mobjects: list = []
+
+    @classmethod
+    def from_vertex(cls, ul_vertex: tuple[float, float],
+                    dr_vertex: tuple[float, float], **kwargs):
+        left_edge, top_edge = ul_vertex
+        right_edge, bottom_edge = dr_vertex
+        center = np.array(
+            [(right_edge+left_edge)/2, (top_edge+bottom_edge)/2, 0])
+        width = right_edge-left_edge
+        height = top_edge-bottom_edge
+        return cls(center, width, height, **kwargs)
+
+    @classmethod
+    def from_mo(cls, mo, **kwargs):
+        return cls.from_vertex(
+            ul_vertex=mo.get_corner(UL)[:-1],
+            dr_vertex=mo.get_corner(DR)[:-1],
+            **kwargs
+        )
+
+    @classmethod
+    def from_box(cls, box):
+        return cls(center=box.center.copy(),
+                   width=box.width, height=box.height,
+                   arrange=box.arrange, is_unique=True)
+
+    @classmethod
+    def get_full_box(cls, **kwargs):
+        return cls(ORIGIN, SLIDE_WIDTH, SLIDE_HEIGHT, **kwargs)
+
+    @classmethod
+    def get_left_box(cls, width, **kwargs):
+        return cls(LEFT_EDGE+RIGHT*width/2, width, SLIDE_HEIGHT, **kwargs)
+
+    @classmethod
+    def get_right_box(cls, width, **kwargs):
+        return cls(RIGHT_EDGE+LEFT*width/2, width, SLIDE_HEIGHT, **kwargs)
+
+    @classmethod
+    def get_top_box(cls, height, **kwargs):
+        return cls(TOP_EDGE+DOWN*height/2, SLIDE_WIDTH, height, **kwargs)
+
+    @classmethod
+    def get_bottom_box(cls, height, **kwargs):
+        return cls(BOTTOM_EDGE+UP*height/2, SLIDE_WIDTH, height, **kwargs)
+
+    @classmethod
+    def get_inner_box(cls, *, left_box=None, right_box=None,
+                      top_box=None, bottom_box=None, arrange):
+
+        lg = SLIDE_X_RAD + left_box.center[0] + left_box.width/2 \
+            if left_box else 0
+        rg = SLIDE_X_RAD - right_box.center[0] + right_box.width/2 \
+            if right_box else 0
+        tg = SLIDE_Y_RAD - top_box.center[1] + top_box.height/2 \
+            if top_box else 0
+        bg = SLIDE_Y_RAD + bottom_box.center[1] + bottom_box.height/2 \
+            if bottom_box else 0
+
+        box = cls.get_full_box(arrange=arrange)
+        box.shrink(left_gap=lg, right_gap=rg, top_gap=tg, bottom_gap=bg)
+
+        return box
+
+    @classmethod
+    def get_null_box(cls):
+        return cls(ORIGIN, SLIDE_WIDTH, SLIDE_HEIGHT, is_null=True)
+
+    @staticmethod
+    def merge_boxes(boxes, arrange):
+        if len(boxes) == 1:
+            return boxes[0]
+        left_edge = min([b.center[0]-b.width/2 for b in boxes])
+        right_edge = max([b.center[0]+b.width/2 for b in boxes])
+        top_edge = max([b.center[1]+b.height/2 for b in boxes])
+        bottom_edge = min([b.center[1]-b.height/2 for b in boxes])
+
+        return Box.from_vertex(ul_vertex=(left_edge, top_edge),
+                               dr_vertex=(right_edge, bottom_edge),
+                               arrange=arrange)
+
+    def add(self, mobject) -> None:
+        if hasattr(mobject, "width_units") and mobject.width_units == "box":
+            mobject.set(width=self.width*mobject.width, width_units="manim")
+        if hasattr(mobject, "height_units") and mobject.height_units == "box":
+            mobject.set(height=self.height*mobject.height,
+                        height_units="manim")
+
+        self.mobjects.append(mobject)
+
+    def remove(self, mobjects):
+        """Remove specified mobjects from the box."""
+        new_l = restructure_list_to_exclude_certain_family_members(
+            self.mobjects, mobjects)
+        self.mobjects = new_l
+
+    def replace(self, old_mo, new_mo):
+        """Remove specified mobjects from the box."""
+        replace_in_list(self.mobjects, old_mo, new_mo)
+
+    def remove_all_mobjects(self) -> None:
+        self.mobjects = []
+
+    def auto_arrange(self) -> None:
+        """TODO(bersp): DOC"""
+        if self.arrange is None or len(self.mobjects) == 0 or self.is_null:
+            return
+
+        centers = []
+        for mo in self.mobjects:
+            centers.append(mo.get_center())
+            mo.move_to(ORIGIN)
+
+        if self.arrange == "center":
+            (VGroup(*self.mobjects)
+             .move_to(self.center))
+        elif self.arrange == "hcenter":
+            (VGroup(*self.mobjects)
+             .arrange(direction=DOWN, buff=self.arrange_buff)
+             .move_to(self.center))
+        elif self.arrange == "top center":
+            (VGroup(*self.mobjects)
+             .arrange(DOWN, buff=self.arrange_buff)
+             .next_to(self.get_top(), DOWN, buff=0))
+        elif self.arrange == "top left":
+            (VGroup(*self.mobjects)
+             .arrange(DOWN, buff=self.arrange_buff, aligned_edge=LEFT)
+             .next_to(self.get_corner(LEFT, UP), DOWN+RIGHT, buff=0))
+        elif self.arrange == "top right":
+            (VGroup(*self.mobjects)
+             .arrange(DOWN, buff=self.arrange_buff, aligned_edge=RIGHT)
+             .next_to(self.get_corner(RIGHT, UP), DOWN+LEFT, buff=0))
+        elif self.arrange == "center left":
+            (VGroup(*self.mobjects)
+             .arrange(DOWN, buff=self.arrange_buff, aligned_edge=LEFT)
+             .next_to(self.get_left(), RIGHT, buff=0))
+        elif self.arrange == "center right":
+            (VGroup(*self.mobjects)
+             .arrange(DOWN, buff=self.arrange_buff, aligned_edge=RIGHT)
+             .next_to(self.get_right(), LEFT, buff=0))
+        else:
+            raise ValueError(f"Arrange {self.arrange!r} is not defined")
+
+        for cent, mo in zip(centers, self.mobjects):
+
+            if hasattr(mo, 'box_arrange'):
+                if mo.box_arrange == "none":
+                    pass
+                elif mo.box_arrange == "center":
+                    mo.move_to(self.center)
+                elif mo.box_arrange == "hcenter":
+                    mo.set_x(self.center[0])
+                elif mo.box_arrange == "vcenter":
+                    mo.set_y(self.center[1])
+                else:
+                    ValueError(
+                        f"'box arrange' {mo.box_arrange!r} is not defined")
+
+            mo.shift(cent)
+
+    def def_grid(self, grid, hspace=0.5, vspace=0.5,
+                 width_ratios=None, height_ratios=None,
+                 arrange="self") -> dict[str, Box]:
+        """
+        TODO(bersp): Handle errors (bad defined grid)
+        """
+
+        if arrange == "self":
+            arrange = self.arrange
+
+        grid = np.asarray(grid)
+        nrows, ncols = grid.shape
+
+        if width_ratios is None:
+            width_ratios = np.asarray([1]*ncols)/ncols
+        else:
+            width_ratios = np.asarray(width_ratios)
+            width_ratios = width_ratios/width_ratios.sum()
+
+        if height_ratios is None:
+            height_ratios = np.asarray([1]*nrows)/nrows
+        else:
+            height_ratios = np.asarray(height_ratios)
+            height_ratios = height_ratios/height_ratios.sum()
+
+        grid_widths = width_ratios * (self.width-hspace*(ncols-1))
+        grid_heights = height_ratios * (self.height-vspace*(nrows-1))
+
+        centers_x = []
+        cx = -self.width/2 - hspace
+        for gw in grid_widths:
+            cx += gw/2 + hspace
+            centers_x.append(cx)
+            cx += gw/2
+
+        centers_y = []
+        cy = self.height/2 + hspace
+        for gh in grid_heights:
+            cy -= gh/2 + hspace
+            centers_y.append(cy)
+            cy -= gh/2
+
+        x0, y0, _ = self.center
+        subgrid = np.zeros(shape=(nrows, ncols), dtype='object')
+        for row, (cy, gh) in enumerate(zip(centers_y, grid_heights)):
+            for col, (cx, gw) in enumerate(zip(centers_x, grid_widths)):
+                subgrid[row, col] = Box(center=np.array((x0+cx, y0+cy, 0)),
+                                        height=gh, width=gw, arrange=arrange)
+
+        self.grid = {}
+        for label in np.unique(grid):
+            self.grid[label] = Box.merge_boxes(
+                subgrid[np.where(grid == label)], arrange=arrange
+            )
+
+        return self.grid
+
+    def get_bbox_mo(self, color="BLACK") -> VMobject:
+        color = ColorManager().get_color(color)
+        r = (
+            Rectangle(height=self.height, width=self.width,
+                      fill_color=color, fill_opacity=0.2)
+            .set_stroke(color=color, opacity=0.0)
+            .move_to(self.center)
+            .set_z_index(-1)
+        )
+
+        return r
+
+    def get_bbox_grid(self, color="RED") -> VMobject:
+        color = ColorManager().get_color(color)
+
+        if self.grid is None:
+            raise ValueError(f"{self!r} has no defined grid")
+
+        o = VGroup()
+        for g in self.grid.values():
+            o.add(g.get_bbox_mo(color=color))
+
+        return o
+
+    def shrink(self, *, left_gap=0, right_gap=0,
+               top_gap=0, bottom_gap=0) -> Box:
+        self.width = self.width - (left_gap + right_gap)
+        self.height = self.height - (top_gap + bottom_gap)
+        self.center = np.array([self.center[0] + (left_gap - right_gap)/2,
+                               self.center[1] + (bottom_gap - top_gap)/2,
+                               0])
+        return self
+
+    # ---
+
+    def set_center(self, value):
+        self.center = value
+        return self
+
+    def set_width(self, value):
+        self.width = value
+        return self
+
+    def set_height(self, value):
+        self.height = value
+        return self
+
+    def set_arrange(self, value: str | None):
+        self.arrange = None if value == "none" else value
+        return self
+
+    def set_arrange_buff(self, value):
+        self.arrange_buff = value
+        return self
+
+    def null(self, value=True):
+        self.is_null = value
+        return self
+
+    # ---
+
+    def get_left(self):
+        return self.center + self.width/2*LEFT
+
+    def get_right(self):
+        return self.center + self.width/2*RIGHT
+
+    def get_top(self):
+        return self.center + self.height/2*UP
+
+    def get_bottom(self):
+        return self.center + self.height/2*DOWN
+
+    def get_corner(self, x_direction, y_direction):
+        return self.center+self.width/2*x_direction+self.height/2*y_direction
+
+    # ---
+
+    def __eq__(self, other_box):
+        if self.is_unique or other_box.is_unique:
+            return False
+        return (np.all(self.center == other_box.center) and
+                self.width == other_box.width and
+                self.height == other_box.height and
+                self.arrange == other_box.arrange and
+                self.arrange_buff == other_box.arrange_buff and
+                self.is_null == other_box.is_null)
+
+    def __repr__(self):
+        c = f"[{self.center[0]:.2g}, {self.center[1]:.2g}]"
+        return f"Box(center={c}, width={self.width:.2g}, height={self.height:.2g}, arrange={self.arrange}, is_null={self.is_null})"
+
+
+class NamedBoxes:
+    def __init__(self, **boxes):
+        """
+        Parameters
+        ----------
+        **boxes : dict
+            Named boxes
+        """
+        for name, box in boxes.items():
+            self.add(name, box)
+
+    def add(self, name, box):
+        setattr(self, name, box)
+
+    def set_current_box(self, box_or_box_name):
+        """
+        TODO(bersp): Documentation.
+        TODO(bersp): Handle errors.
+        """
+
+        if isinstance(box_or_box_name, Box):
+            setattr(self, "active", box_or_box_name)
+        else:
+            setattr(self, "active", self.__dict__[box_or_box_name])
+
+    def remove_all_mobjects(self):
+        """Remove all mobjects from all boxes in the slide layout."""
+        for _, box in self.__dict__.items():
+            box.remove_all_mobjects()
+
+    def get_bbox_mo(self):
+        """Return a VGroup containing all the bounding boxes of the all boxes."""
+        o = VGroup()
+        for _, box in self.__dict__.items():
+            o += box.get_bbox_mo()
+        return o
+
+    def __repr__(self):
+        s = ''
+        for name, box in self.__dict__.items():
+            s += f"{name} -> {box}\n"
+
+        return s

yerba-0.0.3a0.dev2/yerba/base/image.py

@@ -0,0 +1,186 @@
+import os
+import re
+import subprocess
+import shutil
+import uuid
+from manim import VGroup, Rectangle
+from xml.etree import ElementTree
+from PIL import Image
+
+from ..managers.color_manager import ColorManager
+from ..base.ytext import Ytex
+from ..utils.constants import UL, PX, SLIDE_X_RAD, SLIDE_Y_RAD
+
+
+class ImageSvgBase(VGroup):
+    # TODO(bersp): Implement .rotate to imgs
+    def __init__(self, filename, width, height, draft_mode):
+
+        self.filename = filename
+        self.basename = os.path.basename(filename)
+        self.draft_mode = draft_mode
+
+        colors = ColorManager()
+
+        rec = (Rectangle(width=width, height=height)
+               .set_stroke(opacity=0)
+               .set_fill(color=colors.get_color("BLACK"), opacity=0.8))
+
+        if draft_mode:
+            tex_filename = filename.replace("_", r"\\_")
+            tex_filename = fr"\\texttt{{{tex_filename}}}"
+            super().__init__(
+                rec,
+                Ytex(tex_filename, color=colors.get_color("BLACK")).move_to(
+                     rec).set(width=width*0.9)
+            )
+        else:
+            super().__init__(rec)
+
+    def _manim_to_svg_coords(self):
+        x0, y0 = self.get_corner(UL)[:2]
+        x0 = (SLIDE_X_RAD+x0)*PX
+        y0 = (SLIDE_Y_RAD-y0)*PX
+        w = self.width*PX
+        h = self.height*PX
+
+        return x0, y0, w, h
+
+    def _get_width_and_height(self, width, height,
+                              file_width, file_height):
+
+        ERR = ValueError(
+            r"width or height must be numbers or percentages like '90%'"
+        )
+
+        porcentage_pattern = r"(^\d+(\.\d+)?)%$"
+
+        if isinstance(width, str):
+            m = re.match(porcentage_pattern, width)
+            if m:
+                self.width_units = "box"
+                width = float(m[1])/100
+            else:
+                raise ERR
+
+        if isinstance(height, str):
+            m = re.match(porcentage_pattern, height)
+            if m:
+                self.height_units = "box"
+                height = float(m[1])/100
+            else:
+                raise ERR
+
+        if not ((isinstance(width, (int, float)) or width is None) and
+                (isinstance(height, (int, float)) or height is None)):
+            raise ERR
+
+        if width is not None and height is None:
+            height = file_height/file_width*width
+        elif width is None and height is not None:
+            width = file_width/file_height*height
+        else:
+            raise ValueError(
+                "You have to specify either 'width' or 'height', and not both")
+
+        return width, height
+
+
+class ImageSvg(ImageSvgBase):
+    def __init__(self, filename, width=None, height=None,
+                 draft_mode=False, **_):
+
+        fw, fh = Image.open(filename).size
+        width, height = self._get_width_and_height(width, height, fw, fh)
+
+        super().__init__(filename, width, height, draft_mode)
+
+    def get_svg_str(self):
+        x0, y0, w, h = self._manim_to_svg_coords()
+        img_base64 = (
+            subprocess.run(["base64", self.filename],
+                           stdout=subprocess.PIPE)
+            .stdout.decode("utf-8").replace("\n", "")
+        )
+        s = (f'<image width="{w}" height="{h}" x="{x0}" y="{y0}" '
+             f'href="data:image/png;base64,{img_base64}"/>')
+
+        return s
+
+
+class ImagePDFSvg(ImageSvgBase):
+    def __init__(self, filename, width=None, height=None,
+                 backend='poppler', draft_mode=False, **_):
+        if not shutil.which("inkscape"):
+            raise FileNotFoundError("Inkscape is required to use PDF images.")
+
+        svg_str_raw = self._get_svg_str_raw(filename, backend)
+        self.xml_tree = ElementTree.fromstring(svg_str_raw)
+
+        unique_prefix = f"{uuid.uuid4().hex[:8]}_"
+        self._rename_ids(self.xml_tree, unique_prefix)
+
+        fw, fh = self.xml_tree.get('width'), self.xml_tree.get('height')
+        if fw is not None and fh is not None:
+            fw = float(fw.replace("pt", ""))
+            fh = float(fh.replace("pt", ""))
+        else:
+            raise ValueError("An error occurred while parsing the PDF "
+                             f"file {filename!r} to SVG.")
+
+        width, height = self._get_width_and_height(width, height, fw, fh)
+
+        super().__init__(filename, width, height, draft_mode)
+
+    def get_svg_str(self):
+        x0, y0, w, h = self._manim_to_svg_coords()
+
+        self.xml_tree.set("x", str(x0))
+        self.xml_tree.set("y", str(y0))
+        self.xml_tree.set("width", str(w))
+        self.xml_tree.set("height", str(h))
+
+        s = ElementTree.tostring(self.xml_tree, encoding='unicode')
+        return s
+
+    def _get_svg_str_raw(self, filename, backend):
+        assert backend == "poppler" or backend == "internal", (
+            "Backend must be 'poppler' or 'internal'"
+        )
+        opts = ["--export-plain-svg",
+                "--export-type=svg",
+                "--export-filename=-"]
+        if backend == "poppler":
+            opts.append("--pdf-poppler")
+        s = subprocess.run(["inkscape", *opts, filename],
+                           stdout=subprocess.PIPE, stderr=open(os.devnull, "w")
+                           ).stdout.decode("utf-8")
+
+        return s
+
+    def _rename_ids(self, root, prefix):
+        ids_map = {}
+        for elem in root.iter():
+            if 'id' in elem.attrib:
+                old_id = elem.get('id')
+                new_id = prefix + old_id
+                elem.set('id', new_id)
+                ids_map[old_id] = new_id
+
+        if not ids_map:
+            return
+
+        escaped_ids: list[str] = list(map(re.escape, ids_map.keys()))
+
+        pattern = re.compile(r"#(" + "|".join(escaped_ids) + r")\b")
+
+        def replace_id(m):
+            old = m.group(1)
+            return "#" + ids_map[old]
+
+        for elem in root.iter():
+            for attr_name in list(elem.attrib.keys()):
+                attr_value = elem.attrib[attr_name]
+                if "#" in attr_value:  # Quick verification to not apply re if not necessary
+                    new_attr_value = pattern.sub(replace_id, attr_value)
+                    elem.set(attr_name, new_attr_value)