What you're intending to get back is the transpose of group_by.agg

df.group_by('bar').agg(pl.col('baz')).transpose()

@deanm0000, the transpose does not provide header names like pivot does. Obviously can promote the first row as headers afterwards though.

A perhaps simpler workaround for the issue would be to create a literal column (with a single unique value), use that as the index to pivot and then drop it after.

(
    df.with_columns(pl.lit(1))
    .pivot(values="baz", index="literal", columns="bar", aggregate_function="sum")
    .drop("literal")
)

The above produces the expected output.

Workarounds or alternative approaches aside, I created this issue as I believe (and the type hints in the function indicate) that index=None should be valid, but is currently raising an error.

I wasn't trying to discount the request, just trying to help. That said, what I put in earlier was on mobile without looking at how it worked. A more complete version would be

(
    df.group_by('bar', maintain_order=True).sum()
    .select('baz').transpose(column_names=df['bar'].unique())
    )

A way that doesn't use transpose and so might be more efficient...

(
    df
    .group_by('bar', maintain_order=True)
    .agg(pl.col('baz').sum())
    .select(pl.col('baz').implode().list.to_struct().struct.rename_fields(df['bar'].unique()))
    .unnest('baz')
)

This bug reminds me of this one: #10075

Hey @MarcoGorelli, as you look to have been in the world of pivot lately, thought you may appreciate a heads up on this one.
I have checked again on 0.20.7, and this still produces the same error.

And on main, there is still the discrepancy for index between the type hint (None as an option) and docstring ("One or multiple keys to group by.", implying that None is not okay.).

Hey

Just looking at this again, and I'm not sure about adding complexity to pivot, it's already pretty complicated

The desired functionality can be achieved with

df.group_by('bar').agg(pl.sum('baz')).transpose(column_names='bar')

shape: (1, 2)
┌─────┬─────┐
│ x   ┆ y   │
│ --- ┆ --- │
│ i64 ┆ i64 │
╞═════╪═════╡
│ 4   ┆ 6   │
└─────┴─────┘

which is a bit expensive, but then again so is pivot. And it's arguably clearer than

df.pivot(values="baz", index=None, columns="bar", aggregate_function="sum")

?

Something else I feel uneasy about is this:

• values=None means "use all remaining columns if index and columns have already been specified"

So, for consistency, I'd expect index=None to mean "use all remaining columns if columns and values have been specified". I have some recollection that this is what @mcrumiller was going for at some point, rather than the 1-row variant suggested here

Either that, or to remove | None from the type hint

@MarcoGorelli
It seems there are two points:

• Can the user specify that no index cols should be used and a single output row be produced e.g. index=[].
• should index=None correspond to index=[] or 'all remaining columns'.

I think that the second point is distinct from the first. Perhaps we could allow e.g.

df = pl.DataFrame(
    {
        "foo": ["A", "B", "C"],
        "N": [1, 2, 3],
        "M": [4, 5, 6],
    }
)
df.pivot(index=[], columns="foo", values=None, aggregate_function=None)

shape: (1, 6)
┌─────────┬─────────┬─────────┬─────────┬─────────┬─────────┐
│ N_foo_A ┆ N_foo_B ┆ N_foo_C ┆ M_foo_A ┆ M_foo_B ┆ M_foo_C │
│ ---     ┆ ---     ┆ ---     ┆ ---     ┆ ---     ┆ ---     │
│ i64     ┆ i64     ┆ i64     ┆ i64     ┆ i64     ┆ i64     │
╞═════════╪═════════╪═════════╪═════════╪═════════╪═════════╡
│ 1       ┆ 2       ┆ 3       ┆ 4       ┆ 5       ┆ 6       │
└─────────┴─────────┴─────────┴─────────┴─────────┴─────────┘

Note that this behaviour is already implemented in #15855
so that PR would just have to be modified to remove the None becomes [] logic.