matplotlib.github.com/3.4.2/_modules/dateutil/rrule.html at main · matplotlib/matplotlib.github.com

History

1859 lines (1629 loc) · 259 KB

Raw

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284

285

286

287

288

289

290

291

292

293

294

295

296

297

298

299

300

301

302

303

304

305

306

307

308

309

310

311

312

313

314

315

316

317

318

319

320

321

322

323

324

325

326

327

328

329

330

331

332

333

334

335

336

337

338

339

340

341

342

343

344

345

346

347

348

349

350

351

352

353

354

355

356

357

358

359

360

361

362

363

364

365

366

367

368

369

370

371

372

373

374

375

376

377

378

379

380

381

382

383

384

385

386

387

388

389

390

391

392

393

394

395

396

397

398

399

400

401

402

403

404

405

406

407

408

409

410

411

412

413

414

415

416

417

418

419

420

421

422

423

424

425

426

427

428

429

430

431

432

433

434

435

436

437

438

439

440

441

442

443

444

445

446

447

448

449

450

451

452

453

454

455

456

457

458

459

460

461

462

463

464

465

466

467

468

469

470

471

472

473

474

475

476

477

478

479

480

481

482

483

484

485

486

487

488

489

490

491

492

493

494

495

496

497

498

499

500

501

502

503

504

505

506

507

508

509

510

511

512

513

514

515

516

517

518

519

520

521

522

523

524

525

526

527

528

529

530

531

532

533

534

535

536

537

538

539

540

541

542

543

544

545

546

547

548

549

550

551

552

553

554

555

556

557

558

559

560

561

562

563

564

565

566

567

568

569

570

571

572

573

574

575

576

577

578

579

580

581

582

583

584

585

586

587

588

589

590

591

592

593

594

595

596

597

598

599

600

601

602

603

604

605

606

607

608

609

610

611

612

613

614

615

616

617

618

619

620

621

622

623

624

625

626

627

628

629

630

631

632

633

634

635

636

637

638

639

640

641

642

643

644

645

646

647

648

649

650

651

652

653

654

655

656

657

658

659

660

661

662

663

664

665

666

667

668

669

670

671

672

673

674

675

676

677

678

679

680

681

682

683

684

685

686

687

688

689

690

691

692

693

694

695

696

697

698

699

700

701

702

703

704

705

706

707

708

709

710

711

712

713

714

715

716

717

718

719

720

721

722

723

724

725

726

727

728

729

730

731

732

733

734

735

736

737

738

739

740

741

742

743

744

745

746

747

748

749

750

751

752

753

754

755

756

757

758

759

760

761

762

763

764

765

766

767

768

769

770

771

772

773

774

775

776

777

778

779

780

781

782

783

784

785

786

787

788

789

790

791

792

793

794

795

796

797

798

799

800

801

802

803

804

805

806

807

808

809

810

811

812

813

814

815

816

817

818

819

820

821

822

823

824

825

826

827

828

829

830

831

832

833

834

835

836

837

838

839

840

841

842

843

844

845

846

847

848

849

850

851

852

853

854

855

856

857

858

859

860

861

862

863

864

865

866

867

868

869

870

871

872

873

874

875

876

877

878

879

880

881

882

883

884

885

886

887

888

889

890

891

892

893

894

895

896

897

898

899

900

901

902

903

904

905

906

907

908

909

910

911

912

913

914

915

916

917

918

919

920

921

922

923

924

925

926

927

928

929

930

931

932

933

934

935

936

937

938

939

940

941

942

943

944

945

946

947

948

949

950

951

952

953

954

955

956

957

958

959

960

961

962

963

964

965

966

967

968

969

970

971

972

973

974

975

976

977

978

979

980

981

982

983

984

985

986

987

988

989

990

991

992

993

994

995

996

997

998

999

1000

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"

"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

<head>

<title>dateutil.rrule — Matplotlib 3.4.2 documentation</title>

title="Search within Matplotlib 3.4.2 documentation"

href="../../_static/opensearch.xml"/>

</head><body>

