def _init_data(self, data, copy, dtype, **kwargs):
"""
Generate ND initialization; axes are passed
as required objects to __init__
"""
if data is None:
data = {}
if dtype is not None:
dtype = self._validate_dtype(dtype)
passed_axes = [kwargs.get(a) for a in self._AXIS_ORDERS]
axes = None
if isinstance(data, BlockManager):
if any(x is not None for x in passed_axes):
axes = [
x if x is not None else y
for x, y in zip(passed_axes, data.axes)
]
mgr = data
elif isinstance(data, dict):
mgr = self._init_dict(data, passed_axes, dtype=dtype)
copy = False
dtype = None
elif isinstance(data, (np.ndarray, list)):
mgr = self._init_matrix(data, passed_axes, dtype=dtype, copy=copy)
copy = False
dtype = None
else: # pragma: no cover
raise PandasError('Panel constructor not properly called!')
NDFrame.__init__(self, mgr, axes=axes, copy=copy, dtype=dtype)
def _format_input_data(self, data):
"""Check and format the data argument provided to CausalImpact().
Args:
data: Pandas DataFrame
Returns:
correctly formatted Pandas DataFrame
"""
# If <data> is a Pandas DataFrame and the first column is 'date',
# try to convert
if type(data) == pd.DataFrame and type(data.columns[0]) == str:
if data.columns[0].lower() in ["date", "time"]:
data = data.set_index(data.columns[0])
# Try to convert to Pandas DataFrame
try:
data = pd.DataFrame(data)
except PandasError:
raise PandasError("could not convert input data to Pandas \
DataFrame")
# Must have at least 3 time points
if len(data.index) < 3:
raise ValueError("data must have at least 3 time points")
# Must not have NA in covariates (if any)
if len(data.columns) >= 2:
if np.any(pd.isnull(data.iloc[:, 1:])):
raise ValueError("covariates must not contain null values")
return data
def __init__(self,
data=None,
items=None,
major_axis=None,
minor_axis=None,
copy=False,
dtype=None):
"""
Represents wide format panel data, stored as 3-dimensional array
Parameters
----------
data : ndarray (items x major x minor), or dict of DataFrames
items : Index or array-like
axis=1
major_axis : Index or array-like
axis=1
minor_axis : Index or array-like
axis=2
dtype : dtype, default None
Data type to force, otherwise infer
copy : boolean, default False
Copy data from inputs. Only affects DataFrame / 2d ndarray input
"""
if data is None:
data = {}
passed_axes = [items, major_axis, minor_axis]
axes = None
if isinstance(data, BlockManager):
if any(x is not None for x in passed_axes):
axes = [
x if x is not None else y
for x, y in zip(passed_axes, data.axes)
]
mgr = data
elif isinstance(data, dict):
mgr = self._init_dict(data, passed_axes, dtype=dtype)
copy = False
dtype = None
elif isinstance(data, (np.ndarray, list)):
mgr = self._init_matrix(data, passed_axes, dtype=dtype, copy=copy)
copy = False
dtype = None
else: # pragma: no cover
raise PandasError('Panel constructor not properly called!')
NDFrame.__init__(self, mgr, axes=axes, copy=copy, dtype=dtype)
def _construct_return_type(self, result, axes=None, **kwargs):
""" return the type for the ndim of the result """
ndim = result.ndim
if self.ndim == ndim:
""" return the construction dictionary for these axes """
if axes is None:
return self._constructor(result)
return self._constructor(result, **self._construct_axes_dict())
elif self.ndim == ndim + 1:
if axes is None:
return self._constructor_sliced(result)
return self._constructor_sliced(
result, **self._extract_axes_for_slice(self, axes))
raise PandasError('invalid _construct_return_type [self->%s] '
'[result->%s]' % (self.ndim, result.ndim))
def _concat_blocks(self, blocks):
values_list = [b.get_values() for b in blocks if b is not None]
concat_values = com._concat_compat(values_list, axis=self.axis)
if self.axis > 0:
# Not safe to remove this check, need to profile
if not _all_indexes_same([b.items for b in blocks]):
# TODO: Either profile this piece or remove.
# FIXME: Need to figure out how to test whether this line exists or does not...(unclear if even possible
# or maybe would require performance test)
raise PandasError('dtypes are not consistent throughout '
'DataFrames')
return make_block(concat_values,
blocks[0].items,
self.new_axes[0],
placement=blocks[0]._ref_locs)
else:
offsets = np.r_[
0, np.cumsum([len(x._data.axes[0]) for x in self.objs])]
indexer = np.concatenate([
offsets[i] + b.ref_locs for i, b in enumerate(blocks)
if b is not None
])
if self.ignore_index:
concat_items = indexer
else:
concat_items = self.new_axes[0].take(indexer)
if self.ignore_index:
ref_items = self._get_fresh_axis()
return make_block(concat_values, concat_items, ref_items)
block = make_block(concat_values, concat_items, self.new_axes[0])
# we need to set the ref_locs in this block so we have the mapping
# as we now have a non-unique index across dtypes, and we need to
# map the column location to the block location
# GH3602
if not self.new_axes[0].is_unique:
block.set_ref_locs(indexer)
return block
def _construct_return_type(self, result, axes=None, **kwargs):
""" return the type for the ndim of the result """
ndim = getattr(result, 'ndim', None)
# need to assume they are the same
if ndim is None:
if isinstance(result, dict):
ndim = getattr(
list(compat.itervalues(result))[0], 'ndim', None)
# a saclar result
if ndim is None:
ndim = 0
# have a dict, so top-level is +1 dim
else:
ndim += 1
# scalar
if ndim == 0:
return Series(result)
# same as self
elif self.ndim == ndim:
""" return the construction dictionary for these axes """
if axes is None:
return self._constructor(result)
return self._constructor(result, **self._construct_axes_dict())
# sliced
elif self.ndim == ndim + 1:
if axes is None:
return self._constructor_sliced(result)
return self._constructor_sliced(
result, **self._extract_axes_for_slice(self, axes))
raise PandasError('invalid _construct_return_type [self->%s] '
'[result->%s]' % (self, result))
