~ubuntu-branches/ubuntu/raring/pandas/raring-proposed : revision 13

1

# pylint: disable-msg=E1101,W0612

2

from __future__ import with_statement # for Python 2.5

3

import pandas.util.compat as itertools

4

from datetime import datetime, time, timedelta

5

import sys

6

import os

7

import unittest

8

9

import nose

10

11

import numpy as np

12

randn = np.random.randn

13

14

from pandas import (Index, Series, TimeSeries, DataFrame,

15

isnull, date_range, Timestamp, DatetimeIndex,

16

Int64Index, to_datetime, bdate_range)

17

18

from pandas.core.daterange import DateRange

19

import pandas.core.datetools as datetools

20

import pandas.tseries.offsets as offsets

21

import pandas.tseries.frequencies as fmod

22

23

from pandas.util.testing import assert_series_equal, assert_almost_equal

24

import pandas.util.testing as tm

25

26

from pandas.util.py3compat import StringIO

27

28

from pandas.lib import NaT, iNaT

29

import pandas.lib as lib

30

import cPickle as pickle

31

import pandas.core.datetools as dt

32

from numpy.random import rand

33

from pandas.util.testing import assert_frame_equal

34

import pandas.util.py3compat as py3compat

35

from pandas.core.datetools import BDay

36

import pandas.core.common as com

37

38

from numpy.testing.decorators import slow

39

40

41

class TestTimeSeriesDuplicates(unittest.TestCase):

42

43

def setUp(self):

44

dates = [datetime(2000, 1, 2), datetime(2000, 1, 2),

45

datetime(2000, 1, 2), datetime(2000, 1, 3),

46

datetime(2000, 1, 3), datetime(2000, 1, 3),

47

datetime(2000, 1, 4), datetime(2000, 1, 4),

48

datetime(2000, 1, 4), datetime(2000, 1, 5)]

49

50

self.dups = Series(np.random.randn(len(dates)), index=dates)

51

52

def test_constructor(self):

53

self.assert_(isinstance(self.dups, TimeSeries))

54

self.assert_(isinstance(self.dups.index, DatetimeIndex))

55

56

def test_is_unique_monotonic(self):

57

self.assert_(not self.dups.index.is_unique)

58

59

def test_index_unique(self):

60

uniques = self.dups.index.unique()

61

self.assert_(uniques.dtype == 'M8[ns]') # sanity

62

63

def test_duplicate_dates_indexing(self):

64

ts = self.dups

65

66

uniques = ts.index.unique()

67

for date in uniques:

68

result = ts[date]

69

70

mask = ts.index == date

71

total = (ts.index == date).sum()

72

expected = ts[mask]

73

if total > 1:

74

assert_series_equal(result, expected)

75

else:

76

assert_almost_equal(result, expected[0])

77

78

cp = ts.copy()

79

cp[date] = 0

80

expected = Series(np.where(mask, 0, ts), index=ts.index)

81

assert_series_equal(cp, expected)

82

83

self.assertRaises(KeyError, ts.__getitem__, datetime(2000, 1, 6))

84

self.assertRaises(KeyError, ts.__setitem__, datetime(2000, 1, 6), 0)

85

86

def test_range_slice(self):

87

idx = DatetimeIndex(['1/1/2000', '1/2/2000', '1/2/2000', '1/3/2000',

88

'1/4/2000'])

89

90

ts = Series(np.random.randn(len(idx)), index=idx)

91

92

result = ts['1/2/2000':]

93

expected = ts[1:]

94

assert_series_equal(result, expected)

95

96

result = ts['1/2/2000':'1/3/2000']

97

expected = ts[1:4]

98

assert_series_equal(result, expected)

99

100

def test_groupby_average_dup_values(self):

101

result = self.dups.groupby(level=0).mean()

102

expected = self.dups.groupby(self.dups.index).mean()

103

assert_series_equal(result, expected)

104

105

def test_indexing_over_size_cutoff(self):

106

import datetime

107

# #1821

108

109

old_cutoff = lib._SIZE_CUTOFF

110

try:

111

lib._SIZE_CUTOFF = 1000

112

113

# create large list of non periodic datetime

114

dates = []

115

sec = datetime.timedelta(seconds=1)

116

half_sec = datetime.timedelta(microseconds=500000)

117

d = datetime.datetime(2011, 12, 5, 20, 30)

118

n = 1100

119

for i in range(n):

120

dates.append(d)

121

dates.append(d + sec)

122

dates.append(d + sec + half_sec)

123

dates.append(d + sec + sec + half_sec)

124

d += 3 * sec

125

126

# duplicate some values in the list

127

duplicate_positions = np.random.randint(0, len(dates) - 1, 20)

128

for p in duplicate_positions:

129

dates[p + 1] = dates[p]

130

131

df = DataFrame(np.random.randn(len(dates), 4),

132

index=dates,

133

columns=list('ABCD'))

134

135

pos = n * 3

136

timestamp = df.index[pos]

137

self.assert_(timestamp in df.index)

138

139

# it works!

140

df.ix[timestamp]

141

self.assert_(len(df.ix[[timestamp]]) > 0)

142

finally:

143

lib._SIZE_CUTOFF = old_cutoff

144

145

def assert_range_equal(left, right):

146

assert(left.equals(right))

147

assert(left.freq == right.freq)

148

assert(left.tz == right.tz)

149

150

151

def _skip_if_no_pytz():

152

try:

153

import pytz

154

except ImportError:

155

raise nose.SkipTest

156

157

158

class TestTimeSeries(unittest.TestCase):

159

160

def test_dti_slicing(self):

161

dti = DatetimeIndex(start='1/1/2005', end='12/1/2005', freq='M')

162

dti2 = dti[[1,3,5]]

163

164

v1 = dti2[0]

165

v2 = dti2[1]

166

v3 = dti2[2]

167

168

self.assertEquals(v1, Timestamp('2/28/2005'))

169

self.assertEquals(v2, Timestamp('4/30/2005'))

170

self.assertEquals(v3, Timestamp('6/30/2005'))

171

172

# don't carry freq through irregular slicing

173

self.assert_(dti2.freq is None)

174

175

def test_pass_datetimeindex_to_index(self):

176

# Bugs in #1396

177

178

rng = date_range('1/1/2000', '3/1/2000')

179

idx = Index(rng, dtype=object)

180

181

expected = Index(rng.to_pydatetime(), dtype=object)

182

183

self.assert_(np.array_equal(idx.values, expected.values))

184

185

def test_contiguous_boolean_preserve_freq(self):

186

rng = date_range('1/1/2000', '3/1/2000', freq='B')

187

188

mask = np.zeros(len(rng), dtype=bool)

189

mask[10:20] = True

190

191

masked = rng[mask]

192

expected = rng[10:20]

193

self.assert_(expected.freq is not None)

194

assert_range_equal(masked, expected)

195

196

mask[22] = True

197

masked = rng[mask]

198

self.assert_(masked.freq is None)

199

200

def test_getitem_median_slice_bug(self):

201

index = date_range('20090415', '20090519', freq='2B')

202

s = Series(np.random.randn(13), index=index)

203

204

indexer = [slice(6, 7, None)]

205

result = s[indexer]

206

expected = s[indexer[0]]

207

assert_series_equal(result, expected)

208

209

def test_series_box_timestamp(self):

210

rng = date_range('20090415', '20090519', freq='B')

211

s = Series(rng)

212

213

self.assert_(isinstance(s[5], Timestamp))

214

215

rng = date_range('20090415', '20090519', freq='B')

216

s = Series(rng, index=rng)

217

self.assert_(isinstance(s[5], Timestamp))

218

219

self.assert_(isinstance(s.iget_value(5), Timestamp))

220

221

def test_timestamp_to_datetime(self):

222

_skip_if_no_pytz()

223

rng = date_range('20090415', '20090519',

224

tz='US/Eastern')

225

226

stamp = rng[0]

227

dtval = stamp.to_pydatetime()

228

self.assertEquals(stamp, dtval)

229

self.assertEquals(stamp.tzinfo, dtval.tzinfo)

230

231

def test_index_convert_to_datetime_array(self):

232

_skip_if_no_pytz()

233

234

def _check_rng(rng):

235

converted = rng.to_pydatetime()

236

self.assert_(isinstance(converted, np.ndarray))

237

for x, stamp in zip(converted, rng):

238

self.assert_(type(x) is datetime)

239

self.assertEquals(x, stamp.to_pydatetime())

240

self.assertEquals(x.tzinfo, stamp.tzinfo)

241

242

rng = date_range('20090415', '20090519')

243

rng_eastern = date_range('20090415', '20090519', tz='US/Eastern')

244

rng_utc = date_range('20090415', '20090519', tz='utc')

245

246

_check_rng(rng)

247

_check_rng(rng_eastern)

248

_check_rng(rng_utc)

249

250

def test_series_ctor_plus_datetimeindex(self):

251

rng = date_range('20090415', '20090519', freq='B')

252

data = dict((k, 1) for k in rng)

253

254

result = Series(data, index=rng)

255

self.assert_(result.index is rng)

256

257

def test_series_pad_backfill_limit(self):

258

index = np.arange(10)

259

s = Series(np.random.randn(10), index=index)

260

261

result = s[:2].reindex(index, method='pad', limit=5)

262

263

expected = s[:2].reindex(index).fillna(method='pad')

264

expected[-3:] = np.nan

265

assert_series_equal(result, expected)

266

267

result = s[-2:].reindex(index, method='backfill', limit=5)

268

269

expected = s[-2:].reindex(index).fillna(method='backfill')

270

expected[:3] = np.nan

271

assert_series_equal(result, expected)

272

273

def test_series_fillna_limit(self):

274

index = np.arange(10)

275

s = Series(np.random.randn(10), index=index)

276

277

result = s[:2].reindex(index)

278

result = result.fillna(method='pad', limit=5)

279

280

expected = s[:2].reindex(index).fillna(method='pad')

281

expected[-3:] = np.nan

282

assert_series_equal(result, expected)

283

284

result = s[-2:].reindex(index)

285

result = result.fillna(method='bfill', limit=5)

286

287

expected = s[-2:].reindex(index).fillna(method='backfill')

288

expected[:3] = np.nan

289

assert_series_equal(result, expected)

290

291

def test_frame_pad_backfill_limit(self):

292

index = np.arange(10)

293

df = DataFrame(np.random.randn(10, 4), index=index)

294

295

result = df[:2].reindex(index, method='pad', limit=5)

296

297

expected = df[:2].reindex(index).fillna(method='pad')

298

expected.values[-3:] = np.nan

299

tm.assert_frame_equal(result, expected)

300

301

result = df[-2:].reindex(index, method='backfill', limit=5)

302

303

expected = df[-2:].reindex(index).fillna(method='backfill')

304

expected.values[:3] = np.nan

305

tm.assert_frame_equal(result, expected)

306

307

def test_frame_fillna_limit(self):

308

index = np.arange(10)

309

df = DataFrame(np.random.randn(10, 4), index=index)

310

311

result = df[:2].reindex(index)

312

result = result.fillna(method='pad', limit=5)

313

314

expected = df[:2].reindex(index).fillna(method='pad')

315

expected.values[-3:] = np.nan

316

tm.assert_frame_equal(result, expected)

317

318

result = df[-2:].reindex(index)

319

result = result.fillna(method='backfill', limit=5)

320

321

expected = df[-2:].reindex(index).fillna(method='backfill')

322

expected.values[:3] = np.nan

323

tm.assert_frame_equal(result, expected)

324

325

def test_frame_setitem_timestamp(self):

326

#2155

327

columns = DatetimeIndex(start='1/1/2012', end='2/1/2012',

328

freq=datetools.bday)

329

index = range(10)

330

data = DataFrame(columns=columns, index=index)

331

t = datetime(2012, 11, 1)

332

ts = Timestamp(t)

333

data[ts] = np.nan #works

334

335

def test_sparse_series_fillna_limit(self):

336

index = np.arange(10)

337

s = Series(np.random.randn(10), index=index)

338

339

