FM / frame

/usr/local/lib64/python3.6/site-packages/pandas/tests/frame/

/usr/local/lib64/python3.6/site-packages/pandas/tests/frame

Name	Size	Mode	Actions
apply/	-	0755	rm
methods/	-	0755	rm
__pycache__/	-	0755	rm
common.py	1119	0644	edit dl rm
conftest.py	8855	0644	edit dl rm
test_alter_axes.py	8801	0644	edit dl rm
test_analytics.py	46557	0644	edit dl rm
test_api.py	19589	0644	edit dl rm
test_arithmetic.py	54999	0644	edit dl rm
test_axis_select_reindex.py	18320	0644	edit dl rm
test_block_internals.py	23194	0644	edit dl rm
test_combine_concat.py	8607	0644	edit dl rm
test_constructors.py	100607	0644	edit dl rm
test_cumulative.py	4228	0644	edit dl rm
test_dtypes.py	11812	0644	edit dl rm
test_join.py	8779	0644	edit dl rm
test_missing.py	25616	0644	edit dl rm
test_nonunique_indexes.py	17501	0644	edit dl rm
test_operators.py	9068	0644	edit dl rm
test_period.py	1184	0644	edit dl rm
test_query_eval.py	47568	0644	edit dl rm
test_repr_info.py	6729	0644	edit dl rm
test_reshape.py	47482	0644	edit dl rm
test_sort_values_level_as_str.py	2550	0644	edit dl rm
test_subclass.py	23573	0644	edit dl rm
test_timeseries.py	2218	0644	edit dl rm
test_timezones.py	6158	0644	edit dl rm
test_to_csv.py	48182	0644	edit dl rm
test_validate.py	1095	0644	edit dl rm
__init__.py	0	0644	edit dl rm

Edit: /usr/local/lib64/python3.6/site-packages/pandas/tests/frame/test_cumulative.py (4228B)

"""
Tests for DataFrame cumulative operations

See also
--------
tests.series.test_cumulative
"""

import numpy as np

from pandas import DataFrame, Series
import pandas._testing as tm

class TestDataFrameCumulativeOps:
    # ---------------------------------------------------------------------
    # Cumulative Operations - cumsum, cummax, ...

def test_cumsum_corner(self):
        dm = DataFrame(np.arange(20).reshape(4, 5), index=range(4), columns=range(5))
        # TODO(wesm): do something with this?
        result = dm.cumsum()  # noqa

def test_cumsum(self, datetime_frame):
        datetime_frame.iloc[5:10, 0] = np.nan
        datetime_frame.iloc[10:15, 1] = np.nan
        datetime_frame.iloc[15:, 2] = np.nan

# axis = 0
        cumsum = datetime_frame.cumsum()
        expected = datetime_frame.apply(Series.cumsum)
        tm.assert_frame_equal(cumsum, expected)

# axis = 1
        cumsum = datetime_frame.cumsum(axis=1)
        expected = datetime_frame.apply(Series.cumsum, axis=1)
        tm.assert_frame_equal(cumsum, expected)

# works
        df = DataFrame({"A": np.arange(20)}, index=np.arange(20))
        df.cumsum()

# fix issue
        cumsum_xs = datetime_frame.cumsum(axis=1)
        assert np.shape(cumsum_xs) == np.shape(datetime_frame)

def test_cumprod(self, datetime_frame):
        datetime_frame.iloc[5:10, 0] = np.nan
        datetime_frame.iloc[10:15, 1] = np.nan
        datetime_frame.iloc[15:, 2] = np.nan

# axis = 0
        cumprod = datetime_frame.cumprod()
        expected = datetime_frame.apply(Series.cumprod)
        tm.assert_frame_equal(cumprod, expected)

# axis = 1
        cumprod = datetime_frame.cumprod(axis=1)
        expected = datetime_frame.apply(Series.cumprod, axis=1)
        tm.assert_frame_equal(cumprod, expected)

# fix issue
        cumprod_xs = datetime_frame.cumprod(axis=1)
        assert np.shape(cumprod_xs) == np.shape(datetime_frame)

# ints
        df = datetime_frame.fillna(0).astype(int)
        df.cumprod(0)
        df.cumprod(1)

# ints32
        df = datetime_frame.fillna(0).astype(np.int32)
        df.cumprod(0)
        df.cumprod(1)

def test_cummin(self, datetime_frame):
        datetime_frame.iloc[5:10, 0] = np.nan
        datetime_frame.iloc[10:15, 1] = np.nan
        datetime_frame.iloc[15:, 2] = np.nan

# axis = 0
        cummin = datetime_frame.cummin()
        expected = datetime_frame.apply(Series.cummin)
        tm.assert_frame_equal(cummin, expected)

# axis = 1
        cummin = datetime_frame.cummin(axis=1)
        expected = datetime_frame.apply(Series.cummin, axis=1)
        tm.assert_frame_equal(cummin, expected)

# it works
        df = DataFrame({"A": np.arange(20)}, index=np.arange(20))
        df.cummin()

# fix issue
        cummin_xs = datetime_frame.cummin(axis=1)
        assert np.shape(cummin_xs) == np.shape(datetime_frame)

def test_cummax(self, datetime_frame):
        datetime_frame.iloc[5:10, 0] = np.nan
        datetime_frame.iloc[10:15, 1] = np.nan
        datetime_frame.iloc[15:, 2] = np.nan

# axis = 0
        cummax = datetime_frame.cummax()
        expected = datetime_frame.apply(Series.cummax)
        tm.assert_frame_equal(cummax, expected)

# axis = 1
        cummax = datetime_frame.cummax(axis=1)
        expected = datetime_frame.apply(Series.cummax, axis=1)
        tm.assert_frame_equal(cummax, expected)

# it works
        df = DataFrame({"A": np.arange(20)}, index=np.arange(20))
        df.cummax()

# fix issue
        cummax_xs = datetime_frame.cummax(axis=1)
        assert np.shape(cummax_xs) == np.shape(datetime_frame)

def test_cumulative_ops_preserve_dtypes(self):
        # GH#19296 dont incorrectly upcast to object
        df = DataFrame({"A": [1, 2, 3], "B": [1, 2, 3.0], "C": [True, False, False]})

result = df.cumsum()

expected = DataFrame(
            {
                "A": Series([1, 3, 6], dtype=np.int64),
                "B": Series([1, 3, 6], dtype=np.float64),
                "C": df["C"].cumsum(),
            }
        )
        tm.assert_frame_equal(result, expected)

cmd: