is_copy -> _parent

pandas/core/frame.py

@@ -1825,7 +1825,7 @@ def _ixs(self, i, axis=0):
  copy = isinstance(new_values,np.ndarray) and new_values.base is None
  result = Series(new_values, index=self.columns,
  name=self.index[i], dtype=new_values.dtype)
- result._set_is_copy(self, copy=copy)
+ result._set_parent(self, copy=copy)
  return result
 
  # icol
@@ -1957,7 +1957,7 @@ def _getitem_multilevel(self, key):
  if isinstance(result, Series):
  result = self._constructor_sliced(result, index=self.index, name=key)
 
- result._set_is_copy(self)
+ result._set_parent(self)
  return result
  else:
  return self._get_item_cache(key)
@@ -2300,12 +2300,12 @@ def _set_item(self, key, value):
 
  # if we have a multi-index (which potentially has dropped levels)
  # need to raise
- if isinstance(self.is_copy().columns, MultiIndex):
+ if isinstance(self._parent().columns, MultiIndex):
  raise
 
  # we have a chained assignment
  # assign back to the original
- self.is_copy().loc[self.index,key] = value
+ self._parent().loc[self.index,key] = value
 
  def insert(self, loc, column, value, allow_duplicates=False):
  """

pandas/core/generic.py

@@ -78,15 +78,15 @@ class NDFrame(PandasObject):
  axes : list
  copy : boolean, default False
  """
- _internal_names = ['_data', '_cacher', '_item_cache', '_cache',
- 'is_copy', '_subtyp', '_index', '_allow_copy_on_write',
+ _internal_names = ['_data', '_cacher', '_item_cache', '_cache', '_parent',
+ '_subtyp', '_index', '_parent_copy_on_write',
  '_default_kind', '_default_fill_value', '_metadata',
  '__array_struct__', '__array_interface__']
  _internal_names_set = set(_internal_names)
  _accessors = frozenset([])
  _metadata = []
- _allow_copy_on_write = True
- is_copy = None
+ _parent_copy_on_write = True
+ _parent = None
 
  def __init__(self, data, axes=None, copy=False, dtype=None,
  fastpath=False):
@@ -101,10 +101,22 @@ def __init__(self, data, axes=None, copy=False, dtype=None,
  for i, ax in enumerate(axes):
  data = data.reindex_axis(ax, axis=i)
 
- object.__setattr__(self, 'is_copy', None)
+ object.__setattr__(self, '_parent', None)
  object.__setattr__(self, '_data', data)
  object.__setattr__(self, '_item_cache', {})
 
+ def _get_is_copy(self):
+ warnings.warn("is_copy is deprecated will be removed in a future release",
+ FutureWarning)
+ return None
+
+ def _set_is_copy(self, v):
+ warnings.warn("is_copy is deprecated will be removed in a future release",
+ FutureWarning)
+ pass
+
+ is_copy = property(fget=_get_is_copy, fset=_set_is_copy)
+
  def _validate_dtype(self, dtype):
  """ validate the passed dtype """
 
@@ -1092,7 +1104,7 @@ def _get_item_cache(self, item):
  res._set_as_cached(item, self)
 
  # for a chain
- res.is_copy = self.is_copy
+ res._parent = self._parent
  return res
 
  def _set_as_cached(self, item, cacher):
@@ -1144,7 +1156,7 @@ def _is_view(self):
  """ boolean : return if I am a view of another array """
  return self._data.is_view
 
- def _maybe_update_cacher(self, clear=False, verify_is_copy=True):
+ def _maybe_update_cacher(self, clear=False, verify_parent=True):
  """
 
  see if we need to update our parent cacher
@@ -1154,8 +1166,8 @@ def _maybe_update_cacher(self, clear=False, verify_is_copy=True):
  ----------
  clear : boolean, default False
  clear the item cache
- verify_is_copy : boolean, default True
- provide is_copy checks
+ verify_parent : boolean, default True
+ provide parent checks
 
  """
 
@@ -1173,7 +1185,7 @@ def _maybe_update_cacher(self, clear=False, verify_is_copy=True):
  except:
  pass
 
- if verify_is_copy:
+ if verify_parent:
  self._check_copy_on_write()
 
  if clear:
@@ -1197,8 +1209,8 @@ def _slice(self, slobj, axis=0, kind=None):
  result = result.__finalize__(self)
 
  # mark this as a copy if we are not axis=0
- is_copy = axis!=0
- result._set_is_copy(self)
+ parent = axis!=0
+ result._set_parent(self)
  return result
 
  def _set_item(self, key, value):
@@ -1207,23 +1219,23 @@ def _set_item(self, key, value):
  self._data.set(key, value)
  self._clear_item_cache()
 
- def _set_is_copy(self, ref=None, copy=True):
+ def _set_parent(self, ref=None, copy=True):
  if not copy:
- self.is_copy = None
+ self._parent = None
  else:
  if ref is not None:
- self.is_copy = weakref.ref(ref)
+ self._parent = weakref.ref(ref)
  else:
- self.is_copy = None
+ self._parent = None
 
  def _check_copy_on_write(self):
 
  # we could have a copy-on-write scenario
- if self.is_copy and self._allow_copy_on_write:
+ if self._parent and self._parent_copy_on_write:
 
  # we have an exception
- if isinstance(self.is_copy, Exception):
- raise self.is_copy
+ if isinstance(self._parent, Exception):
+ raise self._parent
 
  def get_names_for_obj(__really_unused_name__342424__):
  """Returns all named references for self"""
@@ -1255,14 +1267,14 @@ def get_names_for_obj(__really_unused_name__342424__):
 
  # otherwise we have chained indexing, raise and error
  gc.collect(2)
- if self.is_copy() is not None:
+ if self._parent() is not None:
  names = get_names_for_obj(self)
  if not len(names):
  raise SettingWithCopyError("chained indexing detected, you can fix this ......")
 
  # provide copy-on-write
  self._data = self._data.copy()
- self.is_copy = None
+ self._parent = None
 
  def _check_is_chained_assignment_possible(self):
  """
@@ -1279,7 +1291,7 @@ def _check_is_chained_assignment_possible(self):
  if ref is not None:
  self._check_copy_on_write()
  return True
- elif self.is_copy:
+ elif self._parent:
  self._check_copy_on_write()
  return False
 
@@ -1342,7 +1354,7 @@ def take(self, indices, axis=0, convert=True, is_copy=True):
  # maybe set copy if we didn't actually change the index
  if is_copy:
  if not result._get_axis(axis).equals(self._get_axis(axis)):
- result._set_is_copy(self)
+ result._set_parent(self)
 
  return result
 
@@ -1485,7 +1497,7 @@ def xs(self, key, axis=0, level=None, copy=None, drop_level=True):
  result = self.iloc[loc]
  result.index = new_index
 
- result._set_is_copy(self)
+ result._set_parent(self)
  return result
 
  _xs = xs
@@ -1608,14 +1620,14 @@ def drop(self, labels, axis=0, level=None, inplace=False, errors='raise'):
  else:
  return result
 
- def _update_inplace(self, result, verify_is_copy=True):
+ def _update_inplace(self, result, verify_parent=True):
  """
  replace self internals with result.
 
  Parameters
  ----------
- verify_is_copy : boolean, default True
- provide is_copy checks
+ verify_parent : boolean, default True
+ provide parent checks
 
  """
  # NOTE: This does *not* call __finalize__ and that's an explicit
@@ -1624,7 +1636,7 @@ def _update_inplace(self, result, verify_is_copy=True):
  self._reset_cache()
  self._clear_item_cache()
  self._data = getattr(result,'_data',result)
- self._maybe_update_cacher(verify_is_copy=verify_is_copy)
+ self._maybe_update_cacher(verify_parent=verify_parent)
 
  def add_prefix(self, prefix):
  """

pandas/core/groupby.py

@@ -695,7 +695,7 @@ def _python_apply_general(self, f):
 
  keys, values, mutated = self.grouper.apply(f, self._selected_obj,
  self.axis)
- self._selected_obj._allow_copy_on_write = True
+ self._selected_obj._parent_copy_on_write = True
 
  return self._wrap_applied_output(keys, values,
  not_indexed_same=mutated)
@@ -3596,7 +3596,7 @@ def sort_idx(self):
  def _set_cow(self, data):
  # we may mutate, so don't allow cow
  try:
- data._allow_copy_on_write=False
+ data._parent_copy_on_write=False
  except AttributeError:
  pass
  return data

pandas/core/indexing.py

@@ -273,7 +273,7 @@ def _setitem_with_indexer(self, indexer, value):
  labels = index.insert(len(index),key)
  self.obj._data = self.obj.reindex_axis(labels, i)._data
  self.obj._maybe_update_cacher(clear=True)
- self.obj.is_copy=None
+ self.obj._parent=None
 
  nindexer.append(labels.get_loc(key))
 

pandas/core/ops.py

@@ -191,7 +191,7 @@ def f(self, other):
  # this makes sure that we are aligned like the input
  # we are updating inplace so we want to ignore is_copy
  self._update_inplace(result.reindex_like(self,copy=False)._data,
- verify_is_copy=False)
+ verify_parent=False)
 
  return self
  return f

pandas/core/panel.py

@@ -812,8 +812,7 @@ def xs(self, key, axis=1, copy=None):
  axis_number = self._get_axis_number(axis)
  new_data = self._data.xs(key, axis=axis_number, copy=False)
  result = self._construct_return_type(new_data)
- copy = new_data.is_mixed_type
- result._set_is_copy(self, copy=copy)
+ result._set_parent(self)
  return result
 
  _xs = xs

pandas/core/series.py

@@ -690,7 +690,7 @@ def setitem(key, value):
 
  # we have a chained assignment
  # assign back to the original
- self.is_copy().loc[self.name,key] = value
+ self._parent().loc[self.name,key] = value
  return
 
  setitem(key, value)

pandas/src/reduce.pyx

@@ -488,7 +488,7 @@ def apply_frame_axis0(object frame, object f, object names,
  # Need to infer if our low-level mucking is going to cause a segfault
  if n > 0:
  chunk = frame.iloc[starts[0]:ends[0]]
- chunk._allow_copy_on_write = False
+ chunk._parent_copy_on_write = False
  shape_before = chunk.shape
  try:
  result = f(chunk)
@@ -509,7 +509,7 @@ def apply_frame_axis0(object frame, object f, object names,
  item_cache.clear() # ugh
 
  object.__setattr__(slider.dummy, 'name', names[i])
- object.__setattr__(slider.dummy, '_allow_copy_on_write', False)
+ object.__setattr__(slider.dummy, '_parent_copy_on_write', False)
  piece = f(slider.dummy)
 
  # I'm paying the price for index-sharing, ugh

pandas/tests/test_index.py

@@ -3534,10 +3534,10 @@ def test_set_value_keeps_names(self):
  columns=['one', 'two', 'three', 'four'],
  index=idx)
  df = df.sortlevel()
- self.assertIsNone(df.is_copy)
+ self.assertIsNone(df._parent)
  self.assertEqual(df.index.names, ('Name', 'Number'))
  df = df.set_value(('grethe', '4'), 'one', 99.34)
- self.assertIsNone(df.is_copy)
+ self.assertIsNone(df._parent)
  self.assertEqual(df.index.names, ('Name', 'Number'))
 
  def test_names(self):