<div id="unreleased-message"> You are reading an old version of the documentation (v3.4.2). For the latest version see <a href="/stable/">https://matplotlib.org/stable/</a> </div>

<!--

</div>

-->

<div style="float: left; position: absolute; width: 496px; bottom: 0; padding-bottom: 24px">Version 3.4.2</div>

<div id="forkongithub"><a href="https://github.com/matplotlib/matplotlib">Fork me on GitHub</a></div>

</div>

<ul>

<li><a href="../../users/installing.html">Installation</a></li>

<li><a href="../../contents.html">Documentation</a></li>

<li><a href="../../gallery/index.html">Examples</a></li>

<li><a href="../../tutorials/index.html">Tutorials</a></li>

<li><a href="../../devel/index.html">Contributing</a></li>

</form>

</li>

</ul>

</nav>

<h3>Navigation</h3>

<ul>

<a href="../../genindex.html" title="General Index"

accesskey="I">index</a></li>

<a href="../../py-modindex.html" title="Python Module Index"

>modules</a> |</li>

<li><a href="../../contents.html">contents</a> »</li>

<li class="nav-item nav-item-1"><a href="../index.html" accesskey="U">Module code</a> »</li>

<li class="nav-item nav-item-this"><a href="">dateutil.rrule</a></li>

</ul>

</div>

</div>

<h1>Source code for dateutil.rrule</h1><div class="highlight"><pre>

# -*- coding: utf-8 -*-

"""

The rrule module offers a small, complete, and very fast, implementation of

the recurrence rules documented in the

`iCalendar RFC <https://tools.ietf.org/html/rfc5545>`_,

including support for caching of results.

"""

import itertools

import datetime

import calendar

import re

import sys

try:

from math import gcd

except ImportError:

from fractions import gcd

from six import advance_iterator, integer_types

from six.moves import _thread, range

import heapq

from ._common import weekday as weekdaybase

# For warning about deprecation of until and count

from warnings import warn

__all__ = ["rrule", "rruleset", "rrulestr",

"YEARLY", "MONTHLY", "WEEKLY", "DAILY",

"HOURLY", "MINUTELY", "SECONDLY",

"MO", "TU", "WE", "TH", "FR", "SA", "SU"]

# Every mask is 7 days longer to handle cross-year weekly periods.

M366MASK = tuple([1]*31+[2]*29+[3]*31+[4]*30+[5]*31+[6]*30 +

[7]*31+[8]*31+[9]*30+[10]*31+[11]*30+[12]*31+[1]*7)

M365MASK = list(M366MASK)

M29, M30, M31 = list(range(1, 30)), list(range(1, 31)), list(range(1, 32))

MDAY366MASK = tuple(M31+M29+M31+M30+M31+M30+M31+M31+M30+M31+M30+M31+M31[:7])

MDAY365MASK = list(MDAY366MASK)

M29, M30, M31 = list(range(-29, 0)), list(range(-30, 0)), list(range(-31, 0))

NMDAY366MASK = tuple(M31+M29+M31+M30+M31+M30+M31+M31+M30+M31+M30+M31+M31[:7])

NMDAY365MASK = list(NMDAY366MASK)

M366RANGE = (0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335, 366)

M365RANGE = (0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365)

WDAYMASK = [0, 1, 2, 3, 4, 5, 6]*55

del M29, M30, M31, M365MASK[59], MDAY365MASK[59], NMDAY365MASK[31]

MDAY365MASK = tuple(MDAY365MASK)

M365MASK = tuple(M365MASK)

FREQNAMES = ['YEARLY', 'MONTHLY', 'WEEKLY', 'DAILY', 'HOURLY', 'MINUTELY', 'SECONDLY']

(YEARLY,

MONTHLY,

WEEKLY,

DAILY,

HOURLY,

MINUTELY,

SECONDLY) = list(range(7))

# Imported on demand.

easter = None

parser = None

class weekday(weekdaybase):

"""

This version of weekday does not allow n = 0.

"""

def __init__(self, wkday, n=None):

