Return a list of all stations IDs
973617
def get_stations(self):
        
        request = requests.get("{}/stations".format(
            self.base_url))
        if request.status_code != 200:
            return None
        return request.json()
1093260
def tracks
      ids = track_keys
      return [] if not ids
      return ids.map {|id| Track.get id}
    end
1340019
def get_favorite_radio_stations(self, start=0, max_items=100):
        
        message = 'The output type of this method will probably change in '\
                  'the future to use SoCo data structures'
        warnings.warn(message, stacklevel=2)
        return self.__get_favorites(RADIO_STATIONS, start, max_items)
1324730
def _discover(**kwargs):
  """"""
  query = station_server.MULTICAST_QUERY
  for host, response in multicast.send(query, **kwargs):
    try:
      result = json.loads(response)
    except ValueError:
      _LOG.warn('Received bad JSON over multicast from %s: %s', host, response)
    try:
      yield StationInfo(result['cell'], host, result['port'],
                        result['station_id'], 'ONLINE',
                        result.get('test_description'),
                        result['test_name'])
    except KeyError:
      if 'last_activity_time_millis' in result:
        _LOG.debug('Received old station API response on multicast. Ignoring.')
      else:
        _LOG.warn('Received bad multicast response from %s: %s', host, response)
1220565
def getNetworkIDs(self):
        """"""

        res = []
        i = 0
        while True:
            netid = self.getValue("net_interface.%d.connection" % i)
            if not netid:
                return res
            res.append(netid)
            i += 1
1026003
def list_all(zone=None, permanent=True):
    '''
    
    '''
    _zone = {}
    id_ = ''

    if zone:
        cmd = '--zone={0} --list-all'.format(zone)
    else:
        cmd = '--list-all'

    if permanent:
        cmd += ' --permanent'

    for i in __firewall_cmd(cmd).splitlines():
        if re.match('^[a-z0-9]', i, re.I):
            zone_name = i.rstrip()
        else:
            if i.startswith('\t'):
                _zone[zone_name][id_].append(i.strip())
                continue

            (id_, val) = i.split(':', 1)

            id_ = id_.strip()

            if _zone.get(zone_name, None):
                _zone[zone_name].update({id_: [val.strip()]})
            else:
                _zone[zone_name] = {id_: [val.strip()]}

    return _zone
387934
def parse_stations(html):
    
    html = html.replace('SLs.sls=', '').replace(';SLs.showSuggestion();', '')
    html = json.loads(html)
    return html['suggestions']
438842
def _retrieve_station_history(self, station_ID, limit, interval):
        
        params = {'id': station_ID, 'type': interval, 'lang': self._language}
        if limit is not None:
            params['cnt'] = limit
        uri = http_client.HttpClient.to_url(STATION_WEATHER_HISTORY_URL,
                                            self._API_key,
                                            self._subscription_type,
                                            self._use_ssl)
        _, json_data = self._wapi.cacheable_get_json(uri, params=params)
        station_history = \
            self._parsers['station_history'].parse_JSON(json_data)
        if station_history is not None:
            station_history.set_station_ID(station_ID)
            station_history.set_interval(interval)
        return station_history
661917
def get_digital_channels(channel_list):
    """"""
    dig_ids = digital_channel_ids()
    dig_channels = []
    for ln in dig_ids:
        for ch in channel_list:
            if ch.dct['id'] == ln:
                dig_channels.append(ch)
                break
    return dig_channels
761041
def locations(parameters)
      allowed_parameters = %w(query x y type)

      query = create_query(parameters, allowed_parameters)
      locations = perform('locations', query)

      locations['stations']
    end
1275777
async def stations(self):
        """"""

        data = await self.retrieve(API_DISTRITS)

        Station = namedtuple('Station', ['latitude', 'longitude',
                                         'idAreaAviso', 'idConselho',
                                         'idDistrito', 'idRegiao',
                                         'globalIdLocal', 'local'])

        _stations = []

        for station in data['data']:

            _station = Station(
                self._to_number(station['latitude']),
                self._to_number(station['longitude']),
                station['idAreaAviso'],
                station['idConcelho'],
                station['idDistrito'],
                station['idRegiao'],
                station['globalIdLocal']//100 * 100,
                station['local'],
                )

            _stations.append(_station)

        return _stations
988473
def get_item_ids(self):
        """"""
        item_ids = []
        if self.has_items():
            for idstr in self._my_map['itemIds']:
                item_ids.append(idstr)
        return IdList(item_ids)
849825
def get_departures(self, station):
        
        url = 'http://webservices.ns.nl/ns-api-avt?station=' + station

        raw_departures = self._request('GET', url)
        return self.parse_departures(raw_departures)
896755
def list(self):
        """"""
        return [x["_id"] for x in self._db.system.js.find(projection=["_id"])]
892590
def list_names(cls):
        """"""
        ret = dict([(item['id'], item['name'])
                    for item in cls.list({'items_per_page': 500})])
        return ret
317033
def get_all_stations(self, station_type=None):
        
        params = None
        if station_type and station_type in STATION_TYPE_TO_CODE_DICT:
            url = self.api_base_url + 'getAllStationsXML_WithStationType'
            params = {
                'stationType': STATION_TYPE_TO_CODE_DICT[station_type]
            }
        else:
            url = self.api_base_url + 'getAllStationsXML'

        response = requests.get(
            url, params=params, timeout=10)

        if response.status_code != 200:
            return []

        return self._parse_station_list(response.content)
1265276
def stations
      resp = self.connection.request(
        :get,
        Citibike::Station.path
      )

      return resp if @options[:unwrapped]

      Citibike::Responses::Station.new(resp)
    end