copy from scribble

.gitignore

@@ -0,0 +1,11 @@
+.idea
+__pycache__
+.venv
+.ruff_cache
+
+
+*.dot
+*.svg
+.config
+*.pdf
+*.png

app.py

@@ -1,469 +1,80 @@
 import marimo
 
-__generated_with = "0.9.2"
+__generated_with = "0.9.30"
 app = marimo.App()
 
 
 @app.cell
-def __():
+def __init():
     import marimo as mo
 
-    mo.md("# Welcome to marimo! 🌊🍃")
-    return (mo,)
+    from pyscribble import create
 
-
-@app.cell
-def __(mo):
-    slider = mo.ui.slider(1, 22)
-    return (slider,)
+    return create, mo
 
 
 @app.cell
-def __(mo, slider):
+def __input_name(mo):
+    name = mo.ui.text(placeholder="Name...")
     mo.md(
         f"""
-        marimo is a **reactive** Python notebook.
-
-        This means that unlike traditional notebooks, marimo notebooks **run
-        automatically** when you modify them or
-        interact with UI elements, like this slider: {slider}.
-
-        {"##" + "🍃" * slider.value}
+        Enter the name of the guest: {name}
         """
     )
-    return
-
-
-@app.cell(hide_code=True)
-def __(mo):
-    mo.accordion(
-        {
-            "Tip: disabling automatic execution": mo.md(
-                rf"""
-            marimo lets you disable automatic execution: just go into the
-            notebook settings and set
-
-            "Runtime > On Cell Change" to "lazy".
-
-            When the runtime is lazy, after running a cell, marimo marks its
-            descendants as stale instead of automatically running them. The
-            lazy runtime puts you in control over when cells are run, while
-            still giving guarantees about the notebook state.
-            """
-            )
-        }
-    )
-    return
-
-
-@app.cell(hide_code=True)
-def __(mo):
-    mo.md(
-        """
-        Tip: This is a tutorial notebook. You can create your own notebooks
-        by entering `marimo edit` at the command line.
-        """
-    ).callout()
-    return
-
-
-@app.cell(hide_code=True)
-def __(mo):
-    mo.md(
-        """
-        ## 1. Reactive execution
-
-        A marimo notebook is made up of small blocks of Python code called
-        cells.
-
-        marimo reads your cells and models the dependencies among them: whenever
-        a cell that defines a global variable  is run, marimo
-        **automatically runs** all cells that reference that variable.
-
-        Reactivity keeps your program state and outputs in sync with your code,
-        making for a dynamic programming environment that prevents bugs before they
-        happen.
-        """
-    )
-    return
-
-
-@app.cell(hide_code=True)
-def __(changed, mo):
-    (
-        mo.md(
-            f"""
-            **✨ Nice!** The value of `changed` is now {changed}.
-
-            When you updated the value of the variable `changed`, marimo
-            **reacted** by running this cell automatically, because this cell
-            references the global variable `changed`.
-
-            Reactivity ensures that your notebook state is always
-            consistent, which is crucial for doing good science; it's also what
-            enables marimo notebooks to double as tools and  apps.
-            """
-        )
-        if changed
-        else mo.md(
-            """
-            **🌊 See it in action.** In the next cell, change the value of the
-            variable  `changed` to `True`, then click the run button.
-            """
-        )
-    )
-    return
+    return (name,)
 
 
 @app.cell