if n == 0:

raise ValueError("Can't create weekday with n==0")

super(weekday, self).__init__(wkday, n)

MO, TU, WE, TH, FR, SA, SU = weekdays = tuple(weekday(x) for x in range(7))

def _invalidates_cache(f):

"""

Decorator for rruleset methods which may invalidate the

cached length.

"""

def inner_func(self, *args, **kwargs):

rv = f(self, *args, **kwargs)

self._invalidate_cache()

return rv

return inner_func

class rrulebase(object):

def __init__(self, cache=False):

if cache:

self._cache = []

self._cache_lock = _thread.allocate_lock()

self._invalidate_cache()

else:

self._cache = None

self._cache_complete = False

self._len = None

def __iter__(self):

if self._cache_complete:

return iter(self._cache)

elif self._cache is None:

return self._iter()

else:

return self._iter_cached()

def _invalidate_cache(self):

if self._cache is not None:

self._cache = []

self._cache_complete = False

self._cache_gen = self._iter()

if self._cache_lock.locked():

self._cache_lock.release()

self._len = None

def _iter_cached(self):

i = 0

gen = self._cache_gen

cache = self._cache

acquire = self._cache_lock.acquire

release = self._cache_lock.release

while gen:

if i == len(cache):

acquire()

if self._cache_complete:

break

try:

for j in range(10):

cache.append(advance_iterator(gen))

except StopIteration:

self._cache_gen = gen = None

self._cache_complete = True

break

release()

yield cache[i]

i += 1

while i < self._len:

yield cache[i]

i += 1

def __getitem__(self, item):

if self._cache_complete:

return self._cache[item]

elif isinstance(item, slice):

if item.step and item.step < 0:

return list(iter(self))[item]

else:

return list(itertools.islice(self,

item.start or 0,

item.stop or sys.maxsize,

item.step or 1))

elif item >= 0:

gen = iter(self)

try:

for i in range(item+1):

res = advance_iterator(gen)

except StopIteration:

raise IndexError

return res

else:

def __contains__(self, item):

if self._cache_complete:

return item in self._cache

else:

for i in self:

if i == item:

return True

elif i > item:

return False

# __len__() introduces a large performance penalty.

def count(self):

""" Returns the number of recurrences in this set. It will have go

trough the whole recurrence, if this hasn't been done before. """

if self._len is None:

for x in self:

pass

return self._len

def before(self, dt, inc=False):

""" Returns the last recurrence before the given datetime instance. The

inc keyword defines what happens if dt is an occurrence. With

inc=True, if dt itself is an occurrence, it will be returned. """

if self._cache_complete:

gen = self._cache

else:

gen = self

last = None

if inc:

for i in gen:

if i > dt:

break

last = i

else:

for i in gen:

if i >= dt:

break

last = i

return last

def after(self, dt, inc=False):

""" Returns the first recurrence after the given datetime instance. The

inc keyword defines what happens if dt is an occurrence. With

inc=True, if dt itself is an occurrence, it will be returned. """

if self._cache_complete:

gen = self._cache

else:

gen = self

if inc:

for i in gen:

if i >= dt:

return i

else:

for i in gen:

if i > dt:

return i

return None

def xafter(self, dt, count=None, inc=False):

"""

Generator which yields up to `count` recurrences after the given

datetime instance, equivalent to `after`.

:param dt:

The datetime at which to start generating recurrences.

:param count:

The maximum number of recurrences to generate. If `None` (default),

dates are generated until the recurrence rule is exhausted.

:param inc:

If `dt` is an instance of the rule and `inc` is `True`, it is

included in the output.

:yields: Yields a sequence of `datetime` objects.

"""

if self._cache_complete:

gen = self._cache

else:

gen = self

# Select the comparison function

if inc:

comp = lambda dc, dtc: dc >= dtc

else:

# Generate dates

n = 0

for d in gen:

if comp(d, dt):

if count is not None:

n += 1

if n > count:

break

yield d

def between(self, after, before, inc=False, count=1):