ss = s[:2].reindex(index).to_sparse()

340

result = ss.fillna(method='pad', limit=5)

341

expected = ss.fillna(method='pad', limit=5)

342

expected = expected.to_dense()

343

expected[-3:] = np.nan

344

expected = expected.to_sparse()

345

assert_series_equal(result, expected)

346

347

ss = s[-2:].reindex(index).to_sparse()

348

result = ss.fillna(method='backfill', limit=5)

349

expected = ss.fillna(method='backfill')

350

expected = expected.to_dense()

351

expected[:3] = np.nan

352

expected = expected.to_sparse()

353

assert_series_equal(result, expected)

354

355

def test_sparse_series_pad_backfill_limit(self):

356

index = np.arange(10)

357

s = Series(np.random.randn(10), index=index)

358

s = s.to_sparse()

359

360

result = s[:2].reindex(index, method='pad', limit=5)

361

expected = s[:2].reindex(index).fillna(method='pad')

362

expected = expected.to_dense()

363

expected[-3:] = np.nan

364

expected = expected.to_sparse()

365

assert_series_equal(result, expected)

366

367

result = s[-2:].reindex(index, method='backfill', limit=5)

368

expected = s[-2:].reindex(index).fillna(method='backfill')

369

expected = expected.to_dense()

370

expected[:3] = np.nan

371

expected = expected.to_sparse()

372

assert_series_equal(result, expected)

373

374

def test_sparse_frame_pad_backfill_limit(self):

375

index = np.arange(10)

376

df = DataFrame(np.random.randn(10, 4), index=index)

377

sdf = df.to_sparse()

378

379

result = sdf[:2].reindex(index, method='pad', limit=5)

380

381

expected = sdf[:2].reindex(index).fillna(method='pad')

382

expected = expected.to_dense()

383

expected.values[-3:] = np.nan

384

expected = expected.to_sparse()

385

tm.assert_frame_equal(result, expected)

386

387

result = sdf[-2:].reindex(index, method='backfill', limit=5)

388

389

expected = sdf[-2:].reindex(index).fillna(method='backfill')

390

expected = expected.to_dense()

391

expected.values[:3] = np.nan

392

expected = expected.to_sparse()

393

tm.assert_frame_equal(result, expected)

394

395

def test_sparse_frame_fillna_limit(self):

396

index = np.arange(10)

397

df = DataFrame(np.random.randn(10, 4), index=index)

398

sdf = df.to_sparse()

399

400

result = sdf[:2].reindex(index)

401

result = result.fillna(method='pad', limit=5)

402

403

expected = sdf[:2].reindex(index).fillna(method='pad')

404

expected = expected.to_dense()

405

expected.values[-3:] = np.nan

406

expected = expected.to_sparse()

407

tm.assert_frame_equal(result, expected)

408

409

result = sdf[-2:].reindex(index)

410

result = result.fillna(method='backfill', limit=5)

411

412

expected = sdf[-2:].reindex(index).fillna(method='backfill')

413

expected = expected.to_dense()

414

expected.values[:3] = np.nan

415

expected = expected.to_sparse()

416

tm.assert_frame_equal(result, expected)

417

418

def test_pad_require_monotonicity(self):

419

rng = date_range('1/1/2000', '3/1/2000', freq='B')

420

421

rng2 = rng[::2][::-1]

422

423

self.assertRaises(AssertionError, rng2.get_indexer, rng,

424

method='pad')

425

426

def test_frame_ctor_datetime64_column(self):

427

rng = date_range('1/1/2000 00:00:00', '1/1/2000 1:59:50',

428

freq='10s')

429

dates = np.asarray(rng)

430

431

df = DataFrame({'A': np.random.randn(len(rng)), 'B': dates})

432

self.assert_(np.issubdtype(df['B'].dtype, np.dtype('M8[ns]')))

433

434

def test_frame_add_datetime64_column(self):

435

rng = date_range('1/1/2000 00:00:00', '1/1/2000 1:59:50',

436

freq='10s')

437

df = DataFrame(index=np.arange(len(rng)))

438

439

df['A'] = rng

440

self.assert_(np.issubdtype(df['A'].dtype, np.dtype('M8[ns]')))

441

442

def test_frame_datetime64_pre1900_repr(self):

443

df = DataFrame({'year': date_range('1/1/1700', periods=50,

444

freq='A-DEC')})

445

# it works!

446

repr(df)

447

448

def test_frame_add_datetime64_col_other_units(self):

449

n = 100

450

451

units = ['h', 'm', 's', 'ms', 'D', 'M', 'Y']

452

453

ns_dtype = np.dtype('M8[ns]')

454

455

for unit in units:

456

dtype = np.dtype('M8[%s]' % unit)

457

vals = np.arange(n, dtype=np.int64).view(dtype)

458

459

df = DataFrame({'ints' : np.arange(n)}, index=np.arange(n))

460

df[unit] = vals

461

462

ex_vals = to_datetime(vals.astype('O'))

463

464

self.assert_(df[unit].dtype == ns_dtype)

465

self.assert_((df[unit].values == ex_vals).all())

466

467

# Test insertion into existing datetime64 column

468

df = DataFrame({'ints' : np.arange(n)}, index=np.arange(n))

469

df['dates'] = np.arange(n, dtype=np.int64).view(ns_dtype)

470

471

for unit in units:

472

dtype = np.dtype('M8[%s]' % unit)

473

vals = np.arange(n, dtype=np.int64).view(dtype)

474

475

tmp = df.copy()

476

477

tmp['dates'] = vals

478

ex_vals = to_datetime(vals.astype('O'))

479

480

self.assert_((tmp['dates'].values == ex_vals).all())

481

482

def test_series_ctor_datetime64(self):

483

rng = date_range('1/1/2000 00:00:00', '1/1/2000 1:59:50',

484

freq='10s')

485

dates = np.asarray(rng)

486

487

series = Series(dates)

488

self.assert_(np.issubdtype(series.dtype, np.dtype('M8[ns]')))

489

490

def test_index_cast_datetime64_other_units(self):

491

arr = np.arange(0, 100, 10, dtype=np.int64).view('M8[D]')

492

493

idx = Index(arr)

494

495

self.assert_((idx.values == lib.cast_to_nanoseconds(arr)).all())

496

497

def test_index_astype_datetime64(self):

498

idx = Index([datetime(2012, 1, 1)], dtype=object)

499

500

if np.__version__ >= '1.7':

501

raise nose.SkipTest

502

503

casted = idx.astype(np.dtype('M8[D]'))

504

expected = DatetimeIndex(idx.values)

505

self.assert_(isinstance(casted, DatetimeIndex))

506

self.assert_(casted.equals(expected))

507

508

def test_reindex_series_add_nat(self):

509

rng = date_range('1/1/2000 00:00:00', periods=10, freq='10s')

510

series = Series(rng)

511

512

result = series.reindex(range(15))

513

self.assert_(np.issubdtype(result.dtype, np.dtype('M8[ns]')))

514

515

mask = result.isnull()

516

self.assert_(mask[-5:].all())

517

self.assert_(not mask[:-5].any())

518

519

def test_reindex_frame_add_nat(self):

520

rng = date_range('1/1/2000 00:00:00', periods=10, freq='10s')

521

df = DataFrame({'A': np.random.randn(len(rng)), 'B': rng})

522

523

result = df.reindex(range(15))

524

self.assert_(np.issubdtype(result['B'].dtype, np.dtype('M8[ns]')))

525

526

mask = com.isnull(result)['B']

527

self.assert_(mask[-5:].all())

528

self.assert_(not mask[:-5].any())

529

530

def test_series_repr_nat(self):

531

series = Series([0, 1000, 2000, iNaT], dtype='M8[ns]')

532

533

result = repr(series)

534

expected = ('0 1970-01-01 00:00:00\n'

535

'1 1970-01-01 00:00:00.000001\n'

536

'2 1970-01-01 00:00:00.000002\n'

537

'3 NaT')

538

self.assertEquals(result, expected)

539

540

def test_fillna_nat(self):

541

series = Series([0, 1, 2, iNaT], dtype='M8[ns]')

542

543

filled = series.fillna(method='pad')

544

filled2 = series.fillna(value=series.values[2])

545

546

expected = series.copy()

547

expected.values[3] = expected.values[2]

548

549

assert_series_equal(filled, expected)

550

assert_series_equal(filled2, expected)

551

552

df = DataFrame({'A': series})

553

filled = df.fillna(method='pad')

554

filled2 = df.fillna(value=series.values[2])

555

expected = DataFrame({'A': expected})

556

assert_frame_equal(filled, expected)

557

assert_frame_equal(filled2, expected)

558

559

560

series = Series([iNaT, 0, 1, 2], dtype='M8[ns]')

561

562

filled = series.fillna(method='bfill')

563

filled2 = series.fillna(value=series[1])

564

565

expected = series.copy()

566

expected[0] = expected[1]

567

568

assert_series_equal(filled, expected)

569

assert_series_equal(filled2, expected)

570

571

df = DataFrame({'A': series})

572

filled = df.fillna(method='bfill')

573

filled2 = df.fillna(value=series[1])

574

expected = DataFrame({'A': expected})

575

assert_frame_equal(filled, expected)

576

assert_frame_equal(filled2, expected)

577

578

def test_string_na_nat_conversion(self):

579

# GH #999, #858

580

581

from dateutil.parser import parse

582

583

strings = np.array(['1/1/2000', '1/2/2000', np.nan,

584

'1/4/2000, 12:34:56'], dtype=object)

585

586

expected = np.empty(4, dtype='M8[ns]')

587

for i, val in enumerate(strings):

588

if com.isnull(val):

589

expected[i] = iNaT

590

else:

591

expected[i] = parse(val)

592

593

result = lib.array_to_datetime(strings)

594

assert_almost_equal(result, expected)

595

596

result2 = to_datetime(strings)

597

self.assert_(isinstance(result2, DatetimeIndex))

598

assert_almost_equal(result, result2)

599

600

malformed = np.array(['1/100/2000', np.nan], dtype=object)

601

result = to_datetime(malformed)

602

assert_almost_equal(result, malformed)

603

604

self.assertRaises(ValueError, to_datetime, malformed,

605

errors='raise')

606

607

idx = ['a', 'b', 'c', 'd', 'e']

608

series = Series(['1/1/2000', np.nan, '1/3/2000', np.nan,

609

'1/5/2000'], index=idx, name='foo')

610

dseries = Series([to_datetime('1/1/2000'), np.nan,

611

to_datetime('1/3/2000'), np.nan,

612

to_datetime('1/5/2000')], index=idx, name='foo')

613

614

result = to_datetime(series)

615

dresult = to_datetime(dseries)

616

617

expected = Series(np.empty(5, dtype='M8[ns]'), index=idx)

618

for i in range(5):

619

x = series[i]

620

if isnull(x):

621

expected[i] = iNaT

622

else:

623

expected[i] = to_datetime(x)

624

625

assert_series_equal(result, expected)

626

self.assertEquals(result.name, 'foo')

627

628

assert_series_equal(dresult, expected)

629

self.assertEquals(dresult.name, 'foo')

630

631

def test_to_datetime_iso8601(self):

632

result = to_datetime(["2012-01-01 00:00:00"])

633

exp = Timestamp("2012-01-01 00:00:00")

634

self.assert_(result[0] == exp)

635

636

result = to_datetime(['20121001']) # bad iso 8601

637

exp = Timestamp('2012-10-01')

638

self.assert_(result[0] == exp)

639

640

def test_nat_vector_field_access(self):

641

idx = DatetimeIndex(['1/1/2000', None, None, '1/4/2000'])

642

643

fields = ['year', 'quarter', 'month', 'day', 'hour',

644

'minute', 'second', 'microsecond', 'nanosecond',

645

'week', 'dayofyear']

646

for field in fields:

647

result = getattr(idx, field)

648

expected = [getattr(x, field) if x is not NaT else -1

649

for x in idx]

650

self.assert_(np.array_equal(result, expected))

651

652

def test_nat_scalar_field_access(self):

