solara-ui 1.45.0__py3-none-any.whl

solara/website/components/markdown.py

@@ -0,0 +1,99 @@
+from typing import Callable, Dict, List, Union, cast
+
+import yaml
+import markdown
+import mkdocs_pycafe
+import pymdownx.superfences
+
+import solara
+from solara.components.markdown import formatter, _no_deep_copy_emojione
+
+
+# We want to separate metadata from the markdown files before rendering them, which solara.Markdown doesn't support
+@solara.component
+def MarkdownWithMetadata(content: str, unsafe_solara_execute=True):
+    cleanups = solara.use_ref(cast(List[Callable[[], None]], []))
+    if "---" in content:
+        pre_content, raw_metadata, post_content = content.split("---")
+        metadata: Dict[str, Union[str, List[str]]] = yaml.safe_load(raw_metadata)
+
+        if len(pre_content) == 0:
+            content = post_content
+        else:
+            content = pre_content + post_content
+
+        if "title" not in metadata.keys():
+            metadata["title"] = content.split("#")[1].split("\n")[0]
+
+        for key, value in metadata.items():
+            if key == "title":
+                solara.Title(value)
+            elif ":" in key:
+                solara.Meta(property=key, content=value)
+            else:
+                solara.Meta(name=key, content=value)
+
+    def make_markdown_object():
+        return markdown.Markdown(  # type: ignore
+            extensions=[
+                "pymdownx.highlight",
+                "pymdownx.superfences",
+                "pymdownx.emoji",
+                "toc",  # so we get anchors for h1 h2 etc
+                "tables",
+            ],
+            extension_configs={
+                "pymdownx.emoji": {
+                    "emoji_index": _no_deep_copy_emojione,
+                },
+                "pymdownx.superfences": {
+                    "custom_fences": [
+                        {
+                            "name": "mermaid",
+                            "class": "mermaid",
+                            "format": pymdownx.superfences.fence_div_format,
+                        },
+                        {
+                            "name": "solara",
+                            "class": "",
+                            "validator": mkdocs_pycafe.validator,
+                            "format": mkdocs_pycafe.formatter(
+                                type="solara", next_formatter=formatter(unsafe_solara_execute, cleanups.current), inside_last_div=False
+                            ),
+                        },
+                        {
+                            "name": "python",
+                            "class": "highlight",
+                            "validator": mkdocs_pycafe.validator,
+                            "format": mkdocs_pycafe.formatter(
+                                type="solara", next_formatter=formatter(unsafe_solara_execute, cleanups.current), inside_last_div=False
+                            ),
+                        },
+                    ],
+                },
+            },
+        )
+
+    md_parser = solara.use_memo(make_markdown_object, dependencies=[unsafe_solara_execute])
+
+    def cleanup_wrapper():
+        def cleanup():
+            for cleanup in cleanups.current:
+                cleanup()
+
+        return cleanup
+
+    solara.use_effect(cleanup_wrapper, [])
+
+    with solara.v.Html(
+        tag="div",
+        style_="display: flex; flex-direction: row; justify-content: center; gap: 15px; max-width: 90%; margin: 0 auto;",
+        attributes={"id": "markdown-to-navigate"},
+    ):
+        solara.Markdown(content, unsafe_solara_execute=unsafe_solara_execute, style="flex-grow: 1; max-width: min(100%, 1024px);", md_parser=md_parser)
+        MarkdownNavigation(id="markdown-to-navigate").key("markdown-nav" + str(hash(content)))
+
+
+@solara.component_vue("markdown_nav.vue")
+def MarkdownNavigation(id: str):
+    pass

solara/website/components/markdown_nav.vue

@@ -0,0 +1,34 @@
+<template>
+    <v-list dense :style="`margin: 40px 24px 0 24px; position: sticky; top: 88px; align-self: flex-start;`" class="d-none d-lg-inline-block">
+        <v-list-item
+            v-for="(element, index) in this.sections"
+            :key="index"
+            :href="'#' + element.id"
+            :style="'padding-left: ' + (16 + (element.nodeName[1] - 1) * 20) + 'px;'"
+        >
+            <v-list-item-content>
+                <v-list-item-title>
+                    {{ element.innerText }}
+                </v-list-item-title>
+            </v-list-item-content>
+        </v-list-item>
+    </v-list>
+</template>
+<script>
+module.exports = {
+    mounted() {
+        this.getSections();
+    },
+    methods: {
+        getSections() {
+            const parentToSearch = document.getElementById(this.id);
+            this.sections = parentToSearch.querySelectorAll('h1, h2, h3, h4');
+        },
+    },
+    data() {
+        return {
+            sections: []
+        }
+    }
+}
+</script>

solara/website/components/notebook.py

