Wrapper for fetching details of game by ID

        :param id_: int
        :param return_fields: tuple

        :return: pybomb.clients.Response
970871
def fetch(self, id_, return_fields=None):
        
        game_params = {"id": id_}

        if return_fields is not None:
            self._validate_return_fields(return_fields)
            field_list = ",".join(return_fields)

            game_params["field_list"] = field_list

        response = self._query(game_params, direct=True)

        return response
262807
def fetch(self, refund_id, data={}, **kwargs):
        "
        return super(Refund, self).fetch(refund_id, data, **kwargs)
473045
def client(self, id):
    """"""

    return self.query(Client).filter(Client.id==id).one()
1215715
def _process_for_id(cls, response_raw):
        

        json = response_raw.body_bytes.decode()
        obj = converter.json_to_class(dict, json)
        id_ = converter.deserialize(
            Id,
            cls._unwrap_response_single(obj, cls._FIELD_ID)
        )

        return client.BunqResponse(id_.id_, response_raw.headers)
431639
def ReadResponsesForRequestId(self, session_id, request_id, timestamp=None):
    
    request = rdf_flow_runner.RequestState(id=request_id, session_id=session_id)
    for _, responses in self.ReadResponses([request], timestamp=timestamp):
      return responses
1133991
def get(cls, user_id, client_id):
        
        return cls.query.filter_by(
            user_id=user_id,
            client_id=client_id,
        ).first()
849551
def games_played(self, app_ids):
        
        if not isinstance(app_ids, list):
            raise ValueError("Expected app_ids to be of type list")

        self.current_games_played = app_ids = list(map(int, app_ids))

        self.send(MsgProto(EMsg.ClientGamesPlayed),
                  {'games_played': [{'game_id': app_id} for app_id in app_ids]}
                  )
1117505
def get(self, id):
        
        id = self.key_name(id)
        session_json = self.redis.get(id) or '{}'
        return json_loads(session_json)
1205518
def retrieve(self, request, _id):
        
        _id = deserialize(_id)

        retrieved = self.collection.find_one({'_id': _id})
        if retrieved:
            return Response(serialize(retrieved))
        else:
            return Response(
                response=serialize(
                    DocumentNotFoundError(self.collection.__name__, _id)
                ),
                status=400
            )
840140
def hero_id(response):
    
    for player in response['players']:
        for hero in heroes['heroes']:
            if hero['id'] == player['hero_id']:
                player['hero_name'] = hero['localized_name']

    return response
773698
def get_client_profile(self, client_id):
        
        try:
            response = self._table.get_item(Key={'client_id': client_id})
            compressed_bytes = response['Item']['json_payload'].value
            json_byte_data = zlib.decompress(compressed_bytes)
            json_str_data = json_byte_data.decode('utf8')
            return json.loads(json_str_data)
        except KeyError:
            # No client ID found - not really an error
            return None
        except Exception as e:
            # Return None on error.  The caller in ProfileFetcher will
            # handle error logging
            msg = "Error loading client data for {}.  Error: {}"
            self.logger.debug(msg.format(client_id, str(e)))
            return None
19377
def _fetch_response_id(self, response):
        

        headers = response.headers

        if self.HEADER_RESPONSE_ID_UPPER_CASED in headers:
            return headers[self.HEADER_RESPONSE_ID_UPPER_CASED]

        if self.HEADER_RESPONSE_ID_LOWER_CASED in headers:
            return headers[self.HEADER_RESPONSE_ID_LOWER_CASED]

        return self._ERROR_COULD_NOT_DETERMINE_RESPONSE_ID_HEADER;
1191220
def get(self, id):
        
        data = self.db.get_data(self.get_path, id=id)
        return self._build_item(**data['Data'][self.name])
1071839
def find_by_id(self, story, params={}, **options): 
        
        path = "/stories/%s" % (story)
        return self.client.get(path, params, **options)
143331
def get_async_response(response_id):
    
    response = DYNAMODB_CLIENT.get_item(
        TableName=ASYNC_RESPONSE_TABLE,
        Key={'id': {'S': str(response_id)}}
    )
    if 'Item' not in response:
        return None

    return {
        'status': response['Item']['async_status']['S'],
        'response': json.loads(response['Item']['async_response']['S']),
    }
595223
def get(cls, id):
        '''
        
        '''
        client = cls._new_api_client()
        return client.make_request(cls, 'get', url_params={'id': id})
811570
def get(self, id=None):
        
        if id is None:
            res = self._get('department/list')
        else:
            res = self._get('department/list', params={'id': id})
        return res['department']