653

fields = ['year', 'quarter', 'month', 'day', 'hour',

654

'minute', 'second', 'microsecond', 'nanosecond',

655

'week', 'dayofyear']

656

for field in fields:

657

result = getattr(NaT, field)

658

self.assertEquals(result, -1)

659

660

self.assertEquals(NaT.weekday(), -1)

661

662

def test_to_datetime_empty_string(self):

663

result = to_datetime('')

664

self.assert_(result == '')

665

666

result = to_datetime(['', ''])

667

self.assert_(isnull(result).all())

668

669

def test_to_datetime_other_datetime64_units(self):

670

# 5/25/2012

671

scalar = np.int64(1337904000000000).view('M8[us]')

672

as_obj = scalar.astype('O')

673

674

index = DatetimeIndex([scalar])

675

self.assertEquals(index[0], scalar.astype('O'))

676

677

value = Timestamp(scalar)

678

self.assertEquals(value, as_obj)

679

680

def test_to_datetime_list_of_integers(self):

681

rng = date_range('1/1/2000', periods=20)

682

rng = DatetimeIndex(rng.values)

683

684

ints = list(rng.asi8)

685

686

result = DatetimeIndex(ints)

687

688

self.assert_(rng.equals(result))

689

690

def test_index_to_datetime(self):

691

idx = Index(['1/1/2000', '1/2/2000', '1/3/2000'])

692

693

result = idx.to_datetime()

694

expected = DatetimeIndex(datetools.to_datetime(idx.values))

695

self.assert_(result.equals(expected))

696

697

today = datetime.today()

698

idx = Index([today], dtype=object)

699

result = idx.to_datetime()

700

expected = DatetimeIndex([today])

701

self.assert_(result.equals(expected))

702

703

def test_to_datetime_freq(self):

704

xp = bdate_range('2000-1-1', periods=10, tz='UTC')

705

rs = xp.to_datetime()

706

self.assert_(xp.freq == rs.freq)

707

self.assert_(xp.tzinfo == rs.tzinfo)

708

709

def test_range_misspecified(self):

710

# GH #1095

711

712

self.assertRaises(ValueError, date_range, '1/1/2000')

713

self.assertRaises(ValueError, date_range, end='1/1/2000')

714

self.assertRaises(ValueError, date_range, periods=10)

715

716

self.assertRaises(ValueError, date_range, '1/1/2000', freq='H')

717

self.assertRaises(ValueError, date_range, end='1/1/2000', freq='H')

718

self.assertRaises(ValueError, date_range, periods=10, freq='H')

719

720

def test_reasonable_keyerror(self):

721

# GH #1062

722

index = DatetimeIndex(['1/3/2000'])

723

try:

724

index.get_loc('1/1/2000')

725

except KeyError, e:

726

self.assert_('2000' in str(e))

727

728

def test_reindex_with_datetimes(self):

729

rng = date_range('1/1/2000', periods=20)

730

ts = Series(np.random.randn(20), index=rng)

731

732

result = ts.reindex(list(ts.index[5:10]))

733

expected = ts[5:10]

734

tm.assert_series_equal(result, expected)

735

736

result = ts[list(ts.index[5:10])]

737

tm.assert_series_equal(result, expected)

738

739

def test_promote_datetime_date(self):

740

rng = date_range('1/1/2000', periods=20)

741

ts = Series(np.random.randn(20), index=rng)

742

743

ts_slice = ts[5:]

744

ts2 = ts_slice.copy()

745

ts2.index = [x.date() for x in ts2.index]

746

747

result = ts + ts2

748

result2 = ts2 + ts

749

expected = ts + ts[5:]

750

assert_series_equal(result, expected)

751

assert_series_equal(result2, expected)

752

753

# test asfreq

754

result = ts2.asfreq('4H', method='ffill')

755

expected = ts[5:].asfreq('4H', method='ffill')

756

assert_series_equal(result, expected)

757

758

result = rng.get_indexer(ts2.index)

759

expected = rng.get_indexer(ts_slice.index)

760

self.assert_(np.array_equal(result, expected))

761

762

def test_date_range_gen_error(self):

763

rng = date_range('1/1/2000 00:00', '1/1/2000 00:18', freq='5min')

764

self.assertEquals(len(rng), 4)

765

766

def test_first_subset(self):

767

ts = _simple_ts('1/1/2000', '1/1/2010', freq='12h')

768

result = ts.first('10d')

769

self.assert_(len(result) == 20)

770

771

ts = _simple_ts('1/1/2000', '1/1/2010')

772

result = ts.first('10d')

773

self.assert_(len(result) == 10)

774

775

result = ts.first('3M')

776

expected = ts[:'3/31/2000']

777

assert_series_equal(result, expected)

778

779

result = ts.first('21D')

780

expected = ts[:21]

781

assert_series_equal(result, expected)

782

783

result = ts[:0].first('3M')

784

assert_series_equal(result, ts[:0])

785

786

def test_last_subset(self):

787

ts = _simple_ts('1/1/2000', '1/1/2010', freq='12h')

788

result = ts.last('10d')

789

self.assert_(len(result) == 20)

790

791

ts = _simple_ts('1/1/2000', '1/1/2010')

792

result = ts.last('10d')

793

self.assert_(len(result) == 10)

794

795

result = ts.last('21D')

796

expected = ts['12/12/2009':]

797

assert_series_equal(result, expected)

798

799

result = ts.last('21D')

800

expected = ts[-21:]

801

assert_series_equal(result, expected)

802

803

result = ts[:0].last('3M')

804

assert_series_equal(result, ts[:0])

805

806

def test_add_offset(self):

807

rng = date_range('1/1/2000', '2/1/2000')

808

809

result = rng + offsets.Hour(2)

810

expected = date_range('1/1/2000 02:00', '2/1/2000 02:00')

811

self.assert_(result.equals(expected))

812

813

def test_format_pre_1900_dates(self):

814

rng = date_range('1/1/1850', '1/1/1950', freq='A-DEC')

815

rng.format()

816

ts = Series(1, index=rng)

817

repr(ts)

818

819

def test_repeat(self):

820

rng = date_range('1/1/2000', '1/1/2001')

821

822

result = rng.repeat(5)

823

self.assert_(result.freq is None)

824

self.assert_(len(result) == 5 * len(rng))

825

826

def test_at_time(self):

827

rng = date_range('1/1/2000', '1/5/2000', freq='5min')

828

ts = Series(np.random.randn(len(rng)), index=rng)

829

rs = ts.at_time(rng[1])

830

self.assert_((rs.index.hour == rng[1].hour).all())

831

self.assert_((rs.index.minute == rng[1].minute).all())

832

self.assert_((rs.index.second == rng[1].second).all())

833

834

result = ts.at_time('9:30')

835

expected = ts.at_time(time(9, 30))

836

assert_series_equal(result, expected)

837

838

df = DataFrame(np.random.randn(len(rng), 3), index=rng)

839

840

result = ts[time(9, 30)]

841

result_df = df.ix[time(9, 30)]

842

expected = ts[(rng.hour == 9) & (rng.minute == 30)]

843

exp_df = df[(rng.hour == 9) & (rng.minute == 30)]

844

845

# expected.index = date_range('1/1/2000', '1/4/2000')

846

847

assert_series_equal(result, expected)

848

tm.assert_frame_equal(result_df, exp_df)

849

850

chunk = df.ix['1/4/2000':]

851

result = chunk.ix[time(9, 30)]

852

expected = result_df[-1:]

853

tm.assert_frame_equal(result, expected)

854

855

# midnight, everything

856

rng = date_range('1/1/2000', '1/31/2000')

857

ts = Series(np.random.randn(len(rng)), index=rng)

858

859

result = ts.at_time(time(0, 0))

860

assert_series_equal(result, ts)

861

862

# time doesn't exist

863

rng = date_range('1/1/2012', freq='23Min', periods=384)

864

ts = Series(np.random.randn(len(rng)), rng)

865

rs = ts.at_time('16:00')

866

self.assert_(len(rs) == 0)

867

868

def test_at_time_frame(self):

869

rng = date_range('1/1/2000', '1/5/2000', freq='5min')

870

ts = DataFrame(np.random.randn(len(rng), 2), index=rng)

871

rs = ts.at_time(rng[1])

872

self.assert_((rs.index.hour == rng[1].hour).all())

873

self.assert_((rs.index.minute == rng[1].minute).all())

874

self.assert_((rs.index.second == rng[1].second).all())

875

876

result = ts.at_time('9:30')

877

expected = ts.at_time(time(9, 30))

878

assert_frame_equal(result, expected)

879

880

result = ts.ix[time(9, 30)]

881

expected = ts.ix[(rng.hour == 9) & (rng.minute == 30)]

882

883

assert_frame_equal(result, expected)

884

885

# midnight, everything

886

rng = date_range('1/1/2000', '1/31/2000')

887

ts = DataFrame(np.random.randn(len(rng), 3), index=rng)

888

889

result = ts.at_time(time(0, 0))

890

assert_frame_equal(result, ts)

891

892

# time doesn't exist

893

rng = date_range('1/1/2012', freq='23Min', periods=384)

894

ts = DataFrame(np.random.randn(len(rng), 2), rng)

895

rs = ts.at_time('16:00')

896

self.assert_(len(rs) == 0)

897

898

def test_between_time(self):

899

rng = date_range('1/1/2000', '1/5/2000', freq='5min')

900

ts = Series(np.random.randn(len(rng)), index=rng)

901

stime = time(0, 0)

902

etime = time(1, 0)

903

904

close_open = itertools.product([True, False], [True, False])

905

for inc_start, inc_end in close_open:

906

filtered = ts.between_time(stime, etime, inc_start, inc_end)

907

exp_len = 13 * 4 + 1

908

if not inc_start:

909

exp_len -= 5

910

if not inc_end:

911

exp_len -= 4

912

913

self.assert_(len(filtered) == exp_len)

914

for rs in filtered.index:

915

t = rs.time()

916

if inc_start:

917

self.assert_(t >= stime)

918

else:

919

self.assert_(t > stime)

920

921

if inc_end:

922

self.assert_(t <= etime)

923

else:

924

self.assert_(t < etime)

925

926

result = ts.between_time('00:00', '01:00')

927

expected = ts.between_time(stime, etime)

928

assert_series_equal(result, expected)

929

930

#across midnight

931

rng = date_range('1/1/2000', '1/5/2000', freq='5min')

932

ts = Series(np.random.randn(len(rng)), index=rng)

933

stime = time(22, 0)

934

etime = time(9, 0)

935

936

close_open = itertools.product([True, False], [True, False])

937

for inc_start, inc_end in close_open:

938

filtered = ts.between_time(stime, etime, inc_start, inc_end)

939

exp_len = (12 * 11 + 1) * 4 + 1

940

if not inc_start:

941

exp_len -= 4

942

if not inc_end:

943

exp_len -= 4

944

945

self.assert_(len(filtered) == exp_len)

946

for rs in filtered.index:

947

t = rs.time()

948

if inc_start:

949

self.assert_((t >= stime) or (t <= etime))

950

else:

951

self.assert_((t > stime) or (t <= etime))

952

953

if inc_end:

954

self.assert_((t <= etime) or (t >= stime))

955

else:

956

self.assert_((t < etime) or (t >= stime))

957

958

def test_between_time_frame(self):

959

rng = date_range('1/1/2000', '1/5/2000', freq='5min')

960

ts = DataFrame(np.random.randn(len(rng), 2), index=rng)

961

stime = time(0, 0)

962

etime = time(1, 0)

963

964

close_open = itertools.product([True, False], [True, False])

965

for inc_start, inc_end in close_open:

966

filtered = ts.between_time(stime, etime, inc_start, inc_end)

967

exp_len = 13 * 4 + 1

968

if not inc_start:

969

exp_len -= 5

970

if not inc_end:

971

exp_len -= 4

972

973

self.assert_(len(filtered) == exp_len)

974

for rs in filtered.index:

975

t = rs.time()

976

if inc_start:

977