@@ -0,0 +1,171 @@
+import ast
+import linecache
+from pathlib import Path
+from typing import Any, Dict
+
+import IPython
+import nbformat
+
+import solara
+import solara.components.applayout
+import solara.toestand
+from solara.components.markdown import ExceptionGuard
+
+HERE = Path(__file__).parent
+
+
+def execute_notebook(path: Path):
+    nb: nbformat.NotebookNode = nbformat.read(path, 4)
+    stat = path.stat()
+    scope: Dict[str, Any] = {}
+    for cell_index, cell in enumerate(nb.cells):
+        cell_index += 1  # used 1 based
+        cell.scope_snapshot = {}
+        if cell.cell_type == "code":
+            if cell.source.startswith("## solara: skip"):
+                continue
+
+            def execute(cell=cell):
+                source = cell.source
+                cell_path = f"app.ipynb input cell {cell_index}"
+                entry = (
+                    stat.st_size,
+                    stat.st_mtime,
+                    [line + "\n" for line in source.splitlines()],
+                    cell_path,
+                )
+
+                linecache.cache[cell_path] = entry
+                code = ast.parse(source, cell_path, "exec")
+                value = None
+                with solara.Column():
+                    if code.body:
+                        last_statement = code.body[-1]
+                        if isinstance(last_statement, ast.Expr):
+                            code.body.pop()
+                            last = ast.Expression(last_statement.value)
+                            exec(compile(code, "<string>", mode="exec"), scope)
+                            value = eval(compile(last, "<string>", mode="eval"), scope)
+                        else:
+                            exec(compile(code, "<string>", mode="exec"), scope)
+                    import matplotlib_inline.backend_inline
+
+                    matplotlib_inline.backend_inline.flush_figures()
+                scope_snapshot = {**scope}
+                cell.__dict__["scope_snapshot"] = scope_snapshot
+                return value
+
+            # every cell gets a snapshot of the scope
+            # avoid the buggy setitem of NotebookNode
+            # which causes an recursion error
+            yield cell_index, cell, execute
+        elif cell.cell_type == "markdown":
+            # last_expressions.append(None)
+            yield cell_index, cell, lambda: None
+        else:
+            raise ValueError(f"Unknown cell type: {cell.cell_type}, supported types are: code, markdown")
+
+
+@solara.component
+def NotebookExecute(notebook_path: Path, show_last_expressions=False, auto_show_page=False):
+    import IPython.core.pylabtools as pylabtools
+
+    shell = IPython.get_ipython().kernel.shell
+
+    # TODO: there is a change the cleanup will not be called
+    pylabtools.select_figure_formats(shell, ["png"])
+
+    def cleanup():
+        def _cleanup():
+            from matplotlib.figure import Figure
+
+            png_formatter = shell.display_formatter.formatters["image/png"]
+            png_formatter.pop(Figure)
+
+        return _cleanup
+
+    solara.use_effect(cleanup, [])
+    values = list(solara.use_memo(lambda: execute_notebook(notebook_path)))
+
+    last_page = None
+
+    solara.components.applayout.should_use_embed.provide(True)
+    with solara.Column(style={"max-width": "100%"}) as main:
+        for cell_index, cell, executor in values:
+            cell_index += 1  # used 1 based
+            if cell.cell_type == "code":
+                if cell.source.startswith("## solara: skip"):
+                    continue
+                solara.Markdown(
+                    f"""
+```python
+{cell.source}
+```"""
+                )
+                # we execute here, such that any side effect (display, etc)
+                # will be done under the context of the Column
+                with ExceptionGuard():
+                    with solara.AppLayout(navigation=False, toolbar_dark=True):
+                        # we don't want to listen to reactive variables
+                        copy = set(solara.toestand.thread_local.reactive_used or [])
+                        try:
+                            last_expression = executor()
+                        finally:
+                            solara.toestand.thread_local.reactive_used = copy
+                    scope = cell.scope_snapshot
+                    page = scope.get("Page")
+                    if auto_show_page and page != last_page and page is not None:
+                        page()
+                    else:
+                        if show_last_expressions:
+                            if last_expression is not None:
+                                solara.display(last_expression)
+                last_page = page
+            elif cell.cell_type == "markdown":
+                solara.Markdown(cell.source)
+            else:
+                raise ValueError(f"Unknown cell type: {cell.cell_type}, supported types are: code, markdown")
+    return main
+
+
+@solara.component
+def Notebook(notebook_path: Path, show_last_expressions=False, auto_show_page=False, execute=True, outputs={}):
+    if execute:
+        return NotebookExecute(notebook_path, show_last_expressions, auto_show_page)
+    else:
+        with solara.Column(style={"max-width": "1024px"}) as main:
+            nb: nbformat.NotebookNode = nbformat.read(notebook_path, 4)
+            for cell_index, cell in enumerate(nb.cells):
+                cell_index += 1
+                if cell.cell_type == "code":
+                    if cell.source.startswith("## solara: skip"):
+                        continue
+                    solara.Markdown(
+                        f"""
+```python
+{cell.source}
+```"""
+                    )
+                    if cell.outputs:
+                        for output in cell.outputs:
+                            if output.output_type == "display_data":
+                                solara.display(output.data, raw=True)
+                            elif output.output_type == "execute_result":
+                                if "text/html" in output.data:
+                                    solara.display(output.data, raw=True)
+                    else:
+                        cell_id = str(cell.id)
+                        output = outputs.get(cell_id) or outputs.get(cell_index)
+                        if output is None:
+                            if cell_id in outputs or cell_index in outputs:
+                                pass  # explicit None
+                            else:
+                                solara.display(f"Output missing for cell: {cell_index} id {cell_id}")
+                        else:
+                            solara.display(output)
+
+                elif cell.cell_type == "markdown":
+                    solara.Markdown(cell.source)
+                else:
+                    raise ValueError(f"Unknown cell type: {cell.cell_type}, supported types are: code, markdown")
+        return main

