def __init__(self, values, items, ref_items, ndim=2,
do_integrity_check=False):
if values.dtype != _NS_DTYPE:
values = lib.cast_to_nanoseconds(values)
Block.__init__(self, values, items, ref_items, ndim=ndim,
do_integrity_check=do_integrity_check)
def set(self, item, value):
"""
Modify Block in-place with new item value
Returns
-------
None
"""
loc = self.items.get_loc(item)
if value.dtype != _NS_DTYPE:
value = lib.cast_to_nanoseconds(value)
self.values[loc] = value
def __new__(cls, data=None,
freq=None, start=None, end=None, periods=None,
copy=False, name=None, tz=None,
verify_integrity=True, normalize=False, **kwds):
warn = False
if 'offset' in kwds and kwds['offset']:
freq = kwds['offset']
warn = True
freq_infer = False
if not isinstance(freq, DateOffset):
if freq != 'infer':
freq = to_offset(freq)
else:
freq_infer = True
freq = None
if warn:
import warnings
warnings.warn("parameter 'offset' is deprecated, "
"please use 'freq' instead",
FutureWarning)
offset = freq
if periods is not None:
if com.is_float(periods):
periods = int(periods)
elif not com.is_integer(periods):
raise ValueError('Periods must be a number, got %s' %
str(periods))
if data is None and offset is None:
raise ValueError("Must provide freq argument if no data is "
"supplied")
if data is None:
return cls._generate(start, end, periods, name, offset,
tz=tz, normalize=normalize)
if not isinstance(data, np.ndarray):
if np.isscalar(data):
raise ValueError('DatetimeIndex() must be called with a '
'collection of some kind, %s was passed'
% repr(data))
# other iterable of some kind
if not isinstance(data, (list, tuple)):
data = list(data)
data = np.asarray(data, dtype='O')
# try a few ways to make it datetime64
if lib.is_string_array(data):
data = _str_to_dt_array(data, offset)
else:
data = tools.to_datetime(data)
data.offset = offset
if issubclass(data.dtype.type, basestring):
subarr = _str_to_dt_array(data, offset)
elif issubclass(data.dtype.type, np.datetime64):
if isinstance(data, DatetimeIndex):
subarr = data.values
if offset is None:
offset = data.offset
verify_integrity = False
else:
if data.dtype != _NS_DTYPE:
subarr = lib.cast_to_nanoseconds(data)
else:
subarr = data
elif data.dtype == _INT64_DTYPE:
if copy:
subarr = np.asarray(data, dtype=_NS_DTYPE)
else:
subarr = data.view(_NS_DTYPE)
else:
subarr = tools.to_datetime(data)
if not np.issubdtype(subarr.dtype, np.datetime64):
raise TypeError('Unable to convert %s to datetime dtype'
% str(data))
if tz is not None:
tz = tools._maybe_get_tz(tz)
# Convert local to UTC
ints = subarr.view('i8')
subarr = lib.tz_localize_to_utc(ints, tz)
subarr = subarr.view(_NS_DTYPE)
subarr = subarr.view(cls)
subarr.name = name
subarr.offset = offset
subarr.tz = tz
if verify_integrity and len(subarr) > 0:
if offset is not None and not freq_infer:
inferred = subarr.inferred_freq
if inferred != offset.freqstr:
raise ValueError('Dates do not conform to passed '
'frequency')
if freq_infer:
inferred = subarr.inferred_freq
if inferred:
subarr.offset = to_offset(inferred)
return subarr
def form_blocks(arrays, names, axes):
# pre-filter out items if we passed it
items = axes[0]
if len(arrays) < len(items):
extra_items = items - Index(names)
else:
extra_items = []
# put "leftover" items in float bucket, where else?
# generalize?
float_items = []
complex_items = []
int_items = []
bool_items = []
object_items = []
datetime_items = []
for k, v in zip(names, arrays):
if issubclass(v.dtype.type, np.floating):
float_items.append((k, v))
elif issubclass(v.dtype.type, np.complexfloating):
complex_items.append((k, v))
elif issubclass(v.dtype.type, np.datetime64):
if v.dtype != _NS_DTYPE:
v = lib.cast_to_nanoseconds(v)
if hasattr(v, 'tz') and v.tz is not None:
object_items.append((k, v))
else:
datetime_items.append((k, v))
elif issubclass(v.dtype.type, np.integer):
int_items.append((k, v))
elif v.dtype == np.bool_:
bool_items.append((k, v))
else:
object_items.append((k, v))
blocks = []
if len(float_items):
float_block = _simple_blockify(float_items, items, np.float64)
blocks.append(float_block)
if len(complex_items):
complex_block = _simple_blockify(complex_items, items, np.complex128)
blocks.append(complex_block)
if len(int_items):
int_block = _simple_blockify(int_items, items, np.int64)
blocks.append(int_block)
if len(datetime_items):
datetime_block = _simple_blockify(datetime_items, items, _NS_DTYPE)
blocks.append(datetime_block)
if len(bool_items):
bool_block = _simple_blockify(bool_items, items, np.bool_)
blocks.append(bool_block)
if len(object_items) > 0:
object_block = _simple_blockify(object_items, items, np.object_)
blocks.append(object_block)
if len(extra_items):
shape = (len(extra_items),) + tuple(len(x) for x in axes[1:])
# empty items -> dtype object
block_values = np.empty(shape, dtype=object)
block_values.fill(nan)
na_block = make_block(block_values, extra_items, items)
blocks.append(na_block)
blocks = _consolidate(blocks, items)
return blocks
def __init__(self, values, items, ref_items, ndim=2):
if values.dtype != _NS_DTYPE:
values = lib.cast_to_nanoseconds(values)
Block.__init__(self, values, items, ref_items, ndim=ndim)
def __init__(self, values, items, ref_items, ndim=2):
if values.dtype != _NS_DTYPE:
values = lib.cast_to_nanoseconds(values)
Block.__init__(self, values, items, ref_items, ndim=ndim)
def form_blocks(arrays, names, axes):
# pre-filter out items if we passed it
items = axes[0]
if len(arrays) < len(items):
extra_items = items - Index(names)
else:
extra_items = []
# put "leftover" items in float bucket, where else?
# generalize?
float_items = []
complex_items = []
int_items = []
bool_items = []
object_items = []
datetime_items = []
for k, v in zip(names, arrays):
if issubclass(v.dtype.type, np.floating):
float_items.append((k, v))
elif issubclass(v.dtype.type, np.complexfloating):
complex_items.append((k, v))
elif issubclass(v.dtype.type, np.datetime64):
if v.dtype != _NS_DTYPE:
v = lib.cast_to_nanoseconds(v)
if hasattr(v, 'tz') and v.tz is not None:
object_items.append((k, v))
else:
datetime_items.append((k, v))
elif issubclass(v.dtype.type, np.integer):
int_items.append((k, v))
elif v.dtype == np.bool_:
bool_items.append((k, v))
else:
object_items.append((k, v))
blocks = []
if len(float_items):
float_block = _simple_blockify(float_items, items, np.float64)
blocks.append(float_block)
if len(complex_items):
complex_block = _simple_blockify(complex_items, items, np.complex128)
blocks.append(complex_block)
if len(int_items):
int_block = _simple_blockify(int_items, items, np.int64)
blocks.append(int_block)
if len(datetime_items):
datetime_block = _simple_blockify(datetime_items, items, _NS_DTYPE)
blocks.append(datetime_block)
if len(bool_items):
bool_block = _simple_blockify(bool_items, items, np.bool_)
blocks.append(bool_block)
if len(object_items) > 0:
object_block = _simple_blockify(object_items, items, np.object_)
blocks.append(object_block)
if len(extra_items):
shape = (len(extra_items),) + tuple(len(x) for x in axes[1:])
# empty items -> dtype object
block_values = np.empty(shape, dtype=object)
block_values.fill(nan)
na_block = make_block(block_values, extra_items, items)
blocks.append(na_block)
blocks = _consolidate(blocks, items)
return blocks
def __new__(cls,
data=None,
freq=None,
start=None,
end=None,
periods=None,
copy=False,
name=None,
tz=None,
verify_integrity=True,
normalize=False,
**kwds):
dayfirst = kwds.pop('dayfirst', None)
yearfirst = kwds.pop('yearfirst', None)
warn = False
if 'offset' in kwds and kwds['offset']:
freq = kwds['offset']
warn = True
freq_infer = False
if not isinstance(freq, DateOffset):
if freq != 'infer':
freq = to_offset(freq)
else:
freq_infer = True
freq = None
if warn:
import warnings
warnings.warn(
"parameter 'offset' is deprecated, "
"please use 'freq' instead", FutureWarning)
offset = freq
if periods is not None:
if com.is_float(periods):
periods = int(periods)
elif not com.is_integer(periods):
raise ValueError('Periods must be a number, got %s' %
str(periods))
if data is None and offset is None:
raise ValueError("Must provide freq argument if no data is "
"supplied")
if data is None:
return cls._generate(start,
end,
periods,
name,
offset,
tz=tz,
normalize=normalize)
if not isinstance(data, np.ndarray):
if np.isscalar(data):
raise ValueError('DatetimeIndex() must be called with a '
'collection of some kind, %s was passed' %
repr(data))
# other iterable of some kind
if not isinstance(data, (list, tuple)):
data = list(data)
data = np.asarray(data, dtype='O')
# try a few ways to make it datetime64
if lib.is_string_array(data):
data = _str_to_dt_array(data,
offset,
dayfirst=dayfirst,
yearfirst=yearfirst)
else:
data = tools.to_datetime(data)
data.offset = offset
if isinstance(data, DatetimeIndex):
if name is not None:
data.name = name
return data
if issubclass(data.dtype.type, basestring):
subarr = _str_to_dt_array(data,
offset,
dayfirst=dayfirst,
yearfirst=yearfirst)
elif issubclass(data.dtype.type, np.datetime64):
if isinstance(data, DatetimeIndex):
if tz is None:
tz = data.tz
subarr = data.values
if offset is None:
offset = data.offset
verify_integrity = False
else:
if data.dtype != _NS_DTYPE:
subarr = lib.cast_to_nanoseconds(data)
else:
subarr = data
elif data.dtype == _INT64_DTYPE:
if isinstance(data, Int64Index):
raise TypeError('cannot convert Int64Index->DatetimeIndex')
if copy:
subarr = np.asarray(data, dtype=_NS_DTYPE)
else:
subarr = data.view(_NS_DTYPE)
else:
try:
subarr = tools.to_datetime(data)
except ValueError:
# tz aware
subarr = tools.to_datetime(data, utc=True)
if not np.issubdtype(subarr.dtype, np.datetime64):
raise TypeError('Unable to convert %s to datetime dtype' %
str(data))
if isinstance(subarr, DatetimeIndex):
if tz is None:
tz = subarr.tz
else:
if tz is not None:
tz = tools._maybe_get_tz(tz)
if (not isinstance(data, DatetimeIndex)
or getattr(data, 'tz', None) is None):
# Convert tz-naive to UTC
ints = subarr.view('i8')
subarr = lib.tz_localize_to_utc(ints, tz)
subarr = subarr.view(_NS_DTYPE)
subarr = subarr.view(cls)
subarr.name = name
subarr.offset = offset
subarr.tz = tz
if verify_integrity and len(subarr) > 0:
if offset is not None and not freq_infer:
inferred = subarr.inferred_freq
if inferred != offset.freqstr:
raise ValueError('Dates do not conform to passed '
'frequency')
if freq_infer:
inferred = subarr.inferred_freq
if inferred:
subarr.offset = to_offset(inferred)
return subarr
def __new__(
cls,
data=None,
freq=None,
start=None,
end=None,
periods=None,
copy=False,
name=None,
tz=None,
verify_integrity=True,
normalize=False,
**kwds
):
dayfirst = kwds.pop("dayfirst", None)
yearfirst = kwds.pop("yearfirst", None)
warn = False
if "offset" in kwds and kwds["offset"]:
freq = kwds["offset"]
warn = True
freq_infer = False
if not isinstance(freq, DateOffset):
if freq != "infer":
freq = to_offset(freq)
else:
freq_infer = True
freq = None
if warn:
import warnings
warnings.warn("parameter 'offset' is deprecated, " "please use 'freq' instead", FutureWarning)
offset = freq
if periods is not None:
if com.is_float(periods):
periods = int(periods)
elif not com.is_integer(periods):
raise ValueError("Periods must be a number, got %s" % str(periods))
if data is None and offset is None:
raise ValueError("Must provide freq argument if no data is " "supplied")
if data is None:
return cls._generate(start, end, periods, name, offset, tz=tz, normalize=normalize)
if not isinstance(data, np.ndarray):
if np.isscalar(data):
raise ValueError(
"DatetimeIndex() must be called with a " "collection of some kind, %s was passed" % repr(data)
)
# other iterable of some kind
if not isinstance(data, (list, tuple)):
data = list(data)
data = np.asarray(data, dtype="O")
# try a few ways to make it datetime64
if lib.is_string_array(data):
data = _str_to_dt_array(data, offset, dayfirst=dayfirst, yearfirst=yearfirst)
else:
data = tools.to_datetime(data)
data.offset = offset
if isinstance(data, DatetimeIndex):
if name is not None:
data.name = name
return data
if issubclass(data.dtype.type, basestring):
subarr = _str_to_dt_array(data, offset, dayfirst=dayfirst, yearfirst=yearfirst)
elif issubclass(data.dtype.type, np.datetime64):
if isinstance(data, DatetimeIndex):
if tz is None:
tz = data.tz
subarr = data.values
if offset is None:
offset = data.offset
verify_integrity = False
else:
if data.dtype != _NS_DTYPE:
subarr = lib.cast_to_nanoseconds(data)
else:
subarr = data
elif data.dtype == _INT64_DTYPE:
if isinstance(data, Int64Index):
raise TypeError("cannot convert Int64Index->DatetimeIndex")
if copy:
subarr = np.asarray(data, dtype=_NS_DTYPE)
else:
subarr = data.view(_NS_DTYPE)
else:
try:
subarr = tools.to_datetime(data)
except ValueError:
# tz aware
subarr = tools.to_datetime(data, utc=True)
if not np.issubdtype(subarr.dtype, np.datetime64):
raise TypeError("Unable to convert %s to datetime dtype" % str(data))
if isinstance(subarr, DatetimeIndex):
if tz is None:
tz = subarr.tz
else:
if tz is not None:
tz = tools._maybe_get_tz(tz)
if not isinstance(data, DatetimeIndex) or getattr(data, "tz", None) is None:
# Convert tz-naive to UTC
ints = subarr.view("i8")
subarr = lib.tz_localize_to_utc(ints, tz)
subarr = subarr.view(_NS_DTYPE)
subarr = subarr.view(cls)
subarr.name = name
subarr.offset = offset
subarr.tz = tz
if verify_integrity and len(subarr) > 0:
if offset is not None and not freq_infer:
inferred = subarr.inferred_freq
if inferred != offset.freqstr:
raise ValueError("Dates do not conform to passed " "frequency")
if freq_infer:
inferred = subarr.inferred_freq
if inferred:
subarr.offset = to_offset(inferred)
return subarr
def form_blocks(data, axes):
# pre-filter out items if we passed it
items = axes[0]
if len(data) < len(items):
extra_items = items - Index(data.keys())
else:
extra_items = []
# put "leftover" items in float bucket, where else?
# generalize?
float_dict = {}
complex_dict = {}
int_dict = {}
bool_dict = {}
object_dict = {}
datetime_dict = {}
for k, v in data.iteritems():
if issubclass(v.dtype.type, np.floating):
float_dict[k] = v
elif issubclass(v.dtype.type, np.complexfloating):
complex_dict[k] = v
elif issubclass(v.dtype.type, np.datetime64):
if v.dtype != _NS_DTYPE:
v = lib.cast_to_nanoseconds(v)
datetime_dict[k] = v
elif issubclass(v.dtype.type, np.integer):
int_dict[k] = v
elif v.dtype == np.bool_:
bool_dict[k] = v
else:
object_dict[k] = v
blocks = []
if len(float_dict):
float_block = _simple_blockify(float_dict, items, np.float64)
blocks.append(float_block)
if len(complex_dict):
complex_block = _simple_blockify(complex_dict, items, np.complex128)
blocks.append(complex_block)
if len(int_dict):
int_block = _simple_blockify(int_dict, items, np.int64)
blocks.append(int_block)
for k, v in list(datetime_dict.items()):
# hackeroo
if hasattr(v, 'tz') and v.tz is not None:
del datetime_dict[k]
object_dict[k] = v.asobject
if len(datetime_dict):
datetime_block = _simple_blockify(datetime_dict, items,
np.dtype('M8[ns]'))
blocks.append(datetime_block)
if len(bool_dict):
bool_block = _simple_blockify(bool_dict, items, np.bool_)
blocks.append(bool_block)
if len(object_dict) > 0:
object_block = _simple_blockify(object_dict, items, np.object_)
blocks.append(object_block)
if len(extra_items):
shape = (len(extra_items),) + tuple(len(x) for x in axes[1:])
# empty items -> dtype object
block_values = np.empty(shape, dtype=object)
block_values.fill(nan)
na_block = make_block(block_values, extra_items, items,
do_integrity_check=True)
blocks.append(na_block)
blocks = _consolidate(blocks, items)
return blocks