self.assert_(t >= stime)

978

else:

979

self.assert_(t > stime)

980

981

if inc_end:

982

self.assert_(t <= etime)

983

else:

984

self.assert_(t < etime)

985

986

result = ts.between_time('00:00', '01:00')

987

expected = ts.between_time(stime, etime)

988

assert_frame_equal(result, expected)

989

990

#across midnight

991

rng = date_range('1/1/2000', '1/5/2000', freq='5min')

992

ts = DataFrame(np.random.randn(len(rng), 2), index=rng)

993

stime = time(22, 0)

994

etime = time(9, 0)

995

996

close_open = itertools.product([True, False], [True, False])

997

for inc_start, inc_end in close_open:

998

filtered = ts.between_time(stime, etime, inc_start, inc_end)

999

exp_len = (12 * 11 + 1) * 4 + 1

1000

if not inc_start:

1001

exp_len -= 4

1002

if not inc_end:

1003

exp_len -= 4

1004

1005

self.assert_(len(filtered) == exp_len)

1006

for rs in filtered.index:

1007

t = rs.time()

1008

if inc_start:

1009

self.assert_((t >= stime) or (t <= etime))

1010

else:

1011

self.assert_((t > stime) or (t <= etime))

1012

1013

if inc_end:

1014

self.assert_((t <= etime) or (t >= stime))

1015

else:

1016

self.assert_((t < etime) or (t >= stime))

1017

1018

def test_dti_constructor_preserve_dti_freq(self):

1019

rng = date_range('1/1/2000', '1/2/2000', freq='5min')

1020

1021

rng2 = DatetimeIndex(rng)

1022

self.assert_(rng.freq == rng2.freq)

1023

1024

def test_normalize(self):

1025

rng = date_range('1/1/2000 9:30', periods=10, freq='D')

1026

1027

result = rng.normalize()

1028

expected = date_range('1/1/2000', periods=10, freq='D')

1029

self.assert_(result.equals(expected))

1030

1031

self.assert_(result.is_normalized)

1032

self.assert_(not rng.is_normalized)

1033

1034

def test_to_period(self):

1035

from pandas.tseries.period import period_range

1036

1037

ts = _simple_ts('1/1/2000', '1/1/2001')

1038

1039

pts = ts.to_period()

1040

exp = ts.copy()

1041

exp.index = period_range('1/1/2000', '1/1/2001')

1042

assert_series_equal(pts, exp)

1043

1044

pts = ts.to_period('M')

1045

self.assert_(pts.index.equals(exp.index.asfreq('M')))

1046

1047

def test_frame_to_period(self):

1048

K = 5

1049

from pandas.tseries.period import period_range

1050

1051

dr = date_range('1/1/2000', '1/1/2001')

1052

pr = period_range('1/1/2000', '1/1/2001')

1053

df = DataFrame(randn(len(dr), K), index=dr)

1054

df['mix'] = 'a'

1055

1056

pts = df.to_period()

1057

exp = df.copy()

1058

exp.index = pr

1059

assert_frame_equal(pts, exp)

1060

1061

pts = df.to_period('M')

1062

self.assert_(pts.index.equals(exp.index.asfreq('M')))

1063

1064

df = df.T

1065

pts = df.to_period(axis=1)

1066

exp = df.copy()

1067

exp.columns = pr

1068

assert_frame_equal(pts, exp)

1069

1070

pts = df.to_period('M', axis=1)

1071

self.assert_(pts.columns.equals(exp.columns.asfreq('M')))

1072

1073

self.assertRaises(ValueError, df.to_period, axis=2)

1074

1075

def test_timestamp_fields(self):

1076

# extra fields from DatetimeIndex like quarter and week

1077

from pandas.lib import Timestamp

1078

idx = tm.makeDateIndex(100)

1079

1080

fields = ['dayofweek', 'dayofyear', 'week', 'weekofyear', 'quarter']

1081

for f in fields:

1082

expected = getattr(idx, f)[-1]

1083

result = getattr(Timestamp(idx[-1]), f)

1084

self.assertEqual(result, expected)

1085

1086

self.assertEqual(idx.freq, Timestamp(idx[-1], idx.freq).freq)

1087

self.assertEqual(idx.freqstr, Timestamp(idx[-1], idx.freq).freqstr)

1088

1089

def test_timestamp_date_out_of_range(self):

1090

self.assertRaises(ValueError, Timestamp, '1676-01-01')

1091

self.assertRaises(ValueError, Timestamp, '2263-01-01')

1092

1093

# 1475

1094

self.assertRaises(ValueError, DatetimeIndex, ['1400-01-01'])

1095

self.assertRaises(ValueError, DatetimeIndex, [datetime(1400, 1, 1)])

1096

1097

def test_timestamp_repr(self):

1098

# pre-1900

1099

stamp = Timestamp('1850-01-01', tz='US/Eastern')

1100

repr(stamp)

1101

1102

iso8601 = '1850-01-01 01:23:45.012345'

1103

stamp = Timestamp(iso8601, tz='US/Eastern')

1104

result = repr(stamp)

1105

self.assert_(iso8601 in result)

1106

1107

def test_datetimeindex_integers_shift(self):

1108

rng = date_range('1/1/2000', periods=20)

1109

1110

result = rng + 5

1111

expected = rng.shift(5)

1112

self.assert_(result.equals(expected))

1113

1114

result = rng - 5

1115

expected = rng.shift(-5)

1116

self.assert_(result.equals(expected))

1117

1118

def test_astype_object(self):

1119

# NumPy 1.6.1 weak ns support

1120

rng = date_range('1/1/2000', periods=20)

1121

1122

casted = rng.astype('O')

1123

exp_values = list(rng)

1124

1125

self.assert_(np.array_equal(casted, exp_values))

1126

1127

def test_catch_infinite_loop(self):

1128

offset = datetools.DateOffset(minute=5)

1129

# blow up, don't loop forever

1130

self.assertRaises(Exception, date_range, datetime(2011,11,11),

1131

datetime(2011,11,12), freq=offset)

1132

1133

def test_append_concat(self):

1134

rng = date_range('5/8/2012 1:45', periods=10, freq='5T')

1135

ts = Series(np.random.randn(len(rng)), rng)

1136

df = DataFrame(np.random.randn(len(rng), 4), index=rng)

1137

1138

result = ts.append(ts)

1139

result_df = df.append(df)

1140

ex_index = DatetimeIndex(np.tile(rng.values, 2))

1141

self.assert_(result.index.equals(ex_index))

1142

self.assert_(result_df.index.equals(ex_index))

1143

1144

appended = rng.append(rng)

1145

self.assert_(appended.equals(ex_index))

1146

1147

appended = rng.append([rng, rng])

1148

ex_index = DatetimeIndex(np.tile(rng.values, 3))

1149

self.assert_(appended.equals(ex_index))

1150

1151

# different index names

1152

rng1 = rng.copy()

1153

rng2 = rng.copy()

1154

rng1.name = 'foo'

1155

rng2.name = 'bar'

1156

self.assert_(rng1.append(rng1).name == 'foo')

1157

self.assert_(rng1.append(rng2).name is None)

1158

1159

def test_set_dataframe_column_ns_dtype(self):

1160

x = DataFrame([datetime.now(), datetime.now()])

1161

self.assert_(x[0].dtype == object)

1162

1163

x[0] = to_datetime(x[0])

1164

self.assert_(x[0].dtype == np.dtype('M8[ns]'))

1165

1166

def test_groupby_count_dateparseerror(self):

1167

dr = date_range(start='1/1/2012', freq='5min', periods=10)

1168

1169

# BAD Example, datetimes first

1170

s = Series(np.arange(10), index=[dr, range(10)])

1171

grouped = s.groupby(lambda x: x[1] % 2 == 0)

1172

result = grouped.count()

1173

1174

s = Series(np.arange(10), index=[range(10), dr])

1175

grouped = s.groupby(lambda x: x[0] % 2 == 0)

1176

expected = grouped.count()

1177

1178

assert_series_equal(result, expected)

1179

1180

def test_datetimeindex_repr_short(self):

1181

dr = date_range(start='1/1/2012', periods=1)

1182

repr(dr)

1183

1184

dr = date_range(start='1/1/2012', periods=2)

1185

repr(dr)

1186

1187

dr = date_range(start='1/1/2012', periods=3)

1188

repr(dr)

1189

1190

def test_constructor_int64_nocopy(self):

1191

# #1624

1192

arr = np.arange(1000, dtype=np.int64)

1193

index = DatetimeIndex(arr)

1194

1195

arr[50:100] = -1

1196

self.assert_((index.asi8[50:100] == -1).all())

1197

1198

arr = np.arange(1000, dtype=np.int64)

1199

index = DatetimeIndex(arr, copy=True)

1200

1201

arr[50:100] = -1

1202

self.assert_((index.asi8[50:100] != -1).all())

1203

1204

def test_series_interpolate_method_values(self):

1205

# #1646

1206

ts = _simple_ts('1/1/2000', '1/20/2000')

1207

ts[::2] = np.nan

1208

1209

result = ts.interpolate(method='values')

1210

exp = ts.interpolate()

1211

assert_series_equal(result, exp)

1212

1213

def test_frame_datetime64_handling_groupby(self):

1214

# it works!

1215

df = DataFrame([(3,np.datetime64('2012-07-03')),

1216

(3,np.datetime64('2012-07-04'))],

1217

columns = ['a', 'date'])

1218

result = df.groupby('a').first()

1219

self.assertEqual(result['date'][3], np.datetime64('2012-07-03'))

1220

1221

def test_series_interpolate_intraday(self):

1222

# #1698

1223

import pandas as pd

1224

index = pd.date_range('1/1/2012', periods=4, freq='12D')

1225

ts = pd.Series([0, 12, 24, 36], index)

1226

new_index = index.append(index + pd.DateOffset(days=1)).order()

1227

1228

exp = ts.reindex(new_index).interpolate(method='time')

1229

1230

index = pd.date_range('1/1/2012', periods=4, freq='12H')

1231

ts = pd.Series([0, 12, 24, 36], index)

1232

new_index = index.append(index + pd.DateOffset(hours=1)).order()

1233

result = ts.reindex(new_index).interpolate(method='time')

1234

1235

self.assert_(np.array_equal(result.values, exp.values))

1236

1237

def test_frame_dict_constructor_datetime64_1680(self):

1238

dr = date_range('1/1/2012', periods=10)

1239

s = Series(dr, index=dr)

1240

1241

# it works!

1242

DataFrame({'a': 'foo', 'b': s}, index=dr)

1243

DataFrame({'a': 'foo', 'b': s.values}, index=dr)

1244

1245

def test_frame_datetime64_mixed_index_ctor_1681(self):

1246

dr = date_range('2011/1/1', '2012/1/1', freq='W-FRI')

1247

ts = Series(dr)

1248

1249

# it works!

1250

d = DataFrame({'A': 'foo', 'B': ts}, index=dr)

1251

self.assert_(d['B'].isnull().all())

1252

1253

def test_frame_timeseries_to_records(self):

1254

index = date_range('1/1/2000', periods=10)

1255

df = DataFrame(np.random.randn(10, 3), index=index,

1256

columns=['a', 'b', 'c'])

1257

1258

result = df.to_records()

1259

result['index'].dtype == 'M8[ns]'

1260

1261

result = df.to_records(index=False)

1262

1263

def test_frame_datetime64_duplicated(self):

1264

dates = date_range('2010-07-01', end='2010-08-05')

1265

1266

tst = DataFrame({'symbol': 'AAA', 'date': dates})

1267

result = tst.duplicated(['date', 'symbol'])

1268

self.assert_((-result).all())

1269

1270

tst = DataFrame({'date': dates})

1271

result = tst.duplicated()

1272

self.assert_((-result).all())

1273

1274

def test_timestamp_compare_with_early_datetime(self):

1275

# e.g. datetime.min

1276

stamp = Timestamp('2012-01-01')

1277

1278

self.assertFalse(stamp == datetime.min)

1279

self.assertFalse(stamp == datetime(1600, 1, 1))