-def __():
-    changed = False
-    return (changed,)
-
-
-@app.cell(hide_code=True)
-def __(mo):
-    mo.accordion(
-        {
-            "Tip: execution order": (
-                """
-                The order of cells on the page has no bearing on
-                the order in which cells are executed: marimo knows that a cell
-                reading a variable must run after the cell that  defines it. This
-                frees you to organize your code in the way that makes the most
-                sense for you.
-                """
-            )
-        }
-    )
-    return
-
-
-@app.cell(hide_code=True)
-def __(mo):
-    mo.md(
-        """
-        **Global names must be unique.** To enable reactivity, marimo imposes a
-        constraint on how names appear in cells: no two cells may define the same
-        variable.
-        """
-    )
-    return
-
-
-@app.cell(hide_code=True)
-def __(mo):
-    mo.accordion(
-        {
-            "Tip: encapsulation": (
-                """
-                By encapsulating logic in functions, classes, or Python modules,
-                you can minimize the number of global variables in your notebook.
-                """
-            )
-        }
-    )
-    return
-
-
-@app.cell(hide_code=True)
-def __(mo):
-    mo.accordion(
-        {
-            "Tip: private variables": (
-                """
-                Variables prefixed with an underscore are "private" to a cell, so
-                they can be defined by multiple cells.
-                """
-            )
-        }
-    )
-    return
-
-
-@app.cell(hide_code=True)
-def __(mo):
+def __input_function(mo):
+    options = ["tanh((-1+2j)*z)", "sinh(3*z)", "exp((-1+2j)*z)"]
+    dropdown = mo.ui.dropdown(options=options, value="sinh(3*z)")
     mo.md(
-        """
-        ## 2. UI elements
-
-        Cells can output interactive UI elements. Interacting with a UI
-        element **automatically triggers notebook execution**: when
-        you interact with a UI element, its value is sent back to Python, and
-        every cell that references that element is re-run.
-
-        marimo provides a library of UI elements to choose from under
-        `marimo.ui`.
+        f"""
+        Enter the complex function: {dropdown}
         """
     )
-    return
-
-
-@app.cell
-def __(mo):
-    mo.md("""**🌊 Some UI elements.** Try interacting with the below elements.""")
-    return
-
-
-@app.cell
-def __(mo):
-    icon = mo.ui.dropdown(["🍃", "🌊", "✨"], value="🍃")
-    return (icon,)
-
-
-@app.cell
-def __(icon, mo):
-    repetitions = mo.ui.slider(1, 16, label=f"number of {icon.value}: ")
-    return (repetitions,)
-
-
-@app.cell
-def __(icon, repetitions):
-    icon, repetitions
-    return
+    return dropdown, options
 
 
 @app.cell
-def __(icon, mo, repetitions):
-    mo.md("# " + icon.value * repetitions.value)
-    return
-
-
-@app.cell(hide_code=True)
-def __(mo):
-    mo.md(
-        """
-        ## 3. marimo is just Python
-
-        marimo cells parse Python (and only Python), and marimo notebooks are
-        stored as pure Python files — outputs are _not_ included. There's no
-        magical syntax.
-
-        The Python files generated by marimo are:
-
-        - easily versioned with git, yielding minimal diffs
-        - legible for both humans and machines
-        - formattable using your tool of choice,
-        - usable as Python  scripts, with UI  elements taking their default
-        values, and
-        - importable by other modules (more on that in the future).
-        """
-    )
-    return
-
-
-@app.cell(hide_code=True)
-def __(mo):
+def __input_event(mo):
+    event = mo.ui.text(placeholder="Event...")
     mo.md(
-        """
-        ## 4. Running notebooks as apps
-
-        marimo notebooks can double as apps. Click the app window icon in the
-        bottom-right to see this notebook in "app view."
-
-        Serve a notebook as an app with `marimo run` at the command-line.
-        Of course, you can use marimo just to level-up your
-        notebooking, without ever making apps.
+        f"""
+        Enter the name of the event: {event}
         """
     )
