Perform a request for videos.

    :param blink: Blink instance.
    :param time: Get videos since this time.  In epoch seconds.
    :param page: Page number to get videos from.
519320
def request_videos(blink, time=None, page=0):
    
    timestamp = get_time(time)
    url = "{}/api/v2/videos/changed?since={}&page={}".format(
        blink.urls.base_url, timestamp, page)
    return http_get(blink, url)
1175008
@Override
    public Page<SubscribedTrack> previousPage(final Page<SubscribedTrack> page, 
                                              final TwilioRestClient client) {
        Request request = new Request(
            HttpMethod.GET,
            page.getPreviousPageUrl(
                Domains.VIDEO.toString(),
                client.getRegion()
            )
        );
        return pageForRequest(client, request);
    }
144601
def _paged_api_call(self, func, kwargs, item_type='photo'):
        
        page = 1
        while True:
            LOG.info("Fetching page %s" % page)
            kwargs['page'] = page
            rsp = self._load_rsp(func(**kwargs))
            if rsp["stat"] == "ok":
                plural = item_type + 's'
                if plural in rsp:
                    items = rsp[plural]
                    if int(items["page"]) < page:
                        LOG.info("End of Flickr pages (%s pages with %s per page)" % (items["pages"], items["perpage"]))
                        break
                    for i in items[item_type]:
                        yield self._prep(i)
                else:
                    yield rsp
                page += 1
            else:
                yield [rsp]
                break
13735
async def async_get(self, url):
        
        self.reset()
        self.next_link = url
        return await self.async_advance_page()
78114
def get_different_page(self, request, page):
        

        if page:
            qs = request.GET.copy()
            qs['page'] = page
            return "%s?%s" % (request.path_info, qs.urlencode())
        return None
1013913
def process_request(self, request):
        
        global _urlconf_pages

        page_list = list(
            Page.objects.exclude(glitter_app_name='').values_list('id', 'url').order_by('id')
        )

        with _urlconf_lock:
            if page_list != _urlconf_pages:
                glitter_urls = 'glitter.urls'
                if glitter_urls in sys.modules:
                    importlib.reload(sys.modules[glitter_urls])
                _urlconf_pages = page_list
689038
def mirror_video(self, is_mirror, callback=None):
        '''
        
        '''
        params = {'isMirror': is_mirror}
        return self.execute_command('mirrorVideo', params, callback=callback)
556444
def check_new_videos(self):
        """"""
        resp = api.request_videos(self.blink,
                                  time=self.blink.last_refresh,
                                  page=0)

        for camera in self.cameras.keys():
            self.motion[camera] = False

        try:
            info = resp['videos']
        except (KeyError, TypeError):
            _LOGGER.warning("Could not check for motion. Response: %s", resp)
            return False

        for entry in info:
            try:
                name = entry['camera_name']
                clip = entry['address']
                timestamp = entry['created_at']
                self.motion[name] = True
                self.last_record[name] = {'clip': clip, 'time': timestamp}
            except KeyError:
                _LOGGER.debug("No new videos since last refresh.")

        return True
659300
function(camera) {
    var time = Date.now();
    this._animations = this._animations.filter(function(anim) {
      return !anim.step(camera, time);
    });
    return this._animations.length > 0;
  }
1177210
def next_page(self):
        
        if not self.next_page_url:
            return None

        response = self._version.domain.twilio.request('GET', self.next_page_url)
        cls = type(self)
        return cls(self._version, response, self._solution)
1021356
def captured_today(self):
        """"""
        if self._cached_videos is None:
            self.make_video_cache()

        return [vdo for vdo in self._cached_videos if vdo.created_today]
799322
def load(self, page = None, verbose=False):
        
        url = self._build_query_url(page, verbose)
        response = self._load(url, verbose)
        response = self._post_load(response, verbose)
        return response
26390
def http_post(blink, url, is_retry=False):
    
    if blink.auth_header is None:
        raise BlinkException(ERROR.AUTH_TOKEN)
    _LOGGER.debug("Making POST request to %s", url)
    return http_req(blink, url=url, headers=blink.auth_header,
                    reqtype='post', is_retry=is_retry)
1068919
def list(opts={as_hash: true})
      page_token = nil
      parameters = {}
      self.timeline_list = []
      begin
        parameters = {}
        parameters['pageToken'] = page_token if page_token.present?
        api_result = google_client.execute(api_method: mirror_api.timeline.list,
                                           parameters: parameters)
        if api_result.success?
          timeline_items = api_result.data
          page_token = nil if timeline_items.items.empty?
          if timeline_items.items.any?
            @timeline_list.concat(timeline_items.items)
            page_token = timeline_items.next_page_token
          end
        else
          puts "An error occurred: #{api_result.data['error']['message']}"
          page_token = nil
        end
      end while page_token.to_s != ''
      timeline_list(opts)
    end
672486
def sendVideo(self, chat_id, video,
                  duration=None,
                  width=None,
                  height=None,
                  thumb=None,
                  caption=None,
                  parse_mode=None,
                  supports_streaming=None,
                  disable_notification=None,
                  reply_to_message_id=None,
                  reply_markup=None):
        
        p = _strip(locals(), more=['video'])
        return self._api_request_with_file('sendVideo', _rectify(p), 'video', video)
1254766
def blink(self, delay=1):
        
        self.toggle()
        gevent.spawn_later(delay, self.toggle)
953378
def from_video(self, path):
        
        frames = self.get_video_frames(path)
        self.handle_type(frames)
        return self