1280

self.assertFalse(stamp == datetime(2700, 1, 1))

1281

self.assert_(stamp != datetime.min)

1282

self.assert_(stamp != datetime(1600, 1, 1))

1283

self.assert_(stamp != datetime(2700, 1, 1))

1284

self.assert_(stamp > datetime(1600, 1, 1))

1285

self.assert_(stamp >= datetime(1600, 1, 1))

1286

self.assert_(stamp < datetime(2700, 1, 1))

1287

self.assert_(stamp <= datetime(2700, 1, 1))

1288

1289

def test_to_html_timestamp(self):

1290

rng = date_range('2000-01-01', periods=10)

1291

df = DataFrame(np.random.randn(10, 4), index=rng)

1292

1293

result = df.to_html()

1294

self.assert_('2000-01-01' in result)

1295

1296

def test_to_csv_numpy_16_bug(self):

1297

frame = DataFrame({'a': date_range('1/1/2000', periods=10)})

1298

1299

buf = StringIO()

1300

frame.to_csv(buf)

1301

1302

result = buf.getvalue()

1303

self.assert_('2000-01-01' in result)

1304

1305

def _simple_ts(start, end, freq='D'):

1306

rng = date_range(start, end, freq=freq)

1307

return Series(np.random.randn(len(rng)), index=rng)

1308

1309

1310

class TestDatetimeIndex(unittest.TestCase):

1311

1312

def test_append_join_nondatetimeindex(self):

1313

rng = date_range('1/1/2000', periods=10)

1314

idx = Index(['a', 'b', 'c', 'd'])

1315

1316

result = rng.append(idx)

1317

self.assert_(isinstance(result[0], Timestamp))

1318

1319

# it works

1320

rng.join(idx, how='outer')

1321

1322

def test_astype(self):

1323

rng = date_range('1/1/2000', periods=10)

1324

1325

result = rng.astype('i8')

1326

self.assert_(np.array_equal(result, rng.asi8))

1327

1328

def test_to_period_nofreq(self):

1329

idx = DatetimeIndex(['2000-01-01', '2000-01-02', '2000-01-04'])

1330

self.assertRaises(ValueError, idx.to_period)

1331

1332

idx = DatetimeIndex(['2000-01-01', '2000-01-02', '2000-01-03'],

1333

freq='infer')

1334

idx.to_period()

1335

1336

def test_constructor_coverage(self):

1337

rng = date_range('1/1/2000', periods=10.5)

1338

exp = date_range('1/1/2000', periods=10)

1339

self.assert_(rng.equals(exp))

1340

1341

self.assertRaises(ValueError, DatetimeIndex, start='1/1/2000',

1342

periods='foo', freq='D')

1343

1344

self.assertRaises(ValueError, DatetimeIndex, start='1/1/2000',

1345

end='1/10/2000')

1346

1347

self.assertRaises(ValueError, DatetimeIndex, '1/1/2000')

1348

1349

# generator expression

1350

gen = (datetime(2000, 1, 1) + timedelta(i) for i in range(10))

1351

result = DatetimeIndex(gen)

1352

expected = DatetimeIndex([datetime(2000, 1, 1) + timedelta(i)

1353

for i in range(10)])

1354

self.assert_(result.equals(expected))

1355

1356

# NumPy string array

1357

strings = np.array(['2000-01-01', '2000-01-02', '2000-01-03'])

1358

result = DatetimeIndex(strings)

1359

expected = DatetimeIndex(strings.astype('O'))

1360

self.assert_(result.equals(expected))

1361

1362

from_ints = DatetimeIndex(expected.asi8)

1363

self.assert_(from_ints.equals(expected))

1364

1365

# non-conforming

1366

self.assertRaises(ValueError, DatetimeIndex,

1367

['2000-01-01', '2000-01-02', '2000-01-04'],

1368

freq='D')

1369

1370

self.assertRaises(ValueError, DatetimeIndex,

1371

start='2011-01-01', freq='b')

1372

self.assertRaises(ValueError, DatetimeIndex,

1373

end='2011-01-01', freq='B')

1374

self.assertRaises(ValueError, DatetimeIndex, periods=10, freq='D')

1375

1376

def test_comparisons_coverage(self):

1377

rng = date_range('1/1/2000', periods=10)

1378

1379

# raise TypeError for now

1380

self.assertRaises(TypeError, rng.__lt__, rng[3].value)

1381

1382

result = rng == list(rng)

1383

exp = rng == rng

1384

self.assert_(np.array_equal(result, exp))

1385

1386

def test_map(self):

1387

rng = date_range('1/1/2000', periods=10)

1388

1389

f = lambda x: x.strftime('%Y%m%d')

1390

result = rng.map(f)

1391

exp = [f(x) for x in rng]

1392

self.assert_(np.array_equal(result, exp))

1393

1394

def test_add_union(self):

1395

rng = date_range('1/1/2000', periods=5)

1396

rng2 = date_range('1/6/2000', periods=5)

1397

1398

result = rng + rng2

1399

expected = rng.union(rng2)

1400

self.assert_(result.equals(expected))

1401

1402

def test_misc_coverage(self):

1403

rng = date_range('1/1/2000', periods=5)

1404

result = rng.groupby(rng.day)

1405

self.assert_(isinstance(result.values()[0][0], Timestamp))

1406

1407

idx = DatetimeIndex(['2000-01-03', '2000-01-01', '2000-01-02'])

1408

self.assert_(idx.equals(list(idx)))

1409

1410

non_datetime = Index(list('abc'))

1411

self.assert_(not idx.equals(list(non_datetime)))

1412

1413

def test_union_coverage(self):

1414

idx = DatetimeIndex(['2000-01-03', '2000-01-01', '2000-01-02'])

1415

ordered = DatetimeIndex(idx.order(), freq='infer')

1416

result = ordered.union(idx)

1417

self.assert_(result.equals(ordered))

1418

1419

result = ordered[:0].union(ordered)

1420

self.assert_(result.equals(ordered))

1421

self.assert_(result.freq == ordered.freq)

1422

1423

def test_union_bug_1730(self):

1424

rng_a = date_range('1/1/2012', periods=4, freq='3H')

1425

rng_b = date_range('1/1/2012', periods=4, freq='4H')

1426

1427

result = rng_a.union(rng_b)

1428

exp = DatetimeIndex(sorted(set(list(rng_a)) | set(list(rng_b))))

1429

self.assert_(result.equals(exp))

1430

1431

def test_union_bug_1745(self):

1432

left = DatetimeIndex(['2012-05-11 15:19:49.695000'])

1433

right = DatetimeIndex(['2012-05-29 13:04:21.322000',

1434

'2012-05-11 15:27:24.873000',

1435

'2012-05-11 15:31:05.350000'])

1436

1437

result = left.union(right)

1438

exp = DatetimeIndex(sorted(set(list(left)) | set(list(right))))

1439

self.assert_(result.equals(exp))

1440

1441

def test_intersection_bug_1708(self):

1442

from pandas import DateOffset

1443

index_1 = date_range('1/1/2012', periods=4, freq='12H')

1444

index_2 = index_1 + DateOffset(hours=1)

1445

1446

result = index_1 & index_2

1447

self.assertEqual(len(result), 0)

1448

1449

# def test_add_timedelta64(self):

1450

# rng = date_range('1/1/2000', periods=5)

1451

# delta = rng.values[3] - rng.values[1]

1452

1453

# result = rng + delta

1454

# expected = rng + timedelta(2)

1455

# self.assert_(result.equals(expected))

1456

1457

def test_get_duplicates(self):

1458

idx = DatetimeIndex(['2000-01-01', '2000-01-02', '2000-01-02',

1459

'2000-01-03', '2000-01-03', '2000-01-04'])

1460

1461

result = idx.get_duplicates()

1462

ex = DatetimeIndex(['2000-01-02', '2000-01-03'])

1463

self.assert_(result.equals(ex))

1464

1465

def test_argmin_argmax(self):

1466

idx = DatetimeIndex(['2000-01-04', '2000-01-01', '2000-01-02'])

1467

self.assertEqual(idx.argmin(), 1)

1468

self.assertEqual(idx.argmax(), 0)

1469

1470

def test_order(self):

1471

idx = DatetimeIndex(['2000-01-04', '2000-01-01', '2000-01-02'])

1472

1473

ordered = idx.order()

1474

self.assert_(ordered.is_monotonic)

1475

1476

ordered = idx.order(ascending=False)

1477

self.assert_(ordered[::-1].is_monotonic)

1478

1479

ordered, dexer = idx.order(return_indexer=True)

1480

self.assert_(ordered.is_monotonic)

1481

self.assert_(np.array_equal(dexer, [1, 2, 0]))

1482

1483

ordered, dexer = idx.order(return_indexer=True, ascending=False)

1484

self.assert_(ordered[::-1].is_monotonic)

1485

self.assert_(np.array_equal(dexer, [0, 2, 1]))

1486

1487

def test_insert(self):

1488

idx = DatetimeIndex(['2000-01-04', '2000-01-01', '2000-01-02'])

1489

1490

result = idx.insert(2, datetime(2000, 1, 5))

1491

exp = DatetimeIndex(['2000-01-04', '2000-01-01', '2000-01-05',

1492

'2000-01-02'])

1493

self.assert_(result.equals(exp))

1494

1495

idx = date_range('1/1/2000', periods=3, freq='M')

1496

result = idx.insert(3, datetime(2000, 4, 30))

1497

self.assert_(result.freqstr == 'M')

1498

1499

def test_map_bug_1677(self):

1500

index = DatetimeIndex(['2012-04-25 09:30:00.393000'])

1501

f = index.asof

1502

1503

result = index.map(f)

1504

expected = np.array([f(index[0])])

1505

self.assert_(np.array_equal(result, expected))

1506

1507

def test_groupby_function_tuple_1677(self):

1508

df = DataFrame(np.random.rand(100),

1509

index=date_range("1/1/2000", periods=100))

1510

monthly_group = df.groupby(lambda x: (x.year,x.month))

1511

1512

result = monthly_group.mean()

1513

self.assert_(isinstance(result.index[0], tuple))

1514

1515

def test_append_numpy_bug_1681(self):

1516

# another datetime64 bug

1517

dr = date_range('2011/1/1', '2012/1/1', freq='W-FRI')

1518

a = DataFrame()

1519

c = DataFrame({'A': 'foo', 'B': dr}, index=dr)

1520

1521

result = a.append(c)

1522

self.assert_((result['B'] == dr).all())

1523

1524

def test_isin(self):

1525

index = tm.makeDateIndex(4)

1526

result = index.isin(index)

1527

self.assert_(result.all())

1528

1529

result = index.isin(list(index))

1530

self.assert_(result.all())

1531

1532

assert_almost_equal(index.isin([index[2], 5]),

1533

[False, False, True, False])

1534

1535

def test_union(self):

1536

i1 = Int64Index(np.arange(0, 20, 2))

1537

i2 = Int64Index(np.arange(10, 30, 2))

1538

result = i1.union(i2)

1539

expected = Int64Index(np.arange(0, 30, 2))

1540

self.assert_(np.array_equal(result, expected))

1541

1542

def test_union_with_DatetimeIndex(self):

1543

i1 = Int64Index(np.arange(0, 20, 2))

1544

i2 = DatetimeIndex(start='2012-01-03 00:00:00', periods=10, freq='D')

1545

i1.union(i2) # Works

1546

i2.union(i1) # Fails with "AttributeError: can't set attribute"

1547

1548

class TestLegacySupport(unittest.TestCase):

1549

1550

@classmethod

1551

def setUpClass(cls):

1552

if py3compat.PY3:

1553

raise nose.SkipTest

1554

1555

pth, _ = os.path.split(os.path.abspath(__file__))

1556

filepath = os.path.join(pth, 'data', 'frame.pickle')

1557

1558

with open(filepath, 'rb') as f:

1559

cls.frame = pickle.load(f)

1560

1561

filepath = os.path.join(pth, 'data', 'series.pickle')

1562

