Python WebUtils.get_json方法代码示例

# 需要导入模块: from web_utils import WebUtils [as 别名]
# 或者: from web_utils.WebUtils import get_json [as 别名]
    def perform_transcription(self,
                              api_token,
                              job_id,
                              fidelity,
                              priority=None,
                              callback_url=None,
                              turnaround_hours=None,
                              target_language=None,
                              options=None):
        self.__assert_argument(fidelity, 'Fidelity')
        query_dict = self.__init_job_req_dict(api_token, job_id)
        query_dict['transcription_fidelity'] = fidelity
        if priority:
            query_dict['priority'] = priority
        if callback_url:
            query_dict['callback_url'] = callback_url
        if turnaround_hours:
            query_dict['turnaround_hours'] = turnaround_hours
        if target_language:
            query_dict['target_language'] = target_language
        if options:
            query_dict['options'] = json.dumps(options.get_dict())

        response = WebUtils.get_json(self.base_url, self.PERFORM_TRANSCRIPTION, 'GET', WebUtils.BASIC_TIMEOUT, query_dict)
        return response['TaskId']

# 需要导入模块: from web_utils import WebUtils [as 别名]
# 或者: from web_utils.WebUtils import get_json [as 别名]
 def add_media_to_job_file(self, api_token, job_id, media_file):
     self.__assert_argument(media_file, 'Media File')
     query_dict = self.__init_job_req_dict(api_token, job_id)
     file_size = fstat(media_file.fileno()).st_size
     response = WebUtils.get_json(self.base_url, self.ADD_MEDIA_TO_JOB_PATH, 'POST', WebUtils.UPLOAD_TIMEOUT,
                                  query_dict, {'Content-Type': 'video/mp4', 'Content-Length': file_size}, media_file)
     return response['TaskId']

# 需要导入模块: from web_utils import WebUtils [as 别名]
# 或者: from web_utils.WebUtils import get_json [as 别名]
    def get_element_list(self, api_token, job_id, elementlist_version=None):
        query_dict = self.__init_job_req_dict(api_token, job_id)
        if elementlist_version:
            query_dict['elementlist_version'] = elementlist_version

        response = WebUtils.get_json(self.base_url, self.GET_ELEMENT_LIST_PATH, 'GET', WebUtils.BASIC_TIMEOUT, query_dict)
        return response

# 需要导入模块: from web_utils import WebUtils [as 别名]
# 或者: from web_utils.WebUtils import get_json [as 别名]
 def generate_api_key(self, api_token, username, force_new=False):
     self.__assert_argument(username, 'Username')
     query_dict = self.__init_access_req_dict(api_token)
     query_dict['account_id'] = username
     query_dict['force_new'] = force_new
     response = WebUtils.get_json(self.base_url, self.GENERATE_API_KEY_PATH, 'GET', WebUtils.BASIC_TIMEOUT, query_dict)
     return response['ApiKey']

# 需要导入模块: from web_utils import WebUtils [as 别名]
# 或者: from web_utils.WebUtils import get_json [as 别名]
    def login(self, username, password=None, api_securekey=None, use_headers=False):
        """
        :type username: basestring
        :type password: basestring|None
        :type api_securekey: basestring|None
        :type use_headers: bool
        :rtype: basestring
        """
        self.__assert_argument(username, 'Username')
        # Password or API Secure Key must be supplied but not both
        if password is None and api_securekey is None:
            raise ValueError('Password or API Secure Key must be supplied for login.')

        query_dict = self.__init_version_dict()
        headers = dict()

        if use_headers:
            headers['x-auth-user'] = username
            if password:
                headers['x-auth-password'] = password
            if api_securekey:
                headers['x-auth-securekey'] = api_securekey
        else:
            query_dict['username'] = username
            if password:
                query_dict['password'] = password
            if api_securekey:
                query_dict['securekey'] = api_securekey

        response = WebUtils.get_json(self.base_url, self.LOGIN_PATH, 'GET', WebUtils.BASIC_TIMEOUT, query_dict, headers)
        return response['ApiToken']

# 需要导入模块: from web_utils import WebUtils [as 别名]
# 或者: from web_utils.WebUtils import get_json [as 别名]
 def delete_job(self, api_token, job_id):
     """
     :type api_token: basestring
     :type job_id: basestring
     :rtype: basestring
     """
     query_dict = self.__init_job_req_dict(api_token, job_id)
     response = WebUtils.get_json(self.base_url, self.DELETE_JOB_PATH, 'GET', WebUtils.BASIC_TIMEOUT, query_dict)
     return response['TaskId']

# 需要导入模块: from web_utils import WebUtils [as 别名]
# 或者: from web_utils.WebUtils import get_json [as 别名]
 def get_list_of_element_lists(self, api_token, job_id):
     """
     :type api_token: basestring
     :type job_id: basestring
     :rtype: list
     """
     query_dict = self.__init_job_req_dict(api_token, job_id)
     response = WebUtils.get_json(self.base_url, self.GET_LIST_OF_ELEMENT_LISTS_PATH, 'GET', WebUtils.BASIC_TIMEOUT, query_dict)
     return response