""" Returns all the occurrences of the rrule between after and before.

The inc keyword defines what happens if after and/or before are

themselves occurrences. With inc=True, they will be included in the

list, if they are found in the recurrence set. """

if self._cache_complete:

gen = self._cache

else:

gen = self

started = False

l = []

if inc:

for i in gen:

if i > before:

break

elif not started:

if i >= after:

started = True

l.append(i)

else:

l.append(i)

else:

for i in gen:

if i >= before:

break

elif not started:

if i > after:

started = True

l.append(i)

else:

l.append(i)

return l

<div class="viewcode-block" id="rrule"><a class="viewcode-back" href="../../api/dates_api.html#matplotlib.dates.rrule">[docs]</a>class rrule(rrulebase):

"""

That's the base of the rrule operation. It accepts all the keywords

defined in the RFC as its constructor parameters (except byday,

which was renamed to byweekday) and more. The constructor prototype is::

rrule(freq)

Where freq must be one of YEARLY, MONTHLY, WEEKLY, DAILY, HOURLY, MINUTELY,

or SECONDLY.

.. note::

Per RFC section 3.3.10, recurrence instances falling on invalid dates

and times are ignored rather than coerced:

Recurrence rules may generate recurrence instances with an invalid

date (e.g., February 30) or nonexistent local time (e.g., 1:30 AM

on a day where the local time is moved forward by an hour at 1:00

AM). Such recurrence instances MUST be ignored and MUST NOT be

counted as part of the recurrence set.

This can lead to possibly surprising behavior when, for example, the

start date occurs at the end of the month:

>>> from dateutil.rrule import rrule, MONTHLY

>>> from datetime import datetime

>>> start_date = datetime(2014, 12, 31)

>>> list(rrule(freq=MONTHLY, count=4, dtstart=start_date))

... # doctest: +NORMALIZE_WHITESPACE

[datetime.datetime(2014, 12, 31, 0, 0),

datetime.datetime(2015, 1, 31, 0, 0),

datetime.datetime(2015, 3, 31, 0, 0),

datetime.datetime(2015, 5, 31, 0, 0)]

Additionally, it supports the following keyword arguments:

:param dtstart:

The recurrence start. Besides being the base for the recurrence,

missing parameters in the final recurrence instances will also be

extracted from this date. If not given, datetime.now() will be used

instead.

:param interval:

The interval between each freq iteration. For example, when using

YEARLY, an interval of 2 means once every two years, but with HOURLY,

it means once every two hours. The default interval is 1.

:param wkst:

The week start day. Must be one of the MO, TU, WE constants, or an

integer, specifying the first day of the week. This will affect

recurrences based on weekly periods. The default week start is got

from calendar.firstweekday(), and may be modified by

calendar.setfirstweekday().

:param count:

If given, this determines how many occurrences will be generated.

.. note::

As of version 2.5.0, the use of the keyword ``until`` in conjunction

with ``count`` is deprecated, to make sure ``dateutil`` is fully

compliant with `RFC-5545 Sec. 3.3.10 <https://tools.ietf.org/

html/rfc5545#section-3.3.10>`_. Therefore, ``until`` and ``count``

**must not** occur in the same call to ``rrule``.

:param until:

If given, this must be a datetime instance specifying the upper-bound

limit of the recurrence. The last recurrence in the rule is the greatest

datetime that is less than or equal to the value specified in the

``until`` parameter.

.. note::

As of version 2.5.0, the use of the keyword ``until`` in conjunction

with ``count`` is deprecated, to make sure ``dateutil`` is fully

compliant with `RFC-5545 Sec. 3.3.10 <https://tools.ietf.org/

html/rfc5545#section-3.3.10>`_. Therefore, ``until`` and ``count``

**must not** occur in the same call to ``rrule``.

:param bysetpos:

If given, it must be either an integer, or a sequence of integers,

positive or negative. Each given integer will specify an occurrence

number, corresponding to the nth occurrence of the rule inside the

frequency period. For example, a bysetpos of -1 if combined with a

MONTHLY frequency, and a byweekday of (MO, TU, WE, TH, FR), will

result in the last work day of every month.

:param bymonth:

If given, it must be either an integer, or a sequence of integers,

meaning the months to apply the recurrence to.

:param bymonthday:

If given, it must be either an integer, or a sequence of integers,

meaning the month days to apply the recurrence to.

:param byyearday:

If given, it must be either an integer, or a sequence of integers,

meaning the year days to apply the recurrence to.

:param byeaster:

If given, it must be either an integer, or a sequence of integers,

positive or negative. Each integer will define an offset from the

Easter Sunday. Passing the offset 0 to byeaster will yield the Easter

Sunday itself. This is an extension to the RFC specification.

:param byweekno:

If given, it must be either an integer, or a sequence of integers,

meaning the week numbers to apply the recurrence to. Week numbers

have the meaning described in ISO8601, that is, the first week of

the year is that containing at least four days of the new year.

:param byweekday:

If given, it must be either an integer (0 == MO), a sequence of

integers, one of the weekday constants (MO, TU, etc), or a sequence

of these constants. When given, these variables will define the

weekdays where the recurrence will be applied. It's also possible to

use an argument n for the weekday instances, which will mean the nth

occurrence of this weekday in the period. For example, with MONTHLY,

or with YEARLY and BYMONTH, using FR(+1) in byweekday will specify the

first friday of the month where the recurrence happens. Notice that in

the RFC documentation, this is specified as BYDAY, but was renamed to

avoid the ambiguity of that keyword.

:param byhour:

If given, it must be either an integer, or a sequence of integers,

meaning the hours to apply the recurrence to.

:param byminute:

If given, it must be either an integer, or a sequence of integers,

meaning the minutes to apply the recurrence to.

:param bysecond:

If given, it must be either an integer, or a sequence of integers,

meaning the seconds to apply the recurrence to.

:param cache:

If given, it must be a boolean value specifying to enable or disable

caching of results. If you will use the same rrule instance multiple

times, enabling caching will improve the performance considerably.

"""