with open(filepath, 'rb') as f:

1563

cls.series = pickle.load(f)

1564

1565

def test_pass_offset_warn(self):

1566

from StringIO import StringIO

1567

import sys

1568

buf = StringIO()

1569

1570

sys.stderr = buf

1571

DatetimeIndex(start='1/1/2000', periods=10, offset='H')

1572

sys.stderr = sys.__stderr__

1573

1574

def test_unpickle_legacy_frame(self):

1575

dtindex = DatetimeIndex(start='1/3/2005', end='1/14/2005',

1576

freq=BDay(1))

1577

1578

unpickled = self.frame

1579

1580

self.assertEquals(type(unpickled.index), DatetimeIndex)

1581

self.assertEquals(len(unpickled), 10)

1582

self.assert_((unpickled.columns == Int64Index(np.arange(5))).all())

1583

self.assert_((unpickled.index == dtindex).all())

1584

self.assertEquals(unpickled.index.offset, BDay(1, normalize=True))

1585

1586

def test_unpickle_legacy_series(self):

1587

from pandas.core.datetools import BDay

1588

1589

unpickled = self.series

1590

1591

dtindex = DatetimeIndex(start='1/3/2005', end='1/14/2005',

1592

freq=BDay(1))

1593

1594

self.assertEquals(type(unpickled.index), DatetimeIndex)

1595

self.assertEquals(len(unpickled), 10)

1596

self.assert_((unpickled.index == dtindex).all())

1597

self.assertEquals(unpickled.index.offset, BDay(1, normalize=True))

1598

1599

def test_unpickle_legacy_len0_daterange(self):

1600

pth, _ = os.path.split(os.path.abspath(__file__))

1601

filepath = os.path.join(pth, 'data', 'series_daterange0.pickle')

1602

1603

result = com.load(filepath)

1604

1605

ex_index = DatetimeIndex([], freq='B')

1606

1607

self.assert_(result.index.equals(ex_index))

1608

self.assert_(isinstance(result.index.freq, offsets.BDay))

1609

self.assert_(len(result) == 0)

1610

1611

def test_arithmetic_interaction(self):

1612

index = self.frame.index

1613

obj_index = index.asobject

1614

1615

dseries = Series(rand(len(index)), index=index)

1616

oseries = Series(dseries.values, index=obj_index)

1617

1618

result = dseries + oseries

1619

expected = dseries * 2

1620

self.assert_(isinstance(result.index, DatetimeIndex))

1621

assert_series_equal(result, expected)

1622

1623

result = dseries + oseries[:5]

1624

expected = dseries + dseries[:5]

1625

self.assert_(isinstance(result.index, DatetimeIndex))

1626

assert_series_equal(result, expected)

1627

1628

def test_join_interaction(self):

1629

index = self.frame.index

1630

obj_index = index.asobject

1631

1632

def _check_join(left, right, how='inner'):

1633

ra, rb, rc = left.join(right, how=how, return_indexers=True)

1634

ea, eb, ec = left.join(DatetimeIndex(right), how=how,

1635

return_indexers=True)

1636

1637

self.assert_(isinstance(ra, DatetimeIndex))

1638

self.assert_(ra.equals(ea))

1639

1640

assert_almost_equal(rb, eb)

1641

assert_almost_equal(rc, ec)

1642

1643

_check_join(index[:15], obj_index[5:], how='inner')

1644

_check_join(index[:15], obj_index[5:], how='outer')

1645

_check_join(index[:15], obj_index[5:], how='right')

1646

_check_join(index[:15], obj_index[5:], how='left')

1647

1648

def test_join_nonunique(self):

1649

idx1 = to_datetime(['2012-11-06 16:00:11.477563',

1650

'2012-11-06 16:00:11.477563'])

1651

idx2 = to_datetime(['2012-11-06 15:11:09.006507',

1652

'2012-11-06 15:11:09.006507'])

1653

rs = idx1.join(idx2, how='outer')

1654

self.assert_(rs.is_monotonic)

1655

1656

def test_unpickle_daterange(self):

1657

pth, _ = os.path.split(os.path.abspath(__file__))

1658

filepath = os.path.join(pth, 'data', 'daterange_073.pickle')

1659

1660

rng = com.load(filepath)

1661

self.assert_(type(rng[0]) == datetime)

1662

self.assert_(isinstance(rng.offset, offsets.BDay))

1663

self.assert_(rng.values.dtype == object)

1664

1665

def test_setops(self):

1666

index = self.frame.index

1667

obj_index = index.asobject

1668

1669

result = index[:5].union(obj_index[5:])

1670

expected = index

1671

self.assert_(isinstance(result, DatetimeIndex))

1672

self.assert_(result.equals(expected))

1673

1674

result = index[:10].intersection(obj_index[5:])

1675

expected = index[5:10]

1676

self.assert_(isinstance(result, DatetimeIndex))

1677

self.assert_(result.equals(expected))

1678

1679

result = index[:10] - obj_index[5:]

1680

expected = index[:5]

1681

self.assert_(isinstance(result, DatetimeIndex))

1682

self.assert_(result.equals(expected))

1683

1684

def test_index_conversion(self):

1685

index = self.frame.index

1686

obj_index = index.asobject

1687

1688

conv = DatetimeIndex(obj_index)

1689

self.assert_(conv.equals(index))

1690

1691

self.assertRaises(ValueError, DatetimeIndex, ['a', 'b', 'c', 'd'])

1692

1693

def test_tolist(self):

1694

rng = date_range('1/1/2000', periods=10)

1695

1696

result = rng.tolist()

1697

self.assert_(isinstance(result[0], Timestamp))

1698

1699

def test_object_convert_fail(self):

1700

idx = DatetimeIndex([NaT])

1701

self.assertRaises(ValueError, idx.astype, 'O')

1702

1703

def test_setops_conversion_fail(self):

1704

index = self.frame.index

1705

1706

right = Index(['a', 'b', 'c', 'd'])

1707

1708

result = index.union(right)

1709

expected = Index(np.concatenate([index.asobject, right]))

1710

self.assert_(result.equals(expected))

1711

1712

result = index.intersection(right)

1713

expected = Index([])

1714

self.assert_(result.equals(expected))

1715

1716

def test_legacy_time_rules(self):

1717

rules = [('WEEKDAY', 'B'),

1718

('EOM', 'BM'),

1719

('W@MON', 'W-MON'), ('W@TUE', 'W-TUE'), ('W@WED', 'W-WED'),

1720

('W@THU', 'W-THU'), ('W@FRI', 'W-FRI'),

1721

('Q@JAN', 'BQ-JAN'), ('Q@FEB', 'BQ-FEB'), ('Q@MAR', 'BQ-MAR'),

1722

('A@JAN', 'BA-JAN'), ('A@FEB', 'BA-FEB'), ('A@MAR', 'BA-MAR'),

1723

('A@APR', 'BA-APR'), ('A@MAY', 'BA-MAY'), ('A@JUN', 'BA-JUN'),

1724

('A@JUL', 'BA-JUL'), ('A@AUG', 'BA-AUG'), ('A@SEP', 'BA-SEP'),

1725

('A@OCT', 'BA-OCT'), ('A@NOV', 'BA-NOV'), ('A@DEC', 'BA-DEC'),

1726

('WOM@1FRI', 'WOM-1FRI'), ('WOM@2FRI', 'WOM-2FRI'),

1727

('WOM@3FRI', 'WOM-3FRI'), ('WOM@4FRI', 'WOM-4FRI')]

1728

1729

start, end = '1/1/2000', '1/1/2010'

1730

1731

for old_freq, new_freq in rules:

1732

old_rng = date_range(start, end, freq=old_freq)

1733

new_rng = date_range(start, end, freq=new_freq)

1734

self.assert_(old_rng.equals(new_rng))

1735

1736

# test get_legacy_offset_name

1737

offset = datetools.get_offset(new_freq)

1738

old_name = datetools.get_legacy_offset_name(offset)

1739

self.assertEquals(old_name, old_freq)

1740

1741

def test_ms_vs_MS(self):

1742

left = datetools.get_offset('ms')

1743

right = datetools.get_offset('MS')

1744

self.assert_(left == datetools.Milli())

1745

self.assert_(right == datetools.MonthBegin())

1746

1747

def test_rule_aliases(self):

1748

rule = datetools.to_offset('10us')

1749

self.assert_(rule == datetools.Micro(10))

1750

1751

def test_slice_year(self):

1752

dti = DatetimeIndex(freq='B', start=datetime(2005,1,1), periods=500)

1753

1754

s = Series(np.arange(len(dti)), index=dti)

1755

result = s['2005']

1756

expected = s[s.index.year == 2005]

1757

assert_series_equal(result, expected)

1758

1759

df = DataFrame(np.random.rand(len(dti), 5), index=dti)

1760

result = df.ix['2005']

1761

expected = df[df.index.year == 2005]

1762

assert_frame_equal(result, expected)

1763

1764

rng = date_range('1/1/2000', '1/1/2010')

1765

1766

result = rng.get_loc('2009')

1767

expected = slice(3288, 3653)

1768

self.assert_(result == expected)

1769

1770

def test_slice_quarter(self):

1771

dti = DatetimeIndex(freq='D', start=datetime(2000,6,1), periods=500)

1772

1773

s = Series(np.arange(len(dti)), index=dti)

1774

self.assertEquals(len(s['2001Q1']), 90)

1775

1776

df = DataFrame(np.random.rand(len(dti), 5), index=dti)

1777

self.assertEquals(len(df.ix['1Q01']), 90)

1778

1779

def test_slice_month(self):

1780

dti = DatetimeIndex(freq='D', start=datetime(2005,1,1), periods=500)

1781

s = Series(np.arange(len(dti)), index=dti)

1782

self.assertEquals(len(s['2005-11']), 30)

1783

1784

df = DataFrame(np.random.rand(len(dti), 5), index=dti)

1785

self.assertEquals(len(df.ix['2005-11']), 30)

1786

1787

assert_series_equal(s['2005-11'], s['11-2005'])

1788

1789

def test_partial_slice(self):

1790

rng = DatetimeIndex(freq='D', start=datetime(2005,1,1), periods=500)

1791

s = Series(np.arange(len(rng)), index=rng)

1792

1793

result = s['2005-05':'2006-02']

1794

expected = s['20050501':'20060228']

1795

assert_series_equal(result, expected)

1796

1797

result = s['2005-05':]

1798

expected = s['20050501':]

1799

assert_series_equal(result, expected)

1800

1801

result = s[:'2006-02']

1802

expected = s[:'20060228']

1803

assert_series_equal(result, expected)

1804

1805

def test_partial_not_monotonic(self):

1806

rng = date_range(datetime(2005,1,1), periods=20, freq='M')

1807

ts = Series(np.arange(len(rng)), index=rng)

1808

ts = ts.take(np.random.permutation(20))

1809

1810

self.assertRaises(Exception, ts.__getitem__, '2005')

1811

1812

def test_date_range_normalize(self):

1813

snap = datetime.today()

1814

n = 50

1815

1816

rng = date_range(snap, periods=n, normalize=False, freq='2D')

1817

1818

offset = timedelta(2)

1819

values = np.array([snap + i * offset for i in range(n)],

1820

dtype='M8[ns]')

1821

1822

self.assert_(np.array_equal(rng, values))

1823

1824

rng = date_range('1/1/2000 08:15', periods=n, normalize=False, freq='B')

1825

the_time = time(8, 15)

1826

for val in rng:

1827

self.assert_(val.time() == the_time)

1828

1829

def test_timedelta(self):

1830

# this is valid too

1831

index = date_range('1/1/2000', periods=50, freq='B')

1832

shifted = index + timedelta(1)

1833

back = shifted + timedelta(-1)

1834

self.assert_(tm.equalContents(index, back))

1835

self.assertEqual(shifted.freq, index.freq)

1836

self.assertEqual(shifted.freq, back.freq)

1837

1838

result = index - timedelta(1)

1839

expected = index + timedelta(-1)

1840

self.assert_(result.equals(expected))

