60class Content:
 61    """
 62    A class to build and render HTML content.
 63
 64    Methods:
 65        clear(): Clears the current content.
 66        add_script(name: str, script: str): Adds a script with a given name.
 67        add_heading(text: str, tag: str = "h3", icon: str = None, **kwargs): Adds a heading with an optional icon.
 68        add_text(text: str, tag: str = "p", **kwargs): Adds a paragraph or span of text.
 69        add_list(items: list, ordered=False, **kwargs): Adds an ordered or unordered list.
 70        add_image(src: str, alt: str = "", **kwargs): Adds an image from a URL or local source.
 71        add_svg(svg: str, **kwargs): Adds an SVG element.
 72        add_plotly(json: str, **kwargs): Adds a Plotly chart.
 73        add_altair(json: str, **kwargs): Adds an Altair chart.
 74        add_div(div: str, **kwargs): Adds a div element.
 75        add_fig(src: Figure, alt: str = "", as_svg=True, **kwargs): Adds a Matplotlib figure.
 76        render(): Renders the content as a pretty-formatted HTML string.
 77    """
 78    def __init__(self):
 79        self.content = ""
 80        self.scripts = {}
 81        self.grid_cols = 0
 82
 83    def clear(self):
 84        """Clears the current content."""
 85        self.content = ""
 86
 87    def add_script(self, name: str, script: str):
 88        """
 89        Adds a script with a given name.
 90        
 91        Args:
 92            name (str): The name of the script.
 93            script (str): The script content.
 94        """
 95        self.scripts[name] = script
 96
 97    def add_heading(self, text: str, tag: str = "h3", icon: str = None, **kwargs):
 98        """
 99        Adds a heading with an optional icon.
100        
101        Args:
102            text (str): The heading text.
103            tag (str, optional): The HTML tag for the heading (default is "h3").
104            icon (str, optional): The icon class for the heading.
105            **kwargs: Additional style and class attributes.
106        
107        Raises:
108            ValueError: If the tag is not a valid heading tag.
109        """
110        if tag not in ["h1", "h2", "h3", "h4", "h5"]:
111            raise ValueError("Invalid tag, the tag must be one of h1, h2, h3, h4 or h5")
112
113        s = _parse_style_class(kwargs)
114        self.content += (
115            f"<{tag} {s}><i class='{icon}'></i> {text}</{tag}>"
116            if icon
117            else f"<{tag} {s}>{text}</{tag}>"
118        )
119
120    def add_text(self, text: str, tag: str = "p", **kwargs):
121        """
122        Adds a paragraph or span of text.
123        
124        Args:
125            text (str): The text content.
126            tag (str, optional): The HTML tag for the text (default is "p").
127            **kwargs: Additional style and class attributes.
128        
129        Raises:
130            ValueError: If the tag is not a valid text tag.
131        """
132        if tag not in ["p", "span"]:
133            raise ValueError("Invalid tag, the tag must be one of p or span")
134
135        s = _parse_style_class(kwargs)
136        self.content += f"""<{tag} {s}>{text}</{tag}>"""
137
138    def add_list(self, items: list, ordered=False, **kwargs):
139        """
140        Adds an ordered or unordered list.
141        
142        Args:
143            items (list): A list of items to be added to the list.
144            ordered (bool, optional): Whether the list should be ordered (default is False).
145            **kwargs: Additional style and class attributes.
146        """
147        list_tag = "ol" if ordered else "ul"
148        s = _parse_style_class(kwargs)
149        list_items = "\n".join([f"<li>{item}</li>" for item in items])
150        self.content += f"<{list_tag} {s}>\n{list_items}\n</{list_tag}>"
151
152    def add_image(self, src: str, alt: str = "", **kwargs):
153        """
154        Adds an image from a URL or local source.
155        
156        Args:
157            src (str): The source URL or local path of the image.
158            alt (str, optional): The alt text for the image (default is "").
159            **kwargs: Additional style and class attributes.
160        
161        Raises:
162            Exception: If the image cannot be fetched from the URL.
163        """
164        if 'class' not in kwargs:
165            kwargs['class'] = []
166        elif isinstance(kwargs['class'], str):
167            kwargs['class'] = [kwargs['class']]
168        kwargs['class'].append('img-fluid')
169
170        if src.startswith(('http://', 'https://')):
171            response = requests.get(src)
172            if response.status_code == 200:
173                image_data = response.content
174            else:
175                raise Exception(f"Failed to fetch image from URL: {src}")
176        else:
177            with open(src, "rb") as f:
178                image_data = f.read()
179
180        image_base64 = base64.b64encode(image_data).decode("utf-8")
181        image_src = f"data:image/png;base64,{image_base64}"
182
183        s = _parse_style_class(kwargs)
184        self.content += f"""<img src="{image_src}" alt="{alt}" {s}>"""
185
186    def add_svg(self, svg: str, **kwargs):
187        """
188        Adds an SVG element.
189        
190        Args:
191            svg (str): The SVG content.
192            **kwargs: Additional style and class attributes.
193        """
194        if 'class' not in kwargs:
195            kwargs['class'] = []
196        elif isinstance(kwargs['class'], str):
197            kwargs['class'] = [kwargs['class']]
198        kwargs['class'].append('img-fluid')
199
200        s = _parse_style_class(kwargs)
201        self.content += f"""<div {s}>{svg}</div>"""
202
203    def add_plotly(self, json: str, **kwargs):
204        """
205        Adds a Plotly chart.
206        
207        Args:
208            json (str): The Plotly chart data in JSON format.
209            **kwargs: Additional style and class attributes.
210        """
211        if 'class' not in kwargs:
212            kwargs['class'] = []
213        elif isinstance(kwargs['class'], str):
214            kwargs['class'] = [kwargs['class']]
215        kwargs['class'].append('img-fluid')
216
217        s = _parse_style_class(kwargs)
218
219        j = json.replace("'", "\u2019")
220        chart_id = "chart-" + str(uuid.uuid4())
221        self.content += f"""<div {s} id='{chart_id}'></div>
222            <script>var Plotjson = '{j}';
223            var figure = JSON.parse(Plotjson);
224            Plotly.newPlot('{chart_id}', figure.data, figure.layout);</script>"""
225
226    def add_altair(self, json: str, **kwargs):
227        """
228        Adds an Altair chart.
229        
230        Args:
231            json (str): The Altair chart data in JSON format.
232            **kwargs: Additional style and class attributes.
233        """
234        if 'class' not in kwargs:
235            kwargs['class'] = []
236        elif isinstance(kwargs['class'], str):
237            kwargs['class'] = [kwargs['class']]
238        kwargs['class'].append('img-fluid')
239
240        s = _parse_style_class(kwargs)
241
242        chart_id = "chart-" + str(uuid.uuid4())
243        self.content += f"""<div {s} id='{chart_id}'></div>
244        <script>var opt = {{renderer: "svg"}};
245        vegaEmbed("#{chart_id}", {json} , opt);</script>"""
246
247    def add_div(self, div: str, **kwargs):
248        """
249        Adds a div element.
250        
251        Args:
252            div (str): The div content.
253            **kwargs: Additional style and class attributes.
254        """
255        s = _parse_style_class(kwargs)
256        self.content += f"""<div {s}>{div}</div>"""
257
258    def add_fig(self, src: Figure, alt: str = "", as_svg=True, **kwargs):
259        """
260        Adds a Matplotlib figure.
261        
262        Args:
263            src (Figure): The Matplotlib figure object.
264            alt (str, optional): The alt text for the image (default is "").
265            as_svg (bool, optional): Whether to render the figure as SVG (default is True).
266            **kwargs: Additional style and class attributes.
267        """
268        if 'class' not in kwargs:
269            kwargs['class'] = []
270        elif isinstance(kwargs['class'], str):
271            kwargs['class'] = [kwargs['class']]
272        kwargs['class'].append('img-fluid')
273        s = _parse_style_class(kwargs)
274
275        buffer = BytesIO()
276        if as_svg:
277            src.savefig(buffer, format='svg')
278            svg = buffer.getvalue()
279            svg = svg.replace(b'\n', b'').decode('utf-8')
280            self.content += f"""<div {s}>{svg}</div>"""
281        else:
282            src.savefig(buffer, format='png')
283            image_data = buffer.getvalue()
284            image_base64 = base64.b64encode(image_data).decode("utf-8")
285            image_src = f"data:image/png;base64,{image_base64}"
286            self.content += f"""<img src="{image_src}" alt="{alt}" {s}>"""
287        buffer.close()
288
289    def render(self):
290        """
291        Renders the content as a pretty-formatted HTML string.
292        
293        Returns:
294            str: The rendered HTML content.
295        """
296        html = f"""<div>{self.content}</div>"""
297        soup = BeautifulSoup(html, "html.parser")
298        ident_content = soup.prettify()
299        return ident_content

 37class Slide:
 38    """
 39    A class representing a slide in the presentation.
 40
 41    Attributes:
 42        content (str): The HTML content of the slide.
 43        center (bool): Whether the slide content should be centered.
 44        kwargs (dict): Additional attributes for the slide element.
 45    """
 46    def __init__(self, center=False, **kwargs):
 47        """
 48        Initializes a new Slide object.
 49
 50        Args:
 51            center (bool): Whether the slide content should be centered (default is False).
 52            **kwargs: Additional attributes for the slide element.
 53        """
 54        self.content = ""
 55        self.center = center
 56        self.kwargs = kwargs
 57
 58    def add_title(self, text: str, tag: str = "h3", icon: str = None, **kwargs):
 59        """
 60        Adds a title to the slide.
 61
 62        Args:
 63            text (str): The title text.
 64            tag (str, optional): The HTML tag for the title (default is "h3").
 65            icon (str, optional): The icon class for the title.
 66            **kwargs: Additional style and class attributes.
 67        """
 68        c = Content()
 69        c.add_heading(text, tag, icon, **kwargs)
 70        row = "<div class='row'><div class='col-12 mx-auto'>"
 71        self.content += row + c.render() + "</div></div>"
 72
 73    def add_content(self, content: list, columns=None, styles: list = None):
 74        """
 75        Adds content to the slide.
 76
 77        Args:
 78            content (list): A list of content elements (str or Figure).
 79            columns (list, optional): A list of column sizes for the content elements (default is [12]).
 80            styles (list, optional): A list of style dictionaries for the content elements.
 81        """
 82        if columns is None:
 83            columns = [12]
 84
 85        _check_styles(styles, content, columns)
 86
 87        row = "<div class='row'>"
 88        for i in range(len(content)):
 89            col = content[i]
 90            if isinstance(col, (str, Figure)):
 91                col = _check_content_type(col)
 92                if styles and len(styles) > i:
 93                    col = f"<div class='col-md-{columns[i]}' {_parse_style_class(styles[i])}>{col}</div>"
 94                else:
 95                    col = f"<div class='col-md-{columns[i]}'>{col}</div>"
 96            row += col
 97        self.content += row + "</div>"
 98
 99    def add_card(self, cards: list, styles: list = None):
