diff --git a/.travis.yml b/.travis.yml index 6b60b37e0..becf1cf5f 100644 --- a/.travis.yml +++ b/.travis.yml @@ -124,7 +124,8 @@ script: - python test/trial_runner_test.py - python test/trial_scheduler_test.py - python test/cython_test.py - - python -m pytest test/dataframe.py + - python -m pytest python/ray/dataframe/test/test_dataframe.py + - python -m pytest python/ray/dataframe/test/test_series.py - python -m pytest python/ray/rllib/test/test_catalog.py - python -m pytest python/ray/rllib/test/test_filters.py diff --git a/python/ray/dataframe/__init__.py b/python/ray/dataframe/__init__.py index e0b125609..3e3192735 100644 --- a/python/ray/dataframe/__init__.py +++ b/python/ray/dataframe/__init__.py @@ -5,10 +5,11 @@ from __future__ import print_function from .dataframe import DataFrame from .dataframe import from_pandas from .dataframe import to_pandas +from .series import Series import ray import pandas as pd -__all__ = ["DataFrame", "from_pandas", "to_pandas"] +__all__ = ["DataFrame", "from_pandas", "to_pandas", "Series"] ray.register_custom_serializer(pd.DataFrame, use_pickle=True) ray.register_custom_serializer(pd.core.indexes.base.Index, use_pickle=True) diff --git a/python/ray/dataframe/dataframe.py b/python/ray/dataframe/dataframe.py index f811db682..33093ece6 100644 --- a/python/ray/dataframe/dataframe.py +++ b/python/ray/dataframe/dataframe.py @@ -19,14 +19,14 @@ class DataFrame(object): """ assert(len(df) > 0) - self.df = df + self._df = df self.columns = columns def __str__(self): - return str(pd.concat(ray.get(self.df))) + return "ray.DataFrame object" def __repr__(self): - return str(pd.concat(ray.get(self.df))) + return "ray.DataFrame object" @property def index(self): @@ -35,7 +35,7 @@ class DataFrame(object): Returns: The union of all indexes across the partitions. """ - indices = ray.get(self.map_partitions(lambda df: df.index).df) + indices = ray.get(self._map_partitions(lambda df: df.index)._df) return indices[0].append(indices[1:]) @property @@ -45,7 +45,7 @@ class DataFrame(object): Returns: The number of elements in the DataFrame. """ - sizes = ray.get(self.map_partitions(lambda df: df.size).df) + sizes = ray.get(self._map_partitions(lambda df: df.size)._df) return sum(sizes) @property @@ -57,7 +57,7 @@ class DataFrame(object): """ # The number of dimensions is common across all partitions. # The first partition will be enough. - return ray.get(_deploy_func.remote(lambda df: df.ndim, self.df[0])) + return ray.get(_deploy_func.remote(lambda df: df.ndim, self._df[0])) @property def ftypes(self): @@ -68,7 +68,7 @@ class DataFrame(object): """ # The ftypes are common across all partitions. # The first partition will be enough. - return ray.get(_deploy_func.remote(lambda df: df.ftypes, self.df[0])) + return ray.get(_deploy_func.remote(lambda df: df.ftypes, self._df[0])) @property def dtypes(self): @@ -79,7 +79,7 @@ class DataFrame(object): """ # The dtypes are common across all partitions. # The first partition will be enough. - return ray.get(_deploy_func.remote(lambda df: df.dtypes, self.df[0])) + return ray.get(_deploy_func.remote(lambda df: df.dtypes, self._df[0])) @property def empty(self): @@ -89,7 +89,7 @@ class DataFrame(object): True if the DataFrame is empty. False otherwise. """ - all_empty = ray.get(self.map_partitions(lambda df: df.empty).df) + all_empty = ray.get(self._map_partitions(lambda df: df.empty)._df) return False not in all_empty @property @@ -100,7 +100,7 @@ class DataFrame(object): The numpy representation of this DataFrame. """ return np.concatenate( - ray.get(self.map_partitions(lambda df: df.values).df)) + ray.get(self._map_partitions(lambda df: df.values)._df)) @property def axes(self): @@ -120,7 +120,7 @@ class DataFrame(object): """ return (len(self.index), len(self.columns)) - def map_partitions(self, func, *args): + def _map_partitions(self, func, *args): """Apply a function on each partition. Args: @@ -130,7 +130,7 @@ class DataFrame(object): A new DataFrame containing the result of the function. """ assert(callable(func)) - new_df = [_deploy_func.remote(func, part) for part in self.df] + new_df = [_deploy_func.remote(func, part) for part in self._df] return DataFrame(new_df, self.columns) @@ -140,9 +140,9 @@ class DataFrame(object): Returns: A new DataFrame containing the new column names. """ - new_dfs = self.map_partitions(lambda df: df.add_prefix(prefix)) + new_dfs = self._map_partitions(lambda df: df.add_prefix(prefix)) new_cols = self.columns.map(lambda x: str(prefix) + str(x)) - return DataFrame(new_dfs.df, new_cols) + return DataFrame(new_dfs._df, new_cols) def add_suffix(self, suffix): """Add a suffix to each of the column names. @@ -150,9 +150,9 @@ class DataFrame(object): Returns: A new DataFrame containing the new column names. """ - new_dfs = self.map_partitions(lambda df: df.add_suffix(suffix)) + new_dfs = self._map_partitions(lambda df: df.add_suffix(suffix)) new_cols = self.columns.map(lambda x: str(x) + str(suffix)) - return DataFrame(new_dfs.df, new_cols) + return DataFrame(new_dfs._df, new_cols) def applymap(self, func): """Apply a function to a DataFrame elementwise. @@ -161,7 +161,7 @@ class DataFrame(object): func (callable): The function to apply. """ assert(callable(func)) - return self.map_partitions(lambda df: df.applymap(lambda x: func(x))) + return self._map_partitions(lambda df: df.applymap(lambda x: func(x))) def copy(self, deep=True): """Creates a shallow copy of the DataFrame. @@ -169,7 +169,7 @@ class DataFrame(object): Returns: A new DataFrame pointing to the same partitions as this one. """ - return DataFrame(self.df, self.columns) + return DataFrame(self._df, self.columns) def groupby(self, by=None, axis=0, level=None, as_index=True, sort=True, group_keys=True, squeeze=False, **kwargs): @@ -188,12 +188,12 @@ class DataFrame(object): """ indices = list(set( - [index for df in ray.get(self.df) for index in list(df.index)])) + [index for df in ray.get(self._df) for index in list(df.index)])) - chunksize = int(len(indices) / len(self.df)) + chunksize = int(len(indices) / len(self._df)) partitions = [] - for df in self.df: + for df in self._df: partitions.append(_shuffle.remote(df, indices, chunksize)) partitions = ray.get(partitions) @@ -220,7 +220,7 @@ class DataFrame(object): Returns: A new DataFrame with the result of the reduction. """ - return self.groupby(axis=axis).map_partitions(func) + return self.groupby(axis=axis)._map_partitions(func) def sum(self, axis=None, skipna=True, level=None, numeric_only=None): """Perform a sum across the DataFrame. @@ -232,7 +232,7 @@ class DataFrame(object): Returns: The sum of the DataFrame. """ - sum_of_partitions = self.map_partitions( + sum_of_partitions = self._map_partitions( lambda df: df.sum(axis=axis, skipna=skipna, level=level, numeric_only=numeric_only)) @@ -246,7 +246,7 @@ class DataFrame(object): Returns: A new DataFrame with the applied absolute value. """ - return self.map_partitions(lambda df: df.abs()) + return self._map_partitions(lambda df: df.abs()) def isin(self, values): """Fill a DataFrame with booleans for cells contained in values. @@ -260,7 +260,7 @@ class DataFrame(object): True: cell is contained in values. False: otherwise """ - return self.map_partitions(lambda df: df.isin(values)) + return self._map_partitions(lambda df: df.isin(values)) def isna(self): """Fill a DataFrame with booleans for cells containing NA. @@ -271,7 +271,7 @@ class DataFrame(object): True: cell contains NA. False: otherwise. """ - return self.map_partitions(lambda df: df.isna()) + return self._map_partitions(lambda df: df.isna()) def isnull(self): """Fill a DataFrame with booleans for cells containing a null value. @@ -282,7 +282,7 @@ class DataFrame(object): True: cell contains null. False: otherwise. """ - return self.map_partitions(lambda df: df.isnull) + return self._map_partitions(lambda df: df.isnull) def keys(self): """Get the info axis for the DataFrame. @@ -291,7 +291,7 @@ class DataFrame(object): A pandas Index for this DataFrame. """ # Each partition should have the same index, so we'll use 0's - return ray.get(_deploy_func.remote(lambda df: df.keys(), self.df[0])) + return ray.get(_deploy_func.remote(lambda df: df.keys(), self._df[0])) def transpose(self, *args, **kwargs): """Transpose columns and rows for the DataFrame. @@ -301,7 +301,7 @@ class DataFrame(object): Returns: A new DataFrame transposed from this DataFrame. """ - local_transpose = self.map_partitions( + local_transpose = self._map_partitions( lambda df: df.transpose(*args, **kwargs)) # Sum will collapse the NAs from the groupby return local_transpose.reduce_by_index(lambda df: df.sum(), axis=1) @@ -1019,9 +1019,6 @@ class DataFrame(object): def __unicode__(self): raise NotImplementedError("Not Yet implemented.") - def __neg__(self): - raise NotImplementedError("Not Yet implemented.") - def __invert__(self): raise NotImplementedError("Not Yet implemented.") @@ -1070,6 +1067,112 @@ class DataFrame(object): def __deepcopy__(self, memo=None): raise NotImplementedError("Not Yet implemented.") + def __and__(self, other): + raise NotImplementedError("Not Yet implemented.") + + def __or__(self, other): + raise NotImplementedError("Not Yet implemented.") + + def __xor__(self, other): + raise NotImplementedError("Not Yet implemented.") + + def __lt__(self, other): + raise NotImplementedError("Not Yet implemented.") + + def __le__(self, other): + raise NotImplementedError("Not Yet implemented.") + + def __gt__(self, other): + raise NotImplementedError("Not Yet implemented.") + + def __ge__(self, other): + raise NotImplementedError("Not Yet implemented.") + + def __eq__(self, other): + raise NotImplementedError("Not Yet implemented.") + + def __ne__(self, other): + raise NotImplementedError("Not Yet implemented.") + + def __add__(self, other): + raise NotImplementedError("Not Yet implemented.") + + def __iadd__(self, other): + raise NotImplementedError("Not Yet implemented.") + + def __mul__(self, other): + raise NotImplementedError("Not Yet implemented.") + + def __imul__(self, other): + raise NotImplementedError("Not Yet implemented.") + + def __pow__(self, other): + raise NotImplementedError("Not Yet implemented.") + + def __ipow__(self, other): + raise NotImplementedError("Not Yet implemented.") + + def __sub__(self, other): + raise NotImplementedError("Not Yet implemented.") + + def __isub__(self, other): + raise NotImplementedError("Not Yet implemented.") + + def __neg__(self): + raise NotImplementedError("Not Yet implemented.") + + def __floordiv__(self, other): + raise NotImplementedError("Not Yet implemented.") + + def __truediv__(self, other): + raise NotImplementedError("Not Yet implemented.") + + def __mod__(self, other): + raise NotImplementedError("Not Yet implemented.") + + def __sizeof__(self): + raise NotImplementedError("Not Yet implemented.") + + @property + def __doc__(self): + raise NotImplementedError("Not Yet implemented.") + + @property + def blocks(self): + raise NotImplementedError("Not Yet implemented.") + + @property + def style(self): + raise NotImplementedError("Not Yet implemented.") + + def iat(axis=None): + raise NotImplementedError("Not Yet implemented.") + + def __rsub__(other, axis=None, level=None, fill_value=None): + raise NotImplementedError("Not Yet implemented.") + + def loc(axis=None): + raise NotImplementedError("Not Yet implemented.") + + @property + def is_copy(self): + raise NotImplementedError("Not Yet implemented.") + + def __itruediv__(other): + raise NotImplementedError("Not Yet implemented.") + + def __div__(other, axis=None, level=None, fill_value=None): + raise NotImplementedError("Not Yet implemented.") + + def at(axis=None): + raise NotImplementedError("Not Yet implemented.") + + def ix(axis=None): + raise NotImplementedError("Not Yet implemented.") + + def iloc(axis=None): + raise NotImplementedError("Not Yet implemented.") + @ray.remote def _shuffle(df, indices, chunksize): @@ -1114,7 +1217,7 @@ def _local_groupby(df_rows, axis=0): @ray.remote def _deploy_func(func, dataframe, *args): - """Deploys a function for the map_partitions call. + """Deploys a function for the _map_partitions call. Args: dataframe (pandas.DataFrame): The pandas DataFrame for this partition. @@ -1171,4 +1274,4 @@ def to_pandas(df): Returns: A new pandas DataFrame. """ - return pd.concat(ray.get(df.df)) + return pd.concat(ray.get(df._df)) diff --git a/python/ray/dataframe/pandas_code_gen.py b/python/ray/dataframe/pandas_code_gen.py new file mode 100644 index 000000000..b5969281c --- /dev/null +++ b/python/ray/dataframe/pandas_code_gen.py @@ -0,0 +1,93 @@ +from __future__ import absolute_import +from __future__ import division +from __future__ import print_function + +import inspect + + +def code_gen(pd_obj, ray_obj, path): + """Generate code skeleton for methods not in Ray + + Args: + pd_obj: The pandas object to generate code from. + ray_obj: The ray object to diff against. + path: Path to output the file to. + """ + + with open(path, "w") as outfile: + funcs = pandas_ray_diff(pd_obj, ray_obj) + + for func in funcs: + if func[0] == "_" and func[1] != "_": + continue + if "attr" in func: + # let's not mess with these + continue + try: + outfile.write("\ndef " + func + + str(inspect.signature(getattr(pd_obj, func))) + + ":\n") + except TypeError: + outfile.write("\n@property") + outfile.write("\ndef " + func + "(self):\n") + except ValueError: + continue + outfile.write( + " raise NotImplementedError(\"Not Yet implemented.\")\n") + + +def code_gen_test(ray_obj, path, name): + """Generate tests for methods in Ray.""" + + with open(path, "a") as outfile: + funcs = dir(ray_obj) + + for func in funcs: + if func[0] == "_" and func[1] != "_": + continue + + outfile.write("\n\ndef test_" + func + "():\n") + outfile.write( + " ray_" + name + " = create_test_" + name + "()\n\n" + + " with pytest.raises(NotImplementedError):\n" + + " ray_" + name + "." + func) + try: + first = True + param_num = \ + len(inspect.signature(getattr(ray_obj, func)).parameters) + if param_num > 1: + param_num -= 1 + + for _ in range(param_num): + if first: + outfile.write("(None") + first = False + else: + outfile.write(", None") + except (TypeError, ValueError, NotImplementedError): + outfile.write("\n") + continue + + if first: + outfile.write("(") + outfile.write(")\n") + + +def pandas_ray_diff(pd_obj, ray_obj): + """Gets the diff of the methods in the Pandas and Ray objects. + + Args: + pd_obj: The Pandas object to diff. + ray_obj: The Ray object to diff. + + Returns: + A list of method names that are different between the two. + """ + pd_funcs = dir(pd_obj) + ray_funcs = dir(ray_obj) + + pd_funcs = set(filter(lambda f: f[0] != "_" or f[1] == "_", + pd_funcs)) + + diff = [x for x in pd_funcs if x not in set(ray_funcs)] + return diff diff --git a/python/ray/dataframe/series.py b/python/ray/dataframe/series.py new file mode 100644 index 000000000..91ac792f2 --- /dev/null +++ b/python/ray/dataframe/series.py @@ -0,0 +1,957 @@ +from __future__ import absolute_import +from __future__ import division +from __future__ import print_function + +import numpy as np + + +def na_op(): + """Pandas uses a similar function to handle na values. + """ + raise NotImplementedError("Not Yet implemented.") + + +class Series(object): + + @property + def T(self): + raise NotImplementedError("Not Yet implemented.") + + def __abs__(self): + raise NotImplementedError("Not Yet implemented.") + + def __add__(self, right, name='__add__', na_op=na_op): + raise NotImplementedError("Not Yet implemented.") + + def __and__(self, other): + raise NotImplementedError("Not Yet implemented.") + + def __array__(self, result=None): + raise NotImplementedError("Not Yet implemented.") + + def __array_prepare__(self, result, context=None): + raise NotImplementedError("Not Yet implemented.") + + @property + def __array_priority__(self): + raise NotImplementedError("Not Yet implemented.") + + def __array_wrap__(self, result, context=None): + raise NotImplementedError("Not Yet implemented.") + + def __bool__(self): + raise NotImplementedError("Not Yet implemented.") + + def __bytes__(self): + raise NotImplementedError("Not Yet implemented.") + + def __class__(self, data=None, index=None, dtype=None, name=None, + copy=False, fastpath=False): + raise NotImplementedError("Not Yet implemented.") + + def __contains__(self, key): + 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.") + + def __delitem__(self, key): + raise NotImplementedError("Not Yet implemented.") + + def __dir__(self): + return list(type(self).__dict__.keys()) + + def __div__(self, right, name='__truediv__', na_op=na_op): + raise NotImplementedError("Not Yet implemented.") + + def __divmod__(self, right, name='__divmod__', na_op=na_op): + raise NotImplementedError("Not Yet implemented.") + + @property + def __doc__(self): + raise NotImplementedError("Not Yet implemented.") + + def __eq__(self, other, axis=None): + raise NotImplementedError("Not Yet implemented.") + + def __finalize__(self, other, method=None, **kwargs): + raise NotImplementedError("Not Yet implemented.") + + def __float__(self): + raise NotImplementedError("Not Yet implemented.") + + def __floordiv__(self, right, name='__floordiv__', na_op=na_op): + raise NotImplementedError("Not Yet implemented.") + + def __ge__(self, other, axis=None): + raise NotImplementedError("Not Yet implemented.") + + def __getitem__(self, key): + raise NotImplementedError("Not Yet implemented.") + + def __getstate__(self): + raise NotImplementedError("Not Yet implemented.") + + def __gt__(self, other, axis=None): + raise NotImplementedError("Not Yet implemented.") + + def __iadd__(self, other): + raise NotImplementedError("Not Yet implemented.") + + def __imul__(self, other): + raise NotImplementedError("Not Yet implemented.") + + def __int__(self): + raise NotImplementedError("Not Yet implemented.") + + def __invert__(self): + raise NotImplementedError("Not Yet implemented.") + + def __ipow__(self, other): + raise NotImplementedError("Not Yet implemented.") + + def __isub__(self, other): + raise NotImplementedError("Not Yet implemented.") + + def __iter__(self): + raise NotImplementedError("Not Yet implemented.") + + def __itruediv__(self, other): + raise NotImplementedError("Not Yet implemented.") + + def __le__(self, other, axis=None): + raise NotImplementedError("Not Yet implemented.") + + def __len__(self): + raise NotImplementedError("Not Yet implemented.") + + def __long__(self): + raise NotImplementedError("Not Yet implemented.") + + def __lt__(self, other, axis=None): + raise NotImplementedError("Not Yet implemented.") + + def __mod__(self, right, name='__mod__', na_op=na_op): + raise NotImplementedError("Not Yet implemented.") + + def __mul__(self, right, name='__mul__', na_op=na_op): + raise NotImplementedError("Not Yet implemented.") + + def __ne__(self, other, axis=None): + raise NotImplementedError("Not Yet implemented.") + + def __neg__(self): + raise NotImplementedError("Not Yet implemented.") + + def __nonzero__(self): + raise NotImplementedError("Not Yet implemented.") + + def __or__(self, other): + raise NotImplementedError("Not Yet implemented.") + + def __pow__(self, right, name='__pow__', na_op=na_op): + raise NotImplementedError("Not Yet implemented.") + + def __repr__(self): + raise NotImplementedError("Not Yet implemented.") + + def __round__(self, decimals=0): + raise NotImplementedError("Not Yet implemented.") + + def __setitem__(self, key, value): + raise NotImplementedError("Not Yet implemented.") + + def __setstate__(self, state): + raise NotImplementedError("Not Yet implemented.") + + def __sizeof__(self): + raise NotImplementedError("Not Yet implemented.") + + def __str__(self): + raise NotImplementedError("Not Yet implemented.") + + def __sub__(self, right, name='__sub__', na_op=na_op): + raise NotImplementedError("Not Yet implemented.") + + def __truediv__(self, right, name='__truediv__', na_op=na_op): + raise NotImplementedError("Not Yet implemented.") + + def __xor__(self, other): + raise NotImplementedError("Not Yet implemented.") + + def abs(self): + raise NotImplementedError("Not Yet implemented.") + + def add(self, other, level=None, fill_value=None, axis=0): + raise NotImplementedError("Not Yet implemented.") + + def add_prefix(self, prefix): + raise NotImplementedError("Not Yet implemented.") + + def add_suffix(self, suffix): + 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, to_append, ignore_index=False, verify_integrity=False): + raise NotImplementedError("Not Yet implemented.") + + def apply(self, func, convert_dtype=True, args=(), **kwds): + raise NotImplementedError("Not Yet implemented.") + + def argmax(self, axis=None, skipna=True, *args, **kwargs): + raise NotImplementedError("Not Yet implemented.") + + def argmin(self, axis=None, skipna=True, *args, **kwargs): + raise NotImplementedError("Not Yet implemented.") + + def argsort(self, axis=0, kind='quicksort', order=None): + 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 astype(self, dtype, copy=True, errors='raise', **kwargs): + raise NotImplementedError("Not Yet implemented.") + + def at(self, axis=None): + raise NotImplementedError("Not Yet implemented.") + + def at_time(self, time, asof=False): + raise NotImplementedError("Not Yet implemented.") + + def autocorr(self, lag=1): + raise NotImplementedError("Not Yet implemented.") + + def between(self, left, right, inclusive=True): + 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 clip(self, lower=None, upper=None, axis=None, *args, **kwargs): + raise NotImplementedError("Not Yet implemented.") + + def clip_lower(self, threshold, axis=None): + raise NotImplementedError("Not Yet implemented.") + + def clip_upper(self, threshold, axis=None): + raise NotImplementedError("Not Yet implemented.") + + def combine(self, other, func, fill_value=np.nan): + 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 compress(self, condition, *args, **kwargs): + 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 copy(self, deep=True): + raise NotImplementedError("Not Yet implemented.") + + def corr(self, other, method='pearson', min_periods=None): + raise NotImplementedError("Not Yet implemented.") + + def count(self, level=None): + raise NotImplementedError("Not Yet implemented.") + + def cov(self, other, 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): + raise NotImplementedError("Not Yet implemented.") + + def div(self, other, level=None, fill_value=None, axis=0): + raise NotImplementedError("Not Yet implemented.") + + def divide(self, other, level=None, fill_value=None, axis=0): + raise NotImplementedError("Not Yet implemented.") + + def dot(self, other): + raise NotImplementedError("Not Yet implemented.") + + def drop(self, labels, axis=0, level=None, inplace=False, errors='raise'): + raise NotImplementedError("Not Yet implemented.") + + def drop_duplicates(self, keep='first', inplace=False): + raise NotImplementedError("Not Yet implemented.") + + def dropna(self, axis=0, inplace=False, **kwargs): + raise NotImplementedError("Not Yet implemented.") + + def duplicated(self, keep='first'): + raise NotImplementedError("Not Yet implemented.") + + def eq(self, other, level=None, fill_value=None, axis=0): + raise NotImplementedError("Not Yet implemented.") + + def equals(self, other): + 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 factorize(self, sort=False, na_sentinel=-1): + 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, level=None, fill_value=None, axis=0): + raise NotImplementedError("Not Yet implemented.") + + def from_array(self, arr, index=None, name=None, dtype=None, copy=False, + fastpath=False): + raise NotImplementedError("Not Yet implemented.") + + def from_csv(self, path, sep=',', parse_dates=True, header=None, + index_col=0, encoding=None, infer_datetime_format=False): + raise NotImplementedError("Not Yet implemented.") + + def ge(self, other, level=None, fill_value=None, axis=0): + 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, label, takeable=False): + raise NotImplementedError("Not Yet implemented.") + + def get_values(self): + raise NotImplementedError("Not Yet implemented.") + + def groupby(self, by=None, axis=0, level=None, as_index=True, sort=True, + group_keys=True, squeeze=False, **kwargs): + raise NotImplementedError("Not Yet implemented.") + + def gt(self, other, level=None, fill_value=None, axis=0): + raise NotImplementedError("Not Yet implemented.") + + def head(self, n=5): + raise NotImplementedError("Not Yet implemented.") + + def hist(self, by=None, ax=None, grid=True, xlabelsize=None, xrot=None, + ylabelsize=None, yrot=None, figsize=None, bins=10, **kwds): + raise NotImplementedError("Not Yet implemented.") + + def iat(self, axis=None): + raise NotImplementedError("Not Yet implemented.") + + def idxmax(self, axis=None, skipna=True, *args, **kwargs): + raise NotImplementedError("Not Yet implemented.") + + def idxmin(self, axis=None, skipna=True, *args, **kwargs): + raise NotImplementedError("Not Yet implemented.") + + def iloc(self, axis=None): + 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 isin(self, values): + raise NotImplementedError("Not Yet implemented.") + + def isnull(self): + raise NotImplementedError("Not Yet implemented.") + + def item(self): + raise NotImplementedError("Not Yet implemented.") + + def items(self): + raise NotImplementedError("Not Yet implemented.") + + def iteritems(self): + raise NotImplementedError("Not Yet implemented.") + + def ix(self, axis=None): + raise NotImplementedError("Not Yet implemented.") + + def keys(self): + 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, level=None, fill_value=None, axis=0): + raise NotImplementedError("Not Yet implemented.") + + def loc(self, axis=None): + raise NotImplementedError("Not Yet implemented.") + + def lt(self, other, level=None, fill_value=None, axis=0): + raise NotImplementedError("Not Yet implemented.") + + def mad(self, axis=None, skipna=None, level=None): + raise NotImplementedError("Not Yet implemented.") + + def map(self, arg, na_action=None): + raise NotImplementedError("Not Yet implemented.") + + def mask(self, cond, other=np.nan, inplace=False, axis=None, level=None, + try_cast=False, raise_on_error=True): + 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 memory_usage(self, index=True, deep=False): + 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, level=None, fill_value=None, axis=0): + raise NotImplementedError("Not Yet implemented.") + + def mode(self): + raise NotImplementedError("Not Yet implemented.") + + def mul(self, other, level=None, fill_value=None, axis=0): + raise NotImplementedError("Not Yet implemented.") + + def multiply(self, other, level=None, fill_value=None, axis=0): + raise NotImplementedError("Not Yet implemented.") + + def ne(self, other, level=None, fill_value=None, axis=0): + raise NotImplementedError("Not Yet implemented.") + + def nlargest(self, n=5, keep='first'): + raise NotImplementedError("Not Yet implemented.") + + def nonzero(self): + raise NotImplementedError("Not Yet implemented.") + + def notnull(self): + raise NotImplementedError("Not Yet implemented.") + + def nsmallest(self, n=5, keep='first'): + raise NotImplementedError("Not Yet implemented.") + + def nunique(self, 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 plot(self, kind='line', ax=None, figsize=None, use_index=True, + title=None, grid=None, legend=False, 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, label=None, secondary_y=False, **kwds): + raise NotImplementedError("Not Yet implemented.") + + def pop(self, item): + raise NotImplementedError("Not Yet implemented.") + + def pow(self, other, level=None, fill_value=None, axis=0): + raise NotImplementedError("Not Yet implemented.") + + def prod(self, axis=None, skipna=None, level=None, numeric_only=None, + **kwargs): + raise NotImplementedError("Not Yet implemented.") + + def product(self, axis=None, skipna=None, level=None, numeric_only=None, + **kwargs): + raise NotImplementedError("Not Yet implemented.") + + def ptp(self, axis=None, skipna=None, level=None, numeric_only=None, + **kwargs): + raise NotImplementedError("Not Yet implemented.") + + def put(self, *args, **kwargs): + raise NotImplementedError("Not Yet implemented.") + + def quantile(self, q=0.5, interpolation='linear'): + raise NotImplementedError("Not Yet implemented.") + + def radd(self, other, level=None, fill_value=None, axis=0): + 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 ravel(self, order='C'): + raise NotImplementedError("Not Yet implemented.") + + def rdiv(self, other, level=None, fill_value=None, axis=0): + raise NotImplementedError("Not Yet implemented.") + + def reindex(self, index=None, **kwargs): + raise NotImplementedError("Not Yet implemented.") + + def reindex_axis(self, labels, axis=0, **kwargs): + 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, index=None, **kwargs): + 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): + raise NotImplementedError("Not Yet implemented.") + + def repeat(self, repeats, *args, **kwargs): + 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, name=None, inplace=False): + raise NotImplementedError("Not Yet implemented.") + + def reshape(self, *args, **kwargs): + raise NotImplementedError("Not Yet implemented.") + + def rfloordiv(self, other, level=None, fill_value=None, axis=0): + raise NotImplementedError("Not Yet implemented.") + + def rmod(self, other, level=None, fill_value=None, axis=0): + raise NotImplementedError("Not Yet implemented.") + + def rmul(self, other, level=None, fill_value=None, axis=0): + 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, level=None, fill_value=None, axis=0): + raise NotImplementedError("Not Yet implemented.") + + def rsub(self, other, level=None, fill_value=None, axis=0): + raise NotImplementedError("Not Yet implemented.") + + def rtruediv(self, other, level=None, fill_value=None, axis=0): + 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 searchsorted(self, value, side='left', sorter=None): + raise NotImplementedError("Not Yet implemented.") + + def select(self, crit, axis=0): + 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, axis, labels): + raise NotImplementedError("Not Yet implemented.") + + def set_value(self, label, 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): + raise NotImplementedError("Not Yet implemented.") + + def sort_values(self, axis=0, ascending=True, inplace=False, + kind='quicksort', na_position='last'): + raise NotImplementedError("Not Yet implemented.") + + def sortlevel(self, level=0, ascending=True, sort_remaining=True): + raise NotImplementedError("Not Yet implemented.") + + def squeeze(self, axis=None): + 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, level=None, fill_value=None, axis=0): + raise NotImplementedError("Not Yet implemented.") + + def subtract(self, other, level=None, fill_value=None, axis=0): + raise NotImplementedError("Not Yet implemented.") + + def sum(self, axis=None, skipna=None, level=None, numeric_only=None, + **kwargs): + raise NotImplementedError("Not Yet implemented.") + + def swapaxes(self, axis1, axis2, copy=True): + raise NotImplementedError("Not Yet implemented.") + + def swaplevel(self, i=-2, j=-1, copy=True): + raise NotImplementedError("Not Yet implemented.") + + def tail(self, n=5): + raise NotImplementedError("Not Yet implemented.") + + def take(self, indices, axis=0, convert=True, is_copy=False, **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=None, index=True, sep=',', na_rep='', + float_format=None, header=False, index_label=None, mode='w', + encoding=None, date_format=None, decimal='.'): + raise NotImplementedError("Not Yet implemented.") + + def to_dense(self): + raise NotImplementedError("Not Yet implemented.") + + def to_dict(self): + 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): + raise NotImplementedError("Not Yet implemented.") + + def to_frame(self, name=None): + raise NotImplementedError("Not Yet implemented.") + + def to_hdf(self, path_or_buf, key, **kwargs): + 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): + raise NotImplementedError("Not Yet implemented.") + + def to_latex(self, buf=None, columns=None, col_space=None, header=True, + index=True, na_rep='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_period(self, freq=None, copy=True): + raise NotImplementedError("Not Yet implemented.") + + def to_pickle(self, path, compression='infer'): + raise NotImplementedError("Not Yet implemented.") + + def to_sparse(self, kind='block', fill_value=None): + 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_string(self, buf=None, na_rep='NaN', float_format=None, + header=True, index=True, length=False, dtype=False, + name=False, max_rows=None): + raise NotImplementedError("Not Yet implemented.") + + def to_timestamp(self, freq=None, how='start', copy=True): + raise NotImplementedError("Not Yet implemented.") + + def to_xarray(self): + raise NotImplementedError("Not Yet implemented.") + + def tolist(self): + raise NotImplementedError("Not Yet implemented.") + + def transform(self, func, *args, **kwargs): + raise NotImplementedError("Not Yet implemented.") + + def transpose(self, *args, **kwargs): + raise NotImplementedError("Not Yet implemented.") + + def truediv(self, other, level=None, fill_value=None, axis=0): + 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 unique(self): + raise NotImplementedError("Not Yet implemented.") + + def unstack(self, level=-1, fill_value=None): + raise NotImplementedError("Not Yet implemented.") + + def update(self, other): + raise NotImplementedError("Not Yet implemented.") + + def valid(self, inplace=False, **kwargs): + raise NotImplementedError("Not Yet implemented.") + + def value_counts(self, normalize=False, sort=True, ascending=False, + bins=None, dropna=True): + 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 view(self, dtype=None): + raise NotImplementedError("Not Yet implemented.") + + def where(self, cond, other=np.nan, inplace=False, axis=None, level=None, + try_cast=False, raise_on_error=True): + raise NotImplementedError("Not Yet implemented.") + + def xs(key, axis=0, level=None, drop_level=True): + raise NotImplementedError("Not Yet implemented.") + + @property + def asobject(self): + raise NotImplementedError("Not Yet implemented.") + + @property + def axes(self): + raise NotImplementedError("Not Yet implemented.") + + @property + def base(self): + raise NotImplementedError("Not Yet implemented.") + + @property + def blocks(self): + raise NotImplementedError("Not Yet implemented.") + + @property + def data(self): + raise NotImplementedError("Not Yet implemented.") + + @property + def dtype(self): + raise NotImplementedError("Not Yet implemented.") + + @property + def dtypes(self): + raise NotImplementedError("Not Yet implemented.") + + @property + def empty(self): + raise NotImplementedError("Not Yet implemented.") + + @property + def flags(self): + raise NotImplementedError("Not Yet implemented.") + + @property + def ftype(self): + raise NotImplementedError("Not Yet implemented.") + + @property + def ftypes(self): + raise NotImplementedError("Not Yet implemented.") + + @property + def hasnans(self): + raise NotImplementedError("Not Yet implemented.") + + @property + def imag(self): + raise NotImplementedError("Not Yet implemented.") + + @property + def index(self): + raise NotImplementedError("Not Yet implemented.") + + @property + def is_copy(self): + raise NotImplementedError("Not Yet implemented.") + + @property + def is_monotonic(self): + raise NotImplementedError("Not Yet implemented.") + + @property + def is_monotonic_decreasing(self): + raise NotImplementedError("Not Yet implemented.") + + @property + def is_monotonic_increasing(self): + raise NotImplementedError("Not Yet implemented.") + + @property + def is_unique(self): + raise NotImplementedError("Not Yet implemented.") + + @property + def itemsize(self): + raise NotImplementedError("Not Yet implemented.") + + @property + def name(self): + raise NotImplementedError("Not Yet implemented.") + + @property + def nbytes(self): + raise NotImplementedError("Not Yet implemented.") + + @property + def ndim(self): + raise NotImplementedError("Not Yet implemented.") + + @property + def real(self): + raise NotImplementedError("Not Yet implemented.") + + @property + def shape(self): + raise NotImplementedError("Not Yet implemented.") + + @property + def size(self): + raise NotImplementedError("Not Yet implemented.") + + @property + def strides(self): + raise NotImplementedError("Not Yet implemented.") + + @property + def values(self): + raise NotImplementedError("Not Yet implemented.") diff --git a/test/dataframe.py b/python/ray/dataframe/test/test_dataframe.py similarity index 95% rename from test/dataframe.py rename to python/ray/dataframe/test/test_dataframe.py index 3c31fb980..9b4caf3d5 100644 --- a/test/dataframe.py +++ b/python/ray/dataframe/test/test_dataframe.py @@ -84,7 +84,7 @@ def test_copy(ray_df): new_ray_df = ray_df.copy() assert(new_ray_df is not ray_df) - assert(new_ray_df.df == ray_df.df) + assert(new_ray_df._df == ray_df._df) @pytest.fixture @@ -1665,3 +1665,80 @@ def test___deepcopy__(): with pytest.raises(NotImplementedError): ray_df.__deepcopy__() + + +def test_blocks(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.blocks + + +def test_style(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.style + + +def test_iat(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.iat() + + +def test___rsub__(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.__rsub__(None, None, None) + + +def test_loc(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.loc() + + +def test_is_copy(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.is_copy + + +def test___itruediv__(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.__itruediv__() + + +def test___div__(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.__div__(None) + + +def test_at(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.at() + + +def test_ix(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.ix() + + +def test_iloc(): + ray_df = create_test_dataframe() + + with pytest.raises(NotImplementedError): + ray_df.iloc() diff --git a/python/ray/dataframe/test/test_series.py b/python/ray/dataframe/test/test_series.py new file mode 100644 index 000000000..7c8b33d8e --- /dev/null +++ b/python/ray/dataframe/test/test_series.py @@ -0,0 +1,1995 @@ +from __future__ import absolute_import +from __future__ import division +from __future__ import print_function + +import pytest +import ray.dataframe as rdf +import ray + +ray.init() + + +@pytest.fixture +def create_test_series(): + return rdf.Series() + + +def test_T(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.T + + +def test___abs__(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.__abs__() + + +def test___add__(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.__add__(None, None) + + +def test___and__(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.__and__(None) + + +def test___array__(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.__array__(None) + + +def test___array_prepare__(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.__array_prepare__(None) + + +def test___array_priority__(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.__array_priority__ + + +def test___array_wrap__(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.__array_wrap__(None) + + +def test___bool__(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.__bool__() + + +def test___bytes__(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.__bytes__() + + +def test___class__(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.__class__(None, None, None, None, None) + + +def test___contains__(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.__contains__(None) + + +def test___copy__(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.__copy__(None) + + +def test___deepcopy__(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.__deepcopy__(None) + + +def test___delitem__(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.__delitem__(None) + + +def test___div__(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.__div__(None, None) + + +def test___divmod__(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.__divmod__(None, None) + + +def test___doc__(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.__doc__ + + +def test___eq__(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.__eq__(None) + + +def test___finalize__(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.__finalize__(None, None) + + +def test___float__(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.__float__() + + +def test___floordiv__(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.__floordiv__(None, None) + + +def test___ge__(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.__ge__(None) + + +def test___getitem__(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.__getitem__(None) + + +def test___getstate__(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.__getstate__() + + +def test___gt__(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.__gt__(None) + + +def test___iadd__(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.__iadd__(None) + + +def test___imul__(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.__imul__(None) + + +def test___int__(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.__int__() + + +def test___invert__(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.__invert__() + + +def test___ipow__(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.__ipow__(None) + + +def test___isub__(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.__isub__(None) + + +def test___iter__(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.__iter__() + + +def test___itruediv__(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.__itruediv__(None) + + +def test___le__(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.__le__(None) + + +def test___len__(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.__len__() + + +def test___long__(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.__long__() + + +def test___lt__(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.__lt__(None) + + +def test___mod__(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.__mod__(None, None) + + +def test___mul__(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.__mul__(None, None) + + +def test___ne__(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.__ne__(None) + + +def test___neg__(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.__neg__() + + +def test___nonzero__(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.__nonzero__() + + +def test___or__(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.__or__(None) + + +def test___pow__(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.__pow__(None, None) + + +def test___repr__(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.__repr__() + + +def test___round__(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.__round__(None) + + +def test___setitem__(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.__setitem__(None, None) + + +def test___setstate__(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.__setstate__(None) + + +def test___sizeof__(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.__sizeof__() + + +def test___str__(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.__str__() + + +def test___sub__(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.__sub__(None, None) + + +def test___truediv__(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.__truediv__(None, None) + + +def test___xor__(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.__xor__(None) + + +def test_abs(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.abs() + + +def test_add(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.add(None, None, None) + + +def test_add_prefix(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.add_prefix(None) + + +def test_add_suffix(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.add_suffix(None) + + +def test_agg(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.agg(None, None, None) + + +def test_aggregate(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.aggregate(None, None, None) + + +def test_align(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.align(None, None, None, None, None, None, None, None, None) + + +def test_all(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.all(None, None, None, None) + + +def test_any(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.any(None, None, None, None) + + +def test_append(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.append(None, None) + + +def test_apply(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.apply(None, None, None) + + +def test_argmax(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.argmax(None, None, None) + + +def test_argmin(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.argmin(None, None, None) + + +def test_argsort(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.argsort(None, None) + + +def test_as_blocks(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.as_blocks(None) + + +def test_as_matrix(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.as_matrix(None) + + +def test_asfreq(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.asfreq(None, None, None, None) + + +def test_asobject(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.asobject + + +def test_asof(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.asof(None) + + +def test_astype(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.astype(None, None, None) + + +def test_at(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.at(None) + + +def test_at_time(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.at_time(None) + + +def test_autocorr(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.autocorr(None) + + +def test_axes(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.axes + + +def test_base(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.base + + +def test_between(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.between(None, None) + + +def test_between_time(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.between_time(None, None, None) + + +def test_bfill(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.bfill(None, None, None) + + +def test_blocks(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.blocks + + +def test_bool(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.bool() + + +def test_clip(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.clip(None, None, None, None) + + +def test_clip_lower(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.clip_lower(None) + + +def test_clip_upper(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.clip_upper(None) + + +def test_combine(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.combine(None, None) + + +def test_combine_first(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.combine_first(None) + + +def test_compound(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.compound(None, None) + + +def test_compress(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.compress(None, None) + + +def test_consolidate(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.consolidate(None) + + +def test_convert_objects(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.convert_objects(None, None, None) + + +def test_copy(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.copy(None) + + +def test_corr(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.corr(None, None) + + +def test_count(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.count(None) + + +def test_cov(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.cov(None) + + +def test_cummax(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.cummax(None, None, None) + + +def test_cummin(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.cummin(None, None, None) + + +def test_cumprod(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.cumprod(None, None, None) + + +def test_cumsum(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.cumsum(None, None, None) + + +def test_data(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.data + + +def test_describe(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.describe(None, None) + + +def test_diff(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.diff(None) + + +def test_div(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.div(None, None, None) + + +def test_divide(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.divide(None, None, None) + + +def test_dot(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.dot(None) + + +def test_drop(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.drop(None, None, None, None) + + +def test_drop_duplicates(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.drop_duplicates(None) + + +def test_dropna(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.dropna(None, None) + + +def test_dtype(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.dtype + + +def test_dtypes(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.dtypes + + +def test_duplicated(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.duplicated(None) + + +def test_empty(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.empty + + +def test_eq(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.eq(None, None, None) + + +def test_equals(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.equals(None) + + +def test_ewm(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.ewm(None, None, None, None, None, None, None, None) + + +def test_expanding(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.expanding(None, None, None) + + +def test_factorize(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.factorize(None) + + +def test_ffill(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.ffill(None, None, None) + + +def test_fillna(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.fillna(None, None, None, None, None, None) + + +def test_filter(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.filter(None, None, None) + + +def test_first(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.first(None) + + +def test_first_valid_index(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.first_valid_index() + + +def test_flags(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.flags + + +def test_floordiv(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.floordiv(None, None, None) + + +def test_from_array(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.from_array(None, None, None, None, None) + + +def test_from_csv(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.from_csv(None, None, None, None, None, None) + + +def test_ftype(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.ftype + + +def test_ftypes(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.ftypes + + +def test_ge(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.ge(None, None, None) + + +def test_get(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.get(None) + + +def test_get_dtype_counts(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.get_dtype_counts() + + +def test_get_ftype_counts(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.get_ftype_counts() + + +def test_get_value(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.get_value(None) + + +def test_get_values(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.get_values() + + +def test_groupby(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.groupby(None, None, None, None, None, None, None) + + +def test_gt(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.gt(None, None, None) + + +def test_hasnans(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.hasnans + + +def test_head(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.head(None) + + +def test_hist(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.hist(None, None, None, None, None, None, None, None, None) + + +def test_iat(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.iat(None) + + +def test_idxmax(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.idxmax(None, None, None) + + +def test_idxmin(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.idxmin(None, None, None) + + +def test_iloc(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.iloc(None) + + +def test_imag(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.imag + + +def test_index(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.index + + +def test_interpolate(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.interpolate(None, None, None, None, None, None) + + +def test_is_copy(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.is_copy + + +def test_is_monotonic(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.is_monotonic + + +def test_is_monotonic_decreasing(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.is_monotonic_decreasing + + +def test_is_monotonic_increasing(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.is_monotonic_increasing + + +def test_is_unique(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.is_unique + + +def test_isin(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.isin(None) + + +def test_isnull(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.isnull() + + +def test_item(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.item() + + +def test_items(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.items() + + +def test_itemsize(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.itemsize + + +def test_iteritems(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.iteritems() + + +def test_ix(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.ix(None) + + +def test_keys(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.keys() + + +def test_kurt(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.kurt(None, None, None, None) + + +def test_kurtosis(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.kurtosis(None, None, None, None) + + +def test_last(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.last(None) + + +def test_last_valid_index(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.last_valid_index() + + +def test_le(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.le(None, None, None) + + +def test_loc(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.loc(None) + + +def test_lt(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.lt(None, None, None) + + +def test_mad(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.mad(None, None) + + +def test_map(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.map(None) + + +def test_mask(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.mask(None, None, None, None, None, None) + + +def test_max(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.max(None, None, None, None) + + +def test_mean(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.mean(None, None, None, None) + + +def test_median(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.median(None, None, None, None) + + +def test_memory_usage(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.memory_usage(None) + + +def test_min(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.min(None, None, None, None) + + +def test_mod(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.mod(None, None, None) + + +def test_mode(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.mode() + + +def test_mul(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.mul(None, None, None) + + +def test_multiply(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.multiply(None, None, None) + + +def test_name(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.name + + +def test_nbytes(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.nbytes + + +def test_ndim(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.ndim + + +def test_ne(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.ne(None, None, None) + + +def test_nlargest(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.nlargest(None) + + +def test_nonzero(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.nonzero() + + +def test_notnull(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.notnull() + + +def test_nsmallest(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.nsmallest(None) + + +def test_nunique(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.nunique(None) + + +def test_pct_change(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.pct_change(None, None, None, None) + + +def test_pipe(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.pipe(None, None) + + +def test_plot(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.plot(None, None, None, None, None, None, None, None, None, + None, None, None, None, None, None, None, None, None, + None, None, None, None, None) + + +def test_pop(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.pop(None) + + +def test_pow(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.pow(None, None, None) + + +def test_prod(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.prod(None, None, None, None) + + +def test_product(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.product(None, None, None, None) + + +def test_ptp(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.ptp(None, None, None, None) + + +def test_put(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.put(None) + + +def test_quantile(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.quantile(None) + + +def test_radd(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.radd(None, None, None) + + +def test_rank(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.rank(None, None, None, None, None) + + +def test_ravel(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.ravel(None) + + +def test_rdiv(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.rdiv(None, None, None) + + +def test_real(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.real + + +def test_reindex(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.reindex(None) + + +def test_reindex_axis(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.reindex_axis(None, None) + + +def test_reindex_like(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.reindex_like(None, None, None, None) + + +def test_rename(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.rename(None) + + +def test_rename_axis(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.rename_axis(None, None, None) + + +def test_reorder_levels(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.reorder_levels(None) + + +def test_repeat(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.repeat(None, None) + + +def test_replace(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.replace(None, None, None, None, None, None) + + +def test_resample(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.resample(None, None, None, None, None, None, None, None, + None, None, None, None) + + +def test_reset_index(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.reset_index(None, None, None) + + +def test_reshape(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.reshape(None) + + +def test_rfloordiv(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.rfloordiv(None, None, None) + + +def test_rmod(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.rmod(None, None, None) + + +def test_rmul(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.rmul(None, None, None) + + +def test_rolling(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.rolling(None, None, None, None, None, None, None) + + +def test_round(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.round(None, None) + + +def test_rpow(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.rpow(None, None, None) + + +def test_rsub(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.rsub(None, None, None) + + +def test_rtruediv(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.rtruediv(None, None, None) + + +def test_sample(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.sample(None, None, None, None, None) + + +def test_searchsorted(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.searchsorted(None, None) + + +def test_select(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.select(None) + + +def test_sem(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.sem(None, None, None, None, None) + + +def test_set_axis(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.set_axis(None, None) + + +def test_set_value(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.set_value(None, None) + + +def test_shape(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.shape + + +def test_shift(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.shift(None, None) + + +def test_size(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.size + + +def test_skew(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.skew(None, None, None, None) + + +def test_slice_shift(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.slice_shift(None) + + +def test_sort_index(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.sort_index(None, None, None, None, None, None) + + +def test_sort_values(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.sort_values(None, None, None, None) + + +def test_sortlevel(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.sortlevel(None, None) + + +def test_squeeze(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.squeeze(None) + + +def test_std(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.std(None, None, None, None, None) + + +def test_strides(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.strides + + +def test_sub(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.sub(None, None, None) + + +def test_subtract(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.subtract(None, None, None) + + +def test_sum(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.sum(None, None, None, None) + + +def test_swapaxes(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.swapaxes(None, None) + + +def test_swaplevel(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.swaplevel(None, None) + + +def test_tail(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.tail(None) + + +def test_take(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.take(None, None, None, None) + + +def test_to_clipboard(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.to_clipboard(None, None) + + +def test_to_csv(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.to_csv(None, None, None, None, None, None, None, None, + None, None) + + +def test_to_dense(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.to_dense() + + +def test_to_dict(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.to_dict() + + +def test_to_excel(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.to_excel(None, None, None, None, None, None, None, None, + None, None, None, None, None, None) + + +def test_to_frame(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.to_frame(None) + + +def test_to_hdf(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.to_hdf(None, None) + + +def test_to_json(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.to_json(None, None, None, None, None, None, None) + + +def test_to_latex(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.to_latex(None, None, None, None, None, None, None, None, + None, None, None, None, None, None, None, None, + None, None) + + +def test_to_msgpack(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.to_msgpack(None, None) + + +def test_to_period(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.to_period(None) + + +def test_to_pickle(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.to_pickle(None) + + +def test_to_sparse(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.to_sparse(None) + + +def test_to_sql(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.to_sql(None, None, None, None, None, None, None, None) + + +def test_to_string(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.to_string(None, None, None, None, None, None, None, None) + + +def test_to_timestamp(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.to_timestamp(None, None) + + +def test_to_xarray(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.to_xarray() + + +def test_tolist(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.tolist() + + +def test_transform(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.transform(None, None) + + +def test_transpose(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.transpose(None) + + +def test_truediv(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.truediv(None, None, None) + + +def test_truncate(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.truncate(None, None, None) + + +def test_tshift(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.tshift(None, None) + + +def test_tz_convert(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.tz_convert(None, None, None) + + +def test_tz_localize(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.tz_localize(None, None, None, None) + + +def test_unique(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.unique() + + +def test_unstack(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.unstack(None) + + +def test_update(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.update(None) + + +def test_valid(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.valid(None) + + +def test_value_counts(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.value_counts(None, None, None, None) + + +def test_values(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.values + + +def test_var(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.var(None, None, None, None, None) + + +def test_view(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.view(None) + + +def test_where(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.where(None, None, None, None, None, None) + + +def test_xs(): + ray_series = create_test_series() + + with pytest.raises(NotImplementedError): + ray_series.xs(None, None, None)