nelsie

119class SlideDeck:
120    def __init__(
121        self,
122        *,
123        width: float = 1024,
124        height: float = 768,
125        bg_color: str = "white",
126        image_directory: str | None = None,
127        resources: Resources | None = None,
128        default_font: str = "sans-serif",
129        default_monospace_font: str = "monospace",
130        default_code_theme: str = "InspiredGitHub",
131        default_code_language: str | None = None,
132    ):
133        """
134        A top-level class of Nelsie. It represents a set of slides.
135
136        Arguments:
137        * width - default width of a slide (could be overriden for each slide)
138        * height - default width of a slide (could be overriden for each slide)
139        * bg_color - default background color a slide (could be overriden for each slide)
140        * image_directory - default path where images are searched for (could be overriden for each slide)
141        * resource - Resource instance, if None a new instance is created
142        * default_font - Name of default font
143        * default_monospace_font - Name of the default monospace font
144        * default_code_theme - Name of default theme for syntax highlighting (.code() method):
145            Available themes:
146            * "base16-ocean.dark"
147            * "base16-eighties.dark"
148            * "base16-mocha.dark"
149            * "base16-ocean.light"
150            * "InspiredGitHub"
151            * "Solarized (dark)"
152            * "Solarized (light)"
153        * default_code_language - Default language to use for syntax highlighting (.code() method)
154        """
155        if resources is None:
156            resources = Resources()
157
158        self.width = width
159        self.height = height
160        self.bg_color = bg_color
161        self.image_directory = image_directory
162        self.resources = resources
163        self.default_code_theme = default_code_theme
164        self.default_code_language = default_code_language
165        self._deck = nelsie_rs.Deck(default_font, default_monospace_font)
166        self._slides: List[Slide] = []
167
168    def set_style(self, name: str, style: TextStyle):
169        self._deck.set_style(self.resources._resources, name, style, False, None, None)
170
171    def update_style(self, name: str, style: TextStyle):
172        self._deck.set_style(self.resources._resources, name, style, True, None, None)
173
174    def get_style(self, name: str, step: int = 1) -> TextStyle:
175        return _data_to_text_style(self._deck.get_style(name, step, None, None))
176
177    def new_slide(
178        self,
179        *,
180        width: float | None = None,
181        height: float | None = None,
182        bg_color: str | None = None,
183        image_directory: str | None = None,
184        name: str = "",
185        debug_steps: bool = False,
186        debug_layout: bool | str = False,
187        counters: list[str] | None = None,
188        parent_slide: tuple[Slide, int] | None = None,
189        step_1: bool = True,
190    ) -> Slide:
191        """
192        Creates a new slide in the slide deck.
193        """
194        if width is None:
195            width = self.width
196        if height is None:
197            height = self.height
198        if bg_color is None:
199            bg_color = self.bg_color
200        if image_directory is None:
201            image_directory = self.image_directory
202        debug_layout = parse_debug_layout(debug_layout)
203        slide_id = self._deck.new_slide(width, height, bg_color, name, step_1, debug_steps, counters, parent_slide)
204
205        slide = Slide(self, slide_id, name, image_directory, debug_layout)
206        self._slides.append(slide)
207        return slide
208
209    def slide(
210        self,
211        *,
212        width: float | None = None,
213        height: float | None = None,
214        bg_color: str | None = None,
215        image_directory: str | None = None,
216        name: str = "",
217        debug_steps: bool = False,
218        debug_layout: bool | str = False,
219        counters: list[str] | None = None,
220        parent_slide: tuple[Slide, int] | None = None,
221        step_1: bool = True,
222    ):
223        """
224        Decorator for creating new slide.
225        It immediately calls the decorated function that should define content of the slide.
226        Slide is automatically added into the deck.
227
228        Example:
229        ```python
230        deck = SlideDeck()
231
232        @deck.slide()
233        def my_first_slide(slide):
234            slide.text("Hello!")
235        ```
236        """
237
238        def helper(fn):
239            slide = self.new_slide(
240                width=width,
241                height=height,
242                bg_color=bg_color,
243                image_directory=image_directory,
244                name=name,
245                debug_steps=debug_steps,
246                debug_layout=debug_layout,
247                counters=counters,
248                parent_slide=parent_slide,
249                step_1=step_1,
250            )
251            fn(slide)
252            return slide
253
254        return helper
255
256    def render(
257        self,
258        path: str | pathlib.Path | None,
259        output_format: Literal["pdf"] | Literal["svg"] | Literal["png"] = "pdf",
260        *,
261        verbose: int = 1,
262        compression_level: int = 1,
263        n_threads: int | None = None,
264    ) -> None | list[bytes]:
265        """
266        Render slides
267
268        If format is "pdf" then a single PDF file is created. If format is "svg" or "png" then
269        `path` specifies a directory where the slides are created as an individual files.
270
271        If `path` is None then objects are not written to the file system, and they are returned as python objects
272        from the method call.
273
274        `compression_level` defines the level of compression for PDF, allowed ranges are 0-10
275        (0 = no compression, 1 = fast compression, 10 = maximal compression)
276        """
277        assert 0 <= compression_level <= 10
278        if path:
279            path = str(path)
280        return self._deck.render(
281            self.resources._resources,
282            verbose,
283            output_format,
284            compression_level,
285            path,
286            n_threads,
287        )