100        """
101        Adds cards to the slide.
102
103        Args:
104            cards (list): A list of card dictionaries with 'image', 'title', and 'text' keys.
105            styles (list, optional): A list of style dictionaries for the cards.
106        """
107        _check_styles(styles, cards)
108
109        if styles is None:
110            styles = [{'class': 'bg-info'}] * len(cards)
111
112        cards_html = ""
113        for card, style in zip(cards, styles):
114            if 'class' not in style:
115                style['class'] = []
116            elif isinstance(style['class'], str):
117                style['class'] = [style['class']]
118            style['class'].append('card h-100')
119
120            s = _parse_style_class(style)
121            card_html = ""
122            for key in card.keys():
123                if key == 'image':
124                    card_html += f'<img src="{card[key]}" class="card-img-top mx-auto" alt="">'
125                elif key == 'title':
126                    card_html += f'<h4 class="card-title">{card[key]}</h4>'
127                elif key == 'text':
128                    card[key] = _add_list_classes(card[key])
129                    card_html += f'<p class="card-text" style="font-size:60%">{card[key]}</p>'
130            cards_html += f"""
131            <div class="col">
132                <div {s}> 
133                    {card_html}
134                </div>
135            </div>"""
136        self.content += f"<div class='row'>{cards_html}</div>"
137
138    def add_title_page(self, title_page_content: dict, styles: list = None):
139        """
140        Adds a title page to the slide.
141
142        Args:
143            title_page_content (dict): A dictionary with 'title', 'subtitle', 'authors', and 'logo' keys.
144            styles (list, optional): A list of style dictionaries for the title, subtitle, authors, and logo.
145        """
146        title = title_page_content.get('title', '')
147        subtitle = title_page_content.get('subtitle', '')
148        authors = title_page_content.get('authors', '')
149        logo = title_page_content.get('logo', '')
150
151        _check_styles(styles, title_page_content)
152
153        if styles is None:
154            styles = []
155
156        title_s = _parse_style_class(styles[0]) if styles else ""
157        subtitle_s = _parse_style_class(styles[1]) if styles else ""
158        authors_s = _parse_style_class(styles[2]) if styles else ""
159        logo_s = _parse_style_class(styles[3]) if styles else ""
160
161        title_html = f'<div class="row"><div class="col-12"><h2 {title_s}>{title}</h2></div></div>' if title else ''
162        subtitle_html = f'<div class="row"><div class="col-12"><h3 {subtitle_s}>{subtitle}</h3></div></div>' if subtitle else ''
163        authors_html = f'<div class="col-9"><h4 {authors_s}>{authors}</h4></div>' if authors else ''
164        logo_html = f'<div class="col-3"><img src="{logo}" {logo_s}></div>' if logo else ''
165        authors_logo_html = f'<div class="row align-items-center">{authors_html}{logo_html}</div>'
166
167
168        title_page_html = f'<div class="title-page">{title_html}{subtitle_html}{authors_logo_html}</div>'
169        self.content += title_page_html
170
171    def render_slide_html(self):
172        """
173        Renders the slide as an HTML string.
174
175        Returns:
176            str: The HTML representation of the slide.
177        """
178        css_links = """
179        <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/reveal.js/4.4.0/reveal.min.css">
180        <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/reveal.js/4.4.0/theme/moon.min.css">
181        <link rel="stylesheet" href="https://stackpath.bootstrapcdn.com/bootstrap/4.5.2/css/bootstrap.min.css">
182        <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.2.1/css/all.min.css">
183        """
184        js_links = """
185        <script src="https://cdnjs.cloudflare.com/ajax/libs/reveal.js/4.4.0/reveal.js"></script>
186        <script src="https://cdnjs.cloudflare.com/ajax/libs/reveal.js/4.4.0/plugin/notes/notes.js"></script>
187        <script src="https://cdn.jsdelivr.net/npm/vega@5"></script>
188        <script src="https://cdn.jsdelivr.net/npm/vega-lite@4.8"></script>
189        <script src="https://cdn.jsdelivr.net/npm/vega-embed@6"></script>
190        <script src="https://cdn.plot.ly/plotly-2.17.1.min.js"></script>
191        <script src="https://cdnjs.cloudflare.com/ajax/libs/jquery/2.0.3/jquery.min.js"></script>
192        <script src="https://cdn.jsdelivr.net/npm/mathjax@3/es5/tex-mml-chtml.js"></script>
193        """
194
195        kwargs_str = ' '.join([f'{k}="{v}"' for k, v in self.kwargs.items()])
196        slide_html = f"""
197        <!DOCTYPE html>
198        <html lang="en">
199        <head>
200            <meta charset="UTF-8">
201            <meta name="viewport" content="width=device-width, initial-scale=1.0">
202            <title>Slide</title>
203            {css_links}
204            <style>
205                .reveal .slides section {{
206                    top: 0 !important;
207                }}
208            </style>
209        </head>
210        <body>
211            <div class="reveal">
212                <div class="slides">
213                    <section {kwargs_str} class='{'center' if self.center else ''}'>
214                        <div class='container' style='text-align: left;' >
215                            {self.content}
216                        </div>
217                    </section>
218                </div>
219            </div>
220            {js_links}
221            <script>
222                Reveal.initialize({{
223                    center: false,
224                    controls: true,
225                    progress: true,
226                    history: true,
227                    transition: 'slide',
228                    plugins: [RevealNotes]
229                }});
230            </script>
231        </body>
232        </html>
233        """
234        return slide_html
235
236    def save_slide_html(self, file_name):
237        """
238        Saves the slide as an HTML file.
239
240        Args:
241            file_name (str): The name of the file to save the slide as.
242        """
243        slide_html = self.render_slide_html()
244        with open(file_name, "w") as f:
245            f.write(slide_html)