-    return
-
-
-@app.cell(hide_code=True)
-def __(mo):
-    mo.md(
-        """
-        ## 5. The `marimo` command-line tool
-
-        **Creating and editing notebooks.** Use
-
-        ```
-        marimo edit
-        ```
-
-        in a terminal to start the marimo notebook server. From here
-        you can create a new notebook or edit existing ones.
-
-
-        **Running as apps.** Use
-
-        ```
-        marimo run notebook.py
-        ```
+    return (event,)
 
-        to start a webserver that serves your notebook as an app in read-only mode,
-        with code cells hidden.
 
-        **Convert a Jupyter notebook.** Convert a Jupyter notebook to a marimo
-        notebook using `marimo convert`:
-
-        ```
-        marimo convert your_notebook.ipynb > your_app.py
-        ```
-
-        **Tutorials.** marimo comes packaged with tutorials:
-
-        - `dataflow`: more on marimo's automatic execution
-        - `ui`: how to use UI elements
-        - `markdown`: how to write markdown, with interpolated values and
-           LaTeX
-        - `plots`: how plotting works in marimo
-        - `sql`: how to use SQL
-        - `layout`: layout elements in marimo
-        - `fileformat`: how marimo's file format works
-        - `markdown-format`: for using `.md` files in marimo
-        - `for-jupyter-users`: if you are coming from Jupyter
+@app.cell
+def __output(create, dropdown, event, mo, name):
+    from io import BytesIO
 
-        Start a tutorial with `marimo tutorial`; for example,
+    fig = create(name=name.value, fct=dropdown.value, event=event.value, n=100)
 
-        ```
-        marimo tutorial dataflow
-        ```
+    img = fig.to_image(format="png")
+    # print(img)
+    data = BytesIO(img)
 
-        In addition to tutorials, we have examples in our
-        [our GitHub repo](https://www.github.com/marimo-team/marimo/tree/main/examples).
-        """
+    # Create a download button for the Plotly graph
+    download_btn = mo.download(
+        data=data,
+        filename=f"{name.value}_{event.value}_plot.png",
+        label="Download",
+        mimetype="image/png",
     )
-    return
-
 
-@app.cell(hide_code=True)
-def __(mo):
+    # Display the plot and download button
     mo.md(
-        """
-        ## 6. The marimo editor
-
-        Here are some tips to help you get started with the marimo editor.
-        """
-    )
-    return
-
-
-@app.cell
-def __(mo, tips):
-    mo.accordion(tips)
-    return
-
-
-@app.cell(hide_code=True)
-def __(mo):
-    mo.md("""## Finally, a fun fact""")
-    return
-
+        f"""
+    {download_btn}
 
-@app.cell(hide_code=True)
-def __(mo):
-    mo.md(
-        """
-        The name "marimo" is a reference to a type of algae that, under
-        the right conditions, clumps together to form a small sphere
-        called a "marimo moss ball". Made of just strands of algae, these
-        beloved assemblages are greater than the sum of their parts.
-        """
+    {mo.ui.plotly(fig)}
+    """
     )
-    return
-
-
-@app.cell(hide_code=True)
-def __():
-    tips = {
-        "Saving": (
-            """
-            **Saving**
-
-            - _Name_ your app using the box at the top of the screen, or
-              with `Ctrl/Cmd+s`. You can also create a named app at the
-              command line, e.g., `marimo edit app_name.py`.
-
-            - _Save_ by clicking the save icon on the bottom right, or by
-              inputting `Ctrl/Cmd+s`. By default marimo is configured
-              to autosave.
-            """
-        ),
-        "Running": (
-            """
-            1. _Run a cell_ by clicking the play ( ▷ ) button on the top
-            right of a cell, or by inputting `Ctrl/Cmd+Enter`.
-
-            2. _Run a stale cell_  by clicking the yellow run button on the
-            right of the cell, or by inputting `Ctrl/Cmd+Enter`. A cell is
-            stale when its code has been modified but not run.
-
-            3. _Run all stale cells_ by clicking the play ( ▷ ) button on
-            the bottom right of the screen, or input `Ctrl/Cmd+Shift+r`.
-            """
-        ),
-        "Console Output": (
-            """
-            Console output (e.g., `print()` statements) is shown below a
-            cell.
-            """
-        ),
-        "Creating, Moving, and Deleting Cells": (
-            """
-            1. _Create_ a new cell above or below a given one by clicking
-                the plus button to the left of the cell, which appears on
-                mouse hover.
-
-            2. _Move_ a cell up or down by dragging on the handle to the 
-                right of the cell, which appears on mouse hover.
-
-            3. _Delete_ a cell by clicking the trash bin icon. Bring it
-                back by clicking the undo button on the bottom right of the
-                screen, or with `Ctrl/Cmd+Shift+z`.
-            """
-        ),
-        "Disabling Automatic Execution": (
-            """
-            Via the notebook settings (gear icon) or footer panel, you
-            can disable automatic execution. This is helpful when
-            working with expensive notebooks or notebooks that have
-            side-effects like database transactions.
-            """
-        ),
-        "Disabling Cells": (
-            """
-            You can disable a cell via the cell context menu.
-            marimo will never run a disabled cell or any cells that depend on it.
-            This can help prevent accidental execution of expensive computations
-            when editing a notebook.
-            """
-        ),
-        "Code Folding": (
-            """
-            You can collapse or fold the code in a cell by clicking the arrow
-            icons in the line number column to the left, or by using keyboard
-            shortcuts.
 
-            Use the command palette (`Ctrl/Cmd+k`) or a keyboard shortcut to
-            quickly fold or unfold all cells.
-            """
-        ),
-        "Code Formatting": (
-            """
-            If you have [ruff](https://github.com/astral-sh/ruff) installed,
-            you can format a cell with the keyboard shortcut `Ctrl/Cmd+b`.
-            """
-        ),
-        "Command Palette": (
-            """
-            Use `Ctrl/Cmd+k` to open the command palette.
-            """
-        ),
-        "Keyboard Shortcuts": (
-            """
-            Open the notebook menu (top-right) or input `Ctrl/Cmd+Shift+h` to
-            view a list of all keyboard shortcuts.
-            """
-        ),
-        "Configuration": (
-            """
-           Configure the editor by clicking the gears icon near the top-right
-           of the screen.
-           """
-        ),
-    }
-    return (tips,)
+    # return fig, download_btn
 
 
 if __name__ == "__main__":