10class InSteps(Generic[T]):
11    """
12    InSteps is a wrapper that allows to set a different values for each step.
13    InSteps defines values in "key" steps, in other steps the value remains until it is changed
14    another key step.
15
16    Example:
17    ```python
18    slide.box(..., bg_color=InSteps({1: "green", 4: "red"})
19    ```
20
21    Defines "green" background for steps 1, 2, 3; and "red" for step 4 and further.
22
23    InSteps can be also initialized by a list, then it defines values for first `n` steps,
24    where `n` is a length of the list. It means that `InSteps(["a", "b", "c"])` is equal to
25    `InSteps({1: "a", 2: "b", 3: "c"})`
26    """
27
28    def __init__(
29        self,
30        values: Sequence[T] | dict[Step | int, T],
31    ):
32        if isinstance(values, Sequence):
33            tmp = {}
34            prev = None
35            for i, v in enumerate(values):
36                if i != 0 and v == prev:
37                    continue
38                tmp[i + 1] = v
39                prev = v
40            values = tmp
41        elif not isinstance(values, dict):
42            raise ValueError("Invalid type for values")
43        self.in_step_values = values
44
45    def get(self, step: int, default: S = None) -> T | None:
46        v = self.in_step_values.get(step)
47        if v is not None:
48            return v
49        if step <= 0:
50            return default
51        return self.get(step - 1, default)
52
53    def map(self, fn):
54        return InSteps(
55            {step: fn(v) for step, v in self.in_step_values.items()},
56        )
57
58    def key_steps(self):
59        return self.in_step_values.keys()
60
61    def zip(self, other: "InSteps[S]") -> "InSteps[tuple[S, T]]":
62        keys = set(self.key_steps())
63        keys.update(other.key_steps())
64        return InSteps(
65            {step: (self.get(step), other.get(step)) for step in keys},
66        )

 37class Path:
 38    def __init__(
 39        self,
 40        *,
 41        stroke: Stroke | None = None,
 42        fill_color: str | None = None,
 43        arrow_start: Arrow | None = None,
 44        arrow_end: Arrow | None = None,
 45    ):
 46        self.stroke = stroke
 47        self.fill_color = fill_color
 48        self.commands = []
 49        self.points = []
 50        self.arrow_start = arrow_start
 51        self.arrow_end = arrow_end
 52
 53    @staticmethod
 54    def oval(
 55        x1: PathValue,
 56        y1: PathValue,
 57        x2: PathValue,
 58        y2: PathValue,
 59        *,
 60        stroke: Stroke | None = None,
 61        fill_color: str | None = None,
 62    ):
 63        path = Path(stroke=stroke, fill_color=fill_color)
 64        path.commands.append("oval")
 65        path.points = [x1, y1, x2, y2]
 66        return path
 67
 68    @property
 69    def last_point(self):
 70        """
 71        Returns a last point in the path, if path is empty, returns 0,0
 72        :return: A tuple (x, y)
 73        """
 74        if len(self.points) < 2:
 75            return 0, 0
 76        else:
 77            return self.points[-2], self.points[-1]
 78
 79    def close(self):
 80        self.commands.append("close")
 81        return self
 82
 83    def move_to(self, x: PathValue, y: PathValue):
 84        self.commands.append("move")
 85        self.points.append(x)
 86        self.points.append(y)
 87        return self
 88
 89    def move_by(self, x: PathValue, y: PathValue) -> "Path":
 90        """
 91        Perform a move relative to the last point of the path.
 92        If path is empty, it starts from 0,0
 93        """
 94        x_old, y_old = self.last_point
 95
 96        return self.move_to(x_old + x, y_old + y)
 97
 98    def line_to(self, x: PathValue, y: PathValue):
 99        self.commands.append("line")
