Opens page in browser

        :param n_times: Times to open page in browser
160497
def open_in_browser(self, n_times):
        

        for _ in range(n_times):
            webbrowser.open(self.url)
377904
def * times
      result = self.slice 0, 0
      frames = self.slice 0..-1
      times.times do
        result.concat frames
      end
      result
    end
1299208
def time_to_first_byte(self):
        
        # The unknown page is just a placeholder for entries with no page ID.
        # As such, it would not have a TTFB
        if self.page_id == 'unknown':
            return None
        ttfb = 0
        for entry in self.entries:
            if entry['response']['status'] == 200:
                for k, v in iteritems(entry['timings']):
                    if k != 'receive':
                        if v > 0:
                            ttfb += v
                break
            else:
                ttfb += entry['time']

        return ttfb
479365
def open_fake_page(self, page_text, url=None, soup_config=None):
        
        soup_config = soup_config or self.soup_config
        self.__state = _BrowserState(
            page=bs4.BeautifulSoup(page_text, **soup_config),
            url=url)
382648
def next_page(self):
        
        for link in self.links:
            if link.next:
                return self._load(link.next)
        raise PaginationError('No more entries.')
1121094
function Times(params) {
  this.creation = params.creation;
  this.queuing = params.queuing;
  this.start = params.start;
  this.finish = params.finish;
}
733456
def process_url(self, page_num, page_size, url):
        
        params = dict()
        if page_num is not None:
            url = re.sub('page=\d+', '', url)
            params['page'] = page_num
        if page_size is not None:
            url = re.sub('per_page=\d+', '', url)
            params['per_page'] = page_size
        return params, url
491260
def for_page(self, page, per_page):
        
        start = (page - 1) * per_page

        return self[start:start + per_page]
484454
def rspr(self, times=1, **kwargs):
        

        spr = SPR(self.copy())
        for _ in range(times):
            spr.rspr(**kwargs)
        return spr.tree
985472
def handle_pagination(self, page_num=None, page_size=None):
        
        self._response_json = self.get_next_page(page_num=page_num, page_size=page_size)
        self.update_attrs()
        self.position = 0
        self.values = self.process_page()
674378
def shuffle(self, times=1):
        
        for _ in xrange(times):
            random.shuffle(self.cards)
902828
def open(self, url, *args, **kwargs):
        
        if self.__verbose == 1:
            sys.stdout.write('.')
            sys.stdout.flush()
        elif self.__verbose >= 2:
            print(url)

        resp = self.get(url, *args, **kwargs)
        self.__state = _BrowserState(page=resp.soup, url=resp.url,
                                     request=resp.request)
        return resp
180239
def bench(client, n):
    
    items = list(range(n))

    # Time client publish operations
    # ------------------------------
    started = time.time()
    for i in items:
        client.publish('test', i)
    duration = time.time() - started

    print('Publisher client stats:')
    util.print_stats(n, duration)
832131
public AbstractIntList times(int times) {
	AbstractIntList newList = new IntArrayList(times*size());
	for (int i=times; --i >= 0; ) {
		newList.addAllOfFromTo(this,0,size()-1);
	}
	return newList;
}
94850
def <<(times)
      r = times.shift
      @repeat += 1 if @times[:repeat].last != r
      @times[:repeat] << r
      TIMES.zip(times) { |t, time| @times[t] << time.to_f }
      self
    end
257842
def absolute_redirect_n_times(n):
    

    assert n > 0

    if n == 1:
        return redirect(url_for("view_get", _external=True))

    return _redirect("absolute", n, True)
739965
def relative_redirect_n_times(n):
    

    assert n > 0

    response = app.make_response("")
    response.status_code = 302

    if n == 1:
        response.headers["Location"] = url_for("view_get")
        return response

    response.headers["Location"] = url_for("relative_redirect_n_times", n=n - 1)
    return response