1841

1842

def test_shift(self):

1843

ts = Series(np.random.randn(5),

1844

index=date_range('1/1/2000', periods=5, freq='H'))

1845

1846

result = ts.shift(1, freq='5T')

1847

exp_index = ts.index.shift(1, freq='5T')

1848

self.assert_(result.index.equals(exp_index))

1849

1850

# GH #1063, multiple of same base

1851

result = ts.shift(1, freq='4H')

1852

exp_index = ts.index + datetools.Hour(4)

1853

self.assert_(result.index.equals(exp_index))

1854

1855

idx = DatetimeIndex(['2000-01-01', '2000-01-02', '2000-01-04'])

1856

self.assertRaises(ValueError, idx.shift, 1)

1857

1858

def test_setops_preserve_freq(self):

1859

rng = date_range('1/1/2000', '1/1/2002')

1860

1861

result = rng[:50].union(rng[50:100])

1862

self.assert_(result.freq == rng.freq)

1863

1864

result = rng[:50].union(rng[30:100])

1865

self.assert_(result.freq == rng.freq)

1866

1867

result = rng[:50].union(rng[60:100])

1868

self.assert_(result.freq is None)

1869

1870

result = rng[:50].intersection(rng[25:75])

1871

self.assert_(result.freqstr == 'D')

1872

1873

nofreq = DatetimeIndex(list(rng[25:75]))

1874

result = rng[:50].union(nofreq)

1875

self.assert_(result.freq == rng.freq)

1876

1877

result = rng[:50].intersection(nofreq)

1878

self.assert_(result.freq == rng.freq)

1879

1880

def test_min_max(self):

1881

rng = date_range('1/1/2000', '12/31/2000')

1882

rng2 = rng.take(np.random.permutation(len(rng)))

1883

1884

the_min = rng2.min()

1885

the_max = rng2.max()

1886

self.assert_(isinstance(the_min, Timestamp))

1887

self.assert_(isinstance(the_max, Timestamp))

1888

self.assertEqual(the_min, rng[0])

1889

self.assertEqual(the_max, rng[-1])

1890

1891

self.assertEqual(rng.min(), rng[0])

1892

self.assertEqual(rng.max(), rng[-1])

1893

1894

def test_min_max_series(self):

1895

rng = date_range('1/1/2000', periods=10, freq='4h')

1896

lvls = ['A','A','A','B','B','B','C','C','C','C']

1897

df = DataFrame({'TS': rng, 'V' : np.random.randn(len(rng)),

1898

'L' : lvls})

1899

1900

result = df.TS.max()

1901

exp = Timestamp(df.TS.iget(-1))

1902

self.assertTrue(isinstance(result, Timestamp))

1903

self.assertEqual(result, exp)

1904

1905

result = df.TS.min()

1906

exp = Timestamp(df.TS.iget(0))

1907

self.assertTrue(isinstance(result, Timestamp))

1908

self.assertEqual(result, exp)

1909

1910

def test_from_M8_structured(self):

1911

dates = [ (datetime(2012, 9, 9, 0, 0),

1912

datetime(2012, 9, 8, 15, 10))]

1913

arr = np.array(dates,

1914

dtype=[('Date', '<M8[us]'), ('Forecasting', '<M8[us]')])

1915

df = DataFrame(arr)

1916

1917

self.assertEqual(df['Date'][0], dates[0][0])

1918

self.assertEqual(df['Forecasting'][0], dates[0][1])

1919

1920

s = Series(arr['Date'])

1921

self.assertTrue(s[0], Timestamp)

1922

self.assertEqual(s[0], dates[0][0])

1923

1924

s = Series.from_array(arr['Date'], Index([0]))

1925

self.assertEqual(s[0], dates[0][0])

1926

1927

class TestLegacyCompat(unittest.TestCase):

1928

1929

def setUp(self):

1930

from StringIO import StringIO

1931

# suppress deprecation warnings

1932

sys.stderr = StringIO()

1933

1934

def test_inferTimeRule(self):

1935

from pandas.tseries.frequencies import inferTimeRule

1936

1937

index1 = [datetime(2010, 1, 29, 0, 0),

1938

datetime(2010, 2, 26, 0, 0),

1939

datetime(2010, 3, 31, 0, 0)]

1940

1941

index2 = [datetime(2010, 3, 26, 0, 0),

1942

datetime(2010, 3, 29, 0, 0),

1943

datetime(2010, 3, 30, 0, 0)]

1944

1945

index3 = [datetime(2010, 3, 26, 0, 0),

1946

datetime(2010, 3, 27, 0, 0),

1947

datetime(2010, 3, 29, 0, 0)]

1948

1949

# LEGACY

1950

assert inferTimeRule(index1) == 'EOM'

1951

assert inferTimeRule(index2) == 'WEEKDAY'

1952

1953

self.assertRaises(Exception, inferTimeRule, index1[:2])

1954

self.assertRaises(Exception, inferTimeRule, index3)

1955

1956

def test_time_rule(self):

1957

result = DateRange('1/1/2000', '1/30/2000', time_rule='WEEKDAY')

1958

result2 = DateRange('1/1/2000', '1/30/2000', timeRule='WEEKDAY')

1959

expected = date_range('1/1/2000', '1/30/2000', freq='B')

1960

1961

self.assert_(result.equals(expected))

1962

self.assert_(result2.equals(expected))

1963

1964

def tearDown(self):

1965

sys.stderr = sys.__stderr__

1966

1967

1968

class TestDatetime64(unittest.TestCase):

1969

"""

1970

Also test supoprt for datetime64[ns] in Series / DataFrame

1971

"""

1972

1973

1974

def setUp(self):

1975

dti = DatetimeIndex(start=datetime(2005,1,1),

1976

end=datetime(2005,1,10), freq='Min')

1977

self.series = Series(rand(len(dti)), dti)

1978

1979

def test_datetimeindex_accessors(self):

1980

dti = DatetimeIndex(freq='Q-JAN', start=datetime(1997,12,31), periods=100)

1981

1982

self.assertEquals(dti.year[0], 1998)

1983

self.assertEquals(dti.month[0], 1)

1984

self.assertEquals(dti.day[0], 31)

1985

self.assertEquals(dti.hour[0], 0)

1986

self.assertEquals(dti.minute[0], 0)

1987

self.assertEquals(dti.second[0], 0)

1988

self.assertEquals(dti.microsecond[0], 0)

1989

self.assertEquals(dti.dayofweek[0], 5)

1990

1991

self.assertEquals(dti.dayofyear[0], 31)

1992

self.assertEquals(dti.dayofyear[1], 120)

1993

1994

self.assertEquals(dti.weekofyear[0], 5)

1995

self.assertEquals(dti.weekofyear[1], 18)

1996

1997

self.assertEquals(dti.quarter[0], 1)

1998

self.assertEquals(dti.quarter[1], 2)

1999

2000

self.assertEquals(len(dti.year), 100)

2001

self.assertEquals(len(dti.month), 100)

2002

self.assertEquals(len(dti.day), 100)

2003

self.assertEquals(len(dti.hour), 100)

2004

self.assertEquals(len(dti.minute), 100)

2005

self.assertEquals(len(dti.second), 100)

2006

self.assertEquals(len(dti.microsecond), 100)

2007

self.assertEquals(len(dti.dayofweek), 100)

2008

self.assertEquals(len(dti.dayofyear), 100)

2009

self.assertEquals(len(dti.weekofyear), 100)

2010

self.assertEquals(len(dti.quarter), 100)

2011

2012

def test_nanosecond_field(self):

2013

dti = DatetimeIndex(np.arange(10))

2014

2015

self.assert_(np.array_equal(dti.nanosecond, np.arange(10)))

2016

2017

def test_datetimeindex_diff(self):

2018

dti1 = DatetimeIndex(freq='Q-JAN', start=datetime(1997,12,31),

2019

periods=100)

2020

dti2 = DatetimeIndex(freq='Q-JAN', start=datetime(1997,12,31),

2021

periods=98)

2022

self.assert_( len(dti1.diff(dti2)) == 2)

2023

2024

def test_fancy_getitem(self):

2025

dti = DatetimeIndex(freq='WOM-1FRI', start=datetime(2005,1,1),

2026

end=datetime(2010,1,1))

2027

2028

s = Series(np.arange(len(dti)), index=dti)

2029

2030

self.assertEquals(s[48], 48)

2031

self.assertEquals(s['1/2/2009'], 48)

2032

self.assertEquals(s['2009-1-2'], 48)

2033

self.assertEquals(s[datetime(2009,1,2)], 48)

2034

self.assertEquals(s[lib.Timestamp(datetime(2009,1,2))], 48)

2035

self.assertRaises(KeyError, s.__getitem__, '2009-1-3')

2036

2037

assert_series_equal(s['3/6/2009':'2009-06-05'],

2038

s[datetime(2009,3,6):datetime(2009,6,5)])

2039

2040

def test_fancy_setitem(self):

2041

dti = DatetimeIndex(freq='WOM-1FRI', start=datetime(2005,1,1),

2042

end=datetime(2010,1,1))

2043

2044

s = Series(np.arange(len(dti)), index=dti)

2045

s[48] = -1

2046

self.assertEquals(s[48], -1)

2047

s['1/2/2009'] = -2

2048

self.assertEquals(s[48], -2)

2049

s['1/2/2009':'2009-06-05'] = -3

2050

self.assert_((s[48:54] == -3).all())

2051

2052

def test_datetimeindex_constructor(self):

2053

arr = ['1/1/2005', '1/2/2005', 'Jn 3, 2005', '2005-01-04']

2054

self.assertRaises(Exception, DatetimeIndex, arr)

2055

2056

arr = ['1/1/2005', '1/2/2005', '1/3/2005', '2005-01-04']

2057

idx1 = DatetimeIndex(arr)

2058

2059

arr = [datetime(2005,1,1), '1/2/2005', '1/3/2005', '2005-01-04']

2060

idx2 = DatetimeIndex(arr)

2061

2062

arr = [lib.Timestamp(datetime(2005,1,1)), '1/2/2005', '1/3/2005',

2063

'2005-01-04']

2064

idx3 = DatetimeIndex(arr)

2065

2066

arr = np.array(['1/1/2005', '1/2/2005', '1/3/2005',

2067

'2005-01-04'], dtype='O')

2068

idx4 = DatetimeIndex(arr)

2069

2070

arr = to_datetime(['1/1/2005', '1/2/2005', '1/3/2005', '2005-01-04'])

2071

idx5 = DatetimeIndex(arr)

2072

2073

arr = to_datetime(['1/1/2005', '1/2/2005', 'Jan 3, 2005', '2005-01-04'])

2074

idx6 = DatetimeIndex(arr)

2075

2076

idx7 = DatetimeIndex(['12/05/2007', '25/01/2008'], dayfirst=True)

2077

idx8 = DatetimeIndex(['2007/05/12', '2008/01/25'], dayfirst=False,

2078

yearfirst=True)

2079

self.assert_(idx7.equals(idx8))

2080

2081

for other in [idx2, idx3, idx4, idx5, idx6]:

2082

self.assert_( (idx1.values == other.values).all() )

2083

2084

sdate = datetime(1999, 12, 25)

2085

edate = datetime(2000, 1, 1)

2086

idx = DatetimeIndex(start=sdate, freq='1B', periods=20)

2087

self.assertEquals(len(idx), 20)

2088

self.assertEquals(idx[0], sdate + 0 * dt.bday)

2089

self.assertEquals(idx.freq, 'B')

2090

2091

idx = DatetimeIndex(end=edate, freq=('D', 5), periods=20)

2092

self.assertEquals(len(idx), 20)

2093

self.assertEquals(idx[-1], edate)

2094

self.assertEquals(idx.freq, '5D')

2095

2096

idx1 = DatetimeIndex(start=sdate, end=edate, freq='W-SUN')

2097

idx2 = DatetimeIndex(start=sdate, end=edate,

2098

freq=dt.Week(weekday=6))

2099

self.assertEquals(len(idx1), len(idx2))

