Get numbers of players for app id

        :param app_id: app id
        :type app_id: :class:`int`
        :return: number of players
        :rtype: :class:`int`, :class:`.EResult`
199502
def get_player_count(self, app_id, timeout=5):
        
        resp = self.send_job_and_wait(MsgProto(EMsg.ClientGetNumberOfCurrentPlayersDP),
                                      {'appid': app_id},
                                      timeout=timeout
                                     )
        if resp is None:
            return EResult.Timeout
        elif resp.eresult == EResult.OK:
            return resp.player_count
        else:
            return EResult(resp.eresult)
1215797
function getAge (keyword, apps) {
    // FIXME this is a number in google play now
    const updated = R.pluck('updated', apps).map(getDaysSince);
    const avg = R.sum(updated) / apps.length;
    const max = 500;
    const score = calc.izScore(max, avg);

    return {
      avgDaysSinceUpdated: avg,
      score
    };
  }
821239
def org_find_apps(object_id, input_params={}, always_retry=True, **kwargs):
    
    return DXHTTPRequest('/%s/findApps' % object_id, input_params, always_retry=always_retry, **kwargs)
199823
def get_player_stats(self, player_key, board_key):
        
        player_stats_url = self.api_path + 'player/' + player_key + '/league/' + board_key + '/stats/'
        response = self.get_response(player_stats_url)
        return response
478243
def game_counts(n_back=20):
    """"""
    for _, model_name in get_models[-n_back:]:
        games = get_games(model_name)
        print("Model: {}, Games: {}".format(model_name, len(games)))
617507
def is_playing_shared_game(self, steamID, appid_playing, format=None):
        
        parameters = {'steamid' : steamID, 'appid_playing' : appid_playing}
        if format is not None:
            parameters['format'] = format
        url = self.create_request_url(self.interface, 'IsPlayingSharedGame', 1,
            parameters)
        data = self.retrieve_request(url)
        return self.return_data(data, format=format)
1060988
def app_size(self):
        ""
        if self._nodes is None:
            return self._app_size
        return sum(i.app_size() for i in self._nodes)
61815
def get_recently_played_games(self, steamID, count=0, format=None):
        
        parameters = {'steamid' : steamID, 'count' : count}
        if format is not None:
            parameters['format'] = format
        url = self.create_request_url(self.interface, 'GetRecentlyPlayedGames', 1,
            parameters)
        data = self.retrieve_request(url)
        return self.return_data(data, format=format)
1073552
def get_version(self, app_id, version):
        
        response = self._do_request('GET', '/v2/apps/{app_id}/versions/{version}'
                                    .format(app_id=app_id, version=version))
        return MarathonApp.from_json(response.json())
692881
def find_application(app_id=None, app_name=None):
        
        LOGGER.debug("ApplicationService.find_application")
        if (app_id is None or not app_id) and (app_name is None or not app_name):
            raise exceptions.ArianeCallParametersError('id and name')

        if (app_id is not None and app_id) and (app_name is not None and app_name):
            LOGGER.warn('ApplicationService.find_application - Both id and name are defined. '
                        'Will give you search on id.')
            app_name = None

        params = None
        if app_id is not None and app_id:
            params = {'id': app_id}
        elif app_name is not None and app_name:
            params = {'name': app_name}

        ret = None
        if params is not None:
            args = {'http_operation': 'GET', 'operation_path': 'get', 'parameters': params}
            response = ApplicationService.requester.call(args)
            if response.rc == 0:
                ret = Application.json_2_application(response.response_content)
            elif response.rc != 404:
                err_msg = 'ApplicationService.find_application - Problem while finding application (id:' + \
                          str(app_id) + ', name:' + str(app_name) + '). ' + \
                          'Reason: ' + str(response.response_content) + '-' + str(response.error_message) + \
                          " (" + str(response.rc) + ")"
                LOGGER.warning(
                    err_msg
                )

        return ret
1094415
def get_release_count(self, package_name: str) -> int:
        
        validate_package_name(package_name)
        self._validate_set_registry()
        return self.registry._num_release_ids(package_name)
1330447
def get_activity(self, id_num):
        
        url = self._build_url('my', 'activities', id_num)
        return self._json(url)
438718
def app_show(self, id, **kwargs):
        ""
        api_path = "/api/v2/apps/{id}.json"
        api_path = api_path.format(id=id)
        return self.call(api_path, **kwargs)
1216646
def delete_app(self, app_id, force=False):
        
        params = {'force': force}
        response = self._do_request(
            'DELETE', '/v2/apps/{app_id}'.format(app_id=app_id), params=params)
        return response.json()
1194120
def running_apps(device_id):
    
    if not is_valid_device_id(device_id):
        abort(403)
    if device_id not in devices:
        abort(404)
    return jsonify(running_apps=devices[device_id].running_apps)
228286
def get_projected_player_game_stats_by_player(self, season, week, player_id):
        
        result = self._method_call("PlayerGameProjectionStatsByPlayerID/{season}/{week}/{player_id}", "projections", season=season, week=week, player_id=player_id)
        return result
843312
def count(cls, user_id):
        
        return cls.query.with_entities(
            cls.user_id).filter_by(user_id=user_id).count()