Get the status of a service agreement.

        :param agreement_id: id of the agreement, hex str
        :return: dict with condition status of each of the agreement's conditions or None if the
        agreement is invalid.
967445
def status(self, agreement_id):
        
        condition_ids = self._keeper.agreement_manager.get_agreement(agreement_id).condition_ids
        result = {"agreementId": agreement_id}
        conditions = dict()
        for i in condition_ids:
            conditions[self._keeper.get_condition_name_by_address(
                self._keeper.condition_manager.get_condition(
                    i).type_ref)] = self._keeper.condition_manager.get_condition_state(i)
        result["conditions"] = conditions
        return result
20587
def sharing_agreements(self):
        
        if self.api and self.sharing_agreement_ids:
            return self.api._get_sharing_agreements(self.sharing_agreement_ids)
742012
def _retrieve_problem(self, id_):
        
        future = Future(self, id_, self.return_matrix, None)
        self.client._poll(future)
        return future
383072
def show_status(self, status):
        
        statuses = self.get_statuses()
        statuses = [x for x in statuses if x['value'] == status]
        if len(statuses) == 0:
            raise Exception("Unknown status value")
        else:
            return statuses[0]
1074370
def scan_status(scan_id)
      r = execute(make_xml('ScanStatusRequest', 'scan-id' => scan_id))
      r.success ? r.attributes['status'] : nil
    end
228632
def get_status_updates(self, startup_id):
    
    return _get_request(_STATUS_U.format(c_api=_C_API_BEGINNING,
                                                             api=_API_VERSION,
                                                             startup_id=startup_id,
                                                             at=self.access_token))
1020368
def status(self, id):
        
        id = self.__unpack_id(id)
        url = '/api/v1/statuses/{0}'.format(str(id))
        return self.__api_request('GET', url)
1063363
def status_favourite(self, id):
        
        id = self.__unpack_id(id)
        url = '/api/v1/statuses/{0}/favourite'.format(str(id))
        return self.__api_request('POST', url)
985627
def lookup(self, id_list, **kw):
        
        result_id_pack = ','.join([str(_id) for _id in id_list])
        if not result_id_pack:
            return []
        return self.twitter.statuses.lookup(_id=result_id_pack)
1142135
def status_pin(self, id):
        
        id = self.__unpack_id(id)
        url = '/api/v1/statuses/{0}/pin'.format(str(id))
        return self.__api_request('POST', url)
1252927
def status_reblogged_by(self, id):
        
        id = self.__unpack_id(id)
        url = '/api/v1/statuses/{0}/reblogged_by'.format(str(id))
        return self.__api_request('GET', url)
1189078
def identify_id(id: str) -> bool:
    
    return re.match(r'^https?://', id, flags=re.IGNORECASE) is not None
435237
def status(self, reference_id, **params):
        
        return self.get(VOICE_STATUS_RESOURCE.format(reference_id=reference_id),
                        **params)
638125
def get_service_agreements(storage_path, status='pending'):
    
    conn = sqlite3.connect(storage_path)
    try:
        cursor = conn.cursor()
        return [
            row for row in
            cursor.execute(
                '''
                SELECT id, did, service_definition_id, price, files, start_time, status
                FROM service_agreements 
                WHERE status=?;
                ''',
                (status,))
        ]
    finally:
        conn.close()
399200
def get_language_model_status(self, model_id, token=None, url=API_TRAIN_LANGUAGE_MODEL):
        
        auth = 'Bearer ' + self.check_for_token(token)        
        h = {'Authorization': auth, 'Cache-Control':'no-cache'}
        the_url = url + '/' + model_id
        r = requests.get(the_url, headers=h)

        return r
1290218
def get_statuses(self, batch_ids):
        
        with self._lock:
            return {b: self.get_status(b) for b in batch_ids}
268999
def get_job_status(self, job_id):
        
        response = self._client.describe_jobs(jobs=[job_id])

        # Error checking
        status_code = response['ResponseMetadata']['HTTPStatusCode']
        if status_code != 200:
            msg = 'Job status request received status code {0}:\n{1}'
            raise Exception(msg.format(status_code, response))

        return response['jobs'][0]['status']