def __init__(self, freq, dtstart=None,

interval=1, wkst=None, count=None, until=None, bysetpos=None,

bymonth=None, bymonthday=None, byyearday=None, byeaster=None,

byweekno=None, byweekday=None,

byhour=None, byminute=None, bysecond=None,

cache=False):

super(rrule, self).__init__(cache)

global easter

if not dtstart:

if until and until.tzinfo:

dtstart = datetime.datetime.now(tz=until.tzinfo).replace(microsecond=0)

else:

dtstart = datetime.datetime.now().replace(microsecond=0)

elif not isinstance(dtstart, datetime.datetime):

else:

dtstart = dtstart.replace(microsecond=0)

self._dtstart = dtstart

self._tzinfo = dtstart.tzinfo

self._freq = freq

self._interval = interval

self._count = count

# Cache the original byxxx rules, if they are provided, as the _byxxx

# attributes do not necessarily map to the inputs, and this can be

# a problem in generating the strings. Only store things if they've

# been supplied (the string retrieval will just use .get())

self._original_rule = {}

if until and not isinstance(until, datetime.datetime):

until = datetime.datetime.fromordinal(until.toordinal())

self._until = until

if self._dtstart and self._until:

if (self._dtstart.tzinfo is not None) != (self._until.tzinfo is not None):

# According to RFC5545 Section 3.3.10:

# https://tools.ietf.org/html/rfc5545#section-3.3.10

#

# > If the "DTSTART" property is specified as a date with UTC

# > time or a date with local time and time zone reference,

# > then the UNTIL rule part MUST be specified as a date with

# > UTC time.

raise ValueError(

'RRULE UNTIL values must be specified in UTC when DTSTART '

'is timezone-aware'

)

if count is not None and until:

warn("Using both 'count' and 'until' is inconsistent with RFC 5545"

" and has been deprecated in dateutil. Future versions will "

"raise an error.", DeprecationWarning)

if wkst is None:

self._wkst = calendar.firstweekday()

elif isinstance(wkst, integer_types):

