BUG: Bug in Series update where the parent frame is not updating its cache based on

      changes (GH4080)

BUG: Series not updating properly with object dtype (GH33217)

BUG: (GH3386) fillna same issue as (GH4080), not updating cacher

Author: jreback

doc/source/release.rst

@@ -121,7 +121,7 @@ pandas 0.13
 
 In 0.13.0 there is a major refactor primarily to subclass ``Series`` from ``NDFrame``,
 which is the base class currently for ``DataFrame`` and ``Panel``, to unify methods
-and behaviors. Series formerly subclassed directly from ``ndarray``.
+and behaviors. Series formerly subclassed directly from ``ndarray``. (:issue:`4080`,:issue:`3862`,:issue:`816`)
 
 - Refactor of series.py/frame.py/panel.py to move common code to generic.py
   - added _setup_axes to created generic NDFrame structures
@@ -177,6 +177,9 @@ and behaviors. Series formerly subclassed directly from ``ndarray``.
   values to propogate to a new object from an existing (e.g. name in ``Series`` will follow
   more automatically now)
 
+- Bug in Series update where the parent frame is not updating its cache based on
+  changes (:issue:`4080`) or types (:issue:`3217`), fillna (:issue:`3386`)
+
 **Experimental Features**
 
 **Bug Fixes**

doc/source/v0.13.0.txt