2100

self.assertEquals(idx1.offset, idx2.offset)

2101

2102

idx1 = DatetimeIndex(start=sdate, end=edate, freq='QS')

2103

idx2 = DatetimeIndex(start=sdate, end=edate,

2104

freq=dt.QuarterBegin(startingMonth=1))

2105

self.assertEquals(len(idx1), len(idx2))

2106

self.assertEquals(idx1.offset, idx2.offset)

2107

2108

idx1 = DatetimeIndex(start=sdate, end=edate, freq='BQ')

2109

idx2 = DatetimeIndex(start=sdate, end=edate,

2110

freq=dt.BQuarterEnd(startingMonth=12))

2111

self.assertEquals(len(idx1), len(idx2))

2112

self.assertEquals(idx1.offset, idx2.offset)

2113

2114

def test_dti_snap(self):

2115

dti = DatetimeIndex(['1/1/2002', '1/2/2002', '1/3/2002', '1/4/2002',

2116

'1/5/2002', '1/6/2002', '1/7/2002'], freq='D')

2117

2118

res = dti.snap(freq='W-MON')

2119

exp = date_range('12/31/2001', '1/7/2002', freq='w-mon')

2120

exp = exp.repeat([3, 4])

2121

self.assert_( (res == exp).all() )

2122

2123

res = dti.snap(freq='B')

2124

2125

exp = date_range('1/1/2002', '1/7/2002', freq='b')

2126

exp = exp.repeat([1, 1, 1, 2, 2])

2127

self.assert_( (res == exp).all() )

2128

2129

def test_dti_reset_index_round_trip(self):

2130

dti = DatetimeIndex(start='1/1/2001', end='6/1/2001', freq='D')

2131

d1 = DataFrame({'v' : np.random.rand(len(dti))}, index=dti)

2132

d2 = d1.reset_index()

2133

self.assert_(d2.dtypes[0] == np.dtype('M8[ns]'))

2134

d3 = d2.set_index('index')

2135

assert_frame_equal(d1, d3)

2136

2137

def test_datetimeindex_union_join_empty(self):

2138

dti = DatetimeIndex(start='1/1/2001', end='2/1/2001', freq='D')

2139

empty = Index([])

2140

2141

result = dti.union(empty)

2142

self.assert_(isinstance(result, DatetimeIndex))

2143

self.assert_(result is result)

2144

2145

result = dti.join(empty)

2146

self.assert_(isinstance(result, DatetimeIndex))

2147

2148

def test_series_set_value(self):

2149

# #1561

2150

2151

dates = [datetime(2001, 1, 1), datetime(2001, 1, 2)]

2152

index = DatetimeIndex(dates)

2153

2154

s = Series().set_value(dates[0], 1.)

2155

s2 = s.set_value(dates[1], np.nan)

2156

2157

exp = Series([1., np.nan], index=index)

2158

2159

assert_series_equal(s2, exp)

2160

2161

# s = Series(index[:1], index[:1])

2162

# s2 = s.set_value(dates[1], index[1])

2163

# self.assert_(s2.values.dtype == 'M8[ns]')

2164

2165

@slow

2166

def test_slice_locs_indexerror(self):

2167

times = [datetime(2000, 1, 1) + timedelta(minutes=i) for i in range(1000000)]

2168

s = Series(range(1000000), times)

2169

s.ix[datetime(1900,1,1):datetime(2100,1,1)]

2170

2171

2172

class TestSeriesDatetime64(unittest.TestCase):

2173

2174

def setUp(self):

2175

self.series = Series(date_range('1/1/2000', periods=10))

2176

2177

def test_auto_conversion(self):

2178

series = Series(list(date_range('1/1/2000', periods=10)))

2179

self.assert_(series.dtype == object)

2180

2181

def test_constructor_cant_cast_datetime64(self):

2182

self.assertRaises(TypeError, Series,

2183

date_range('1/1/2000', periods=10), dtype=float)

2184

2185

def test_series_comparison_scalars(self):

2186

val = datetime(2000, 1, 4)

2187

result = self.series > val

2188

expected = np.array([x > val for x in self.series])

2189

self.assert_(np.array_equal(result, expected))

2190

2191

val = self.series[5]

2192

result = self.series > val

2193

expected = np.array([x > val for x in self.series])

2194

self.assert_(np.array_equal(result, expected))

2195

2196

def test_between(self):

2197

left, right = self.series[[2, 7]]

2198

2199

result = self.series.between(left, right)

2200

expected = (self.series >= left) & (self.series <= right)

2201

assert_series_equal(result, expected)

2202

2203

#----------------------------------------------------------------------

2204

# NaT support

2205

2206

def test_NaT_scalar(self):

2207

series = Series([0, 1000, 2000, iNaT], dtype='M8[ns]')

2208

2209

val = series[3]

2210

self.assert_(com.isnull(val))

2211

2212

series[2] = val

2213

self.assert_(com.isnull(series[2]))

2214

2215

def test_set_none_nan(self):

2216

self.series[3] = None

2217

self.assert_(self.series[3] is lib.NaT)

2218

2219

self.series[3:5] = None

2220

self.assert_(self.series[4] is lib.NaT)

2221

2222

self.series[5] = np.nan

2223

self.assert_(self.series[5] is lib.NaT)

2224

2225

self.series[5:7] = np.nan

2226

self.assert_(self.series[6] is lib.NaT)

2227

2228

def test_intercept_astype_object(self):

2229

# Work around NumPy 1.6 bugs

2230

result = self.series.astype(object)

2231

result2 = self.series.astype('O')

2232

expected = Series([x for x in self.series], dtype=object)

2233

2234

assert_series_equal(result, expected)

2235

assert_series_equal(result2, expected)

2236

2237

df = DataFrame({'a': self.series,

2238

'b' : np.random.randn(len(self.series))})

2239

2240

result = df.values.squeeze()

2241

self.assert_((result[:, 0] == expected.values).all())

2242

2243

df = DataFrame({'a': self.series,

2244

'b' : ['foo'] * len(self.series)})

2245

2246

result = df.values.squeeze()

2247

self.assert_((result[:, 0] == expected.values).all())

2248

2249

def test_union(self):

2250

rng1 = date_range('1/1/1999', '1/1/2012', freq='MS')

2251

s1 = Series(np.random.randn(len(rng1)), rng1)

2252

2253

rng2 = date_range('1/1/1980', '12/1/2001', freq='MS')

2254

s2 = Series(np.random.randn(len(rng2)), rng2)

2255

df = DataFrame({'s1' : s1, 's2' : s2})

2256

self.assert_(df.index.values.dtype == np.dtype('M8[ns]'))

2257

2258

def test_intersection(self):

2259

rng = date_range('6/1/2000', '6/15/2000', freq='D')

2260

rng = rng.delete(5)

2261

2262

rng2 = date_range('5/15/2000', '6/20/2000', freq='D')

2263

rng2 = DatetimeIndex(rng2.values)

2264

2265

result = rng.intersection(rng2)

2266

self.assert_(result.equals(rng))

2267

2268

#empty same freq GH2129

2269

rng = date_range('6/1/2000', '6/15/2000', freq='T')

2270

result = rng[0:0].intersection(rng)

2271

self.assert_(len(result) == 0)

2272

2273

result = rng.intersection(rng[0:0])

2274

self.assert_(len(result) == 0)

2275

2276

def test_date_range_bms_bug(self):

2277

# #1645

2278

rng = date_range('1/1/2000', periods=10, freq='BMS')

2279

2280

ex_first = Timestamp('2000-01-03')

2281

self.assertEquals(rng[0], ex_first)

2282

2283

def test_string_index_series_name_converted(self):

2284

# #1644

2285

df = DataFrame(np.random.randn(10, 4),

2286

index=date_range('1/1/2000', periods=10))

2287

2288

result = df.ix['1/3/2000']

2289

self.assertEquals(result.name, df.index[2])

2290

2291

result = df.T['1/3/2000']

2292

self.assertEquals(result.name, df.index[2])

2293

2294

class TestTimestamp(unittest.TestCase):

2295

2296

def test_basics_nanos(self):

2297

val = np.int64(946684800000000000).view('M8[ns]')

2298

stamp = Timestamp(val.view('i8') + 500)

2299

self.assert_(stamp.year == 2000)

2300

self.assert_(stamp.month == 1)

2301

self.assert_(stamp.microsecond == 0)

2302

self.assert_(stamp.nanosecond == 500)

2303

2304

def test_comparison(self):

2305

# 5-18-2012 00:00:00.000

2306

stamp = 1337299200000000000L

2307

2308

val = Timestamp(stamp)

2309

2310

self.assert_(val == val)

2311

self.assert_(not val != val)

2312

self.assert_(not val < val)

2313

self.assert_(val <= val)

2314

self.assert_(not val > val)

2315

self.assert_(val >= val)

2316

2317

other = datetime(2012, 5, 18)

2318

self.assert_(val == other)

2319

self.assert_(not val != other)

2320

self.assert_(not val < other)

2321

self.assert_(val <= other)

2322

self.assert_(not val > other)

2323

self.assert_(val >= other)

2324

2325

other = Timestamp(stamp + 100)

2326

2327

self.assert_(not val == other)

2328

self.assert_(val != other)

2329

self.assert_(val < other)

2330

self.assert_(val <= other)

2331

self.assert_(other > val)

2332

self.assert_(other >= val)

2333

2334

def test_cant_compare_tz_naive_w_aware(self):

2335

_skip_if_no_pytz()

2336

# #1404

2337

a = Timestamp('3/12/2012')

2338

b = Timestamp('3/12/2012', tz='utc')

2339

2340

self.assertRaises(Exception, a.__eq__, b)

2341

self.assertRaises(Exception, a.__ne__, b)

2342

self.assertRaises(Exception, a.__lt__, b)

2343

self.assertRaises(Exception, a.__gt__, b)

2344

self.assertRaises(Exception, b.__eq__, a)

2345

self.assertRaises(Exception, b.__ne__, a)

2346

self.assertRaises(Exception, b.__lt__, a)

2347

self.assertRaises(Exception, b.__gt__, a)

2348

2349

self.assertRaises(Exception, a.__eq__, b.to_pydatetime())

2350

self.assertRaises(Exception, a.to_pydatetime().__eq__, b)

2351

2352

def test_delta_preserve_nanos(self):

2353

val = Timestamp(1337299200000000123L)

2354

result = val + timedelta(1)

2355

self.assert_(result.nanosecond == val.nanosecond)

2356

2357

def test_frequency_misc(self):

2358

self.assertEquals(fmod.get_freq_group('T'),

2359

fmod.FreqGroup.FR_MIN)

2360

2361

code, stride = fmod.get_freq_code(offsets.Hour())

2362

self.assertEquals(code, fmod.FreqGroup.FR_HR)

2363

2364

code, stride = fmod.get_freq_code((5, 'T'))

2365

self.assertEquals(code, fmod.FreqGroup.FR_MIN)

2366

self.assertEquals(stride, 5)

2367

2368

offset = offsets.Hour()

2369

result = fmod.to_offset(offset)

2370

self.assertEquals(result, offset)

2371

2372

result = fmod.to_offset((5, 'T'))

2373

expected = offsets.Minute(5)

2374

self.assertEquals(result, expected)

2375

2376

self.assertRaises(KeyError, fmod.get_freq_code, (5, 'baz'))

2377

2378

self.assertRaises(ValueError, fmod.to_offset, '100foo')

2379

2380

self.assertRaises(ValueError, fmod.to_offset, ('', ''))

2381

2382

result = fmod.get_standard_freq(offsets.Hour())

2383

self.assertEquals(result, 'H')

2384

2385

def test_hash_equivalent(self):

2386

d = {datetime(2011, 1, 1) : 5}

2387

stamp = Timestamp(datetime(2011, 1, 1))

2388

self.assertEquals(d[stamp], 5)

2389

2390

if __name__ == '__main__':

2391

nose.runmodule(argv=[__file__,'-vvs','-x','--pdb', '--pdb-failure'],

2392

exit=False)