It currently gets documentation from pl.DataFrame

import polars as pl
from polars import col

def _args_as_list(x):
  if len(x) == 0:
      return []
  elif isinstance(x[0], list):
      return x[0]
  elif isinstance(x[0], pl.Series):
      return list(x[0])
  else:
      return [*x]

def _as_list(x):
  if isinstance(x, list):
      return x.copy()
  else:
      return [x]

def tibble(*args, **kwargs):
  args = _args_as_list(args)
  if len(args) == 0:
    kwargs = {key:_as_list(value) for key, value in kwargs.items()}
    return pl.DataFrame(kwargs)
  elif len(args) == 1:
    return pl.DataFrame(args[0])
  else:
    raise ValueError

tibble(x = [1, 2, 3], y = ['a', 'a', 'b'])

Would allow R-like syntax while also allowing generation through a dictionary

Would just call pl.when().then().otherwise() in the background

Probably should also include functions as well as methods

Which one should we go with?

I think we should be able to use polars series instead of numpy arrays and get the same functionality (for our use case). This would also allow us to drop numpy as a dependency.

To Do:

• Remove from relocate
• Remove from tests

Should the syntax be the same as pl.DataFrame.rename? Currently polars mimics pandas syntax. Or should it be something that attempts to mimic tidyverse syntax?

Note: polars also has a .rename_col() with syntax df.rename_col('old', 'new').

• everything()
• starts_with()
• ends_with()
• contains()

Probably should be made with a groupby arg. But at the very least should mask the polars implementations.

In __init__.py, it looks for the installed version of tidypolars, however if it hasn't been previously installed it throws a PackageNotFoundError error. One work around is to comment block the script in __init__.py and then import tidypolars. Then uncomment block the script in __init__.py, restart the kernel, and then import tidypolars.

I attempted to fix in a new branch "update-init".

#14 Removing numpy would also help the initial import of tidypolars. That was another error that was thrown since I didn't have numpy installed on my test env. I doubt this would be a problem since most users have numpy. This is not something I addressed in the new branch "update-init".

• .left_join()
• .inner_join()
• .full_join()

Should we add this? I think it's a pretty commonly used alias in the tidyverse

We need to wait on this one until pl.Expr.fill_null() gains a "strategy" arg

Edit: pola-rs/polars#1517

Probably should wait for #38

Or maybe we just leave these to be accessed by Expr methods

Should the class be called Tibble?

We're importing Series from polars, seems a bit odd to be using tibble/Series instead of Tibble/Series.

We should be able to just call

import pandas as pd
pandas_df = pd.DataFrame({'x': range(3), 'y': range(3)})

import polars as pl
polars_df = pl.DataFrame({'x': range(3), 'y': range(3)})

tp.tibble(pandas_df)
tp.tibble(polars_df)

Should we error on .groupby()?

Probably would lead to some difficult errors to debug for users.

We could also add a helpful error message "`df.groupby()` doesn't work on tibbles. Did you mean `df.group_by()`?"

https://stackoverflow.com/questions/5827277/how-to-hide-superclass-methods-in-a-subclass

Do we need these? Both .head() and .tail() work by group

Or maybe to the bottom of the module

https://stackoverflow.com/questions/4732850/is-there-a-way-to-keep-docstrings-separate-from-the-functions-they-document

What should the syntax be? Should it just be the same as pl.DataFrame.rename but return a tibble? Currently polars mimics pandas syntax.

Note: polars also has a .rename_col() with syntax df.rename_col('old', 'new').

This would allow for things like .lag()/.lead() instead of using the functions. It would also allow us to control what methods a user has access to. However his would be a ton more work, and might not lead to much benefit.

Tasks:

• tibble method
• grouped_tibble method

To start:

• pandas
• polars

Later:

• dplyr
• data.table