solara/website/components/sidebar.py

@@ -0,0 +1,105 @@
+import solara
+
+
+@solara.component
+def Sidebar():
+    route_current, all_routes = solara.use_route(-1)
+    router = solara.use_router()
+    if route_current is None:
+        return solara.Error("Page not found")
+
+    # Pick out documentation route, so we can use this on any page
+    for route in all_routes:
+        if route.path == "documentation":
+            all_routes = route.children
+            break
+
+    with solara.v.List(
+        expand=True,
+        nav=True,
+        style_="height: 100%; max-height: 100vh; display: flex; flex-direction: column; background-color: var(--color-material-background); overflow-y: auto;",
+    ) as main:
+        with solara.v.ListItemGroup(v_model=router.path):
+            # e.g. getting_started, examples, components, api, advanced, faq
+            for route in all_routes:
+                if len(route.children) == 1 or route.path == "/":
+                    with solara.Link("/documentation/" + route.path if route.path != "/" else "/documentation"):
+                        with solara.v.ListItem(value="/documentation/" + route.path if route.path != "/" else "/documentation"):
+                            if route.path == "/":
+                                solara.v.ListItemIcon(children=[solara.v.Icon(children=["mdi-home"])])
+                            solara.v.ListItemTitle(style_="padding: 0 20px;", children=[route.label])
+                else:
+                    path_top_level = "/documentation/" + route.path
+                    top_level_expanded = router.path.startswith(path_top_level)
+                    with solara.v.ListGroup(
+                        v_slots=[
+                            {
+                                "name": "activator",
+                                "children": solara.v.ListItemTitle(
+                                    children=[route.label],
+                                    style_="padding: 0 20px;",
+                                ),
+                            }
+                        ],
+                        value=top_level_expanded,
+                        eager=True,  # better for SEO
+                    ):
+                        for item in route.children:
+                            label = item.label
+                            if item.path == "/" and route.path in ["examples", "api", "components"]:
+                                # the 'homepage' of the subpage are named Overview
+                                label = "Overview"
+                            path_sub = "/documentation/" + route.path + "/" + item.path
+                            sub_should_be_expanded = router.path.startswith(path_sub)
+                            if item.children != [] and any([c.label is not None and c.path != "/" for c in item.children]):
+                                with solara.v.ListGroup(
+                                    v_slots=[
+                                        {
+                                            "name": "activator",
+                                            "children": solara.v.ListItemTitle(
+                                                children=[label],
+                                            ),
+                                        }
+                                    ],
+                                    sub_group=True,
+                                    no_action=True,
+                                    eager=True,  # better for SEO
+                                    value=sub_should_be_expanded,
+                                ):
+                                    for subitem in item.children:
+                                        # skip the 'homepage' of the examples only
+                                        if subitem.path == "/" and route.path not in ["getting_started", "advanced"]:
+                                            continue
+                                        path = (
+                                            "/documentation/" + route.path + "/" + item.path + "/" + (subitem.path if subitem.path != "/" else "")
+                                            if item.path != "fullscreen"
+                                            else "/apps/" + subitem.path
+                                        )
+                                        with solara.Link(
+                                            path,
+                                        ):
+                                            with solara.v.ListItem(dense=True, style_="margin-left: 40px; padding: 0 20px;", value=path):
+                                                solara.v.ListItemContent(
+                                                    children=[subitem.label],
+                                                )
+                            else:
+                                path = "/documentation/" + route.path + ("/" + item.path if item.path != "/" else "")
+                                with solara.Link(path):
+                                    with solara.v.ListItem(dense=True, style_="padding: 0 20px;", value=path):
+                                        solara.v.ListItemContent(
+                                            children=[label],
+                                        )
+            with solara.Link("/contact"):
+                with solara.v.ListItem(value="/contact"):
+                    solara.v.ListItemIcon(children=[solara.v.Icon(children=["mdi-email"])])
+                    solara.v.ListItemTitle(style_="padding: 0 20px;", children=["Contact"])
+            with solara.Link("/changelog"):
+                with solara.v.ListItem(value="/changelog"):
+                    solara.v.ListItemIcon(children=[solara.v.Icon(children=["mdi-history"])])
+                    solara.v.ListItemTitle(style_="padding: 0 20px;", children=["Changelog"])
+            with solara.Link("/roadmap"):
+                with solara.v.ListItem(value="/roadmap"):
+                    solara.v.ListItemIcon(children=[solara.v.Icon(children=["mdi-road"])])
+                    solara.v.ListItemTitle(style_="padding: 0 20px;", children=["Roadmap"])
+
+    return main