Fetches the local / instance-wide timeline, not including replies.

        Returns a list of `toot dicts`_.
344530
def timeline_local(self, max_id=None, min_id=None, since_id=None, limit=None):
        
        return self.timeline('local', max_id=max_id, min_id=min_id,
                             since_id=since_id, limit=limit)
896094
def get_updates(self, offset=None, limit=None, timeout=None):
        
        payload = dict(offset=offset, limit=limit, timeout=timeout)
        return self._get('getUpdates', payload)
381440
def public_timeline(self, delegate, params={}, extra_args=None):
        ""

        return self.__get('/statuses/public_timeline.atom', delegate, params,
                          extra_args=extra_args)
1068705
def from_node(index, value):
        
        try:
            lines = json.loads(value)
        except (TypeError, ValueError):
            lines = None
        if not isinstance(lines, list):
            lines = []
        return TimelineHistory(index, value, lines)
814412
def timeline(self, user_id=None, screen_name=None, max_id=None,
                 since_id=None, max_pages=None):
        

        if user_id and screen_name:
            raise ValueError('only user_id or screen_name may be passed')

        # Strip if screen_name is prefixed with '@'
        if screen_name:
            screen_name = screen_name.lstrip('@')
        id = screen_name or str(user_id)
        id_type = "screen_name" if screen_name else "user_id"
        log.info("starting user timeline for user %s", id)

        if screen_name or user_id:
            url = "https://api.twitter.com/1.1/statuses/user_timeline.json"
        else:
            url = "https://api.twitter.com/1.1/statuses/home_timeline.json"

        params = {"count": 200, id_type: id, "include_ext_alt_text": "true"}

        retrieved_pages = 0
        reached_end = False

        while True:
            if since_id:
                # Make the since_id inclusive, so we can avoid retrieving
                # an empty page of results in some cases
                params['since_id'] = str(int(since_id) - 1)
            if max_id:
                params['max_id'] = max_id

            try:
                resp = self.get(url, params=params, allow_404=True)
                retrieved_pages += 1
            except requests.exceptions.HTTPError as e:
                if e.response.status_code == 404:
                    log.warn("no timeline available for %s", id)
                    break
                elif e.response.status_code == 401:
                    log.warn("protected account %s", id)
                    break
                raise e

            statuses = resp.json()

            if len(statuses) == 0:
                log.info("no new tweets matching %s", params)
                break

            for status in statuses:
                # We've certainly reached the end of new results
                if since_id is not None and status['id_str'] == str(since_id):
                    reached_end = True
                    break
                # If you request an invalid user_id, you may still get
                # results so need to check.
                if not user_id or id == status.get("user",
                                                   {}).get("id_str"):
                    yield status

            if reached_end:
                log.info("no new tweets matching %s", params)
                break

            if max_pages is not None and retrieved_pages == max_pages:
                log.info("reached max page limit for %s", params)
                break

            max_id = str(int(status["id_str"]) - 1)
306030
def history(self):
        
        res = self._api_request('hist')
        if res[0][0] == '-1':
            raise PuushError("History retrieval failed.")
        
        files = []
        for line in res[1:]:
            id, upload_time, url, filename, views, _ = line
            files.append(self._File(id, url, filename, upload_time, views))
        return files
314036
def requestTimingInfo(self):
        
        try:
            return tuple(item.split('=')[1] for item in self.http_response.header.get('CMS-Server-Time').split())
        except AttributeError:
            return None, None
353021
@SuppressWarnings("unused") // called through reflection by RequestServer
  public TimelineV3 fetch(int version, TimelineV3 s) {
    Timeline t = s.createAndFillImpl();
    t.snapshot = new TimelineSnapshot(H2O.CLOUD,TimeLine.system_snapshot());
    return s.fillFromImpl(t);
  }
884548
def get_all(cls, parent=None, **params):

        if parent is not None:
            route = copy(parent.route)
        else:
            route = {}
        if cls.ID_NAME is not None:
            # Empty string triggers "get all resources"
            route[cls.ID_NAME] = ""

        base_obj = cls(key=parent.key, route=route, config=parent.config)
        """"""

        start = datetime.now()
        r = requests.get(
            base_obj._url(), auth=(base_obj.key, ""), params=params)
        cls._delay_for_ratelimits(start)

        if r.status_code not in cls.TRUTHY_CODES:
            return base_obj._handle_request_exception(r)

        response = r.json()
        objects_data = response.get(base_obj.ENVELOPE or base_obj, [])

        return_objects = []
        for data in objects_data:
            # Note that this approach does not get meta data
            return_objects.append(
                cls.get(
                    parent=parent,
                    id=data.get(cls.ID_NAME, data.get("id")),
                    data=data))

        return return_objects
919824
def home_timeline(self, delegate, params={}, extra_args=None):
        """"""
        return self.__get('/statuses/home_timeline.xml', delegate, params,
            txml.Statuses, extra_args=extra_args)
849006
def _GetTimelineStatEntries(client_id, file_path, with_history=True):
  """"""

  if data_store.RelationalDBEnabled():
    fn = _GetTimelineStatEntriesRelDB
  else:
    fn = _GetTimelineStatEntriesLegacy

  for v in fn(client_id, file_path, with_history=with_history):
    yield v
828247
def timeline(self):
        """"""
        rev = int(self.db.get('site:rev'))
        if rev != self.revision:
            self.reload_site()

        return self._timeline
346542
def last_seen_local(self) -> Optional[datetime]:
        """"""
        if self._node['seen']:
            return datetime.fromtimestamp(self._node['seen'])
1297825
def get_organizations(self, since=github.GithubObject.NotSet):
        
        assert since is github.GithubObject.NotSet or isinstance(since, (int, long)), since
        url_parameters = dict()
        if since is not github.GithubObject.NotSet:
            url_parameters["since"] = since
        return github.PaginatedList.PaginatedList(
            github.NamedUser.NamedUser,
            self.__requester,
            "/organizations",
            url_parameters
        )
1027780
def get_current(self):
        

        where = slice(self._oldest_frame_idx(), self._pos)
        major_axis = pd.DatetimeIndex(deepcopy(self.date_buf[where]), tz='utc')
        return pd.Panel(self.buffer.values[:, where, :], self.items,
                        major_axis, self.minor_axis, dtype=self.dtype)
56715
def timeline_entities_for_model(model_class)
      @timeline_entities_for_model[model_class] ||= begin
        result = { }

        self.timelines.each do |timeline_kind, timeline_class|
          result[timeline_class] = [ ]

          timeline_class.routes.each do |route|
            entities_ary = @activity_entities[route.activity_class]
            (entities_ary || [ ]).each do |entity_name|
              result[timeline_class] << entity_name if (@entity_classes[entity_name] == model_class)
            end
          end

          result[timeline_class].uniq!
        end

        result
      end
    end
220312
def scoped_timeline(ids, opts = {})
      ids      = ids.join(',') if ids.is_a?(Array)
      params   = { user_ids: ids }.merge!(opts)
      resource = SCOPED_TIMELINE % { id: @id }
      request  = Request.new(client, :get, resource, params: params)
      response = request.perform
      response.body[:data]
    end