self._wkst = wkst

else:

self._wkst = wkst.weekday

if bysetpos is None:

self._bysetpos = None

elif isinstance(bysetpos, integer_types):

if bysetpos == 0 or not (-366 <= bysetpos <= 366):

raise ValueError("bysetpos must be between 1 and 366, "

"or between -366 and -1")

self._bysetpos = (bysetpos,)

else:

self._bysetpos = tuple(bysetpos)

for pos in self._bysetpos:

if pos == 0 or not (-366 <= pos <= 366):

raise ValueError("bysetpos must be between 1 and 366, "

"or between -366 and -1")

if self._bysetpos:

self._original_rule['bysetpos'] = self._bysetpos

if (byweekno is None and byyearday is None and bymonthday is None and

byweekday is None and byeaster is None):

if freq == YEARLY:

if bymonth is None:

bymonth = dtstart.month

self._original_rule['bymonth'] = None

bymonthday = dtstart.day

self._original_rule['bymonthday'] = None

elif freq == MONTHLY:

bymonthday = dtstart.day

elif freq == WEEKLY:

byweekday = dtstart.weekday()

# bymonth

if bymonth is None:

self._bymonth = None

else:

if isinstance(bymonth, integer_types):

bymonth = (bymonth,)

self._bymonth = tuple(sorted(set(bymonth)))

if 'bymonth' not in self._original_rule:

# byyearday

if byyearday is None:

self._byyearday = None

else:

if isinstance(byyearday, integer_types):

byyearday = (byyearday,)

self._byyearday = tuple(sorted(set(byyearday)))

self._original_rule['byyearday'] = self._byyearday

# byeaster

if byeaster is not None:

if not easter:

from dateutil import easter

if isinstance(byeaster, integer_types):

self._byeaster = (byeaster,)

else:

self._byeaster = tuple(sorted(byeaster))

self._original_rule['byeaster'] = self._byeaster

else:

self._byeaster = None

# bymonthday

if bymonthday is None:

self._bymonthday = ()

self._bynmonthday = ()

else:

if isinstance(bymonthday, integer_types):

bymonthday = (bymonthday,)

bymonthday = set(bymonthday) # Ensure it's unique

self._bymonthday = tuple(sorted(x for x in bymonthday if x > 0))

self._bynmonthday = tuple(sorted(x for x in bymonthday if x < 0))

# Storing positive numbers first, then negative numbers

if 'bymonthday' not in self._original_rule:

itertools.chain(self._bymonthday, self._bynmonthday))

# byweekno

if byweekno is None:

self._byweekno = None

else:

if isinstance(byweekno, integer_types):

byweekno = (byweekno,)

self._byweekno = tuple(sorted(set(byweekno)))

self._original_rule['byweekno'] = self._byweekno

# byweekday / bynweekday

if byweekday is None:

self._byweekday = None

self._bynweekday = None

else:

# If it's one of the valid non-sequence types, convert to a

# single-element sequence before the iterator that builds the

# byweekday set.

if isinstance(byweekday, integer_types) or hasattr(byweekday, "n"):

byweekday = (byweekday,)

self._byweekday = set()

self._bynweekday = set()

for wday in byweekday:

if isinstance(wday, integer_types):

self._byweekday.add(wday)

elif not wday.n or freq > MONTHLY:

else:

self._bynweekday.add((wday.weekday, wday.n))

if not self._byweekday:

self._byweekday = None

elif not self._bynweekday:

self._bynweekday = None

if self._byweekday is not None:

self._byweekday = tuple(sorted(self._byweekday))

orig_byweekday = [weekday(x) for x in self._byweekday]

else:

orig_byweekday = ()

if self._bynweekday is not None:

self._bynweekday = tuple(sorted(self._bynweekday))

orig_bynweekday = [weekday(*x) for x in self._bynweekday]

else:

orig_bynweekday = ()

if 'byweekday' not in self._original_rule:

self._original_rule['byweekday'] = tuple(itertools.chain(

orig_byweekday, orig_bynweekday))

