Merge remote-tracking branch 'upstream/main' into fp/functors

.github/workflows/typos.yaml

@@ -13,4 +13,3 @@ jobs:
         uses: styfle/[email protected]
       - uses: actions/checkout@v4
       - uses: crate-ci/[email protected]
-name: Tests

optimization/05_portfolio_optimization.py

@@ -47,7 +47,7 @@ def _(mo):
         r"""
         ## Asset returns and risk
 
-        We will only model investments held for one period. The initial prices are $p_i > 0$. The end of period prices are $p_i^+ >0$. The asset (fractional) returns are $r_i = (p_i^+-p_i)/p_i$. The porfolio (fractional) return is $R = r^Tw$.
+        We will only model investments held for one period. The initial prices are $p_i > 0$. The end of period prices are $p_i^+ >0$. The asset (fractional) returns are $r_i = (p_i^+-p_i)/p_i$. The portfolio (fractional) return is $R = r^Tw$.
 
         A common model is that $r$ is a random variable with mean ${\bf E}r = \mu$ and covariance ${\bf E{(r-\mu)(r-\mu)^T}} = \Sigma$.
         It follows that $R$ is a random variable with ${\bf E}R = \mu^T w$ and ${\bf var}(R) = w^T\Sigma w$. In real-world applications, $\mu$ and $\Sigma$ are estimated from data and models, and $w$ is chosen using a library like CVXPY.

polars/10_strings.py

@@ -0,0 +1,1004 @@
+# /// script
+# requires-python = ">=3.12"
+# dependencies = [
+#     "altair==5.5.0",
+#     "marimo",
+#     "numpy==2.2.3",
+#     "polars==1.24.0",
+# ]
+# ///
+
+import marimo
+
+__generated_with = "0.11.17"
+app = marimo.App(width="medium")
+
+
+@app.cell(hide_code=True)
+def _(mo):
+    mo.md(
+        r"""
+        # Strings
+
+        _By [Péter Ferenc Gyarmati](http://github.com/peter-gy)_.
+
+        In this chapter we're going to dig into string manipulation. For a fun twist, we'll be mostly playing around with a dataset that every Polars user has bumped into without really thinking about it—the source code of the `polars` module itself. More precisely, we'll use a dataframe that pulls together all the Polars expressions and their docstrings, giving us a cool, hands-on way to explore the expression API in a truly data-driven manner.
+
+        We'll cover parsing, length calculation, case conversion, and much more, with practical examples and visualizations. Finally, we will combine various techniques you learned in prior chapters to build a fully interactive playground in which you can execute the official code examples of Polars expressions.
+        """
+    )
+    return
+
+
+@app.cell(hide_code=True)
+def _(mo):
+    mo.md(
+        r"""
+        ## 🛠️  Parsing & Conversion
+
+        Let's warm up with one of the most frequent use cases: parsing raw strings into various formats.
+        We'll take a tiny dataframe with metadata about Python packages represented as raw JSON strings and we'll use Polars string expressions to parse the attributes into their true data types.
+        """
+    )
+    return
+
+
+@app.cell
+def _(pl):
+    pip_metadata_raw_df = pl.DataFrame(
+        [
+            '{"package": "polars", "version": "1.24.0", "released_at": "2025-03-02T20:31:12+0000", "size_mb": "30.9"}',
+            '{"package": "marimo", "version": "0.11.14", "released_at": "2025-03-04T00:28:57+0000", "size_mb": "10.7"}',
+        ],
+        schema={"raw_json": pl.String},
+    )
+    pip_metadata_raw_df
+    return (pip_metadata_raw_df,)
+
+
+@app.cell(hide_code=True)
+def _(mo):
+    mo.md(r"""We can use the [`json_decode`](https://docs.pola.rs/api/python/stable/reference/series/api/polars.Series.str.json_decode.html) expression to parse the raw JSON strings into Polars-native structs and we can use the [unnest](https://docs.pola.rs/api/python/stable/reference/dataframe/api/polars.DataFrame.unnest.html) dataframe operation to have a dedicated column per parsed attribute.""")
+    return
+
+
+@app.cell
+def _(pip_metadata_raw_df, pl):
+    pip_metadata_df = pip_metadata_raw_df.select(json=pl.col('raw_json').str.json_decode()).unnest('json')
+    pip_metadata_df
+    return (pip_metadata_df,)
+
+
+@app.cell(hide_code=True)
+def _(mo):
+    mo.md(r"""This is already a much friendlier representation of the data we started out with, but note that since the JSON entries had only string attributes, all values are strings, even the temporal `released_at` and numerical `size_mb` columns.""")
+    return
+
+
+@app.cell(hide_code=True)
+def _(mo):
+    mo.md(r"""As we know that the `size_mb` column should have a decimal representation, we go ahead and use [`to_decimal`](https://docs.pola.rs/api/python/stable/reference/expressions/api/polars.Expr.str.to_decimal.html#polars.Expr.str.to_decimal) to perform the conversion.""")
+    return
+
+
+@app.cell
+def _(pip_metadata_df, pl):
+    pip_metadata_df.select(
+        'package',
+        'version',
+        pl.col('size_mb').str.to_decimal(),
+    )
+    return
+
+
+@app.cell(hide_code=True)
+def _(mo):
+    mo.md(
+        r"""
+        Moving on to the `released_at` attribute which indicates the exact time when a given Python package got released, we have a bit more options to consider. We can convert to `Date`, `DateTime`, and `Time` types based on the desired temporal granularity. The [`to_date`](https://docs.pola.rs/api/python/stable/reference/expressions/api/polars.Expr.str.to_date.html), [`to_datetime`](https://docs.pola.rs/api/python/stable/reference/expressions/api/polars.Expr.str.to_datetime.html), and [`to_time`](https://docs.pola.rs/api/python/stable/reference/expressions/api/polars.Expr.str.to_time.html) expressions are here to help us with the conversion, all we need is to provide the desired format string.
+
+        Since Polars uses Rust under the hood to implement all its expressions, we need to consult the [`chrono::format`](https://docs.rs/chrono/latest/chrono/format/strftime/index.html) reference to come up with appropriate format strings.
+
+        Here's a quick reference:
+
+        | Specifier | Meaning            |
+        |-----------|--------------------|
+        | `%Y`      | Year (e.g., 2025) |
+        | `%m`      | Month (01-12)     |
+        | `%d`      | Day (01-31)       |
+        | `%H`      | Hour (00-23)      |
+        | `%z`      | UTC offset        |
+
+        The raw strings we are working with look like `"2025-03-02T20:31:12+0000"`. We can match this using the `"%Y-%m-%dT%H:%M:%S%z"` format string.
+        """
+    )
+    return
+
+
+@app.cell
+def _(pip_metadata_df, pl):
+    pip_metadata_df.select(
+        'package',
+        'version',
+        release_date=pl.col('released_at').str.to_date('%Y-%m-%dT%H:%M:%S%z'),
+        release_datetime=pl.col('released_at').str.to_datetime('%Y-%m-%dT%H:%M:%S%z'),
+        release_time=pl.col('released_at').str.to_time('%Y-%m-%dT%H:%M:%S%z'),
+    )
+    return
+
+
+@app.cell(hide_code=True)
+def _(mo):
+    mo.md(r"""Alternatively, instead of using three different functions to perform the conversion to date, we can use a single one, [`strptime`](https://docs.pola.rs/api/python/stable/reference/expressions/api/polars.Expr.str.strptime.html) which takes the desired temporal data type as its first parameter.""")
+    return
+
+
+@app.cell
+def _(pip_metadata_df, pl):
+    pip_metadata_df.select(
+        'package',
+        'version',
+        release_date=pl.col('released_at').str.strptime(pl.Date, '%Y-%m-%dT%H:%M:%S%z'),
+        release_datetime=pl.col('released_at').str.strptime(pl.Datetime, '%Y-%m-%dT%H:%M:%S%z'),
+        release_time=pl.col('released_at').str.strptime(pl.Time, '%Y-%m-%dT%H:%M:%S%z'),
+    )
+    return
+
+
+@app.cell(hide_code=True)
+def _(mo):
+    mo.md(r"""And to wrap up this section on parsing and conversion, let's consider a final scenario. What if we don't want to parse the entire raw JSON string, because we only need a subset of its attributes? Well, in this case we can leverage the [`json_path_match`](https://docs.pola.rs/api/python/stable/reference/expressions/api/polars.Expr.str.json_path_match.html) expression to extract only the desired attributes using standard [JSONPath](https://goessner.net/articles/JsonPath/) syntax.""")
+    return
+
+
+@app.cell
+def _(pip_metadata_raw_df, pl):
+    pip_metadata_raw_df.select(
+        package=pl.col("raw_json").str.json_path_match("$.package"),
+        version=pl.col("raw_json").str.json_path_match("$.version"),
+        release_date=pl.col("raw_json")
+        .str.json_path_match("$.size_mb")
+        .str.to_decimal(),
+    )
+    return
+
+
+@app.cell(hide_code=True)
+def _(mo):
+    mo.md(
+        r"""
+        ## 📊 Dataset Overview
+
+        Now that we got our hands dirty, let's consider a somewhat wilder dataset for the subsequent sections: a dataframe of metadata about every single expression in your current Polars module.
+
+        At the risk of stating the obvious, in the previous section, when we typed `pl.col('raw_json').str.json_decode()`, we accessed the `json_decode` member of the `str` expression namespace through the `pl.col('raw_json')` expression *instance*. Under the hood, deep inside the Polars source code, there is a corresponding `def json_decode(...)` method with a carefully authored docstring explaining the purpose and signature of the member.
+
+        Since Python makes module introspection simple, we can easily enumerate all Polars expressions and organize their metadata in `expressions_df`, to be used for all the upcoming string manipulation examples.
+        """
+    )
+    return
+
+
+@app.cell(hide_code=True)
+def _(pl):
+    def list_members(expr, namespace) -> list[dict]:
+        """Iterates through the attributes of `expr` and returns their metadata"""
+        members = []
+        for attrname in expr.__dir__():
+            is_namespace = attrname in pl.Expr._accessors
+            is_private = attrname.startswith("_")
+            if is_namespace or is_private:
+                continue
+
+            attr = getattr(expr, attrname)
+            members.append(
+                {
+                    "namespace": namespace,
+                    "member": attrname,
+                    "docstring": attr.__doc__,
+                }
+            )
+        return members
+
+
+    def list_expr_meta() -> list[dict]:
+        # Dummy expression instance to 'crawl'
+        expr = pl.lit("")
+        root_members = list_members(expr, "root")
+        namespaced_members: list[list[dict]] = [
+            list_members(getattr(expr, namespace), namespace)
+            for namespace in pl.Expr._accessors
+        ]
+        return sum(namespaced_members, root_members)
+
+
+    expressions_df = pl.from_dicts(list_expr_meta(), infer_schema_length=None).sort('namespace', 'member')
+    expressions_df
+    return expressions_df, list_expr_meta, list_members
+
+
+@app.cell(hide_code=True)
+def _(mo):
+    mo.md(r"""As the following visualization shows, `str` is one of the richest Polars expression namespaces with multiple dozens of functions in it.""")
+    return
+
+
+@app.cell(hide_code=True)
+def _(alt, expressions_df):
+    expressions_df.plot.bar(
+        x=alt.X("count(member):Q", title='Count of Expressions'),
+        y=alt.Y("namespace:N", title='Namespace').sort("-x"),
+    )
+    return
+
+
+@app.cell(hide_code=True)
+def _(mo):
+    mo.md(
+        r"""
+        ## 📏 Length Calculation
+
+        A common use case is to compute the length of a string. Most people associate string length exclusively with the number of characters the said string consists of; however, in certain scenarios it is useful to also know how much memory is required for storing, so how many bytes are required to represent the textual data.
+
+        The expressions [`len_chars`](https://docs.pola.rs/api/python/stable/reference/expressions/api/polars.Expr.str.len_chars.html) and [`len_bytes`](https://docs.pola.rs/api/python/stable/reference/expressions/api/polars.Expr.str.len_bytes.html) are here to help us with these calculations.
+
+        Below, we compute `docstring_len_chars` and `docstring_len_bytes` columns to see how many characters and bytes the documentation of each expression is made up of.
+        """
+    )
+    return
+
+
+@app.cell
+def _(expressions_df, pl):
+    docstring_length_df = expressions_df.select(
+        'namespace',
+        'member',
+        docstring_len_chars=pl.col("docstring").str.len_chars(),
+        docstring_len_bytes=pl.col("docstring").str.len_bytes(),
+    )
+    docstring_length_df
+    return (docstring_length_df,)
+
+
+@app.cell(hide_code=True)
+def _(mo):
+    mo.md(r"""As the dataframe preview above and the scatterplot below show, the docstring length measured in bytes is almost always bigger than the length expressed in characters. This is due to the fact that the docstrings include characters which require more than a single byte to represent, such as "╞" for displaying dataframe header and body separators.""")
+    return
+
+
+@app.cell
+def _(alt, docstring_length_df):
+    docstring_length_df.plot.point(
+        x=alt.X('docstring_len_chars', title='Docstring Length (Chars)'),
+        y=alt.Y('docstring_len_bytes', title='Docstring Length (Bytes)'),
+        tooltip=['namespace', 'member', 'docstring_len_chars', 'docstring_len_bytes'],
+    )
+    return
+
+
+@app.cell(hide_code=True)
+def _(mo):
+    mo.md(
+        r"""
+        ## 🔠 Case Conversion
+
+        Another frequent string transformation is lowercasing, uppercasing, and titlecasing. We can use [`to_lowercase`](https://docs.pola.rs/api/python/stable/reference/expressions/api/polars.Expr.str.to_lowercase.html), [`to_uppercase`](https://docs.pola.rs/api/python/stable/reference/expressions/api/polars.Expr.str.to_lowercase.html) and [`to_titlecase`](https://docs.pola.rs/api/python/stable/reference/expressions/api/polars.Expr.str.to_titlecase.html) for doing so.
+        """
+    )
+    return
+
+
+@app.cell
+def _(expressions_df, pl):
+    expressions_df.select(
+        member_lower=pl.col('member').str.to_lowercase(),
+        member_upper=pl.col('member').str.to_uppercase(),
+        member_title=pl.col('member').str.to_titlecase(),
+    )
+    return
+
+
+@app.cell(hide_code=True)
+def _(mo):
+    mo.md(
+        r"""
+        ## ➕ Padding
+
+        Sometimes we need to ensure that strings have a fixed-size character length. [`pad_start`](https://docs.pola.rs/api/python/stable/reference/expressions/api/polars.Expr.str.pad_start.html) and [`pad_end`](https://docs.pola.rs/api/python/stable/reference/expressions/api/polars.Expr.str.pad_end.html) can be used to fill the "front" or "back" of a string with a supplied character, while [`zfill`](https://docs.pola.rs/api/python/stable/reference/expressions/api/polars.Expr.str.zfill.html) is a utility for padding the start of a string with `"0"` until it reaches a particular length. In other words, `zfill` is a more specific version of `pad_start`, where the `fill_char` parameter is explicitly set to `"0"`.
+
+        In the example below we take the unique Polars expression namespaces and pad them so that they have a uniform length which you can control via a slider.
+        """
+    )
+    return
+
+
+@app.cell(hide_code=True)
+def _(mo):
+    padding = mo.ui.slider(0, 16, step=1, value=8, label="Padding Size")
+    return (padding,)
+
+
+@app.cell
+def _(expressions_df, padding, pl):
+    padded_df = expressions_df.select("namespace").unique().select(
+        "namespace",
+        namespace_front_padded=pl.col("namespace").str.pad_start(padding.value, "_"),
+        namespace_back_padded=pl.col("namespace").str.pad_end(padding.value, "_"),
+        namespace_zfilled=pl.col("namespace").str.zfill(padding.value),
+    )
+    return (padded_df,)
+
+
+@app.cell(hide_code=True)
+def _(mo, padded_df, padding):
+    mo.vstack([
+        padding,
+        padded_df,
+    ])
+    return
+
+
+@app.cell(hide_code=True)
+def _(mo):
+    mo.md(
+        r"""
+        ## 🔄 Replacing
+
+        Let's say we want to convert from `snake_case` API member names to `kebab-case`, that is, we need to replace the underscore character with a hyphen. For operations like that, we can use [`replace`](https://docs.pola.rs/api/python/stable/reference/expressions/api/polars.Expr.str.replace.html) and [`replace_all`](https://docs.pola.rs/api/python/stable/reference/expressions/api/polars.Expr.str.replace_all.html).
+
+        As the example below demonstrates, `replace` stops after the first occurrence of the to-be-replaced pattern, while `replace_all` goes all the way through and changes all underscores to hyphens resulting in the `kebab-case` representation we were looking for.
+        """
+    )
+    return
+
+
+@app.cell
+def _(expressions_df, pl):
+    expressions_df.select(
+        "member",
+        member_kebab_case_partial=pl.col("member").str.replace("_", "-"),
+        member_kebab_case=pl.col("member").str.replace_all("_", "-"),
+    ).sort(pl.col("member").str.len_chars(), descending=True)
+    return
+
+
+@app.cell(hide_code=True)
+def _(mo):
+    mo.md(
+        r"""
+        A related expression is [`replace_many`](https://docs.pola.rs/api/python/stable/reference/expressions/api/polars.Expr.str.replace_many.html), which accepts *many* pairs of to-be-matched patterns and corresponding replacements and uses the [Aho–Corasick algorithm](https://en.wikipedia.org/wiki/Aho%E2%80%93Corasick_algorithm) to carry out the operation with great performance.
+
+        In the example below we replace all instances of `"min"` with `"minimum"` and `"max"` with `"maximum"` using a single expression.
+        """
+    )
+    return
+
+
+@app.cell
+def _(expressions_df, pl):
+    expressions_df.select(
+        "member",
+        member_modified=pl.col("member").str.replace_many(
+            {
+                "min": "minimum",
+                "max": "maximum",
+            }
+        ),
+    )
+    return
+
+
+@app.cell(hide_code=True)
+def _(mo):
+    mo.md(
+        r"""
+        ## 🔍 Searching & Matching
+
+        A common need when working with strings is to determine whether their content satisfies some condition: whether it starts or ends with a particular substring or contains a certain pattern.
+
+        Let's suppose we want to determine whether a member of the Polars expression API is a "converter", such as `to_decimal`, identified by its `"to_"` prefix. We can use [`starts_with`](https://docs.pola.rs/api/python/stable/reference/expressions/api/polars.Expr.str.starts_with.html) to perform this check.
+        """
+    )
+    return
+
+
+@app.cell
+def _(expressions_df, pl):
+    expressions_df.select(
+        "namespace",
+        "member",
+        is_converter=pl.col("member").str.starts_with("to_"),
+    ).sort(-pl.col("is_converter").cast(pl.Int8))
+    return
+
+
+@app.cell(hide_code=True)
+def _(mo):
+    mo.md(
+        r"""
+        Throughout this course as you have gained familiarity with the expression API you might have noticed that some members end with an underscore such as `or_`, since their "body" is a reserved Python keyword.
+
+        Let's use [`ends_with`](https://docs.pola.rs/api/python/stable/reference/expressions/api/polars.Expr.str.ends_with.html) to find all the members which are named after such keywords.
+        """
+    )
+    return
+
+
+@app.cell
+def _(expressions_df, pl):
+    expressions_df.select(
+        "namespace",
+        "member",
+        is_escaped_keyword=pl.col("member").str.ends_with("_"),
+    ).sort(-pl.col("is_escaped_keyword").cast(pl.Int8))
+    return
+
+
+@app.cell(hide_code=True)
+def _(mo):
+    mo.md(
+        r"""
+        Now let's move on to analyzing the docstrings in a bit more detail. Based on their content we can determine whether a member is deprecated, accepts parameters, comes with examples, or references external URL(s) & related members.
+
+        As demonstrated below, we can compute all these boolean attributes using [`contains`](https://docs.pola.rs/api/python/stable/reference/expressions/api/polars.Expr.str.contains.html) to check whether the docstring includes a particular substring.
+        """
+    )
+    return
+
+
+@app.cell
+def _(expressions_df, pl):
+    expressions_df.select(
+        'namespace',
+        'member',
+        is_deprecated=pl.col('docstring').str.contains('.. deprecated', literal=True),
+        has_parameters=pl.col('docstring').str.contains('Parameters'),
+        has_examples=pl.col('docstring').str.contains('Examples'),
+        has_related_members=pl.col('docstring').str.contains('See Also'),
+        has_url=pl.col('docstring').str.contains('https?://'),
+    )
+    return
+
+
+@app.cell(hide_code=True)
+def _(mo):
+    mo.md(r"""For scenarios where we want to combine multiple substrings to check for, we can use the [`contains`](https://docs.pola.rs/api/python/stable/reference/expressions/api/polars.Expr.str.contains.html) expression to check for the presence of various patterns.""")
+    return
+
+
+@app.cell
+def _(expressions_df, pl):
+    expressions_df.select(
+        'namespace',
+        'member',
+        has_reference=pl.col('docstring').str.contains_any(['See Also', 'https://'])
+    )
+    return
+
+
+@app.cell(hide_code=True)
+def _(mo):
+    mo.md(
+        r"""
+        From the above analysis we could see that almost all the members come with code examples. It would be interesting to know how many variable assignments are going on within each of these examples, right? That's not as simple as checking for a pre-defined literal string containment though, because variables can have arbitrary names - any valid Python identifier is allowed. While the `contains` function supports checking for regular expressions instead of literal strings too, it would not suffice for this exercise because it only tells us whether there is at least a single occurrence of the sought pattern rather than telling us the exact number of matches.
+
+        Fortunately, we can take advantage of [`count_matches`](https://docs.pola.rs/api/python/stable/reference/expressions/api/polars.Expr.str.count_matches.html) to achieve exactly what we want. We specify the regular expression `r'[a-zA-Z_][a-zA-Z0-9_]* = '` according to the [`regex` Rust crate](https://docs.rs/regex/latest/regex/) to match Python identifiers and we leave the rest to Polars.
+
+        In `count_matches(r'[a-zA-Z_][a-zA-Z0-9_]* = ')`:
+
+        - `[a-zA-Z_]` matches a letter or underscore (start of a Python identifier).
+        - `[a-zA-Z0-9_]*` matches zero or more letters, digits, or underscores.
+        - ` = ` matches a space, equals sign, and space (indicating assignment).
+
+        This finds variable assignments like `x = ` or `df_result = ` in docstrings.
+        """
+    )
+    return
+
+
+@app.cell
+def _(expressions_df, pl):
+    expressions_df.select(
+        'namespace',
+        'member',
+        variable_assignment_count=pl.col('docstring').str.count_matches(r'[a-zA-Z_][a-zA-Z0-9_]* = '),
+    )
+    return
+
+
+@app.cell(hide_code=True)
+def _(mo):
+    mo.md(r"""A related application example is to *find* the first index where a particular pattern is present, so that it can be used for downstream processing such as slicing. Below we use the [`find`](https://docs.pola.rs/api/python/stable/reference/expressions/api/polars.Expr.str.find.html) expression to determine the index at which a code example starts in the docstring - identified by the Python shell substring `">>>"`.""")
+    return
+
+
+@app.cell
+def _(expressions_df, pl):
+    expressions_df.select(
+        'namespace',
+        'member',
+        code_example_start=pl.col('docstring').str.find('>>>'),
+    )
+    return
+
+
+@app.cell(hide_code=True)
+def _(mo):
+    mo.md(
+        r"""
+        ## ✂️ Slicing and Substrings
+
+        Sometimes we are only interested in a particular substring. We can use [`head`](https://docs.pola.rs/api/python/stable/reference/expressions/api/polars.Expr.str.head.html), [`tail`](https://docs.pola.rs/api/python/stable/reference/expressions/api/polars.Expr.str.tail.html) and [`slice`](https://docs.pola.rs/api/python/stable/reference/expressions/api/polars.Expr.str.slice.html) to extract a substring from the start, end, or between arbitrary indices.
+        """
+    )
+    return
+
+
+@app.cell
+def _(mo):
+    slice = mo.ui.slider(1, 50, step=1, value=25, label="Slice Size")
+    return (slice,)
+
+
+@app.cell
+def _(expressions_df, pl, slice):
+    sliced_df = expressions_df.select(
+        # First 25 chars
+        docstring_head=pl.col("docstring").str.head(slice.value),
+        # 50 chars after the first 25 chars
+        docstring_slice=pl.col("docstring").str.slice(slice.value, 2*slice.value),
+        # Last 25 chars
+        docstring_tail=pl.col("docstring").str.tail(slice.value),
+    )
+    return (sliced_df,)
+
+
+@app.cell
+def _(mo, slice, sliced_df):
+    mo.vstack([
+        slice,
+        sliced_df,
+    ])
+    return
+
+
+@app.cell(hide_code=True)
+def _(mo):
+    mo.md(
+        r"""
+        ## ➗ Splitting
+
+        Certain strings follow a well-defined structure and we might be only interested in some parts of them. For example, when dealing with `snake_cased_expression` member names we might be curious to get only the first, second, or $n^{\text{th}}$ word before an underscore. We would need to *split* the string at a particular pattern for downstream processing.
+
+        The [`split`](https://docs.pola.rs/api/python/stable/reference/expressions/api/polars.Expr.str.split.html), [`split_exact`](https://docs.pola.rs/api/python/stable/reference/expressions/api/polars.Expr.str.split_exact.html) and [`splitn`](https://docs.pola.rs/api/python/stable/reference/expressions/api/polars.Expr.str.splitn.html) expressions enable us to achieve this.
+
+        The primary difference between these string splitting utilities is that `split` produces a list of variadic length based on the number of resulting segments, `splitn` returns a struct with at least `0` and at most `n` fields while `split_exact` returns a struct of exactly `n` fields.
+        """
+    )
+    return
+
+
+@app.cell
+def _(expressions_df, pl):
+    expressions_df.select(
+        'member',
+        member_name_parts=pl.col('member').str.split('_'),
+        member_name_parts_n=pl.col('member').str.splitn('_', n=2),
+        member_name_parts_exact=pl.col('member').str.split_exact('_', n=2),
+    )
+    return
+
+
+@app.cell(hide_code=True)
+def _(mo):
+    mo.md(r"""As a more practical example, we can use the `split` expression with some aggregation to count the number of times a particular word occurs in member names across all namespaces. This enables us to create a word cloud of the API members' constituents!""")
+    return
+
+
+@app.cell(hide_code=True)
+def _(mo, wordcloud, wordcloud_height, wordcloud_width):
+    mo.vstack([
+        wordcloud_width,
+        wordcloud_height,
+        wordcloud,
+    ])
+    return
+
+
+@app.cell(hide_code=True)
+def _(mo):
+    wordcloud_width = mo.ui.slider(0, 64, step=1, value=32, label="Word Cloud Width")
+    wordcloud_height = mo.ui.slider(0, 32, step=1, value=16, label="Word Cloud Height")
+    return wordcloud_height, wordcloud_width
+
+
+@app.cell(hide_code=True)
+def _(alt, expressions_df, pl, random, wordcloud_height, wordcloud_width):
+    wordcloud_df = (
+        expressions_df.select(pl.col("member").str.split("_"))
+        .explode("member")
+        .group_by("member")
+        .agg(pl.len())
+        # Generating random x and y coordinates to distribute the words in the 2D space
+        .with_columns(
+            x=pl.col("member").map_elements(
+                lambda e: random.randint(0, wordcloud_width.value),
+                return_dtype=pl.UInt8,
+            ),
+            y=pl.col("member").map_elements(
+                lambda e: random.randint(0, wordcloud_height.value),
+                return_dtype=pl.UInt8,
+            ),
+        )
+    )
+
+    wordcloud = alt.Chart(wordcloud_df).mark_text(baseline="middle").encode(
+        x=alt.X("x:O", axis=None),
+        y=alt.Y("y:O", axis=None),
+        text="member:N",
+        color=alt.Color("len:Q", scale=alt.Scale(scheme="bluepurple")),
+        size=alt.Size("len:Q", legend=None),
+        tooltip=["member", "len"],
+    ).configure_view(strokeWidth=0)
+    return wordcloud, wordcloud_df
+
+
+@app.cell(hide_code=True)
+def _(mo):
+    mo.md(
+        r"""
+        ## 🔗 Concatenation & Joining
+
+        Often we would like to create longer strings from strings we already have. We might want to create a formatted, sentence-like string or join multiple existing strings in our dataframe into a single one.
+
+        The top-level [`concat_str`](https://docs.pola.rs/api/python/stable/reference/expressions/api/polars.concat_str.html) expression enables us to combine strings *horizontally* in a dataframe. As the example below shows, we can take the `member` and `namespace` column of each row and construct a `description` column in which each row will correspond to the value ``f"- Expression `{member}` belongs to namespace `{namespace}`"``.
+        """
+    )
+    return
+
+
+@app.cell
+def _(expressions_df, pl):
+    descriptions_df = expressions_df.sample(5).select(
+        description=pl.concat_str(
+            [
+                pl.lit("- Expression "),
+                pl.lit("`"),
+                "member",
+                pl.lit("`"),
+                pl.lit(" belongs to namespace "),
+                pl.lit("`"),
+                "namespace",
+                pl.lit("`"),
+            ],
+        )
+    )
+    descriptions_df
+    return (descriptions_df,)
+
+
+@app.cell(hide_code=True)
+def _(mo):
+    mo.md(
+        r"""
+        Now that we have constructed these bullet points through *horizontal* concatenation of strings, we can perform a *vertical* one so that we end up with a single string in which we have a bullet point on each line.
+
+        We will use the [`join`](https://docs.pola.rs/api/python/stable/reference/expressions/api/polars.join.html) expression to do so.
+        """
+    )
+    return
+
+
+@app.cell
+def _(descriptions_df, pl):
+    descriptions_df.select(pl.col('description').str.join('\n'))
+    return
+
+
+@app.cell(hide_code=True)
+def _(descriptions_df, mo, pl):
+    mo.md(f"""In fact, since the string we constructed dynamically is valid markdown, we can display it dynamically using Marimo's `mo.md` utility!
+
+    ---
+
+    {descriptions_df.select(pl.col('description').str.join('\n')).to_numpy().squeeze().tolist()}
+    """)
+    return
+
+
+@app.cell(hide_code=True)
+def _(mo):
+    mo.md(
+        r"""
+        ## 🔍 Pattern-based Extraction
+
+        In the vast majority of the cases, when dealing with unstructured text data, all we really want is to extract something structured from it. A common use case is to extract URLs from text to get a better understanding of related content.
+
+        In the example below that's exactly what we do. We scan the `docstring` of each API member and extract URLs from them using [`extract`](https://docs.pola.rs/api/python/stable/reference/expressions/api/polars.Expr.str.extract.html) and [`extract_all`](https://docs.pola.rs/api/python/stable/reference/expressions/api/polars.Expr.str.extract_all.html) using a simple regular expression to match http and https URLs.
+
+        Note that `extract` stops after a first match and returns a scalar result (or `null` if there was no match) while `extract_all` returns a - potentially empty - list of matches.
+        """
+    )
+    return
+
+
+@app.cell
+def _(expressions_df, pl):
+    url_pattern = r'(https?://[^\s>]+)'
+    expressions_df.select(
+        'namespace',
+        'member',
+        url_match=pl.col('docstring').str.extract(url_pattern),
+        url_matches=pl.col('docstring').str.extract_all(url_pattern),
+    ).filter(pl.col('url_match').is_not_null())
+    return (url_pattern,)
+
+
+@app.cell(hide_code=True)
+def _(mo):
+    mo.md(
+        r"""
+        Note that in each `docstring` where a code example involving dataframes is present, we will see an output such as "shape: (5, 2)" indicating the number of rows and columns of the dataframe produced by the sample code. Let's say we would like to *capture* this information in a structured way.
+
+        [`extract_groups`](https://docs.pola.rs/api/python/stable/reference/expressions/api/polars.Expr.str.extract_groups.html) is a really powerful expression allowing us to achieve exactly that.
+
+        Below we define the regular expression `r"shape:\s*\((?<height>\S+),\s*(?<width>\S+)\)"` with two capture groups, named `height` and `width` and pass it as the parameter of `extract_groups`. After execution, for each `docstring`, we end up with fully structured data we can further process downstream!
+        """
+    )
+    return
+
+
+@app.cell
+def _(expressions_df, pl):
+    expressions_df.select(
+        'namespace',
+        'member',
+        example_df_shape=pl.col('docstring').str.extract_groups(r"shape:\s*\((?<height>\S+),\s*(?<width>\S+)\)"),
+    )
+    return
+
+
+@app.cell(hide_code=True)
+def _(mo):
+    mo.md(
+        r"""
+        ## 🧹 Stripping
+
+        Strings might require some cleaning before further processing, such as the removal of some characters from the beginning or end of the text. [`strip_chars_start`](https://docs.pola.rs/api/python/stable/reference/expressions/api/polars.Expr.str.strip_chars_start.html), [`strip_chars_end`](https://docs.pola.rs/api/python/stable/reference/expressions/api/polars.Expr.str.strip_chars_end.html) and [`strip_chars`](https://docs.pola.rs/api/python/stable/reference/expressions/api/polars.Expr.str.strip_chars.html) are here to facilitate this.
+
+        All we need to do is to specify a set of characters we would like to get rid of and Polars handles the rest for us.
+        """
+    )
+    return
+
+
+@app.cell
+def _(expressions_df, pl):
+    expressions_df.select(
+        "member",
+        member_front_stripped=pl.col("member").str.strip_chars_start("a"),
+        member_back_stripped=pl.col("member").str.strip_chars_end("n"),
+        member_fully_stripped=pl.col("member").str.strip_chars("na"),
+    )
+    return
+
+
+@app.cell(hide_code=True)
+def _(mo):
+    mo.md(
+        r"""
+        Note that when using the above expressions, the specified characters do not need to form a sequence; they are handled as a set. However, in certain use cases we only want to strip complete substrings, so we would need our input to be strictly treated as a sequence rather than as a set.
+
+        That's exactly the rationale behind [`strip_prefix`](https://docs.pola.rs/api/python/stable/reference/expressions/api/polars.Expr.str.strip_prefix.html) and [`strip_suffix`](https://docs.pola.rs/api/python/stable/reference/expressions/api/polars.Expr.str.strip_suffix.html).
+
+        Below we use these to remove the `"to_"` prefixes and `"_with"` suffixes from each member name.
+        """
+    )
+    return
+
+
+@app.cell
+def _(expressions_df, pl):
+    expressions_df.select(
+        "member",
+        member_prefix_stripped=pl.col("member").str.strip_prefix("to_"),
+        member_suffix_stripped=pl.col("member").str.strip_suffix("_with"),
+    ).slice(20)
+    return
+
+
+@app.cell(hide_code=True)
+def _(mo):
+    mo.md(
+        r"""
+        ## 🔑 Encoding & Decoding
+
+        Should you find yourself in the need of encoding your strings into [base64](https://en.wikipedia.org/wiki/Base64) or [hexadecimal](https://en.wikipedia.org/wiki/Hexadecimal) format, then Polars has your back with its [`encode`](https://docs.pola.rs/api/python/stable/reference/expressions/api/polars.Expr.str.encode.html) expression.
+        """
+    )
+    return
+
+
+@app.cell
+def _(expressions_df, pl):
+    encoded_df = expressions_df.select(
+        "member",
+        member_base64=pl.col('member').str.encode('base64'),
+        member_hex=pl.col('member').str.encode('hex'),
+    )
+    encoded_df
+    return (encoded_df,)
+
+
+@app.cell(hide_code=True)
+def _(mo):
+    mo.md(r"""And of course, you can convert back into a human-readable representation using the [`decode`](https://docs.pola.rs/api/python/stable/reference/expressions/api/polars.Expr.str.decode.html) expression.""")
+    return
+
+
+@app.cell
+def _(encoded_df, pl):
+    encoded_df.with_columns(
+        member_base64_decoded=pl.col('member_base64').str.decode('base64').cast(pl.String),
+        member_hex_decoded=pl.col('member_hex').str.decode('hex').cast(pl.String),
+    )
+    return
+
+
+@app.cell(hide_code=True)
+def _(mo):
+    mo.md(
+        r"""
+        ## 🚀 Application: Dynamic Execution of Polars Examples
+
+        Now that we are familiar with string expressions, we can combine them with other Polars operations to build a fully interactive playground where code examples of Polars expressions can be explored.
+
+        We make use of string expressions to extract the raw Python source code of examples from the docstrings and we leverage the interactive Marimo environment to enable the selection of expressions via a searchable dropdown and a fully functional code editor whose output is rendered with Marimo's rich display utilities.
+
+        In other words, we will use Polars to execute Polars. ❄️ How cool is that?
+
+        ---
+        """
+    )
+    return
+
+
+@app.cell(hide_code=True)
+def _(
+    example_editor,
+    execution_result,
+    expression,
+    expression_description,
+    expression_docs_link,
+    mo,
+):
+    mo.vstack(
+        [
+            mo.md(f'### {expression.value}'),
+            expression,
+            mo.hstack([expression_description, expression_docs_link]),
+            example_editor,
+            execution_result,
+        ]
+    )
+    return
+
+
+@app.cell(hide_code=True)
+def _(mo, selected_expression_record):
+    expression_description = mo.md(selected_expression_record["description"])
+    expression_docs_link = mo.md(
+        f"🐻‍❄️ [Official Docs](https://docs.pola.rs/api/python/stable/reference/expressions/api/polars.Expr.{selected_expression_record['expr']}.html)"
+    )
+    return expression_description, expression_docs_link
+
+
+@app.cell(hide_code=True)
+def _(example_editor, execute_code):
+    execution_result = execute_code(example_editor.value)
+    return (execution_result,)
+
+
+@app.cell(hide_code=True)
+def _(code_df, mo):
+    expression = mo.ui.dropdown(code_df.get_column('expr'), value='arr.all', searchable=True)
+    return (expression,)
+
+
+@app.cell(hide_code=True)
+def _(code_df, expression):
+    selected_expression_record = code_df.filter(expr=expression.value).to_dicts()[0]
+    return (selected_expression_record,)
+
+
+@app.cell(hide_code=True)
+def _(mo, selected_expression_record):
+    example_editor = mo.ui.code_editor(value=selected_expression_record["code"])
+    return (example_editor,)
+
+
+@app.cell(hide_code=True)
+def _(expressions_df, pl):
+    code_df = (
+        expressions_df.select(
+            expr=pl.when(pl.col("namespace") == "root")
+            .then("member")
+            .otherwise(pl.concat_str(["namespace", "member"], separator=".")),
+            description=pl.col("docstring")
+            .str.split("\n\n")
+            .list.get(0)
+            .str.slice(9),
+            docstring_lines=pl.col("docstring").str.split("\n"),
+        )
+        .with_row_index()
+        .explode("docstring_lines")
+        .rename({"docstring_lines": "docstring_line"})
+        .with_columns(pl.col("docstring_line").str.strip_chars(" "))
+        .filter(pl.col("docstring_line").str.contains_any([">>> ", "... "]))
+        .with_columns(pl.col("docstring_line").str.slice(4))
+        .group_by(pl.exclude("docstring_line"), maintain_order=True)
+        .agg(code=pl.col("docstring_line").str.join("\n"))
+        .drop("index")
+    )
+    return (code_df,)
+
+
+@app.cell(hide_code=True)
+def _():
+    def execute_code(code: str):
+        import ast
+
+        # Create a new local namespace for execution
+        local_namespace = {}
+
+        # Parse the code into an AST to identify the last expression
+        parsed_code = ast.parse(code)
+
+        # Check if there's at least one statement
+        if not parsed_code.body:
+            return None
+
+        # If the last statement is an expression, we'll need to get its value
+        last_is_expr = isinstance(parsed_code.body[-1], ast.Expr)
+
+        if last_is_expr:
+            # Split the code: everything except the last statement, and the last statement
+            last_expr = ast.Expression(parsed_code.body[-1].value)
+
+            # Remove the last statement from the parsed code
+            parsed_code.body = parsed_code.body[:-1]
+
+            # Execute everything except the last statement
+            if parsed_code.body:
+                exec(
+                    compile(parsed_code, "<string>", "exec"),
+                    globals(),
+                    local_namespace,
+                )
+
+            # Execute the last statement and get its value
+            result = eval(
+                compile(last_expr, "<string>", "eval"), globals(), local_namespace
+            )
+            return result
+        else:
+            # If the last statement is not an expression (e.g., an assignment),
+            # execute the entire code and return None
+            exec(code, globals(), local_namespace)
+            return None
+    return (execute_code,)
+
+
+@app.cell(hide_code=True)
+def _():
+    import polars as pl
+    import marimo as mo
+    import altair as alt
+    import random
+
+    random.seed(42)
+    return alt, mo, pl, random
+
+
+if __name__ == "__main__":
+    app.run()

polars/14_user_defined_functions.py

@@ -0,0 +1,946 @@
+# /// script
+# requires-python = ">=3.12"
+# dependencies = [
+#     "altair==5.5.0",
+#     "beautifulsoup4==4.13.3",
+#     "httpx==0.28.1",
+#     "marimo",
+#     "nest-asyncio==1.6.0",
+#     "numba==0.61.0",
+#     "numpy==2.1.3",
+#     "polars==1.24.0",
+# ]
+# ///
+
+import marimo
+
+__generated_with = "0.11.17"
+app = marimo.App(width="medium")
+
+
+@app.cell(hide_code=True)
+def _(mo):
+    mo.md(
+        r"""
+        # User-Defined Functions
+
+        _By [Péter Ferenc Gyarmati](http://github.com/peter-gy)_.
+
+        Throughout the previous chapters, you've seen how Polars provides a comprehensive set of built-in expressions for flexible data transformation.  But what happens when you need something *more*? Perhaps your project has unique requirements, or you need to integrate functionality from an external Python library. This is where User-Defined Functions (UDFs) come into play, allowing you to extend Polars with your own custom logic.
+
+        In this chapter, we'll weigh the performance trade-offs of UDFs, pinpoint situations where they're truly beneficial, and explore different ways to effectively incorporate them into your Polars workflows. We'll walk through a complete, practical example.
+        """
+    )
+    return
+
+
+@app.cell(hide_code=True)
+def _(mo):
+    mo.md(
+        r"""
+        ## ⚖️ The Cost of UDFs
+
+        > Performance vs. Flexibility
+
+        Polars' built-in expressions are highly optimized for speed and parallel processing. User-defined functions (UDFs), however, introduce a significant performance overhead because they rely on standard Python code, which often runs in a single thread and bypasses Polars' logical optimizations. Therefore, always prioritize native Polars operations *whenever possible*.
+
+        However, UDFs become inevitable when you need to:
+
+        -  **Integrate external libraries:**  Use functionality not directly available in Polars.
+        -  **Implement custom logic:** Handle complex transformations that can't be easily expressed with Polars' built-in functions.
+
+        Let's dive into a real-world project where UDFs were the only way to get the job done, demonstrating a scenario where native Polars expressions simply weren't sufficient.
+        """
+    )
+    return
+
+
+@app.cell(hide_code=True)
+def _(mo):
+    mo.md(
+        r"""
+        ## 📊 Project Overview
+
+        > Scraping and Analyzing Observable Notebook Statistics
+
+        If you're into data visualization, you've probably seen [D3.js](https://d3js.org/) and [Observable Plot](https://observablehq.com/plot/). Both have extensive galleries showcasing amazing visualizations. Each gallery item is a standalone [Observable notebook](https://observablehq.com/documentation/notebooks/), with metrics like stars, comments, and forks – indicators of popularity. But getting and analyzing these statistics directly isn't straightforward. We'll need to scrape the web.
+        """
+    )
+    return
+
+
+@app.cell(hide_code=True)
+def _(mo):
+    mo.hstack(
+        [
+            mo.image(
+                "https://minio.peter.gy/static/assets/marimo/learn/polars/14_d3-gallery.png?0",
+                width=600,
+                caption="Screenshot of https://observablehq.com/@d3/gallery",
+            ),
+            mo.image(
+                "https://minio.peter.gy/static/assets/marimo/learn/polars/14_plot-gallery.png?0",
+                width=600,
+                caption="Screenshot of https://observablehq.com/@observablehq/plot-gallery",
+            ),
+        ]
+    )
+    return
+
+
+@app.cell(hide_code=True)
+def _(mo):
+    mo.md(r"""Our goal is to use Polars UDFs to fetch the HTML content of these gallery pages. Then, we'll use the `BeautifulSoup` Python library to parse the HTML and extract the relevant metadata.  After some data wrangling with native Polars expressions, we'll have a DataFrame listing each visualization notebook. Then, we'll use another UDF to retrieve the number of likes, forks, and comments for each notebook. Finally, we will create our own high-performance UDF to implement a custom notebook ranking scheme. This will involve multiple steps, showcasing different UDF approaches.""")
+    return
+
+
+@app.cell(hide_code=True)
+def _(mo):
+    mo.mermaid('''
+    graph LR;
+        url_df --> |"UDF: Fetch HTML"| html_df
+        html_df --> |"UDF: Parse with BeautifulSoup"| parsed_html_df
+        parsed_html_df --> |"Native Polars: Extract Data"| notebooks_df
+        notebooks_df --> |"UDF: Get Notebook Stats"| notebook_stats_df
+        notebook_stats_df --> |"Numba UDF: Compute Popularity"| notebook_popularity_df
+    ''')
+    return
+
+
+@app.cell(hide_code=True)
+def _(mo):
+    mo.md(r"""Our starting point, `url_df`, is a simple DataFrame with a single `url` column containing the URLs of the D3 and Observable Plot gallery notebooks.""")
+    return
+
+
+@app.cell(hide_code=True)
+def _(pl):
+    url_df = pl.from_dict(
+        {
+            "url": [
+                "https://observablehq.com/@d3/gallery",
+                "https://observablehq.com/@observablehq/plot-gallery",
+            ]
+        }
+    )
+    url_df
+    return (url_df,)
+
+
+@app.cell(hide_code=True)
+def _(mo):
+    mo.md(
+        r"""
+        ## 🔂 Element-Wise UDFs
+
+        > Processing Value by Value
+
+        The most common way to use UDFs is to apply them element-wise.  This means our custom function will execute for *each individual row* in a specified column.  Our first task is to fetch the HTML content for each URL in `url_df`.
+
+        We'll define a Python function that takes a `url` (a string) as input, uses the `httpx` library (an HTTP client) to fetch the content, and returns the HTML as a string. We then integrate this function into Polars using the [`map_elements`](https://docs.pola.rs/api/python/stable/reference/expressions/api/polars.Expr.map_elements.html) expression.
+
+        You'll notice we have to explicitly specify the `return_dtype`.  This is *crucial*.  Polars doesn't automatically know what our custom function will return.  We're responsible for defining the function's logic and, therefore, its output type. By providing the `return_dtype`, we help Polars maintain its internal representation of the DataFrame's schema, enabling query optimization. Think of it as giving Polars a "heads-up" about the data type it should expect.
+        """
+    )
+    return
+
+
+@app.cell(hide_code=True)
+def _(httpx, pl, url_df):
+    html_df = url_df.with_columns(
+        html=pl.col("url").map_elements(
+            lambda url: httpx.get(url).text,
+            return_dtype=pl.String,
+        )
+    )
+    html_df
+    return (html_df,)
+
+
+@app.cell(hide_code=True)
+def _(mo):
+    mo.md(
+        r"""
+        Now, `html_df` holds the HTML for each URL.  We need to parse it. Again, a UDF is the way to go. Parsing HTML with native Polars expressions would be a nightmare! Instead, we'll use the [`beautifulsoup4`](https://pypi.org/project/beautifulsoup4/) library, a standard tool for this.
+
+        These Observable pages are built with [Next.js](https://nextjs.org/), which helpfully serializes page properties as JSON within the HTML. This simplifies our UDF: we'll extract the raw JSON from the `<script id="__NEXT_DATA__" type="application/json">` tag. We'll use [`map_elements`](https://docs.pola.rs/api/python/stable/reference/expressions/api/polars.Expr.map_elements.html) again.  For clarity, we'll define this UDF as a named function, `extract_nextjs_data`, since it's a bit more complex than a simple HTTP request.
+        """
+    )
+    return
+
+
+@app.cell(hide_code=True)
+def _(BeautifulSoup):
+    def extract_nextjs_data(html: str) -> str:
+        soup = BeautifulSoup(html, "html.parser")
+        script_tag = soup.find("script", id="__NEXT_DATA__")
+        return script_tag.text
+    return (extract_nextjs_data,)
+
+
+@app.cell(hide_code=True)
+def _(extract_nextjs_data, html_df, pl):
+    parsed_html_df = html_df.select(
+        "url",
+        next_data=pl.col("html").map_elements(
+            extract_nextjs_data,
+            return_dtype=pl.String,
+        ),
+    )
+    parsed_html_df
+    return (parsed_html_df,)
+
+
+@app.cell(hide_code=True)
+def _(mo):
+    mo.md(r"""With some data wrangling of the raw JSON (using *native* Polars expressions!), we get `notebooks_df`, containing the metadata for each notebook.""")
+    return
+
+
+@app.cell(hide_code=True)
+def _(parsed_html_df, pl):
+    notebooks_df = (
+        parsed_html_df.select(
+            "url",
+            # We extract the content of every cell present in the gallery notebooks
+            cell=pl.col("next_data")
+            .str.json_path_match("$.props.pageProps.initialNotebook.nodes")
+            .str.json_decode()
+            .list.eval(pl.element().struct.field("value")),
+        )
+        # We want one row per cell
+        .explode("cell")
+        # Only keep categorized notebook listing cells starting with H3
+        .filter(pl.col("cell").str.starts_with("### "))
+        # Split up the cells into [heading, description, config] sections
+        .with_columns(pl.col("cell").str.split("\n\n"))
+        .select(
+            gallery_url="url",
+            # Text after the '### ' heading, ignore '<!--' comments'
+            category=pl.col("cell").list.get(0).str.extract(r"###\s+(.*?)(?:\s+<!--.*?-->|$)"),
+            # Paragraph after heading
+            description=pl.col("cell")
+            .list.get(1)
+            .str.strip_chars(" ")
+            .str.replace_all("](/", "](https://observablehq.com/", literal=True),
+            # Parsed notebook config from ${preview([{...}])}
+            notebooks=pl.col("cell")
+            .list.get(2)
+            .str.strip_prefix("${previews([")
+            .str.strip_suffix("]})}")
+            .str.strip_chars(" \n")
+            .str.split("},")
+            # Simple regex-based attribute extraction from JS/JSON objects like
+            # ```js
+            # {
+            #   path: "@d3/spilhaus-shoreline-map",
+            #   "thumbnail": "66a87355e205d820...",
+            #   title: "Spilhaus shoreline map",
+            #   "author": "D3"
+            # }
+            # ```
+            .list.eval(
+                pl.struct(
+                    *(
+                        pl.element()
+                        .str.extract(f'(?:"{key}"|{key})\s*:\s*"([^"]*)"')
+                        .alias(key)
+                        for key in ["path", "thumbnail", "title"]
+                    )
+                )
+            ),
+        )
+        .explode("notebooks")
+        .unnest("notebooks")
+        .filter(pl.col("path").is_not_null())
+        # Final projection to end up with directly usable values
+        .select(
+            pl.concat_str(
+                [
+                    pl.lit("https://static.observableusercontent.com/thumbnail/"),
+                    "thumbnail",
+                    pl.lit(".jpg"),
+                ],
+            ).alias("notebook_thumbnail_src"),
+            "category",
+            "title",
+            "description",
+            pl.concat_str(
+                [pl.lit("https://observablehq.com"), "path"], separator="/"
+            ).alias("notebook_url"),
+        )
+    )
+    notebooks_df
+    return (notebooks_df,)
+
+
+@app.cell(hide_code=True)
+def _(mo):
+    mo.md(
+        r"""
+        ## 📦 Batch-Wise UDFs
+
+        > Processing Entire Series
+
+        `map_elements` calls the UDF for *each row*. Fine for our tiny, two-rows-tall `url_df`. But `notebooks_df` has almost 400 rows! Individual HTTP requests for each would be painfully slow.
+
+        We want stats for each notebook in `notebooks_df`. To avoid sequential requests, we'll use Polars' [`map_batches`](https://docs.pola.rs/api/python/stable/reference/expressions/api/polars.Expr.map_batches.html). This lets us process an *entire Series* (a column) at once.
+
+        Our UDF, `fetch_html_batch`, will take a *Series* of URLs and use `asyncio` to make concurrent requests – a huge performance boost.
+        """
+    )
+    return
+
+
+@app.cell(hide_code=True)
+def _(Iterable, asyncio, httpx, mo):
+    async def _fetch_html_batch(urls: Iterable[str]) -> tuple[str, ...]:
+        async with httpx.AsyncClient(timeout=15) as client:
+            res = await asyncio.gather(*(client.get(url) for url in urls))
+            return tuple((r.text for r in res))
+
+
+    @mo.cache
+    def fetch_html_batch(urls: Iterable[str]) -> tuple[str, ...]:
+        return asyncio.run(_fetch_html_batch(urls))
+    return (fetch_html_batch,)
+
+
+@app.cell(hide_code=True)
+def _(mo):
+    mo.callout(
+        mo.md("""
+    Since `fetch_html_batch` is a pure Python function and performs multiple network requests, it's a good candidate for caching. We use [`mo.cache`](https://docs.marimo.io/api/caching/#marimo.cache) to avoid redundant requests to the same URL. This is a simple way to improve performance without modifying the core logic.
+    """
+        ),
+        kind="info",
+    )
+    return
+
+
+@app.cell(hide_code=True)
+def _(mo, notebooks_df):
+    category = mo.ui.dropdown(
+        notebooks_df.sort("category").get_column("category"),
+        value="Maps",
+    )
+    return (category,)
+
+
+@app.cell(hide_code=True)
+def _(category, extract_nextjs_data, fetch_html_batch, notebooks_df, pl):
+    notebook_stats_df = (
+        # Setting filter upstream to limit number of concurrent HTTP requests
+        notebooks_df.filter(category=category.value)
+        .with_columns(
+            notebook_html=pl.col("notebook_url")
+            .map_batches(fetch_html_batch, return_dtype=pl.List(pl.String))
+            .explode()
+        )
+        .with_columns(
+            notebook_data=pl.col("notebook_html")
+            .map_elements(
+                extract_nextjs_data,
+                return_dtype=pl.String,
+            )
+            .str.json_path_match("$.props.pageProps.initialNotebook")
+            .str.json_decode()
+        )
+        .drop("notebook_html")
+        .with_columns(
+            *[
+                pl.col("notebook_data").struct.field(key).alias(key)
+                for key in ["likes", "forks", "comments", "license"]
+            ]
+        )
+        .drop("notebook_data")
+        .with_columns(pl.col("comments").list.len())
+        .select(
+            pl.exclude("description", "notebook_url"),
+            "description",
+            "notebook_url",
+        )
+        .sort("likes", descending=True)
+    )
+    return (notebook_stats_df,)
+
+
+@app.cell(hide_code=True)
+def _(mo, notebook_stats_df):
+    notebooks = mo.ui.table(notebook_stats_df, selection='single', initial_selection=[2], page_size=5)
+    notebook_height = mo.ui.slider(start=400, stop=2000, value=825, step=25, show_value=True, label='Notebook Height')
+    return notebook_height, notebooks
+
+
+@app.cell(hide_code=True)
+def _():
+    def nb_iframe(notebook_url: str, height=825) -> str:
+        embed_url = notebook_url.replace(
+            "https://observablehq.com", "https://observablehq.com/embed"
+        )
+        return f'<iframe width="100%" height="{height}" frameborder="0" src="{embed_url}?cell=*"></iframe>'
+    return (nb_iframe,)
+
+
+@app.cell(hide_code=True)
+def _(mo):
+    mo.md(r"""Now that we have access to notebook-level statistics, we can rank the visualizations by the number of likes they received & display them interactively.""")
+    return
+
+
+@app.cell(hide_code=True)
+def _(mo):
+    mo.callout("💡 Explore the visualizations by paging through the table below and selecting any of its rows.")
+    return
+
+
+@app.cell(hide_code=True)
+def _(category, mo, nb_iframe, notebook_height, notebooks):
+    notebook = notebooks.value.to_dicts()[0]
+    mo.vstack(
+        [
+            mo.hstack([category, notebook_height]),
+            notebooks,
+            mo.md(f"{notebook['description']}"),
+            mo.md('---'),
+            mo.md(nb_iframe(notebook["notebook_url"], notebook_height.value)),
+        ]
+    )
+    return (notebook,)
+
+
+@app.cell(hide_code=True)
+def _(mo):
+    mo.md(
+        r"""
+        ## ⚙️ Row-Wise UDFs
+
+        > Accessing All Columns at Once
+
+        Sometimes, you need to work with *all* columns of a row at once.  This is where [`map_rows`](https://docs.pola.rs/api/python/stable/reference/dataframe/api/polars.DataFrame.map_rows.html) comes in. It operates directly on the DataFrame, passing each row to your UDF *as a tuple*.
+
+        Below, `create_notebook_summary` takes a row from `notebook_stats_df` (as a tuple) and returns a formatted Markdown string summarizing the notebook's key stats.  We're essentially reducing the DataFrame to a single column.  While this *could* be done with native Polars expressions, it would be much more cumbersome. This example demonstrates a case where a row-wise UDF simplifies the code, even if the underlying operation isn't inherently complex.
+        """
+    )
+    return
+
+
+@app.cell(hide_code=True)
+def _():
+    def create_notebook_summary(row: tuple) -> str:
+        (
+            thumbnail_src,
+            category,
+            title,
+            likes,
+            forks,
+            comments,
+            license,
+            description,
+            notebook_url,
+        ) = row
+        return (
+            f"""
+    ### [{title}]({notebook_url})
+
+    <div style="display: grid; grid-template-columns: 1fr 1fr; gap: 12px; margin: 12px 0;">
+        <div>⭐ <strong>Likes:</strong> {likes}</div>
+        <div>↗️ <strong>Forks:</strong> {forks}</div>
+        <div>💬 <strong>Comments:</strong> {comments}</div>
+        <div>⚖️ <strong>License:</strong> {license}</div>
+    </div>
+
+    <a href="{notebook_url}" target="_blank">
+        <img src="{thumbnail_src}" style="height: 300px;" />
+    <a/>
+    """.strip('\n')
+        )
+    return (create_notebook_summary,)
+
+
+@app.cell(hide_code=True)
+def _(create_notebook_summary, notebook_stats_df, pl):
+    notebook_summary_df = notebook_stats_df.map_rows(
+        create_notebook_summary,
+        return_dtype=pl.String,
+    ).rename({"map": "summary"})
+    notebook_summary_df.head(1)
+    return (notebook_summary_df,)
+
+
+@app.cell(hide_code=True)
+def _(mo):
+    mo.callout("💡 You can explore individual notebook statistics through the carousel. Discover the visualization's source code by clicking the notebook title or the thumbnail.")
+    return
+
+
+@app.cell(hide_code=True)
+def _(mo, notebook_summary_df):
+    mo.carousel(
+        [
+            mo.lazy(mo.md(summary))
+            for summary in notebook_summary_df.get_column("summary")
+        ]
+    )
+    return
+
+
+@app.cell(hide_code=True)
+def _(mo):
+    mo.md(
+        r"""
+        ## 🚀 Higher-performance UDFs
+
+        > Leveraging Numba to Make Python Fast
+
+        Python code doesn't *always* mean slow code. While UDFs *often* introduce performance overhead, there are exceptions. NumPy's universal functions ([`ufuncs`](https://numpy.org/doc/stable/reference/ufuncs.html)) and generalized universal functions ([`gufuncs`](https://numpy.org/neps/nep-0005-generalized-ufuncs.html)) provide high-performance operations on NumPy arrays, thanks to low-level implementations.
+
+        But NumPy's built-in functions are predefined. We can't easily use them for *custom* logic. Enter [`numba`](https://numba.pydata.org/).  Numba is a just-in-time (JIT) compiler that translates Python functions into optimized machine code *at runtime*. It provides decorators like [`numba.guvectorize`](https://numba.readthedocs.io/en/stable/user/vectorize.html#the-guvectorize-decorator) that let us create our *own* high-performance `gufuncs` – *without* writing low-level code!
+        """
+    )
+    return
+
+
+@app.cell(hide_code=True)
+def _(mo):
+    mo.md(
+        r"""
+        Let's create a custom popularity metric to rank notebooks, considering likes, forks, *and* comments (not just likes).  We'll define `weighted_popularity_numba`, decorated with `@numba.guvectorize`.  The decorator arguments specify that we're taking three integer vectors of length `n` and returning a float vector of length `n`.
+
+        The weighted popularity score for each notebook is calculated using the following formula:
+
+        $$
+        \begin{equation}
+        \text{score}_i = w_l \cdot l_i^{f} + w_f \cdot f_i^{f} + w_c \cdot c_i^{f}
+        \end{equation}
+        $$
+
+        with:
+        """
+    )
+    return
+
+
+@app.cell(hide_code=True)
+def _(mo, non_linear_factor, weight_comments, weight_forks, weight_likes):
+    mo.md(rf"""
+    | Symbol | Description |
+    |--------|-------------|
+    | $\text{{score}}_i$ | Popularity score for the *i*-th notebook |
+    | $w_l = {weight_likes.value}$ | Weight for likes |
+    | $l_i$ | Number of likes for the *i*-th notebook |
+    | $w_f = {weight_forks.value}$ | Weight for forks |
+    | $f_i$ | Number of forks for the *i*-th notebook |
+    | $w_c = {weight_comments.value}$ | Weight for comments |
+    | $c_i$ | Number of comments for the *i*-th notebook |
+    | $f = {non_linear_factor.value}$ | Non-linear factor (exponent) |
+    """)
+    return
+
+
+@app.cell(hide_code=True)
+def _(mo):
+    weight_likes = mo.ui.slider(
+        start=0.1,
+        stop=1,
+        value=0.5,
+        step=0.1,
+        show_value=True,
+        label="⭐ Weight for Likes",
+    )
+    weight_forks = mo.ui.slider(
+        start=0.1,
+        stop=1,
+        value=0.3,
+        step=0.1,
+        show_value=True,
+        label="↗️ Weight for Forks",
+    )
+    weight_comments = mo.ui.slider(
+        start=0.1,
+        stop=1,
+        value=0.5,
+        step=0.1,
+        show_value=True,
+        label="💬 Weight for Comments",
+    )
+    non_linear_factor = mo.ui.slider(
+        start=1,
+        stop=2,
+        value=1.2,
+        step=0.1,
+        show_value=True,
+        label="🎢 Non-Linear Factor",
+    )
+    return non_linear_factor, weight_comments, weight_forks, weight_likes
+
+
+@app.cell(hide_code=True)
+def _(
+    non_linear_factor,
+    np,
+    numba,
+    weight_comments,
+    weight_forks,
+    weight_likes,
+):
+    w_l = weight_likes.value
+    w_f = weight_forks.value
+    w_c = weight_comments.value
+    nlf = non_linear_factor.value
+
+
+    @numba.guvectorize(
+        [(numba.int64[:], numba.int64[:], numba.int64[:], numba.float64[:])],
+        "(n), (n), (n) -> (n)",
+    )
+    def weighted_popularity_numba(
+        likes: np.ndarray,
+        forks: np.ndarray,
+        comments: np.ndarray,
+        out: np.ndarray,
+    ):
+        for i in range(likes.shape[0]):
+            out[i] = (
+                w_l * (likes[i] ** nlf)
+                + w_f * (forks[i] ** nlf)
+                + w_c * (comments[i] ** nlf)
+            )
+    return nlf, w_c, w_f, w_l, weighted_popularity_numba
+
+
+@app.cell(hide_code=True)
+def _(mo):
+    mo.md(r"""We apply our JIT-compiled UDF using `map_batches`, as before.  The key is that we're passing entire columns directly to `weighted_popularity_numba`. Polars and Numba handle the conversion to NumPy arrays behind the scenes. This direct integration is a major benefit of using `guvectorize`.""")
+    return
+
+
+@app.cell(hide_code=True)
+def _(notebook_stats_df, pl, weighted_popularity_numba):
+    notebook_popularity_df = (
+        notebook_stats_df.select(
+            pl.col("notebook_thumbnail_src").alias("thumbnail"),
+            "title",
+            "likes",
+            "forks",
+            "comments",
+            popularity=pl.struct(["likes", "forks", "comments"]).map_batches(
+                lambda obj: weighted_popularity_numba(
+                    obj.struct.field("likes"),
+                    obj.struct.field("forks"),
+                    obj.struct.field("comments"),
+                ),
+                return_dtype=pl.Float64,
+            ),
+            url="notebook_url",
+        )
+    )
+    return (notebook_popularity_df,)
+
+
+@app.cell(hide_code=True)
+def _(mo):
+    mo.callout("💡 Adjust the hyperparameters of the popularity ranking UDF. How do the weights and non-linear factor affect the notebook rankings?")
+    return
+
+
+@app.cell(hide_code=True)
+def _(
+    mo,
+    non_linear_factor,
+    notebook_popularity_df,
+    weight_comments,
+    weight_forks,
+    weight_likes,
+):
+    mo.vstack(
+        [
+            mo.hstack([weight_likes, weight_forks]),
+            mo.hstack([weight_comments, non_linear_factor]),
+            notebook_popularity_df,
+        ]
+    )
+    return
+
+
+@app.cell(hide_code=True)
+def _(mo):
+    mo.md(r"""As the slope chart below demonstrates, this new ranking strategy significantly changes the notebook order, as it considers forks and comments, not just likes.""")
+    return
+
+
+@app.cell(hide_code=True)
+def _(alt, notebook_popularity_df, pl):
+    notebook_ranks_df = (
+        notebook_popularity_df.sort("likes", descending=True)
+        .with_row_index("rank_by_likes")
+        .with_columns(pl.col("rank_by_likes") + 1)
+        .sort("popularity", descending=True)
+        .with_row_index("rank_by_popularity")
+        .with_columns(pl.col("rank_by_popularity") + 1)
+        .select("thumbnail", "title", "rank_by_popularity", "rank_by_likes")
+        .unpivot(
+            ["rank_by_popularity", "rank_by_likes"],
+            index="title",
+            variable_name="strategy",
+            value_name="rank",
+        )
+    )
+
+    # Slope chart to visualize rank differences by strategy
+    lines = notebook_ranks_df.plot.line(
+        x="strategy:O",
+        y="rank:Q",
+        color="title:N",
+    )
+    points = notebook_ranks_df.plot.point(
+        x="strategy:O",
+        y="rank:Q",
+        color=alt.Color("title:N", legend=None),
+        fill="title:N",
+    )
+    (points + lines).properties(width=400)
+    return lines, notebook_ranks_df, points
+
+
+@app.cell(hide_code=True)
+def _(mo):
+    mo.md(
+        r"""
+        ## ⏱️ Quantifying the Overhead
+
+        > UDF Performance Comparison
+
+        To truly understand the performance implications of using UDFs, let's conduct a benchmark.  We'll create a DataFrame with random numbers and perform the same numerical operation using four different methods:
+
+        1. **Native Polars:** Using Polars' built-in expressions.
+        2. **`map_elements`:**  Applying a Python function element-wise.
+        3. **`map_batches`:** **Applying** a Python function to the entire Series.
+        4. **`map_batches` with Numba:** Applying a JIT-compiled function to batches, similar to a generalized universal function.
+
+        We'll use a simple, but non-trivial, calculation:  `result = (x * 2.5 + 5) / (x + 1)`. This involves multiplication, addition, and division, giving us a realistic representation of a common numerical operation. We'll use the `timeit` module, to accurately measure execution times over multiple trials.
+        """
+    )
+    return
+
+
+@app.cell(hide_code=True)
+def _(mo):
+    mo.callout("💡 Tweak the benchmark parameters to explore how execution times change with different sample sizes and trial counts. Do you notice anything surprising as you decrease the number of samples?")
+    return
+
+
+@app.cell(hide_code=True)
+def _(benchmark_plot, mo, num_samples, num_trials):
+    mo.vstack(
+        [
+            mo.hstack([num_samples, num_trials]),
+            mo.md(
+                f"""---
+    Performance comparison over **{num_trials.value:,} trials** with **{num_samples.value:,} samples**.
+
+    > Lower execution times are better.
+    """
+            ),
+            benchmark_plot,
+        ]
+    )
+    return
+
+
+@app.cell(hide_code=True)
+def _(mo):
+    mo.md(
+        r"""
+        As anticipated, the `Batch-Wise UDF (Python)` and `Element-Wise UDF` exhibit significantly worse performance, essentially acting as pure-Python for-each loops.  
+
+        However, when Python serves as an interface to lower-level, high-performance libraries, we observe substantial improvements. The `Batch-Wise UDF (NumPy)` lags behind both `Batch-Wise UDF (Numba)` and `Native Polars`, but it still represents a considerable improvement over pure-Python UDFs due to its vectorized computations. 
+
+        Numba's Just-In-Time (JIT) compilation delivers a dramatic performance boost, achieving speeds comparable to native Polars expressions. This demonstrates that UDFs, particularly when combined with tools like Numba, don't inevitably lead to bottlenecks in numerical computations.
+        """
+    )
+    return
+
+
+@app.cell(hide_code=True)
+def _(mo):
+    num_samples = mo.ui.slider(
+        start=1_000,
+        stop=1_000_000,
+        value=250_000,
+        step=1000,
+        show_value=True,
+        debounce=True,
+        label="Number of Samples",
+    )
+    num_trials = mo.ui.slider(
+        start=50,
+        stop=1_000,
+        value=100,
+        step=50,
+        show_value=True,
+        debounce=True,
+        label="Number of Trials",
+    )
+    return num_samples, num_trials
+
+
+@app.cell(hide_code=True)
+def _(np, num_samples, pl):
+    rng = np.random.default_rng(42)
+    sample_df = pl.from_dict({"x": rng.random(num_samples.value)})
+    return rng, sample_df
+
+
+@app.cell(hide_code=True)
+def _(np, num_trials, numba, pl, sample_df, timeit):
+    def run_native():
+        sample_df.with_columns(
+            result_native=(pl.col("x") * 2.5 + 5) / (pl.col("x") + 1)
+        )
+
+
+    def _calculate_elementwise(x: float) -> float:
+        return (x * 2.5 + 5) / (x + 1)
+
+
+    def run_map_elements():
+        sample_df.with_columns(
+            result_map_elements=pl.col("x").map_elements(
+                _calculate_elementwise,
+                return_dtype=pl.Float64,
+            )
+        )
+
+
+    def _calculate_batchwise_numpy(x_series: pl.Series) -> pl.Series:
+        x_array = x_series.to_numpy()
+        result_array = (x_array * 2.5 + 5) / (x_array + 1)
+        return pl.Series(result_array)
+
+
+    def run_map_batches_numpy():
+        sample_df.with_columns(
+            result_map_batches_numpy=pl.col("x").map_batches(
+                _calculate_batchwise_numpy,
+                return_dtype=pl.Float64,
+            )
+        )
+
+
+    def _calculate_batchwise_python(x_series: pl.Series) -> pl.Series:
+        x_array = x_series.to_list()
+        result_array = [_calculate_elementwise(x) for x in x_array]
+        return pl.Series(result_array)
+
+
+    def run_map_batches_python():
+        sample_df.with_columns(
+            result_map_batches_python=pl.col("x").map_batches(
+                _calculate_batchwise_python,
+                return_dtype=pl.Float64,
+            )
+        )
+
+
+    @numba.guvectorize([(numba.float64[:], numba.float64[:])], "(n) -> (n)")
+    def _calculate_batchwise_numba(x: np.ndarray, out: np.ndarray):
+        for i in range(x.shape[0]):
+            out[i] = (x[i] * 2.5 + 5) / (x[i] + 1)
+
+
+    def run_map_batches_numba():
+        sample_df.with_columns(
+            result_map_batches_numba=pl.col("x").map_batches(
+                _calculate_batchwise_numba,
+                return_dtype=pl.Float64,
+            )
+        )
+
+
+    def time_method(callable_name: str, number=num_trials.value) -> float:
+        fn = globals()[callable_name]
+        return timeit.timeit(fn, number=number)
+    return (
+        run_map_batches_numba,
+        run_map_batches_numpy,
+        run_map_batches_python,
+        run_map_elements,
+        run_native,
+        time_method,
+    )
+
+
+@app.cell(hide_code=True)
+def _(alt, pl, time_method):
+    benchmark_df = pl.from_dicts(
+        [
+            {
+                "title": "Native Polars",
+                "callable_name": "run_native",
+            },
+            {
+                "title": "Element-Wise UDF",
+                "callable_name": "run_map_elements",
+            },
+            {
+                "title": "Batch-Wise UDF (NumPy)",
+                "callable_name": "run_map_batches_numpy",
+            },
+            {
+                "title": "Batch-Wise UDF (Python)",
+                "callable_name": "run_map_batches_python",
+            },
+            {
+                "title": "Batch-Wise UDF (Numba)",
+                "callable_name": "run_map_batches_numba",
+            },
+        ]
+    ).with_columns(
+        time=pl.col("callable_name").map_elements(
+            time_method, return_dtype=pl.Float64
+        )
+    )
+
+    benchmark_plot = benchmark_df.plot.bar(
+        x=alt.X("title:N", title="Method", sort="-y"),
+        y=alt.Y("time:Q", title="Execution Time (s)", axis=alt.Axis(format=".3f")),
+    ).properties(width=400)
+    return benchmark_df, benchmark_plot
+
+
+@app.cell(hide_code=True)
+def _():
+    import asyncio
+    import timeit
+    from typing import Iterable
+
+    import altair as alt
+    import httpx
+    import marimo as mo
+    import nest_asyncio
+    import numba
+    import numpy as np
+    from bs4 import BeautifulSoup
+
+    import polars as pl
+
+    # Fixes RuntimeError: asyncio.run() cannot be called from a running event loop
+    nest_asyncio.apply()
+    return (
+        BeautifulSoup,
+        Iterable,
+        alt,
+        asyncio,
+        httpx,
+        mo,
+        nest_asyncio,
+        np,
+        numba,
+        pl,
+        timeit,
+    )
+
+
+if __name__ == "__main__":
+    app.run()

polars/README.md

@@ -23,3 +23,4 @@ You can also open notebooks in our online playground by appending marimo.app/ to
 Thanks to all our notebook authors!
 
 * [Koushik Khan](https://github.com/koushikkhan)
+* [Péter Gyarmati](https://github.com/peter-gy)

probability/08_bayes_theorem.py

@@ -307,7 +307,7 @@ def _(mo):
     mo.md(
         r"""
 
-        _This interactive exmaple was made with [marimo](https://github.com/marimo-team/marimo/blob/main/examples/misc/bayes_theorem.py), and is [based on an explanation of Bayes' Theorem by Grant Sanderson](https://www.youtube.com/watch?v=HZGCoVF3YvM&list=PLzq7odmtfKQw2KIbQq0rzWrqgifHKkPG1&index=1&t=3s)_.
+        _This interactive example was made with [marimo](https://github.com/marimo-team/marimo/blob/main/examples/misc/bayes_theorem.py), and is [based on an explanation of Bayes' Theorem by Grant Sanderson](https://www.youtube.com/watch?v=HZGCoVF3YvM&list=PLzq7odmtfKQw2KIbQq0rzWrqgifHKkPG1&index=1&t=3s)_.
 
         Bayes theorem provides a convenient way to calculate the probability
         of a hypothesis event $H$ given evidence $E$: