From 112ef075632c0815beb9838b91a83331fe649f0b Mon Sep 17 00:00:00 2001 From: Devin Petersohn Date: Sun, 7 Jan 2018 12:00:16 -0800 Subject: [PATCH] Adding all DataFrame methods with NotImplementedErrors (#1403) * Adding all DataFrame methods with NotImplementedErrors * Moving dataframe creation into function call --- python/ray/dataframe/dataframe.py | 759 ++++++++++++++- test/dataframe.py | 1486 +++++++++++++++++++++++++++++ 2 files changed, 2234 insertions(+), 11 deletions(-) diff --git a/python/ray/dataframe/dataframe.py b/python/ray/dataframe/dataframe.py index 47c9bcd4a..f811db682 100644 --- a/python/ray/dataframe/dataframe.py +++ b/python/ray/dataframe/dataframe.py @@ -163,7 +163,7 @@ class DataFrame(object): assert(callable(func)) return self.map_partitions(lambda df: df.applymap(lambda x: func(x))) - def copy(self): + def copy(self, deep=True): """Creates a shallow copy of the DataFrame. Returns: @@ -171,13 +171,8 @@ class DataFrame(object): """ return DataFrame(self.df, self.columns) - def groupby(self, - by=None, - axis=0, - level=None, - as_index=True, - group_keys=True, - squeeze=False): + def groupby(self, by=None, axis=0, level=None, as_index=True, sort=True, + group_keys=True, squeeze=False, **kwargs): """Apply a groupby to this DataFrame. See _groupby() remote task. Args: @@ -227,7 +222,7 @@ class DataFrame(object): """ return self.groupby(axis=axis).map_partitions(func) - def sum(self, axis=None, skipna=True): + def sum(self, axis=None, skipna=True, level=None, numeric_only=None): """Perform a sum across the DataFrame. Args: @@ -238,10 +233,12 @@ class DataFrame(object): The sum of the DataFrame. """ sum_of_partitions = self.map_partitions( - lambda df: df.sum(axis=axis, skipna=skipna)) + lambda df: df.sum(axis=axis, skipna=skipna, level=level, + numeric_only=numeric_only)) return sum_of_partitions.reduce_by_index( - lambda df: df.sum(axis=axis, skipna=skipna)) + lambda df: df.sum(axis=axis, skipna=skipna, level=level, + numeric_only=numeric_only)) def abs(self): """Apply an absolute value function to all numberic columns. @@ -333,6 +330,746 @@ class DataFrame(object): if how != 'any' and how != 'all': raise ValueError(" not correctly set.") + def add(self, other, axis='columns', level=None, fill_value=None): + raise NotImplementedError("Not Yet implemented.") + + def agg(self, func, axis=0, *args, **kwargs): + raise NotImplementedError("Not Yet implemented.") + + def aggregate(self, func, axis=0, *args, **kwargs): + raise NotImplementedError("Not Yet implemented.") + + def align(self, other, join='outer', axis=None, level=None, copy=True, + fill_value=None, method=None, limit=None, fill_axis=0, + broadcast_axis=None): + raise NotImplementedError("Not Yet implemented.") + + def all(self, axis=None, bool_only=None, skipna=None, level=None, + **kwargs): + raise NotImplementedError("Not Yet implemented.") + + def any(self, axis=None, bool_only=None, skipna=None, level=None, + **kwargs): + raise NotImplementedError("Not Yet implemented.") + + def append(self, other, ignore_index=False, verify_integrity=False): + raise NotImplementedError("Not Yet implemented.") + + def apply(self, func, axis=0, broadcast=False, raw=False, reduce=None, + args=(), **kwds): + raise NotImplementedError("Not Yet implemented.") + + def as_blocks(self, copy=True): + raise NotImplementedError("Not Yet implemented.") + + def as_matrix(self, columns=None): + raise NotImplementedError("Not Yet implemented.") + + def asfreq(self, freq, method=None, how=None, normalize=False, + fill_value=None): + raise NotImplementedError("Not Yet implemented.") + + def asof(self, where, subset=None): + raise NotImplementedError("Not Yet implemented.") + + def assign(self, **kwargs): + raise NotImplementedError("Not Yet implemented.") + + def astype(self, dtype, copy=True, errors='raise', **kwargs): + raise NotImplementedError("Not Yet implemented.") + + def at_time(self, time, asof=False): + raise NotImplementedError("Not Yet implemented.") + + def between_time(self, start_time, end_time, include_start=True, + include_end=True): + raise NotImplementedError("Not Yet implemented.") + + def bfill(self, axis=None, inplace=False, limit=None, downcast=None): + raise NotImplementedError("Not Yet implemented.") + + def bool(self): + raise NotImplementedError("Not Yet implemented.") + + def boxplot(self, column=None, by=None, ax=None, fontsize=None, rot=0, + grid=True, figsize=None, layout=None, return_type=None, + **kwds): + raise NotImplementedError("Not Yet implemented.") + + def clip(self, lower=None, upper=None, axis=None, inplace=False, *args, + **kwargs): + raise NotImplementedError("Not Yet implemented.") + + def clip_lower(self, threshold, axis=None, inplace=False): + raise NotImplementedError("Not Yet implemented.") + + def clip_upper(self, threshold, axis=None, inplace=False): + raise NotImplementedError("Not Yet implemented.") + + def combine(self, other, func, fill_value=None, overwrite=True): + raise NotImplementedError("Not Yet implemented.") + + def combine_first(self, other): + raise NotImplementedError("Not Yet implemented.") + + def compound(self, axis=None, skipna=None, level=None): + raise NotImplementedError("Not Yet implemented.") + + def consolidate(self, inplace=False): + raise NotImplementedError("Not Yet implemented.") + + def convert_objects(self, convert_dates=True, convert_numeric=False, + convert_timedeltas=True, copy=True): + raise NotImplementedError("Not Yet implemented.") + + def corr(self, method='pearson', min_periods=1): + raise NotImplementedError("Not Yet implemented.") + + def corrwith(self, other, axis=0, drop=False): + raise NotImplementedError("Not Yet implemented.") + + def count(self, axis=0, level=None, numeric_only=False): + raise NotImplementedError("Not Yet implemented.") + + def cov(self, min_periods=None): + raise NotImplementedError("Not Yet implemented.") + + def cummax(self, axis=None, skipna=True, *args, **kwargs): + raise NotImplementedError("Not Yet implemented.") + + def cummin(self, axis=None, skipna=True, *args, **kwargs): + raise NotImplementedError("Not Yet implemented.") + + def cumprod(self, axis=None, skipna=True, *args, **kwargs): + raise NotImplementedError("Not Yet implemented.") + + def cumsum(self, axis=None, skipna=True, *args, **kwargs): + raise NotImplementedError("Not Yet implemented.") + + def describe(self, percentiles=None, include=None, exclude=None): + raise NotImplementedError("Not Yet implemented.") + + def diff(self, periods=1, axis=0): + raise NotImplementedError("Not Yet implemented.") + + def div(self, other, axis='columns', level=None, fill_value=None): + raise NotImplementedError("Not Yet implemented.") + + def divide(self, other, axis='columns', level=None, fill_value=None): + raise NotImplementedError("Not Yet implemented.") + + def dot(self, other): + raise NotImplementedError("Not Yet implemented.") + + def drop(self, labels=None, axis=0, index=None, columns=None, level=None, + inplace=False, errors='raise'): + raise NotImplementedError("Not Yet implemented.") + + def drop_duplicates(self, subset=None, keep='first', inplace=False): + raise NotImplementedError("Not Yet implemented.") + + def duplicated(self, subset=None, keep='first'): + raise NotImplementedError("Not Yet implemented.") + + def eq(self, other, axis='columns', level=None): + raise NotImplementedError("Not Yet implemented.") + + def equals(self, other): + raise NotImplementedError("Not Yet implemented.") + + def eval(self, expr, inplace=False, **kwargs): + raise NotImplementedError("Not Yet implemented.") + + def ewm(self, com=None, span=None, halflife=None, alpha=None, + min_periods=0, freq=None, adjust=True, ignore_na=False, axis=0): + raise NotImplementedError("Not Yet implemented.") + + def expanding(self, min_periods=1, freq=None, center=False, axis=0): + raise NotImplementedError("Not Yet implemented.") + + def ffill(self, axis=None, inplace=False, limit=None, downcast=None): + raise NotImplementedError("Not Yet implemented.") + + def fillna(self, value=None, method=None, axis=None, inplace=False, + limit=None, downcast=None, **kwargs): + raise NotImplementedError("Not Yet implemented.") + + def filter(self, items=None, like=None, regex=None, axis=None): + raise NotImplementedError("Not Yet implemented.") + + def first(self, offset): + raise NotImplementedError("Not Yet implemented.") + + def first_valid_index(self): + raise NotImplementedError("Not Yet implemented.") + + def floordiv(self, other, axis='columns', level=None, fill_value=None): + raise NotImplementedError("Not Yet implemented.") + + @classmethod + def from_csv(self, path, header=0, sep=', ', index_col=0, + parse_dates=True, encoding=None, tupleize_cols=None, + infer_datetime_format=False): + raise NotImplementedError("Not Yet implemented.") + + @classmethod + def from_dict(self, data, orient='columns', dtype=None): + raise NotImplementedError("Not Yet implemented.") + + @classmethod + def from_items(self, items, columns=None, orient='columns'): + raise NotImplementedError("Not Yet implemented.") + + @classmethod + def from_records(self, data, index=None, exclude=None, columns=None, + coerce_float=False, nrows=None): + raise NotImplementedError("Not Yet implemented.") + + def ge(self, other, axis='columns', level=None): + raise NotImplementedError("Not Yet implemented.") + + def get(self, key, default=None): + raise NotImplementedError("Not Yet implemented.") + + def get_dtype_counts(self): + raise NotImplementedError("Not Yet implemented.") + + def get_ftype_counts(self): + raise NotImplementedError("Not Yet implemented.") + + def get_value(self, index, col, takeable=False): + raise NotImplementedError("Not Yet implemented.") + + def get_values(self): + raise NotImplementedError("Not Yet implemented.") + + def gt(self, other, axis='columns', level=None): + raise NotImplementedError("Not Yet implemented.") + + def head(self, n=5): + raise NotImplementedError("Not Yet implemented.") + + def hist(self, data, column=None, by=None, grid=True, xlabelsize=None, + xrot=None, ylabelsize=None, yrot=None, ax=None, sharex=False, + sharey=False, figsize=None, layout=None, bins=10, **kwds): + raise NotImplementedError("Not Yet implemented.") + + def idxmax(self, axis=0, skipna=True): + raise NotImplementedError("Not Yet implemented.") + + def idxmin(self, axis=0, skipna=True): + raise NotImplementedError("Not Yet implemented.") + + def infer_objects(self): + raise NotImplementedError("Not Yet implemented.") + + def info(self, verbose=None, buf=None, max_cols=None, memory_usage=None, + null_counts=None): + raise NotImplementedError("Not Yet implemented.") + + def insert(self, loc, column, value, allow_duplicates=False): + raise NotImplementedError("Not Yet implemented.") + + def interpolate(self, method='linear', axis=0, limit=None, inplace=False, + limit_direction='forward', downcast=None, **kwargs): + raise NotImplementedError("Not Yet implemented.") + + def items(self): + raise NotImplementedError("Not Yet implemented.") + + def iteritems(self): + raise NotImplementedError("Not Yet implemented.") + + def iterrows(self): + raise NotImplementedError("Not Yet implemented.") + + def itertuples(self, index=True, name='Pandas'): + raise NotImplementedError("Not Yet implemented.") + + def join(self, other, on=None, how='left', lsuffix='', rsuffix='', + sort=False): + raise NotImplementedError("Not Yet implemented.") + + def kurt(self, axis=None, skipna=None, level=None, numeric_only=None, + **kwargs): + raise NotImplementedError("Not Yet implemented.") + + def kurtosis(self, axis=None, skipna=None, level=None, numeric_only=None, + **kwargs): + raise NotImplementedError("Not Yet implemented.") + + def last(self, offset): + raise NotImplementedError("Not Yet implemented.") + + def last_valid_index(self): + raise NotImplementedError("Not Yet implemented.") + + def le(self, other, axis='columns', level=None): + raise NotImplementedError("Not Yet implemented.") + + def lookup(self, row_labels, col_labels): + raise NotImplementedError("Not Yet implemented.") + + def lt(self, other, axis='columns', level=None): + raise NotImplementedError("Not Yet implemented.") + + def mad(self, axis=None, skipna=None, level=None): + raise NotImplementedError("Not Yet implemented.") + + def mask(self, cond, other=np.nan, inplace=False, axis=None, level=None, + errors='raise', try_cast=False, raise_on_error=None): + raise NotImplementedError("Not Yet implemented.") + + def max(self, axis=None, skipna=None, level=None, numeric_only=None, + **kwargs): + raise NotImplementedError("Not Yet implemented.") + + def mean(self, axis=None, skipna=None, level=None, numeric_only=None, + **kwargs): + raise NotImplementedError("Not Yet implemented.") + + def median(self, axis=None, skipna=None, level=None, numeric_only=None, + **kwargs): + raise NotImplementedError("Not Yet implemented.") + + def melt(self, id_vars=None, value_vars=None, var_name=None, + value_name='value', col_level=None): + raise NotImplementedError("Not Yet implemented.") + + def memory_usage(self, index=True, deep=False): + raise NotImplementedError("Not Yet implemented.") + + def merge(self, right, how='inner', on=None, left_on=None, right_on=None, + left_index=False, right_index=False, sort=False, + suffixes=('_x', '_y'), copy=True, indicator=False, + validate=None): + raise NotImplementedError("Not Yet implemented.") + + def min(self, axis=None, skipna=None, level=None, numeric_only=None, + **kwargs): + raise NotImplementedError("Not Yet implemented.") + + def mod(self, other, axis='columns', level=None, fill_value=None): + raise NotImplementedError("Not Yet implemented.") + + def mode(self, axis=0, numeric_only=False): + raise NotImplementedError("Not Yet implemented.") + + def mul(self, other, axis='columns', level=None, fill_value=None): + raise NotImplementedError("Not Yet implemented.") + + def multiply(self, other, axis='columns', level=None, fill_value=None): + raise NotImplementedError("Not Yet implemented.") + + def ne(self, other, axis='columns', level=None): + raise NotImplementedError("Not Yet implemented.") + + def nlargest(self, n, columns, keep='first'): + raise NotImplementedError("Not Yet implemented.") + + def notna(self): + raise NotImplementedError("Not Yet implemented.") + + def notnull(self): + raise NotImplementedError("Not Yet implemented.") + + def nsmallest(self, n, columns, keep='first'): + raise NotImplementedError("Not Yet implemented.") + + def nunique(self, axis=0, dropna=True): + raise NotImplementedError("Not Yet implemented.") + + def pct_change(self, periods=1, fill_method='pad', limit=None, freq=None, + **kwargs): + raise NotImplementedError("Not Yet implemented.") + + def pipe(self, func, *args, **kwargs): + raise NotImplementedError("Not Yet implemented.") + + def pivot(self, index=None, columns=None, values=None): + raise NotImplementedError("Not Yet implemented.") + + def pivot_table(self, values=None, index=None, columns=None, + aggfunc='mean', fill_value=None, margins=False, + dropna=True, margins_name='All'): + raise NotImplementedError("Not Yet implemented.") + + def plot(self, x=None, y=None, kind='line', ax=None, subplots=False, + sharex=None, sharey=False, layout=None, figsize=None, + use_index=True, title=None, grid=None, legend=True, style=None, + logx=False, logy=False, loglog=False, xticks=None, yticks=None, + xlim=None, ylim=None, rot=None, fontsize=None, colormap=None, + table=False, yerr=None, xerr=None, secondary_y=False, + sort_columns=False, **kwds): + raise NotImplementedError("Not Yet implemented.") + + def pop(self, item): + raise NotImplementedError("Not Yet implemented.") + + def pow(self, other, axis='columns', level=None, fill_value=None): + raise NotImplementedError("Not Yet implemented.") + + def prod(self, axis=None, skipna=None, level=None, numeric_only=None, + min_count=0, **kwargs): + raise NotImplementedError("Not Yet implemented.") + + def product(self, axis=None, skipna=None, level=None, numeric_only=None, + min_count=0, **kwargs): + raise NotImplementedError("Not Yet implemented.") + + def quantile(self, q=0.5, axis=0, numeric_only=True, + interpolation='linear'): + raise NotImplementedError("Not Yet implemented.") + + def query(self, expr, inplace=False, **kwargs): + raise NotImplementedError("Not Yet implemented.") + + def radd(self, other, axis='columns', level=None, fill_value=None): + raise NotImplementedError("Not Yet implemented.") + + def rank(self, axis=0, method='average', numeric_only=None, + na_option='keep', ascending=True, pct=False): + raise NotImplementedError("Not Yet implemented.") + + def rdiv(self, other, axis='columns', level=None, fill_value=None): + raise NotImplementedError("Not Yet implemented.") + + def reindex(self, labels=None, index=None, columns=None, axis=None, + method=None, copy=True, level=None, fill_value=np.nan, + limit=None, tolerance=None): + raise NotImplementedError("Not Yet implemented.") + + def reindex_axis(self, labels, axis=0, method=None, level=None, copy=True, + limit=None, fill_value=np.nan): + raise NotImplementedError("Not Yet implemented.") + + def reindex_like(self, other, method=None, copy=True, limit=None, + tolerance=None): + raise NotImplementedError("Not Yet implemented.") + + def rename(self, mapper=None, index=None, columns=None, axis=None, + copy=True, inplace=False, level=None): + raise NotImplementedError("Not Yet implemented.") + + def rename_axis(self, mapper, axis=0, copy=True, inplace=False): + raise NotImplementedError("Not Yet implemented.") + + def reorder_levels(self, order, axis=0): + raise NotImplementedError("Not Yet implemented.") + + def replace(self, to_replace=None, value=None, inplace=False, limit=None, + regex=False, method='pad', axis=None): + raise NotImplementedError("Not Yet implemented.") + + def resample(self, rule, how=None, axis=0, fill_method=None, closed=None, + label=None, convention='start', kind=None, loffset=None, + limit=None, base=0, on=None, level=None): + raise NotImplementedError("Not Yet implemented.") + + def reset_index(self, level=None, drop=False, inplace=False, col_level=0, + col_fill=''): + raise NotImplementedError("Not Yet implemented.") + + def rfloordiv(self, other, axis='columns', level=None, fill_value=None): + raise NotImplementedError("Not Yet implemented.") + + def rmod(self, other, axis='columns', level=None, fill_value=None): + raise NotImplementedError("Not Yet implemented.") + + def rmul(self, other, axis='columns', level=None, fill_value=None): + raise NotImplementedError("Not Yet implemented.") + + def rolling(self, window, min_periods=None, freq=None, center=False, + win_type=None, on=None, axis=0, closed=None): + raise NotImplementedError("Not Yet implemented.") + + def round(self, decimals=0, *args, **kwargs): + raise NotImplementedError("Not Yet implemented.") + + def rpow(self, other, axis='columns', level=None, fill_value=None): + raise NotImplementedError("Not Yet implemented.") + + def rsub(self, other, axis='columns', level=None, fill_value=None): + raise NotImplementedError("Not Yet implemented.") + + def rtruediv(self, other, axis='columns', level=None, fill_value=None): + raise NotImplementedError("Not Yet implemented.") + + def sample(self, n=None, frac=None, replace=False, weights=None, + random_state=None, axis=None): + raise NotImplementedError("Not Yet implemented.") + + def select(self, crit, axis=0): + raise NotImplementedError("Not Yet implemented.") + + def select_dtypes(self, include=None, exclude=None): + raise NotImplementedError("Not Yet implemented.") + + def sem(self, axis=None, skipna=None, level=None, ddof=1, + numeric_only=None, **kwargs): + raise NotImplementedError("Not Yet implemented.") + + def set_axis(self, labels, axis=0, inplace=None): + raise NotImplementedError("Not Yet implemented.") + + def set_index(self, keys, drop=True, append=False, inplace=False, + verify_integrity=False): + raise NotImplementedError("Not Yet implemented.") + + def set_value(self, index, col, value, takeable=False): + raise NotImplementedError("Not Yet implemented.") + + def shift(self, periods=1, freq=None, axis=0): + raise NotImplementedError("Not Yet implemented.") + + def skew(self, axis=None, skipna=None, level=None, numeric_only=None, + **kwargs): + raise NotImplementedError("Not Yet implemented.") + + def slice_shift(self, periods=1, axis=0): + raise NotImplementedError("Not Yet implemented.") + + def sort_index(self, axis=0, level=None, ascending=True, inplace=False, + kind='quicksort', na_position='last', sort_remaining=True, + by=None): + raise NotImplementedError("Not Yet implemented.") + + def sort_values(self, by, axis=0, ascending=True, inplace=False, + kind='quicksort', na_position='last'): + raise NotImplementedError("Not Yet implemented.") + + def sortlevel(self, level=0, axis=0, ascending=True, inplace=False, + sort_remaining=True): + raise NotImplementedError("Not Yet implemented.") + + def squeeze(self, axis=None): + raise NotImplementedError("Not Yet implemented.") + + def stack(self, level=-1, dropna=True): + raise NotImplementedError("Not Yet implemented.") + + def std(self, axis=None, skipna=None, level=None, ddof=1, + numeric_only=None, **kwargs): + raise NotImplementedError("Not Yet implemented.") + + def sub(self, other, axis='columns', level=None, fill_value=None): + raise NotImplementedError("Not Yet implemented.") + + def subtract(self, other, axis='columns', level=None, fill_value=None): + raise NotImplementedError("Not Yet implemented.") + + def swapaxes(self, axis1, axis2, copy=True): + raise NotImplementedError("Not Yet implemented.") + + def swaplevel(self, i=-2, j=-1, axis=0): + raise NotImplementedError("Not Yet implemented.") + + def tail(self, n=5): + raise NotImplementedError("Not Yet implemented.") + + def take(self, indices, axis=0, convert=None, is_copy=True, **kwargs): + raise NotImplementedError("Not Yet implemented.") + + def to_clipboard(self, excel=None, sep=None, **kwargs): + raise NotImplementedError("Not Yet implemented.") + + def to_csv(self, path_or_buf=None, sep=', ', na_rep='', float_format=None, + columns=None, header=True, index=True, index_label=None, + mode='w', encoding=None, compression=None, quoting=None, + quotechar='"', line_terminator='\n', chunksize=None, + tupleize_cols=None, date_format=None, doublequote=True, + escapechar=None, decimal='.'): + raise NotImplementedError("Not Yet implemented.") + + def to_dense(self): + raise NotImplementedError("Not Yet implemented.") + + def to_dict(self, orient='dict', into=dict): + raise NotImplementedError("Not Yet implemented.") + + def to_excel(self, excel_writer, sheet_name='Sheet1', na_rep='', + float_format=None, columns=None, header=True, index=True, + index_label=None, startrow=0, startcol=0, engine=None, + merge_cells=True, encoding=None, inf_rep='inf', verbose=True, + freeze_panes=None): + raise NotImplementedError("Not Yet implemented.") + + def to_feather(self, fname): + raise NotImplementedError("Not Yet implemented.") + + def to_gbq(self, destination_table, project_id, chunksize=10000, + verbose=True, reauth=False, if_exists='fail', + private_key=None): + raise NotImplementedError("Not Yet implemented.") + + def to_hdf(self, path_or_buf, key, **kwargs): + raise NotImplementedError("Not Yet implemented.") + + def to_html(self, buf=None, columns=None, col_space=None, header=True, + index=True, na_rep='np.NaN', formatters=None, + float_format=None, sparsify=None, index_names=True, + justify=None, bold_rows=True, classes=None, escape=True, + max_rows=None, max_cols=None, show_dimensions=False, + notebook=False, decimal='.', border=None): + raise NotImplementedError("Not Yet implemented.") + + def to_json(self, path_or_buf=None, orient=None, date_format=None, + double_precision=10, force_ascii=True, date_unit='ms', + default_handler=None, lines=False, compression=None): + raise NotImplementedError("Not Yet implemented.") + + def to_latex(self, buf=None, columns=None, col_space=None, header=True, + index=True, na_rep='np.NaN', formatters=None, + float_format=None, sparsify=None, index_names=True, + bold_rows=False, column_format=None, longtable=None, + escape=None, encoding=None, decimal='.', multicolumn=None, + multicolumn_format=None, multirow=None): + raise NotImplementedError("Not Yet implemented.") + + def to_msgpack(self, path_or_buf=None, encoding='utf-8', **kwargs): + raise NotImplementedError("Not Yet implemented.") + + def to_panel(self): + raise NotImplementedError("Not Yet implemented.") + + def to_parquet(self, fname, engine='auto', compression='snappy', + **kwargs): + raise NotImplementedError("Not Yet implemented.") + + def to_period(self, freq=None, axis=0, copy=True): + raise NotImplementedError("Not Yet implemented.") + + def to_pickle(self, path, compression='infer', protocol=4): + raise NotImplementedError("Not Yet implemented.") + + def to_records(self, index=True, convert_datetime64=True): + raise NotImplementedError("Not Yet implemented.") + + def to_sparse(self, fill_value=None, kind='block'): + raise NotImplementedError("Not Yet implemented.") + + def to_sql(self, name, con, flavor=None, schema=None, if_exists='fail', + index=True, index_label=None, chunksize=None, dtype=None): + raise NotImplementedError("Not Yet implemented.") + + def to_stata(self, fname, convert_dates=None, write_index=True, + encoding='latin-1', byteorder=None, time_stamp=None, + data_label=None, variable_labels=None): + raise NotImplementedError("Not Yet implemented.") + + def to_string(self, buf=None, columns=None, col_space=None, header=True, + index=True, na_rep='np.NaN', formatters=None, + float_format=None, sparsify=None, index_names=True, + justify=None, line_width=None, max_rows=None, max_cols=None, + show_dimensions=False): + raise NotImplementedError("Not Yet implemented.") + + def to_timestamp(self, freq=None, how='start', axis=0, copy=True): + raise NotImplementedError("Not Yet implemented.") + + def to_xarray(self): + raise NotImplementedError("Not Yet implemented.") + + def transform(self, func, *args, **kwargs): + raise NotImplementedError("Not Yet implemented.") + + def truediv(self, other, axis='columns', level=None, fill_value=None): + raise NotImplementedError("Not Yet implemented.") + + def truncate(self, before=None, after=None, axis=None, copy=True): + raise NotImplementedError("Not Yet implemented.") + + def tshift(self, periods=1, freq=None, axis=0): + raise NotImplementedError("Not Yet implemented.") + + def tz_convert(self, tz, axis=0, level=None, copy=True): + raise NotImplementedError("Not Yet implemented.") + + def tz_localize(self, tz, axis=0, level=None, copy=True, + ambiguous='raise'): + raise NotImplementedError("Not Yet implemented.") + + def unstack(self, level=-1, fill_value=None): + raise NotImplementedError("Not Yet implemented.") + + def update(self, other, join='left', overwrite=True, filter_func=None, + raise_conflict=False): + raise NotImplementedError("Not Yet implemented.") + + def var(self, axis=None, skipna=None, level=None, ddof=1, + numeric_only=None, **kwargs): + raise NotImplementedError("Not Yet implemented.") + + def where(self, cond, other=np.nan, inplace=False, axis=None, level=None, + errors='raise', try_cast=False, raise_on_error=None): + raise NotImplementedError("Not Yet implemented.") + + def xs(self, key, axis=0, level=None, drop_level=True): + raise NotImplementedError("Not Yet implemented.") + + def __getitem__(self, key): + raise NotImplementedError("Not Yet implemented.") + + def __setitem__(self, key, value): + raise NotImplementedError("Not Yet implemented.") + + def __len__(self): + raise NotImplementedError("Not Yet implemented.") + + def __unicode__(self): + raise NotImplementedError("Not Yet implemented.") + + def __neg__(self): + raise NotImplementedError("Not Yet implemented.") + + def __invert__(self): + raise NotImplementedError("Not Yet implemented.") + + def __hash__(self): + raise NotImplementedError("Not Yet implemented.") + + def __iter__(self): + raise NotImplementedError("Not Yet implemented.") + + def __contains__(self, key): + raise NotImplementedError("Not Yet implemented.") + + def __nonzero__(self): + raise NotImplementedError("Not Yet implemented.") + + def __bool__(self): + raise NotImplementedError("Not Yet implemented.") + + def __abs__(self): + raise NotImplementedError("Not Yet implemented.") + + def __round__(self, decimals=0): + raise NotImplementedError("Not Yet implemented.") + + def __array__(self, dtype=None): + raise NotImplementedError("Not Yet implemented.") + + def __array_wrap__(self, result, context=None): + raise NotImplementedError("Not Yet implemented.") + + def __getstate__(self): + raise NotImplementedError("Not Yet implemented.") + + def __setstate__(self, state): + raise NotImplementedError("Not Yet implemented.") + + def __delitem__(self, key): + raise NotImplementedError("Not Yet implemented.") + + def __finalize__(self, other, method=None, **kwargs): + raise NotImplementedError("Not Yet implemented.") + + def __copy__(self, deep=True): + raise NotImplementedError("Not Yet implemented.") + + def __deepcopy__(self, memo=None): + raise NotImplementedError("Not Yet implemented.") + @ray.remote def _shuffle(df, indices, chunksize): diff --git a/test/dataframe.py b/test/dataframe.py index c8f21fdb6..3c31fb980 100644 --- a/test/dataframe.py +++ b/test/dataframe.py @@ -108,6 +108,16 @@ def test_transpose(ray_df, pandas_df): assert(ray_df_equals_pandas(ray_df.transpose(), pandas_df.transpose())) +@pytest.fixture +def create_test_dataframe(): + df = pd.DataFrame({'col1': [0, 1, 2, 3], + 'col2': [4, 5, 6, 7], + 'col3': [8, 9, 10, 11], + 'col4': [12, 13, 14, 15]}) + + return rdf.from_pandas(df, 2) + + def test_int_dataframe(): ray.init() @@ -179,3 +189,1479 @@ def test_float_dataframe(): test_abs(ray_df, pandas_df) test_keys(ray_df, pandas_df) test_transpose(ray_df, pandas_df) + + +def test_add(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.add(None) + + +def test_agg(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.agg(None) + + +def test_aggregate(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.aggregate(None) + + +def test_align(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.align(None) + + +def test_all(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.all() + + +def test_any(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.any() + + +def test_append(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.append(None) + + +def test_apply(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.apply(None) + + +def test_as_blocks(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.as_blocks() + + +def test_as_matrix(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.as_matrix() + + +def test_asfreq(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.asfreq(None) + + +def test_asof(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.asof(None) + + +def test_assign(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.assign() + + +def test_astype(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.astype(None) + + +def test_at_time(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.at_time(None) + + +def test_between_time(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.between_time(None, None) + + +def test_bfill(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.bfill() + + +def test_bool(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.bool() + + +def test_boxplot(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.boxplot() + + +def test_clip(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.clip() + + +def test_clip_lower(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.clip_lower(None) + + +def test_clip_upper(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.clip_upper(None) + + +def test_combine(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.combine(None, None) + + +def test_combine_first(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.combine_first(None) + + +def test_compound(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.compound() + + +def test_consolidate(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.consolidate() + + +def test_convert_objects(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.convert_objects() + + +def test_corr(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.corr() + + +def test_corrwith(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.corrwith(None) + + +def test_count(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.count() + + +def test_cov(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.cov() + + +def test_cummax(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.cummax() + + +def test_cummin(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.cummin() + + +def test_cumprod(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.cumprod() + + +def test_cumsum(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.cumsum() + + +def test_describe(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.describe() + + +def test_diff(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.diff() + + +def test_div(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.div(None) + + +def test_divide(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.divide(None) + + +def test_dot(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.dot(None) + + +def test_drop(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.drop() + + +def test_drop_duplicates(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.drop_duplicates() + + +def test_duplicated(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.duplicated() + + +def test_eq(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.eq(None) + + +def test_equals(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.equals(None) + + +def test_eval(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.eval(None) + + +def test_ewm(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.ewm() + + +def test_expanding(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.expanding() + + +def test_ffill(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.ffill() + + +def test_fillna(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.fillna() + + +def test_filter(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.filter() + + +def test_first(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.first(None) + + +def test_first_valid_index(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.first_valid_index() + + +def test_floordiv(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.floordiv(None) + + +def test_from_csv(): + with pytest.raises(NotImplementedError): + rdf.DataFrame.from_csv(None) + + +def test_from_dict(): + with pytest.raises(NotImplementedError): + rdf.DataFrame.from_dict(None) + + +def test_from_items(): + with pytest.raises(NotImplementedError): + rdf.DataFrame.from_items(None) + + +def test_from_records(): + with pytest.raises(NotImplementedError): + rdf.DataFrame.from_records(None) + + +def test_ge(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.ge(None) + + +def test_get(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.get(None) + + +def test_get_dtype_counts(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.get_dtype_counts() + + +def test_get_ftype_counts(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.get_ftype_counts() + + +def test_get_value(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.get_value(None, None) + + +def test_get_values(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.get_values() + + +def test_gt(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.gt(None) + + +def test_head(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.head() + + +def test_hist(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.hist(None) + + +def test_idxmax(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.idxmax() + + +def test_idxmin(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.idxmin() + + +def test_infer_objects(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.infer_objects() + + +def test_info(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.info() + + +def test_insert(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.insert(None, None, None) + + +def test_interpolate(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.interpolate() + + +def test_items(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.items() + + +def test_iteritems(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.iteritems() + + +def test_iterrows(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.iterrows() + + +def test_itertuples(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.itertuples() + + +def test_join(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.join(None) + + +def test_kurt(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.kurt() + + +def test_kurtosis(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.kurtosis() + + +def test_last(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.last(None) + + +def test_last_valid_index(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.last_valid_index() + + +def test_le(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.le(None) + + +def test_lookup(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.lookup(None, None) + + +def test_lt(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.lt(None) + + +def test_mad(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.mad() + + +def test_mask(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.mask(None) + + +def test_max(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.max() + + +def test_mean(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.mean() + + +def test_median(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.median() + + +def test_melt(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.melt() + + +def test_memory_usage(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.memory_usage() + + +def test_merge(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.merge(None) + + +def test_min(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.min() + + +def test_mod(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.mod(None) + + +def test_mode(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.mode() + + +def test_mul(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.mul(None) + + +def test_multiply(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.multiply(None) + + +def test_ne(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.ne(None) + + +def test_nlargest(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.nlargest(None, None) + + +def test_notna(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.notna() + + +def test_notnull(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.notnull() + + +def test_nsmallest(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.nsmallest(None, None) + + +def test_nunique(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.nunique() + + +def test_pct_change(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.pct_change() + + +def test_pipe(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.pipe(None) + + +def test_pivot(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.pivot() + + +def test_pivot_table(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.pivot_table() + + +def test_plot(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.plot() + + +def test_pop(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.pop(None) + + +def test_pow(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.pow(None) + + +def test_prod(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.prod() + + +def test_product(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.product() + + +def test_quantile(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.quantile() + + +def test_query(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.query(None) + + +def test_radd(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.radd(None) + + +def test_rank(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.rank() + + +def test_rdiv(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.rdiv(None) + + +def test_reindex(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.reindex() + + +def test_reindex_axis(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.reindex_axis(None) + + +def test_reindex_like(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.reindex_like(None) + + +def test_rename(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.rename() + + +def test_rename_axis(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.rename_axis(None) + + +def test_reorder_levels(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.reorder_levels(None) + + +def test_replace(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.replace() + + +def test_resample(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.resample(None) + + +def test_reset_index(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.reset_index() + + +def test_rfloordiv(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.rfloordiv(None) + + +def test_rmod(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.rmod(None) + + +def test_rmul(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.rmul(None) + + +def test_rolling(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.rolling(None) + + +def test_round(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.round() + + +def test_rpow(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.rpow(None) + + +def test_rsub(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.rsub(None) + + +def test_rtruediv(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.rtruediv(None) + + +def test_sample(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.sample() + + +def test_select(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.select(None) + + +def test_select_dtypes(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.select_dtypes() + + +def test_sem(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.sem() + + +def test_set_axis(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.set_axis(None) + + +def test_set_index(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.set_index(None) + + +def test_set_value(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.set_value(None, None, None) + + +def test_shift(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.shift() + + +def test_skew(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.skew() + + +def test_slice_shift(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.slice_shift() + + +def test_sort_index(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.sort_index() + + +def test_sort_values(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.sort_values(None) + + +def test_sortlevel(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.sortlevel() + + +def test_squeeze(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.squeeze() + + +def test_stack(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.stack() + + +def test_std(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.std() + + +def test_sub(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.sub(None) + + +def test_subtract(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.subtract(None) + + +def test_swapaxes(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.swapaxes(None, None) + + +def test_swaplevel(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.swaplevel() + + +def test_tail(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.tail() + + +def test_take(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.take(None) + + +def test_to_clipboard(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.to_clipboard() + + +def test_to_csv(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.to_csv() + + +def test_to_dense(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.to_dense() + + +def test_to_dict(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.to_dict() + + +def test_to_excel(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.to_excel(None) + + +def test_to_feather(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.to_feather(None) + + +def test_to_gbq(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.to_gbq(None, None) + + +def test_to_hdf(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.to_hdf(None, None) + + +def test_to_html(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.to_html() + + +def test_to_json(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.to_json() + + +def test_to_latex(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.to_latex() + + +def test_to_msgpack(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.to_msgpack() + + +def test_to_panel(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.to_panel() + + +def test_to_parquet(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.to_parquet(None) + + +def test_to_period(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.to_period() + + +def test_to_pickle(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.to_pickle(None) + + +def test_to_records(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.to_records() + + +def test_to_sparse(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.to_sparse() + + +def test_to_sql(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.to_sql(None, None) + + +def test_to_stata(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.to_stata(None) + + +def test_to_string(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.to_string() + + +def test_to_timestamp(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.to_timestamp() + + +def test_to_xarray(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.to_xarray() + + +def test_transform(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.transform(None) + + +def test_truediv(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.truediv(None) + + +def test_truncate(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.truncate() + + +def test_tshift(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.tshift() + + +def test_tz_convert(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.tz_convert(None) + + +def test_tz_localize(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.tz_localize(None) + + +def test_unstack(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.unstack() + + +def test_update(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.update(None) + + +def test_var(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.var() + + +def test_where(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.where(None) + + +def test_xs(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.xs(None) + + +def test___getitem__(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.__getitem__(None) + + +def test___setitem__(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.__setitem__(None, None) + + +def test___len__(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.__len__() + + +def test___unicode__(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.__unicode__() + + +def test___neg__(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.__neg__() + + +def test___invert__(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.__invert__() + + +def test___hash__(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.__hash__() + + +def test___iter__(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.__iter__() + + +def test___contains__(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.__contains__(None) + + +def test___nonzero__(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.__nonzero__() + + +def test___bool__(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.__bool__() + + +def test___abs__(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.__abs__() + + +def test___round__(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.__round__() + + +def test___array__(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.__array__() + + +def test___array_wrap__(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.__array_wrap__(None) + + +def test___getstate__(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.__getstate__() + + +def test___setstate__(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.__setstate__(None) + + +def test___delitem__(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.__delitem__(None) + + +def test___finalize__(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.__finalize__(None) + + +def test___copy__(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.__copy__() + + +def test___deepcopy__(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.__deepcopy__()