~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/progress.py

• browse files at revision 1551.2.52
• compare with another revision
• download diff
• download tarball
• view history from revision 1551.2.52

Show diffs side-by-side

added

removed

bzrlib/progress.py

95

95

        else:

96

96

            return None

97

97

 

 

98

    def bottom(self):

 

99

        if len(self._stack) != 0:

 

100

            return self._stack[0]

 

101

        else:

 

102

            return None

 

103

 

98

104

    def get_nested(self):

99

105

        """Return a nested progress bar."""

100

106

        if len(self._stack) == 0:

142

148

        self.show_bar = show_bar

143

149

        self.show_count = show_count

144

150

        self._stack = _stack

 

151

        # seed throttler

 

152

        self.MIN_PAUSE = 0.1 # seconds

 

153

        now = time.clock()

 

154

        # starting now

 

155

        self.start_time = now

 

156

        # next update should not throttle

 

157

        self.last_update = now - self.MIN_PAUSE - 1

145

158

 

146

159

    def finished(self):

147

160

        """Return this bar to its progress stack."""

230

243

    The output file should be in line-buffered or unbuffered mode.

231

244

    """

232

245

    SPIN_CHARS = r'/-\|'

233

 

    MIN_PAUSE = 0.1 # seconds

234

246

 

235

247

 

236

248

    def __init__(self, **kwargs):

239

251

        self.spin_pos = 0

240

252

        self.width = terminal_width()

241

253

        self.start_time = None

242

 

        self.last_update = None

243

254

        self.last_updates = deque()

244

255

        self.child_fraction = 0

245

256

    

246

257

 

247

258

    def throttle(self):

248

259

        """Return True if the bar was updated too recently"""

249

 

        now = time.time()

250

 

        if self.start_time is None:

251

 

            self.start_time = self.last_update = now

252

 

            return False

253

 

        else:

254

 

            interval = now - self.last_update

255

 

            if interval > 0 and interval < self.MIN_PAUSE:

256

 

                return True

 

260

        # time.time consistently takes 40/4000 ms = 0.01 ms.

 

261

        # but every single update to the pb invokes it.

 

262

        # so we use time.clock which takes 20/4000 ms = 0.005ms

 

263

        # on the downside, time.clock() appears to have approximately

 

264

        # 10ms granularity, so we treat a zero-time change as 'throttled.'

 

265

        

 

266

        now = time.clock()

 

267

        interval = now - self.last_update

 

268

        # if interval > 0

 

269

        if interval < self.MIN_PAUSE:

 

270

            return True

257

271

 

258

272

        self.last_updates.append(now - self.last_update)

259

273

        self.last_update = now

281

295

    def update(self, msg, current_cnt=None, total_cnt=None, 

282

296

               child_fraction=0):

283

297

        """Update and redraw progress bar."""

284

 

        self.child_fraction = child_fraction

285

298

 

286

299

        if current_cnt < 0:

287

300

            current_cnt = 0

289

302

        if current_cnt > total_cnt:

290

303

            total_cnt = current_cnt

291

304

        

 

305

        ## # optional corner case optimisation 

 

306

        ## # currently does not seem to fire so costs more than saved.

 

307

        ## # trivial optimal case:

 

308

        ## # NB if callers are doing a clear and restore with

 

309

        ## # the saved values, this will prevent that:

 

310

        ## # in that case add a restore method that calls

 

311

        ## # _do_update or some such

 

312

        ## if (self.last_msg == msg and

 

313

        ##     self.last_cnt == current_cnt and

 

314

        ##     self.last_total == total_cnt and

 

315

        ##     self.child_fraction == child_fraction):

 

316

        ##     return

 

317

 

292

318

        old_msg = self.last_msg

293

319

        # save these for the tick() function

294

320

        self.last_msg = msg

295

321

        self.last_cnt = current_cnt

296

322

        self.last_total = total_cnt

297

 

            

 

323

        self.child_fraction = child_fraction

 

324

 

 

325

        # each function call takes 20ms/4000 = 0.005 ms, 

 

326

        # but multiple that by 4000 calls -> starts to cost.

 

327

        # so anything to make this function call faster

 

328

        # will improve base 'diff' time by up to 0.1 seconds.

298

329

        if old_msg == self.last_msg and self.throttle():

299

 

            return 

300

 

        

301

 

        if self.show_eta and self.start_time and total_cnt:

302

 

            eta = get_eta(self.start_time, current_cnt+child_fraction, 

303

 

                    total_cnt, last_updates = self.last_updates)

 

330

            return

 

331

 

 

332

        if self.show_eta and self.start_time and self.last_total:

 

333

            eta = get_eta(self.start_time, self.last_cnt + self.child_fraction, 

 

334

                    self.last_total, last_updates = self.last_updates)

304

335

            eta_str = " " + str_tdelta(eta)

305

336

        else:

306

337

            eta_str = ""

313

344

        # always update this; it's also used for the bar

314

345

        self.spin_pos += 1

315

346

 

316

 

        if self.show_pct and total_cnt and current_cnt:

317

 

            pct = 100.0 * ((current_cnt + child_fraction) / total_cnt)

 

347

        if self.show_pct and self.last_total and self.last_cnt:

 

348

            pct = 100.0 * ((self.last_cnt + self.child_fraction) / self.last_total)

318

349

            pct_str = ' (%5.1f%%)' % pct

319

350

        else:

320

351

            pct_str = ''

321

352

 

322

353

        if not self.show_count:

323

354

            count_str = ''

324

 

        elif current_cnt is None:

 

355

        elif self.last_cnt is None:

325

356

            count_str = ''

326

 

        elif total_cnt is None:

327

 

            count_str = ' %i' % (current_cnt)

 

357

        elif self.last_total is None:

 

358

            count_str = ' %i' % (self.last_cnt)

328

359

        else:

329

360

            # make both fields the same size

330

 

            t = '%i' % (total_cnt)

331

 

            c = '%*i' % (len(t), current_cnt)

 

361

            t = '%i' % (self.last_total)

 

362

            c = '%*i' % (len(t), self.last_cnt)

332

363

            count_str = ' ' + c + '/' + t 

333

364

 

334

365

        if self.show_bar:

335

366

            # progress bar, if present, soaks up all remaining space

336

 

            cols = self.width - 1 - len(msg) - len(spin_str) - len(pct_str) \

 

367

            cols = self.width - 1 - len(self.last_msg) - len(spin_str) - len(pct_str) \

337

368

                   - len(eta_str) - len(count_str) - 3

338

369

 

339

 

            if total_cnt:

 

370

            if self.last_total:

340

371

                # number of markers highlighted in bar

341

372

                markers = int(round(float(cols) * 

342

 

                              (current_cnt + child_fraction) / total_cnt))

 

373

                              (self.last_cnt + self.child_fraction) / self.last_total))

343

374

                bar_str = '[' + ('=' * markers).ljust(cols) + '] '

344

375

            elif False:

345

376

                # don't know total, so can't show completion.

353

384

        else:

354

385

            bar_str = ''

355

386

 

356

 

        m = spin_str + bar_str + msg + count_str + pct_str + eta_str

 

387

        m = spin_str + bar_str + self.last_msg + count_str + pct_str + eta_str

357

388

 

358

389

        assert len(m) < self.width

359

390

        self.to_file.write('\r' + m.ljust(self.width - 1))

394

425

        else:

395

426

            count = self.current+self.child_fraction

396

427

            if count > self.total:

397

 

                mutter('clamping count of %d to %d' % (count, self.total))

 

428

                if __debug__:

 

429

                    mutter('clamping count of %d to %d' % (count, self.total))

398

430

                count = self.total

399

431

        self.parent.child_update(self.message, count, self.total)

400

432

 

401

433

    def clear(self):

402

434

        pass

403

435

 

 

436

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

 

437

        self.parent.note(*args, **kwargs)

 

438

 

404

439

 

405

440

def str_tdelta(delt):

406

441

    if delt is None:

424

459

    if current > total:

425

460

        return None                     # wtf?

426

461

 

427

 

    elapsed = time.time() - start_time

 

462

    elapsed = time.clock() - start_time

428

463

 

429

464

    if elapsed < 2.0:                   # not enough time to estimate

430

465

        return None

• Older »

Loggerhead is a web-based interface for Breezy
Version: 2.0.1