pyscribble/__init__.py

@@ -0,0 +1 @@
+from ._plot import create

pyscribble/_letter.py

@@ -0,0 +1,37 @@
+import numpy as np
+
+
+def letter(x):
+    # I have copied this data straight from
+    # https://github.com/asgeirbirkis/chebfun/blob/master/scribble.m
+    __letters = {
+        "A": [0, 0.4 + 1j, 0.8, 0.6 + 0.5j, 0.2 + 0.5j],
+        "B": [0, 1j, 0.8 + 0.9j, 0.8 + 0.6j, 0.5j, 0.8 + 0.4j, 0.8 + 0.1j, 0],
+        "C": [0.8 + 1j, 0.8j, 0.2j, 0.8],
+        "D": [0, 0.8 + 0.1j, 0.8 + 0.9j, 1j, 0],
+        "E": [0.8 + 1j, 1j, 0.5j, 0.5j + 0.7, 0.5j, 0, 0.8],
+        "F": [0.8 + 1j, 1j, 0.5j, 0.5j + 0.7, 0.5j, 0],
+        "G": [0.8 + 1j, 0.8j, 0.2j, 0.6, 0.6 + 0.5j, 0.4 + 0.5j, 0.8 + 0.5j],
+        "H": [0, 1j, 0.5j, 0.5j + 0.8, 0.8 + 1j, 0.8],
+        "I": [0, 0.8, 0.4, 0.4 + 1j, 1j, 0.8 + 1j],
+        "J": [0, 0.4, 0.4 + 1j, 1j, 0.8 + 1j],
+        "K": [0, 1j, 0.5j, 0.8 + 1j, 0.5j, 0.8],
+        "L": [1j, 0, 0.8],
+        "M": [0, 0.1 + 1j, 0.4, 0.7 + 1j, 0.8],
+        "N": [0, 1j, 0.8, 0.8 + 1j],
+        "O": [0, 1j, 0.8 + 1j, 0.8, 0],
+        "Q": [0, 1j, 0.8 + 1j, 0.8, 0.6 + 0.2j, 0.9 - 0.1j, 0.8, 0],
+        "P": [0, 1j, 0.8 + 1j, 0.8 + 0.5j, 0.5j],
+        "R": [0, 1j, 0.8 + 1j, 0.8 + 0.6j, 0.5j, 0.8],
+        "S": [0.8 + 1j, 0.9j, 0.6j, 0.8 + 0.4j, 0.8 + 0.1j, 0],
+        "T": [0.4, 0.4 + 1j, 1j, 0.8 + 1j],
+        "U": [1j, 0.1, 0.7, 0.8 + 1j],
+        "V": [1j, 0.4, 0.8 + 1j],
+        "W": [1j, 0.2, 0.4 + 1j, 0.6, 0.8 + 1j],
+        "X": [1j, 0.8, 0.4 + 0.5j, 0.8 + 1j, 0],
+        "Y": [1j, 0.4 + 0.5j, 0.8 + 1j, 0.4 + 0.5j, 0.4],
+        "Z": [1j, 0.8 + 1j, 0, 0.8],
+        " ": [],
+    }
+
+    return np.array(__letters[x.upper()])

pyscribble/_plot.py