@@ -195,6 +195,9 @@ and behaviors. Series formerly subclassed directly from ``ndarray``. (:issue:`40
   values to propogate to a new object from an existing (e.g. name in ``Series`` will follow
   more automatically now)
 
+- Bug in Series update where the parent frame is not updating its cached based on
+  changes (:issue:`4080`) or types (:issue:`3217`), fillna (:issue:`3386`)
+
 Bug Fixes
 ~~~~~~~~~
 

pandas/core/generic.py

@@ -3,6 +3,7 @@
 from pandas import compat
 import itertools
 import operator
+import weakref
 import numpy as np
 import pandas.lib as lib
 from pandas.core.base import PandasObject
@@ -702,11 +703,23 @@ def _get_item_cache(self, item):
             values = self._data.get(item)
             res = self._box_item_values(item, values)
             cache[item] = res
+            res._cacher = (item,weakref.ref(self))
             return res
 
     def _box_item_values(self, key, values):
         raise NotImplementedError
 
+    def _maybe_cache_changed(self, item, value):
+        """ the object has called back to us saying
+        maybe it has changed """
+        self._data.set(item, value)
+
+    def _maybe_update_cacher(self):
+        """ see if we need to update our parent cacher """
+        cacher = getattr(self,'_cacher',None)
+        if cacher is not None:
+            cacher[1]()._maybe_cache_changed(cacher[0],self)
+
     def _clear_item_cache(self):
         self._item_cache.clear()
 
@@ -1437,7 +1450,9 @@ def fillna(self, value=None, method=None, axis=0, inplace=False,
                 for k, v in value.iteritems():
                     if k not in result:
                         continue
-                    result[k].fillna(v, inplace=True)
+                    obj = result[k]
+                    obj.fillna(v, inplace=True)
+                    obj._maybe_update_cacher()
                 return result
             else:
                 new_data = self._data.fillna(value, inplace=inplace,

pandas/core/indexing.py

@@ -1027,7 +1027,7 @@ def _check_bool_indexer(ax, key):
     # this function assumes that com._is_bool_indexer(key) == True
 
     result = key
-    if _is_series(key) and not key.index.equals(ax):
+    if is_series(key) and not key.index.equals(ax):
         result = result.reindex(ax)
         mask = com.isnull(result.values)
         if mask.any():
@@ -1042,10 +1042,6 @@ def _check_bool_indexer(ax, key):
 
     return result
 
-def _is_series(obj):
-    return is_series(obj)
-
-
 def _maybe_convert_indices(indices, n):
     """ if we have negative indicies, translate to postive here
         if have indicies that are out-of-bounds, raise an IndexError """

pandas/core/internals.py

@@ -297,17 +297,13 @@ def fillna(self, value, inplace=False, downcast=None):
             else:
                 return self.copy()
 
-        new_values = self.values if inplace else self.values.copy()
-        mask = com.isnull(new_values)
-
+        mask = com.isnull(self.values)
         value = self._try_fill(value)
-        np.putmask(new_values, mask, value)
+        blocks = self.putmask(mask, value, inplace=inplace)
 
-        block = make_block(
-            new_values, self.items, self.ref_items, fastpath=True)
         if downcast:
-            block = block.downcast()
-        return block
+            blocks = [ b.downcast() for b in blocks ]
+        return blocks
 
     def downcast(self, dtypes=None):
         """ try to downcast each item to the dict of dtypes if present """

pandas/core/series.py

@@ -27,6 +27,7 @@
     _is_index_slice, _maybe_convert_indices)
 from pandas.core import generic
 from pandas.core.internals import SingleBlockManager
+import pandas.core.expressions as expressions
 from pandas.tseries.index import DatetimeIndex
 from pandas.tseries.period import PeriodIndex, Period
 from pandas.tseries.offsets import DateOffset
@@ -2306,7 +2307,9 @@ def update(self, other):
         """
         other = other.reindex_like(self)
         mask = notnull(other)
-        com._maybe_upcast_putmask(self.values, mask, other, change=self.values)
+
+        self._data = self._data.putmask(mask, other, inplace=True)
+        self._maybe_update_cacher()
 
     #----------------------------------------------------------------------
     # Reindexing, sorting

pandas/tests/test_frame.py

@@ -6221,6 +6221,16 @@ def test_fillna(self):
             df.x.fillna(method=m,inplace=1)
             df.x.fillna(method=m)
 
+        # with different dtype (GH3386)
+        df = DataFrame([['a','a',np.nan,'a'],['b','b',np.nan,'b'],['c','c',np.nan,'c']])
+
+        result = df.fillna({ 2: 'foo' })
+        expected = DataFrame([['a','a','foo','a'],['b','b','foo','b'],['c','c','foo','c']])
+        assert_frame_equal(result, expected)
+
+        df.fillna({ 2: 'foo' }, inplace=True)
+        assert_frame_equal(df, expected)
+
     def test_ffill(self):
         self.tsframe['A'][:5] = nan
         self.tsframe['A'][-5:] = nan

pandas/tests/test_series.py

@@ -2550,6 +2550,37 @@ def f(x):
         expected = tsdf.max()
         assert_series_equal(result,expected)
 
+    def test_underlying_data_conversion(self):
+
+        # GH 4080
+        df = DataFrame(dict((c, [1,2,3]) for c in ['a', 'b', 'c']))
+        df.set_index(['a', 'b', 'c'], inplace=True)
+        s = Series([1], index=[(2,2,2)])
+        df['val'] = 0
+        df
+        df['val'].update(s)
+
+        expected = DataFrame(dict(a = [1,2,3], b = [1,2,3], c = [1,2,3], val = [0,1,0]))
+        expected.set_index(['a', 'b', 'c'], inplace=True)
+        tm.assert_frame_equal(df,expected)
+
+        # GH 3970
+        df = DataFrame({ "aa":range(5), "bb":[2.2]*5})
+        df["cc"] = 0.0
+        ck = [True]*len(df)
+        df["bb"].iloc[0] = .13
+        df_tmp = df.iloc[ck]
+        df["bb"].iloc[0] = .15
+        self.assert_(df['bb'].iloc[0] == 0.15)
+
+        # GH 3217
+        df = DataFrame(dict(a = [1,3], b = [np.nan, 2]))
+        df['c'] = np.nan
+        df['c'].update(pd.Series(['foo'],index=[0]))
+
+        expected = DataFrame(dict(a = [1,3], b = [np.nan, 2], c = ['foo',np.nan]))
+        tm.assert_frame_equal(df,expected)
+
     def test_operators_corner(self):
         series = self.ts