feat: Add `concat(..., how="*_relaxed"})` by FBruzzesi · Pull Request #3398 · narwhals-dev/narwhals

FBruzzesi · 2026-01-11T18:31:58Z

Description

As Marco often says, in for a penny in for a pound 😂

This PR builds up on #3396 to showcase how that's useful to implement concat relaxed versions.
It's probably possible to lower some of the repetition, but considering how much time I spent on this (not sooo much so far), I am quite happy with the shape of it.

On top of the new feature there are some minor adjustment for the concat implementations across backends

TODO:

Unknown types for narwhals should keep the original backend dtype and let such backend to deal with it. See comment feat: Add concat(..., how="*_relaxed"}) #3398 (comment)
Backward compatibility: this is more a concern for how={"vertical", "diagonal"}, and would be a followup to this PR

What type of PR is this? (check all applicable)

Related issues

Related issue #<issue number>
Closes [Enh]: Add support for concat(..., how={"vertical_relaxed", "diagonal_relaxed"}) #3386

Checklist

Code follows style guide (ruff)
Tests added
Documented the changes

FBruzzesi · 2026-01-11T18:36:38Z

narwhals/_pandas_like/utils.py

+_DTYPE_BACKEND_PRIORITY: dict[DTypeBackend, Literal[0, 1, 2]] = {
+    "pyarrow": 2,
+    "numpy_nullable": 1,
+    None: 0,
+}


Strong opinions here!

Disclaimer: pandas automatically does something similar already when concatenating dataframes vertically:

{"pyarrow", None} -> "pyarrow"

{"numpy_nullable", None} -> "numpy_nullable"

{"numpy_nullable", "pyarrow"} -> dtype('O') 😭 WHY THOUGH?

FBruzzesi · 2026-01-11T18:41:30Z

narwhals/schema.py

+    return Schema(into_out_schema)
+
+
+def combine_schemas(left: Schema, right: Schema) -> tuple[Schema, Schema]:


Reading this over, combine is definitely the wrong verb here as we end up getting two schemas and they preserve their original dtypes.

I think my first idea was to follow the meshing of the schemas with the to_supertype call, which indeed is always happening when we call this function in the codebase. I will think about a better name but open to suggestions

Wasn't this called merge_schemas or something in polars?

I will think about a better name but open to suggestions

@FBruzzesi I've got an idea that does a similar thing to (perf: Avoid unnecessary lambdas)

Since every use of combine_schema currently looks like this:

lambda x, y: to_supertype(*combine_schemas(x, y)),

We can just define that as the function that gets passed to reduce instead.

I used the name to_supertype_diagonal for now, but I'm not too attached it 😄

Show diff (sorry, very big)

diff --git a/narwhals/_arrow/namespace.py b/narwhals/_arrow/namespace.py index bc450265a..aabb81ec2 100644 --- a/narwhals/_arrow/namespace.py +++ b/narwhals/_arrow/namespace.py @@ -19,7 +19,7 @@ from narwhals._expression_parsing import ( combine_evaluate_output_names, ) from narwhals._utils import Implementation -from narwhals.schema import Schema, combine_schemas, to_supertype +from narwhals.schema import Schema, to_supertype, to_supertype_diagonal if TYPE_CHECKING: from collections.abc import Iterator, Sequence @@ -180,7 +180,7 @@ class ArrowNamespace( def _concat_diagonal_relaxed(self, dfs: Sequence[pa.Table], /) -> pa.Table: native_schemas = tuple(table.schema for table in dfs) out_schema = reduce( - lambda x, y: to_supertype(*combine_schemas(x, y)), + to_supertype_diagonal, (Schema.from_arrow(pa_schema) for pa_schema in native_schemas), ).to_arrow() to_schemas = ( diff --git a/narwhals/_dask/namespace.py b/narwhals/_dask/namespace.py index 5254744ea..5114ee435 100644 --- a/narwhals/_dask/namespace.py +++ b/narwhals/_dask/namespace.py @@ -24,7 +24,7 @@ from narwhals._expression_parsing import ( ) from narwhals._pandas_like.utils import promote_dtype_backend from narwhals._utils import Implementation, zip_strict -from narwhals.schema import Schema, combine_schemas, to_supertype +from narwhals.schema import Schema, to_supertype, to_supertype_diagonal if TYPE_CHECKING: from collections.abc import Iterable, Iterator @@ -177,7 +177,7 @@ class DaskNamespace( dtypes = tuple(df.dtypes.to_dict() for df in dfs) dtype_backend = promote_dtype_backend(dfs, self._implementation) out_schema = reduce( - lambda x, y: to_supertype(*combine_schemas(x, y)), + to_supertype_diagonal, (Schema.from_pandas_like(dtype) for dtype in dtypes), ).to_pandas(dtype_backend=dtype_backend.values()) diff --git a/narwhals/_duckdb/namespace.py b/narwhals/_duckdb/namespace.py index 41c2e8d29..37f773de8 100644 --- a/narwhals/_duckdb/namespace.py +++ b/narwhals/_duckdb/namespace.py @@ -27,7 +27,7 @@ from narwhals._expression_parsing import ( ) from narwhals._sql.namespace import SQLNamespace from narwhals._utils import Implementation -from narwhals.schema import Schema, combine_schemas, to_supertype +from narwhals.schema import Schema, to_supertype, to_supertype_diagonal if TYPE_CHECKING: from collections.abc import Iterable @@ -116,9 +116,7 @@ class DuckDBNamespace( if how == "diagonal_relaxed": schemas = [Schema(df.collect_schema()) for df in items] - out_schema = reduce( - lambda x, y: to_supertype(*combine_schemas(x, y)), schemas - ) + out_schema = reduce(to_supertype_diagonal, schemas) res, *others = ( item.select( *( diff --git a/narwhals/_pandas_like/namespace.py b/narwhals/_pandas_like/namespace.py index 293589471..d43e42d5a 100644 --- a/narwhals/_pandas_like/namespace.py +++ b/narwhals/_pandas_like/namespace.py @@ -24,7 +24,7 @@ from narwhals._pandas_like.utils import ( promote_dtype_backend, ) from narwhals._utils import zip_strict -from narwhals.schema import Schema, combine_schemas, to_supertype +from narwhals.schema import Schema, to_supertype, to_supertype_diagonal if TYPE_CHECKING: from collections.abc import Iterable, Sequence @@ -270,8 +270,7 @@ class PandasLikeNamespace( dtypes = tuple(native_schema(df) for df in dfs) dtype_backend = promote_dtype_backend(dfs, self._implementation) out_schema = reduce( - lambda x, y: to_supertype(*combine_schemas(x, y)), - (Schema.from_pandas_like(dtype) for dtype in dtypes), + to_supertype_diagonal, (Schema.from_pandas_like(dtype) for dtype in dtypes) ).to_pandas(dtype_backend=dtype_backend.values()) native_res = ( diff --git a/narwhals/_spark_like/namespace.py b/narwhals/_spark_like/namespace.py index 275f82589..e67a99e29 100644 --- a/narwhals/_spark_like/namespace.py +++ b/narwhals/_spark_like/namespace.py @@ -19,7 +19,7 @@ from narwhals._spark_like.utils import ( true_divide, ) from narwhals._sql.namespace import SQLNamespace -from narwhals.schema import Schema, combine_schemas, to_supertype +from narwhals.schema import Schema, to_supertype, to_supertype_diagonal if TYPE_CHECKING: from collections.abc import Iterable @@ -195,9 +195,7 @@ class SparkLikeNamespace( if how == "diagonal_relaxed": schemas = tuple(Schema(item.collect_schema()) for item in items) - out_schema = reduce( - lambda x, y: to_supertype(*combine_schemas(x, y)), schemas - ) + out_schema = reduce(to_supertype_diagonal, schemas) native_items = ( item.select( *( diff --git a/narwhals/schema.py b/narwhals/schema.py index 3f5ea8650..59a589034 100644 --- a/narwhals/schema.py +++ b/narwhals/schema.py @@ -387,20 +387,21 @@ def _ensure_names_match(left: Schema, right: Schema) -> tuple[Schema, Schema]: def to_supertype(left: Schema, right: Schema) -> Schema: + """Take two schemas and try to find the supertypes between them.""" # Adapted from polars https://github.com/pola-rs/polars/blob/c2412600210a21143835c9dfcb0a9182f462b619/crates/polars-core/src/schema/mod.rs#L83-L96 left, right = _ensure_names_match(left, right) it = zip(left.keys(), left.values(), right.values()) return Schema((name, _supertype(ltype, rtype)) for (name, ltype, rtype) in it) -def combine_schemas(left: Schema, right: Schema) -> tuple[Schema, Schema]: - """Extend both schemas with names and dtypes missing from the other. +def to_supertype_diagonal(left: Schema, right: Schema) -> Schema: + """Align schemas for `concat(how="diagonal*")` and try to find the supertypes between them. - Returns a tuple of two schemas where each original schema is extended - with the columns that exist in the other schema but not in itself. + Both schemas are extended with the columns that exist in the other schema but not in itself. - The final order for both schemas is: left schema keys first (in order), - followed by keys missing from left (in the order they appear in right). + The final order for both schemas is: + - left schema keys first + - followed by keys missing from left (in the order they appear in right) """ left_names = set(left.keys()) missing_in_left = (kv for kv in right.items() if kv[0] not in left_names) @@ -408,4 +409,4 @@ def combine_schemas(left: Schema, right: Schema) -> tuple[Schema, Schema]: extended_left = Schema((*left.items(), *missing_in_left)) # Reorder right to match: left keys first, then right-only keys extended_right = Schema((kv[0], right.get(*kv)) for kv in extended_left.items()) - return extended_left, extended_right + return to_supertype(extended_left, extended_right)

I used the name to_supertype_diagonal for now, but I'm not too attached it 😄

I don't love it either 😂

What if we just call it merge_schemas as polars, which adds the to_supertype at the end of the current combine_schemas implementation?

What if we just call it merge_schemas as polars, which adds the to_supertype at the end of the current combine_schemas implementation?

I was wrong earlier in (#3398 (comment)).

AFAICT, merge_schemas is only used for "horizontal".

What I was trying to say yesterday on discord:

(1) Schema.to_supertype operates on the simplest case

By this I mean, we only have to do this for concat(how="vertical")

Was that polars uses to_supertype for both paths.
"diagonal" goes through convert_diagonal_concat first and then both go through the same convert_st_union bit

I'm not sure if that helps anything - just trying to correct myself 😅

Was that polars uses to_supertype for both paths.

"diagonal" goes through convert_diagonal_concat first and then both go through the same convert_st_union bit

@FBruzzesi

Okay I just pulled at this thread a bit locally and now have a very rough narwhals port of convert_diagonal_concat.

It's operating over BaseFrame atm, but probably belongs in CompliantNamespace (and using the compliant-level).

I've tested with ibis and I'm pretty sure we can support both "diagonal*" variants this way 🫰

Show diff

diff --git a/narwhals/schema.py b/narwhals/schema.py index 59a589034..5fead8f4e 100644 --- a/narwhals/schema.py +++ b/narwhals/schema.py @@ -7,7 +7,7 @@ https://github.com/pola-rs/polars/blob/main/py-polars/polars/schema.py. from __future__ import annotations from collections import OrderedDict -from collections.abc import Mapping +from collections.abc import Mapping, Sequence from functools import partial from typing import TYPE_CHECKING, cast @@ -26,13 +26,15 @@ from narwhals.exceptions import ComputeError, SchemaMismatchError if TYPE_CHECKING: from collections.abc import Iterable - from typing import Any, ClassVar + from typing import Any, ClassVar, TypeVar import polars as pl import pyarrow as pa from typing_extensions import Self + from narwhals.dataframe import BaseFrame from narwhals.dtypes import DType + from narwhals.expr import Expr from narwhals.typing import ( DTypeBackend, IntoArrowSchema, @@ -40,6 +42,8 @@ if TYPE_CHECKING: IntoPolarsSchema, ) + FrameT = TypeVar("FrameT", bound="BaseFrame[Any]") + __all__ = ["Schema"] @@ -410,3 +414,44 @@ def to_supertype_diagonal(left: Schema, right: Schema) -> Schema: # Reorder right to match: left keys first, then right-only keys extended_right = Schema((kv[0], right.get(*kv)) for kv in extended_left.items()) return to_supertype(extended_left, extended_right) + + +def convert_concat_diagonal(frames: Sequence[FrameT]) -> Sequence[FrameT]: + """Adapted from [`convert_diagonal_concat`]. + + [`convert_diagonal_concat`]: https://github.com/pola-rs/polars/blob/c2412600210a21143835c9dfcb0a9182f462b619/crates/polars-plan/src/plans/conversion/dsl_to_ir/concat.rs#L10-L68 + """ + import narwhals.functions as nw_f + + schemas = [frame.collect_schema() for frame in frames] + it_schemas = iter(schemas) + total_schema = dict(next(it_schemas)) + seen_names = set(total_schema) + to_add_fields: dict[str, DType] = {} + for sch in it_schemas: + to_add_fields.update( + {name: dtype for name, dtype in sch.items() if name not in seen_names} + ) + seen_names.update(to_add_fields) + if not seen_names: + return frames + total_schema.update(to_add_fields) + total_names = tuple(total_schema) + added_exprs: dict[str, Expr] = {} + results: list[FrameT] = [] + for frame, schema in zip(frames, schemas): + to_add_exprs: list[Expr] = [] + for name, dtype in total_schema.items(): + if name not in schema: + maybe_seen = added_exprs.get(name) + if maybe_seen is None: + to_add_expr = nw_f.lit(None, dtype).alias(name) + to_add_exprs.append(to_add_expr) + added_exprs[name] = to_add_expr + else: + to_add_exprs.append(maybe_seen) + result = frame + if to_add_exprs: + result = result.with_columns(to_add_exprs) + results.append(result.select(total_names)) + return results

We end up converting "diagonal*" -> "vertical*" (IIUC)

Updated

I've got the Compliant* version working now over on (https://github.com/narwhals-dev/narwhals/compare/convert-concat-diagonal)

Thanks @dangotbanned - on a pragmatic side, I would say to keep this as a follow up separated from this PR. My understanding from now is that it would only benefit ibis. I would rather have correctness in relaxed and "strict" modes first, and then expand to ibis. Although convert_concat_diagonal might be re-used in duckdb and spark-like as well, I would argue that the current implementation is a bit easier to read and maintain 🙈

Thanks @dangotbanned - on a pragmatic side, I would say to keep this as a follow up separated from this PR.

Absolutely!

I would argue that the current implementation is a bit easier to read

Agreed on that part too @FBruzzesi
I've just finished cleaning things up some and documenting in these few commits (f5c6407...convert-concat-diagonal)

My understanding from now is that it would only benefit ibis.

For how="diagonal"?
You might be right there, but I was thinking this replaces the need for combine_schemas entirely.
That's used in all of the backends (besides polars).

Is combine_schemas shorter than align_diagonal?
Definitely! 😅

But it is also called n_schemas - 1 times per concat.
By my count, each of those calls does:

1x Schema.keys()

3x Schema.items()

2x Schema(...)

I was quite alarmed by that when I noticed it 😳

So in my head, that ^^^

... and all of the extra stuff here ...

narwhals/narwhals/_arrow/namespace.py

Lines 180 to 193 in 8fabb13

def _concat_diagonal_relaxed(self, dfs: Sequence[pa.Table], /) -> pa.Table:

native_schemas = tuple(table.schema for table in dfs)

out_schema = reduce(

lambda x, y: to_supertype(*combine_schemas(x, y)),

(Schema.from_arrow(pa_schema) for pa_schema in native_schemas),

).to_arrow()

to_schemas = (

pa.schema([out_schema.field(name) for name in native_schema.names])

for native_schema in native_schemas

)

to_concat = tuple(

table.cast(to_schema) for table, to_schema in zip(dfs, to_schemas)

)

return self._concat_diagonal(to_concat)

... seems like it could be avoided and we just do align_diagonal -> _concat_vertical_relaxed?

narwhals/narwhals/_arrow/namespace.py

Lines 213 to 218 in 8fabb13

def _concat_vertical_relaxed(self, dfs: Sequence[pa.Table], /) -> pa.Table:

out_schema = reduce(

to_supertype, (Schema.from_arrow(table.schema) for table in dfs)

).to_arrow()

return pa.concat_tables([table.cast(out_schema) for table in dfs])

Note
I would rather fully disolve 🫠 than benchmark again, so I'm just asking to consider how many iterations each is doing 🙏

FBruzzesi · 2026-01-11T18:42:46Z

tests/frame/concat_test.py

+def _cast(frame: LazyFrameT, schema: Schema) -> LazyFrameT:
+    return frame.select(nw.col(name).cast(dtype) for name, dtype in schema.items())


I still cry each time I try to reach out for {DataFrame,LazyFrame}.cast 😂

I want it too 😢

@FBruzzesi let's revive #1045 as a new issue.

The example in that test isn't the motivating part.

What's here could be both more efficient and shorter

narwhals/narwhals/_arrow/namespace.py

Lines 180 to 194 in 8fabb13

def _concat_diagonal_relaxed(self, dfs: Sequence[pa.Table], /) -> pa.Table:

native_schemas = tuple(table.schema for table in dfs)

out_schema = reduce(

lambda x, y: to_supertype(*combine_schemas(x, y)),

(Schema.from_arrow(pa_schema) for pa_schema in native_schemas),

).to_arrow()

to_schemas = (

pa.schema([out_schema.field(name) for name in native_schema.names])

for native_schema in native_schemas

)

to_concat = tuple(

table.cast(to_schema) for table, to_schema in zip(dfs, to_schemas)

)

return self._concat_diagonal(to_concat)

+++ b/narwhals/_arrow/dataframe.py + def cast(self, schema: IntoSchema | Iterable[tuple[str, DType]]) -> Self: + return self._with_native( + self.native.cast(Schema(schema).to_arrow()), validate_column_names=False + ) + +++ b/narwhals/_arrow/namespace.py -from narwhals._arrow.utils import cast_to_comparable_string_types +from narwhals._arrow.utils import cast_to_comparable_string_types, concat_tables -from narwhals.schema import Schema, combine_schemas, to_supertype +from narwhals.schema import Schema, to_supertype, to_supertype_diagonal

With that, we can avoid materializing as much all at once

def concat_diagonal_relaxed(self, dfs: Sequence[ArrowDataFrame], /) -> ArrowDataFrame: schemas = [Schema(df.schema) for df in dfs] supertypes = reduce(to_supertype_diagonal, schemas) to_concat = ( df.cast((name, supertypes[name]) for name in schema).native for df, schema in zip(dfs, schemas) ) return dfs[0]._with_native(concat_tables(to_concat))

Otherwise I am going to forget: #3402

narwhals/_duckdb/namespace.py

```py error: Unsupported target for indexed assignment ("Mapping[str, DType]") ```

narwhals/schema.py

If the function already exists, we can use it instead 😄

#3398 (comment)

Related #3398 (comment)

- Reuse the schemas we've already collected - And rename the variables so it is obvious - Skip checking if columns exist for the first schema - Use a generator inside `dict.update` (instead of many `__setitem__`s) - Use `iter_dtype_backends` instead of creating a new `partial` Unrelated to performance: Return `.values()` instead of a `dict` (no usage of the keys anywhere?)

FBruzzesi · 2026-01-31T12:24:21Z

tests/frame/concat_test.py

+    assert_equal_data(result.collect(), expected_data)
+
+
+def test_pyarrow_concat_vertical_uuid() -> None:


@MarcoGorelli I added 3 tests (pyarrow, duckdb and ibis) to check if the changes in 4a1b946 and b205ddb support what we mentioned yesterday during the community call. Namely that datatypes that are not supported by narwhals are preserved.

For polars, pandas and dask I am not applying these "workarounds" since we should support all their datatypes*

*Exception is made for poalrs Float16 and Null, but also for polars we just dispatch the method without touching the datatypes. Am I missing something for pandas and dask?

pd.PeriodDtype?

But more generally, pandas supports registering extension types and so does polars (recently)

dangotbanned · 2026-01-31T14:35:59Z

narwhals/_utils.py

+    ns: CompliantNamespace[CompliantFrameT, CompliantExprT],
+    mapping: Mapping[str, dtypes.DType],
+) -> Iterable[CompliantExprT]:
+    Unknown = ns._version.dtypes.Unknown()  # noqa: N806


I would:

Move this to https://github.com/narwhals-dev/narwhals/blob/4a1b946eeb3627812a0d44fd270f77837629da3c/narwhals/dtypes/_utils.py

Use from narwhals.dtypes._classes import Unknown at the module-level

Replace == with dtype.base_type() is Unknown

FBruzzesi added 7 commits January 11, 2026 16:13

WIP: Add relaxed versions for all but Dask

3b49eff

WIP: Add unit tests

336f652

fixup col name and pyarrow

7d4cb37

minor standardization

0f17849

pandas-like promote_dtype_backend

cebeeda

dask and tests

942af32

add to_supertype coverage

9743d24

FBruzzesi added the enhancement New feature or request label Jan 11, 2026

Merge branch 'dtypes/supertyping' into feat/supertyping-relaxed-concat

1aa2232

FBruzzesi commented Jan 11, 2026

View reviewed changes

narwhals/_duckdb/namespace.py Show resolved Hide resolved

skip ibis diagonal

3328f2f

dangotbanned mentioned this pull request Jan 11, 2026

feat(DRAFT): Add get_supertype #3396

Draft

32 tasks

FBruzzesi mentioned this pull request Jan 11, 2026

perf: Avoid recursive union all by name call for duckdb diagonal concat #3399

Closed

10 tasks

dangotbanned added 4 commits January 11, 2026 21:20

fix(typing): Make pyright happier

23d0cd4

fix(typing): Pacify mypy for pandas_like

e0ce9eb

wow that was a useless error message!

4b484f4

```py error: Unsupported target for indexed assignment ("Mapping[str, DType]") ```

fix(typing): Tell mypy we have a wider type than the first assignment

683c835

dangotbanned reviewed Jan 11, 2026

View reviewed changes

narwhals/schema.py Outdated Show resolved Hide resolved

dangotbanned added 2 commits January 11, 2026 22:29

perf: Avoid unnecessary lambdas

5bffccd

If the function already exists, we can use it instead 😄

perf: Use a generator instead of intermediate dict

8fabb13

#3398 (comment)

dangotbanned added a commit that referenced this pull request Jan 12, 2026

feat(DRAFT): Support concat(..., how="diagonal") for ibis

8caaf2a

Related #3398 (comment)

dangotbanned mentioned this pull request Jan 13, 2026

[Enh]: Add support {DataFrame, LazyFrame}.cast(...) #3402

Open

dangotbanned mentioned this pull request Jan 15, 2026

feat: Support concat(..., how="diagonal") for ibis #3404

Merged

FBruzzesi added 2 commits January 20, 2026 13:59

ibis diagonal relaxed

909f06b

combine_schemas -> merge_schemas

c832b72

FBruzzesi mentioned this pull request Jan 27, 2026

feat: Allow nested structures in lit #3424

Merged

13 tasks

FBruzzesi added 4 commits January 30, 2026 21:23

merge head

41f8679

preserve unknown for lazy backends

4a1b946

merge head and solve conflicts

cdae5c8

preserve original dtype if not supported by narwhals

b205ddb

FBruzzesi commented Jan 31, 2026

View reviewed changes

FBruzzesi added 2 commits January 31, 2026 13:28

require pyarrow 19

61205dd

add reason

b3576dc

dangotbanned reviewed Jan 31, 2026

View reviewed changes

		return Schema(into_out_schema)


		def combine_schemas(left: Schema, right: Schema) -> tuple[Schema, Schema]:

	def _concat_diagonal_relaxed(self, dfs: Sequence[pa.Table], /) -> pa.Table:
	native_schemas = tuple(table.schema for table in dfs)
	out_schema = reduce(
	lambda x, y: to_supertype(*combine_schemas(x, y)),
	(Schema.from_arrow(pa_schema) for pa_schema in native_schemas),
	).to_arrow()
	to_schemas = (
	pa.schema([out_schema.field(name) for name in native_schema.names])
	for native_schema in native_schemas
	)
	to_concat = tuple(
	table.cast(to_schema) for table, to_schema in zip(dfs, to_schemas)
	)
	return self._concat_diagonal(to_concat)

	def _concat_vertical_relaxed(self, dfs: Sequence[pa.Table], /) -> pa.Table:
	out_schema = reduce(
	to_supertype, (Schema.from_arrow(table.schema) for table in dfs)
	).to_arrow()

	return pa.concat_tables([table.cast(out_schema) for table in dfs])

		def _cast(frame: LazyFrameT, schema: Schema) -> LazyFrameT:
		return frame.select(nw.col(name).cast(dtype) for name, dtype in schema.items())

		assert_equal_data(result.collect(), expected_data)


		def test_pyarrow_concat_vertical_uuid() -> None:

Conversation

FBruzzesi commented Jan 11, 2026 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Description

What type of PR is this? (check all applicable)

Related issues

Checklist

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

dangotbanned Jan 12, 2026 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Updated

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Uh oh!

Uh oh!

Choose a reason for hiding this comment

Uh oh!

dangotbanned Jan 31, 2026 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

2 participants

FBruzzesi commented Jan 11, 2026 •

edited

Loading

dangotbanned Jan 12, 2026 •

edited

Loading

dangotbanned Jan 31, 2026 •

edited

Loading