Пример #1
0
 def urls(self, player_id, option=None, url_id=None, param_dict=None):
     """
     Used to interact with the /players/:id/urls/ endpoint
     """
     path = self.base_url + player_id + '/urls/'
     if option:
         if option.upper() == "NEW":
             # Option 'new' means create a new player URL
             required_params = [
                 'url', 'bitrate'
             ]
             for param in required_params:
                 if param not in param_dict:
                     raise MissingParameter({
                         'message': 'Missing [{}] parameter from parameter \
                         dictionary.'
                     })
             param_dict = {
                 'url': param_dict
             }
             response = session.post(path, data=json.dumps(param_dict), headers=self.headers)
         elif url_id and not option:
             # No option + URL ID = GET on that URL by ID
             response = session.get(path, headers=self.headers)
         elif option.upper() == 'delete'.upper(): # DELETE is a keyword
             if not url_id:
                 raise MissingParameter({
                     'message': 'URL_ID needs to be provided when deleting a player URL.'
                 })
             path = path + url_id
             response = session.delete(path, headers=self.headers)
             return response
         elif option.upper() == 'update'.upper(): # UPDATE is a keyword
             missing_params = [
                 'URL ID' if not url_id else None,
                 'Parameter Dictionary' if not param_dict else None
             ]
             while None in missing_params:
                 missing_params.remove(None)
             if missing_params:
                 raise MissingParameter({
                     'message': '{} needs to be provided when updating a player URL.'\
                         .format(missing_params)
                 })
             path = path + url_id
             param_dict = {
                 'url': param_dict
             }
             response = session.patch(path, json.dumps(param_dict),headers=self.headers)
     else:
         if url_id:
             path = path + url_id
         response = session.get(path, headers=self.headers)
     return response.json()
Пример #2
0
 def create(self, param_dict):
     """
     Used to create a new live stream.
     Valid parameters:
         name, transcoder_type, billing_mode, broadcast_location,
         encoder, delivery_method, aspect_ratio_width, aspect_ratio_height
     """
     required_params = [
         'name', 'broadcast_location', 'encoder',
         'aspect_ratio_height', 'aspect_ratio_width'
     ]
     for key in required_params:
         if key not in param_dict:
             raise MissingParameter({
                 'message': 'Missing parameter [{}]. Cannot create \
                  live stream.'.format(key)
             })
     param_dict = {
         'live_stream': param_dict
     }
     path = self.base_url + 'live_streams/'
     response = session.post(
         path,
         json.dumps(param_dict),
         headers=self.headers
     )
     return response.json()
Пример #3
0
 def info(self, sched_id=None, option=None):
     """
     Used to get information on all schedules or a particular schedule.
     Can also be used to get the state of a particular schedule.
     """
     path = self.base_url
     path = path + sched_id if sched_id else path
     if option:
         if not sched_id:
             raise MissingParameter({
                 'message': 'Need schedule ID if getting the state of a schedule.'
             })
         path = path + "/state"
     response = session.get(path, headers=self.headers)
     return response.json()
Пример #4
0
 def info(self, rec_id=None, option=None):
     """
     Used to get information on all recordings or on one recording
     """
     path = self.base_url + rec_id if rec_id else self.base_url
     if option and option == 'state':
         if rec_id:
             path = path + '/state'
         else:
             raise MissingParameter({
                 'message': 'Recording ID needs to be provided when \
                 getting the state of a recording.'
             })
     response = session.get(path, headers=self.headers)
     return response.json()
Пример #5
0
 def create(self, param_dict):
     """
     Used to create a transcoder.
     """
     path = self.base_url
     for parameter in ['name', 'transcoder_type', 'billing_mode',
         'broadcast_location', 'protocol', 'delivery_method']:
         if parameter not in param_dict:
             raise MissingParameter({
                 'message': 'Parameter [{}] missing from the parameter \
                 dictionary.'.format(parameter)
             })
     param_dict = {
         'transcoder': param_dict
     }
     response = session.post(path, json.dumps(param_dict), headers=self.headers)
     return response.json()
Пример #6
0
 def update(self, player_id, param_dict):
     """
     Used to update parameters on a given player
     """
     missing_params = [
         'Player ID' if not player_id else None,
         'Parameter Dictionary' if not param_dict else None
     ]
     while None in missing_params:
         missing_params.remove(None)
     if missing_params:
         raise MissingParameter(
             {'message': 'Missing {}.'.format(missing_params)})
     param_dict = {'player': param_dict}
     path = "{}{}".format(self.base_url, player_id)
     response = session.patch(path,
                              json.dumps(param_dict),
                              headers=self.headers)
     return response.json()
Пример #7
0
 def info(self, tran_id=None, option=None, uptime_id=None):
     """
     Get information on all transcoders or a specific transcoder
     Valid options: recordings, schedules, state, stats, thumbnail_url
     """
     path = self.base_url + tran_id if tran_id else self.base_url
     valid_options = [
         'recordings', 'schedules', 'state',
         'stats', 'thumbnail_url'
     ]
     if option:
         if not tran_id:
             raise MissingParameter({
                 'message': 'Transcoder ID is also needed when passing in an \
                 option'
             })
         if option not in valid_options:
             raise InvalidParameter({
                 'message': 'Option provided is invalid. Valid options are: {}'\
                     .format(valid_options)
             })
         path = path + option
     response = session.get(path, headers=self.headers)
     return response.json()