# byhour

if byhour is None:

if freq < HOURLY:

self._byhour = {dtstart.hour}

else:

self._byhour = None

else:

if isinstance(byhour, integer_types):

byhour = (byhour,)

if freq == HOURLY:

self._byhour = self.__construct_byset(start=dtstart.hour,

byxxx=byhour,

base=24)

else:

self._byhour = set(byhour)

self._byhour = tuple(sorted(self._byhour))

self._original_rule['byhour'] = self._byhour

# byminute

if byminute is None:

if freq < MINUTELY:

self._byminute = {dtstart.minute}

else:

self._byminute = None

else:

if isinstance(byminute, integer_types):

byminute = (byminute,)

if freq == MINUTELY:

self._byminute = self.__construct_byset(start=dtstart.minute,

byxxx=byminute,

base=60)

else:

self._byminute = set(byminute)

self._byminute = tuple(sorted(self._byminute))

self._original_rule['byminute'] = self._byminute

# bysecond

if bysecond is None:

if freq < SECONDLY:

self._bysecond = ((dtstart.second,))

else:

self._bysecond = None

else:

if isinstance(bysecond, integer_types):

bysecond = (bysecond,)

self._bysecond = set(bysecond)

if freq == SECONDLY:

self._bysecond = self.__construct_byset(start=dtstart.second,

byxxx=bysecond,

base=60)

else:

self._bysecond = tuple(sorted(self._bysecond))

self._original_rule['bysecond'] = self._bysecond

if self._freq >= HOURLY:

self._timeset = None

else:

self._timeset = []

for hour in self._byhour:

for minute in self._byminute:

for second in self._bysecond:

self._timeset.append(

datetime.time(hour, minute, second,

tzinfo=self._tzinfo))

self._timeset.sort()

self._timeset = tuple(self._timeset)

def __str__(self):

"""

Output a string that would generate this RRULE if passed to rrulestr.

This is mostly compatible with RFC5545, except for the

dateutil-specific extension BYEASTER.

"""

output = []

if self._dtstart:

output.append(self._dtstart.strftime('DTSTART:%Y%m%dT%H%M%S'))

h, m, s = self._dtstart.timetuple()[3:6]

parts = ['FREQ=' + FREQNAMES[self._freq]]

if self._interval != 1:

parts.append('INTERVAL=' + str(self._interval))

if self._wkst:

parts.append('WKST=' + repr(weekday(self._wkst))[0:2])

if self._count is not None:

parts.append('COUNT=' + str(self._count))

if self._until:

parts.append(self._until.strftime('UNTIL=%Y%m%dT%H%M%S'))

if self._original_rule.get('byweekday') is not None:

# The str() method on weekday objects doesn't generate

# RFC5545-compliant strings, so we should modify that.

original_rule = dict(self._original_rule)

wday_strings = []

for wday in original_rule['byweekday']:

if wday.n:

wday_strings.append('{n:+d}{wday}'.format(

n=wday.n,

wday=repr(wday)[0:2]))

else:

wday_strings.append(repr(wday))

original_rule['byweekday'] = wday_strings

else:

original_rule = self._original_rule

partfmt = '{name}={vals}'

for name, key in [('BYSETPOS', 'bysetpos'),

('BYMONTH', 'bymonth'),

('BYMONTHDAY', 'bymonthday'),

('BYYEARDAY', 'byyearday'),

('BYWEEKNO', 'byweekno'),

('BYDAY', 'byweekday'),

('BYHOUR', 'byhour'),

('BYMINUTE', 'byminute'),

('BYSECOND', 'bysecond'),

('BYEASTER', 'byeaster')]:

value = original_rule.get(key)

if value:

parts.append(partfmt.format(name=name, vals=(','.join(str(v)

for v in value))))

output.append('RRULE:' + ';'.join(parts))

return '\n'.join(output)

<div class="viewcode-block" id="rrule.replace"><a class="viewcode-back" href="../../api/dates_api.html#matplotlib.dates.rrule.replace">[docs]</a> def replace(self, **kwargs):