100        self.points.append(x)
101        self.points.append(y)
102        return self
103
104    def line_by(self, x: PathValue, y: PathValue):
105        """
106        Draw a line relative to the last point of the path.
107        If path is empty, it starts from 0,0
108        """
109        x_old, y_old = self.last_point
110        return self.line_to(x_old + x, y_old + y)
111
112    def quad_to(self, x1: PathValue, y1: PathValue, x: PathValue, y: PathValue):
113        self.commands.append("quad")
114        self.points.append(x1)
115        self.points.append(y1)
116        self.points.append(x)
117        self.points.append(y)
118        return self
119
120    def cubic_to(
121        self,
122        x1: PathValue,
123        y1: PathValue,
124        x2: PathValue,
125        y2: PathValue,
126        x: PathValue,
127        y: PathValue,
128    ):
129        self.commands.append("cubic")
130        self.points.append(x1)
131        self.points.append(y1)
132        self.points.append(x2)
133        self.points.append(y2)
134        self.points.append(x)
135        self.points.append(y)
136        return self

14@dataclass
15class Stroke:
16    color: str
17    width: float = 1.0
18    dash_array: list[float] | None = None
19    dash_offset: float = 0.0

19@dataclass(frozen=True)
20class TextStyle:
21    font_family: str | list[str] | None = None
22    color: str | None = None
23    size: float | None = None
24    line_spacing: float | None = None
25    italic: bool | None = None
26    stretch: FontStretch | None = None
27    underline: bool | None = None
28    line_through: bool | None = None
29
30    # 1-1000; 400 = Normal, 700 = Bold
31    weight: int | None = None
32
33    # Init only fields
34    # These are used as helpers for initializing
35    # commonly used attributes
36    bold: InitVar[bool | None] = None
37
38    def __post_init__(self, bold: bool | None):
39        if self.size is not None:
40            assert self.size >= 0
41        if self.line_spacing is not None:
42            assert self.line_spacing >= 0
43        if self.weight is not None:
44            assert 1 <= self.weight <= 1000
45            if bold is not None:
46                raise Exception("Cannot set both `weight` and `bold` when creating a TextStyle")
47        if bold is not None:
48            # Workaround to set frozen attribute
49            super().__setattr__("weight", 700)
50
51    def merge(self, other: "TextStyle") -> "TextStyle":
52        assert isinstance(other, TextStyle)
53        return TextStyle(
54            *[b if b is not None else a for (a, b) in zip(unpack_dataclass(self), unpack_dataclass(other))]
55        )

18class Resources:
19    def __init__(
20        self,
21        *,
22        builtin_fonts: bool = True,
23        system_fonts: bool = False,
24        system_fonts_for_svg: bool = True,
25        default_code_syntaxes: bool = True,
26        default_code_themes: bool = True,
27    ):
28        self._resources = nelsie_rs.Resources(
29            system_fonts, system_fonts_for_svg, default_code_syntaxes, default_code_themes
30        )
31        if builtin_fonts:
32            self._resources.load_fonts_dir(BUILTIN_FONTS_DIR)
33            self._resources.set_generic_family("sans-serif", "DejaVu Sans")
34            self._resources.set_generic_family("monospace", "DejaVu Sans Mono")
35
36    def set_sans_serif(self, font_name):
37        self._resources.set_generic_family("sans-serif", font_name)
38
39    def set_monospace(self, font_name):
40        self._resources.set_generic_family("monospace", font_name)
41
42    def set_serif(self, font_name):
43        self._resources.set_generic_family("serif", font_name)
44
45    def load_code_syntax_dir(self, path: str):
46        self._resources.load_code_syntax_dir(path)
47
48    def load_code_theme_dir(self, path: str):
49        self._resources.load_code_theme_dir(path)
50
51    def load_fonts_dir(self, path: str):
52        self._resources.load_fonts_dir(path)
53
54    def syntaxes(self) -> list[tuple[str, list[str]]]:
55        return self._resources.syntaxes()
56
57    def themes(self) -> list[str]:
58        return self._resources.themes()

 7class FontStretch(IntEnum):
 8    UltraCondensed = 1
 9    ExtraCondensed = 2
10    Condensed = 3
11    SemiCondensed = 4
12    Normal = 5
13    SemiExpanded = 6
14    Expanded = 7
15    ExtraExpanded = 8
16    UltraExpanded = 9