@@ -0,0 +1,114 @@
+import plotly.graph_objs as go
+from plotly.subplots import make_subplots
+
+from ._scribble import series
+
+
+# Create the figure with subplots: 2 rows, 1 column
+def __create_fig():
+    fig = make_subplots(
+        rows=2,
+        cols=1,
+        row_heights=[0.5, 0.5],  # Top half and bottom half should be equal
+        vertical_spacing=0.1,  # Some spacing between the top and bottom sections
+        subplot_titles=["", ""],  # No title for the top subplot
+    )
+    return fig
+
+
+def __create_annotation(fig, word):
+    # Add the upside-down word as an annotation in the top subplot
+    fig.add_annotation(
+        x=0.5,  # X position (center)
+        y=1,  # Y position at the top of the subplot
+        text=word,  # The word to display
+        showarrow=False,  # No arrow needed
+        font=dict(size=20, color="blue"),  # Text styling: large, blue font
+        textangle=180,  # Rotate text by 180 degrees (upside down)
+        align="center",  # Center alignment
+        valign="middle",  # Vertical alignment (centered)
+        row=1,
+        col=1,  # Place in the top subplot
+    )
+
+
+def __remove_axis(fig):
+    # Update layout settings
+    fig.update_layout(
+        plot_bgcolor="white",  # White background for clean look
+        paper_bgcolor="white",  # White paper background
+        showlegend=False,  # No legend needed
+        margin=dict(l=30, r=30, t=30, b=30),  # Margins around the plot
+    )
+
+    # Update axes settings for the top subplot (hide grid, ticks, and lines)
+    fig.update_xaxes(
+        row=1,
+        col=1,
+        showgrid=False,
+        zeroline=False,
+        showticklabels=False,
+        showline=False,
+    )
+    fig.update_yaxes(
+        row=1,
+        col=1,
+        showgrid=False,
+        zeroline=False,
+        showticklabels=False,
+        showline=False,
+    )
+
+    # Update axes settings for the bottom subplot (show gridlines and labels)
+    fig.update_xaxes(
+        row=2,
+        col=1,
+        showgrid=True,
+        zeroline=False,
+        showticklabels=False,
+        showline=False,
+    )
+    fig.update_yaxes(
+        row=2,
+        col=1,
+        showgrid=True,
+        zeroline=False,
+        showticklabels=False,
+        showline=False,
+    )
+    return fig
+
+
+def __plot_letters(fig, d):
+    # Create traces for each segment
+    traces = []
+
+    for segment in d:
+        trace = go.Scatter(
+            x=segment.real,  # Real part of the complex number
+            y=segment.imag,  # Imaginary part of the complex number
+            mode="markers+lines",  # Display both markers and lines
+            showlegend=False,
+            line={"width": 3, "color": "blue"},  # Line style
+            marker={"size": 3, "color": "blue"},  # Marker style
+        )
+        traces.append(trace)
+
+    # Add all traces to the bottom subplot
+    for trace in traces:
+        fig.add_trace(trace, row=2, col=1)
+
+
+def create(name, fct, event, n=100):
+    # Create the figure with subplots: 2 rows, 1 column
+    fig = __create_fig()
+    __create_annotation(fig, word=f"{name}<br>{fct}<br>{event}")
+
+    segments = list(series(name, n=n, str=fct))
+
+    # d is now a list of list. Flatten it
+    # d = list(chain.from_iterable(d))
+
+    __plot_letters(fig, segments)
+    __remove_axis(fig)
+    return fig

pyscribble/_scribble.py

@@ -0,0 +1,31 @@
+from itertools import chain
+
+import numexpr as ne
+import numpy as np
+
+from ._letter import letter
+
+
+def series(string, n, str):
+    segments = []
+    for i, _letter in enumerate(string):
+        # move pts to the correction position in a word
+        pts = letter(_letter) + i
+
+        # move pts to unit square
+        pts = 2 * pts / len(string) - 1
+
+        segments.append(ne.evaluate(str, local_dict={"z": list(__segment(pts, n=n))}))
+
+    # segments is a list of list, flatten it
+    return list(chain.from_iterable(segments))
+
+
+def __segment(points, n=100):
+    """
+    Each letter is a represented by a bunch of points a,b,c,d...
+    There are straight segments between two adjacent points
+    We represent each such segment as a collection of n auxilliary points
+    """
+    for a, b in zip(points[:-1], points[1:]):
+        yield np.linspace(a.real, b.real, n) + 1j * np.linspace(a.imag, b.imag, n)

requirements.txt

@@ -1,5 +1,4 @@
-marimo
-# Or a specific version
-# marimo>=0.9.0
-
-# Add other dependencies as needed
+numpy==2.1.3
+plotly==5.24.1
+numexpr==2.10.2
+kaleido