# 需要导入模块: from web_utils import WebUtils [as 别名]
# 或者: from web_utils.WebUtils import get_json [as 别名]
 def get_media(self, api_token, job_id):
     """
     :type api_token: basestring
     :type job_id: basestring
     :rtype: basestring
     """
     query_dict = self.__init_job_req_dict(api_token, job_id)
     response = WebUtils.get_json(self.base_url, self.GET_MEDIA_PATH, 'GET', WebUtils.BASIC_TIMEOUT, query_dict)
     return response['MediaUrl']

# 需要导入模块: from web_utils import WebUtils [as 别名]
# 或者: from web_utils.WebUtils import get_json [as 别名]
 def get_job_info(self, api_token, job_id):
     """
     :type api_token: basestring
     :type job_id: basestring
     :rtype: dict
     """
     query_dict = self.__init_job_req_dict(api_token, job_id)
     response = WebUtils.get_json(self.base_url, self.GET_JOB_INFO_PATH, 'GET', WebUtils.BASIC_TIMEOUT, query_dict)
     return response

# 需要导入模块: from web_utils import WebUtils [as 别名]
# 或者: from web_utils.WebUtils import get_json [as 别名]
 def get_job_list(self, api_token, options=None):
     """
     :type api_token: basestring
     :type options: JobListOptions|None
     :rtype: list
     """
     query_dict = self.__init_access_req_dict(api_token)
     if options:
         query_dict.update(options.get_dict())
     response = WebUtils.get_json(self.base_url, self.GET_JOB_LIST_PATH, 'GET', WebUtils.BASIC_TIMEOUT, query_dict)
     return response

# 需要导入模块: from web_utils import WebUtils [as 别名]
# 或者: from web_utils.WebUtils import get_json [as 别名]
    def get_element_list(self, api_token, job_id, elementlist_version=None):
        """
        :type api_token: basestring
        :type job_id: basestring
        :type elementlist_version: datetime|basestring
        :rtype: dict
        """
        query_dict = self.__init_job_req_dict(api_token, job_id)
        if elementlist_version:
            query_dict['elementlist_version'] = elementlist_version

        response = WebUtils.get_json(self.base_url, self.GET_ELEMENT_LIST_PATH, 'GET', WebUtils.BASIC_TIMEOUT, query_dict)
        return response

# 需要导入模块: from web_utils import WebUtils [as 别名]
# 或者: from web_utils.WebUtils import get_json [as 别名]
 def generate_api_key(self, api_token, sub_account=None, force_new=False):
     """
     :type api_token: basestring
     :type sub_account: basestring|None
     :type force_new: bool
     :rtype: basestring
     """
     query_dict = self.__init_access_req_dict(api_token)
     if sub_account:
         # account_id parameter named sub_account for clarity
         query_dict['account_id'] = sub_account
     query_dict['force_new'] = force_new
     response = WebUtils.get_json(self.base_url, self.GENERATE_API_KEY_PATH, 'GET', WebUtils.BASIC_TIMEOUT, query_dict)
     return response['ApiKey']

# 需要导入模块: from web_utils import WebUtils [as 别名]
# 或者: from web_utils.WebUtils import get_json [as 别名]
    def create_job(self, api_token, job_name=None, language=Language.ENGLISH, external_id=None, sub_account=None):
        query_dict = self.__init_access_req_dict(api_token)

        if job_name:
            query_dict['job_name'] = job_name
        if language:
            query_dict['language'] = language
        if external_id:
            query_dict['external_id'] = external_id
        if sub_account:
            # username parameter named sub_account for clarity
            query_dict['username'] = sub_account

        response = WebUtils.get_json(self.base_url, self.CREATE_JOB_PATH, 'GET', WebUtils.BASIC_TIMEOUT, query_dict)
        # Return a hash with JobId and TaskId
        return response

# 需要导入模块: from web_utils import WebUtils [as 别名]
# 或者: from web_utils.WebUtils import get_json [as 别名]
 def aggregate_statistics(self, api_token, metrics=None, group_by=None, start_date=None, end_date=None, sub_account=None):
     """
     :type api_token: basestring
     :type metrics: list|None
     :type group_by: basestring|None
     :type start_date: date|None
     :type end_date: date|None
     :type sub_account: basestring|None
     :rtype: dict
     """
     query_dict = self.__init_access_req_dict(api_token)
     if metrics:
         query_dict['metrics'] = json.dumps(metrics)
     if group_by:
         query_dict['group_by'] = group_by
     if start_date:
         query_dict['start_date'] = start_date.isoformat()
     if end_date:
         query_dict['end_date'] = end_date.isoformat()
     if sub_account:
         # account_id parameter named sub_account for clarity
         query_dict['account_id'] = sub_account
     response = WebUtils.get_json(self.base_url, self.AGGREGATE_STATISTICS_PATH, 'GET', WebUtils.BASIC_TIMEOUT, query_dict)
     return response

# 需要导入模块: from web_utils import WebUtils [as 别名]
# 或者: from web_utils.WebUtils import get_json [as 别名]
 def __send_media_url(self, api_token, job_id, media_url, path):
     self.__assert_argument(media_url, 'Media URL')
     query_dict = self.__init_job_req_dict(api_token, job_id)
     query_dict['media_url'] = media_url
     response = WebUtils.get_json(self.base_url, path, 'GET', WebUtils.BASIC_TIMEOUT, query_dict)
     return response['TaskId']