"""Return new rrule with same attributes except for those attributes given new

values by whichever keyword arguments are specified."""

new_kwargs = {"interval": self._interval,

"count": self._count,

"dtstart": self._dtstart,

"freq": self._freq,

"until": self._until,

"wkst": self._wkst,

"cache": False if self._cache is None else True }

new_kwargs.update(self._original_rule)

new_kwargs.update(kwargs)

return rrule(**new_kwargs)</div>

def _iter(self):

year, month, day, hour, minute, second, weekday, yearday, _ = \

self._dtstart.timetuple()

# Some local variables to speed things up a bit

freq = self._freq

interval = self._interval

wkst = self._wkst

until = self._until

bymonth = self._bymonth

byweekno = self._byweekno

byyearday = self._byyearday

byweekday = self._byweekday

byeaster = self._byeaster

bymonthday = self._bymonthday

bynmonthday = self._bynmonthday

bysetpos = self._bysetpos

byhour = self._byhour

byminute = self._byminute

bysecond = self._bysecond

ii = _iterinfo(self)

ii.rebuild(year, month)

getdayset = {YEARLY: ii.ydayset,

MONTHLY: ii.mdayset,

WEEKLY: ii.wdayset,

DAILY: ii.ddayset,

HOURLY: ii.ddayset,

MINUTELY: ii.ddayset,

SECONDLY: ii.ddayset}[freq]

if freq < HOURLY:

timeset = self._timeset

else:

gettimeset = {HOURLY: ii.htimeset,

MINUTELY: ii.mtimeset,

SECONDLY: ii.stimeset}[freq]

if ((freq >= HOURLY and

self._byhour and hour not in self._byhour) or

(freq >= MINUTELY and

self._byminute and minute not in self._byminute) or

(freq >= SECONDLY and

self._bysecond and second not in self._bysecond)):

timeset = ()

else:

timeset = gettimeset(hour, minute, second)

total = 0

count = self._count

while True:

# Get dayset with the right frequency

dayset, start, end = getdayset(year, month, day)

# Do the "hard" work ;-)

filtered = False

for i in dayset[start:end]:

if ((bymonth and ii.mmask[i] not in bymonth) or

(byweekno and not ii.wnomask[i]) or

(byweekday and ii.wdaymask[i] not in byweekday) or

(ii.nwdaymask and not ii.nwdaymask[i]) or

(byeaster and not ii.eastermask[i]) or

((bymonthday or bynmonthday) and

ii.mdaymask[i] not in bymonthday and

ii.nmdaymask[i] not in bynmonthday) or

(byyearday and

((i < ii.yearlen and i+1 not in byyearday and

-ii.yearlen+i not in byyearday) or

(i >= ii.yearlen and i+1-ii.yearlen not in byyearday and

-ii.nextyearlen+i-ii.yearlen not in byyearday)))):

dayset[i] = None

filtered = True

# Output results

if bysetpos and timeset:

poslist = []

for pos in bysetpos:

if pos < 0:

daypos, timepos = divmod(pos, len(timeset))

else:

daypos, timepos = divmod(pos-1, len(timeset))

try:

i = [x for x in dayset[start:end]

if x is not None][daypos]

time = timeset[timepos]

except IndexError:

pass

else:

date = datetime.date.fromordinal(ii.yearordinal+i)

res = datetime.datetime.combine(date, time)

if res not in poslist:

poslist.append(res)

poslist.sort()

for res in poslist:

if until and res > until:

self._len = total

return

elif res >= self._dtstart:

if count is not None:

count -= 1

if count < 0:

self._len = total

return

total += 1

yield res

else:

if i is not None:

date = datetime.date.fromordinal(ii.yearordinal + i)

for time in timeset:

if until and res > until:

self._len = total

return

elif res >= self._dtstart:

if count is not None:

count -= 1

if count < 0:

self._len = total

return

total += 1

yield res

View remainder of file in raw view

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

FilesExpand file tree

rrule.html

Latest commit

History

rrule.html

File metadata and controls