Python requests.put函数代码示例

def add_attribute(columns):
    u = 'https://api.parse.com/1/classes/Attribute'
    attrs_request = requests.get(u, data={
        'limit': 500,
    }, headers={
        "X-Parse-Application-Id": keys.PARSE_APP_ID,
        "X-Parse-REST-API-Key": keys.PARSE_REST_KEY
    })

    attribute_records = attrs_request.json()['results']

    print 'Agregando a todos los registros'

    for a in attribute_records:
        columns_dict = {}
        for column in columns:
            if a.get(column) is None:
                print "Agregar columna: ", column
                columns_dict[column] = False

        uu = 'https://api.parse.com/1/classes/Attribute/%s' % a.get('objectId')
        requests.put(uu, data=json.dumps(columns_dict), headers={
            "X-Parse-Application-Id": keys.PARSE_APP_ID,
            "X-Parse-REST-API-Key": keys.PARSE_REST_KEY,
            'Content-type': 'application/json'
        })

    print "Atributos agregados"

    def test_start_stop_server_with_different_ports(self):
        """
        ensure Start and stop server is working properly using ports other than default ports
        """
        response = requests.get(__db_url__)
        value = response.json()
        if value:
            db_length = len(value['databases'])
            last_db_id = value['databases'][db_length-1]['id']

            url = 'http://%s:8000/api/1.0/databases/%u/start' % \
                (__host_or_ip__,last_db_id)

            response = requests.put(url)
            print "Starting...."
            value = response.json()
            if not value['statusstring']:
                print "error"
            elif "Start request sent successfully to servers" in value['statusstring']:
                self.assertEqual(response.status_code, 200)
                time.sleep(5)
                CheckServerStatus(self, last_db_id, 'running')
                time.sleep(10)
                print "Stopping...."
                url_stop = 'http://%s:8000/api/1.0/databases/%u/stop' % \
                (__host_or_ip__,last_db_id)
                response = requests.put(url_stop)
                value = response.json()
                if "Connection broken" in value['statusstring']:
                    self.assertEqual(response.status_code, 200)
                    time.sleep(10)
                    CheckServerStatus(self, last_db_id, 'stopped')
            elif response.status_code == 500:
                self.assertEqual(response.status_code, 500)

def demo_store_secret_two_step_binary():
    """Store secret (2-step):"""
    secret = 'bXktc2VjcmV0LWhlcmU='  # base64 of 'my secret'
    ep_2step = '/'.join([end_point, version, 'secrets'])

    # POST metadata:
    payload = {}
    pr = requests.post(ep_2step, data=json.dumps(payload), headers=hdrs)
    pr_j = pr.json()
    secret_ref = pr_j.get('secret_ref')
    assert secret_ref

    # PUT data to store:
    hdrs_put = dict(hdrs)
    hdrs_put.update({
        'content-type': 'application/octet-stream',
        'content-encoding': 'base64'}
    )
    requests.put(secret_ref, data=secret, headers=hdrs_put)

    # GET secret:
    hdrs_get = dict(hdrs)
    hdrs_get.update({
        'accept': 'application/octet-stream'})
    gr = requests.get(secret_ref, headers=hdrs_get)
    LOG.info('Get secret 2-step (binary): {0}\n'.format(gr.content))

    return secret_ref

def update_article(article, checked_urls):

    article_id = article["article_id"]

    oauth_token = g.user.oauth_token
    oauth_token_secret = g.user.oauth_token_secret

    oauth = OAuth1(
        client_key,
        client_secret=client_secret,
        resource_owner_key=oauth_token,
        resource_owner_secret=oauth_token_secret,
    )

    processed_urls = []
    for k, u in checked_urls.items():
        if u["uri"] in processed_urls:
            continue

        processed_urls.append(u["uri"])

        body = {"link": u["web"]}
        headers = {"content-type": "application/json"}

        response = requests.put(
            "http://api.figshare.com/v1/my_data/articles/{}/links".format(article_id),
            data=json.dumps(body),
            headers=headers,
            auth=oauth,
        )
        results = json.loads(response.content)
        app.logger.debug("Added {} with the following results:\n{}".format(u["uri"], results))

    app.logger.debug("Tag with Linkitup")
    body = {"tag_name": "Enriched with Linkitup"}
    headers = {"content-type": "application/json"}

    response = requests.put(
        "http://api.figshare.com/v1/my_data/articles/{}/tags".format(article_id),
        data=json.dumps(body),
        headers=headers,
        auth=oauth,
    )

    app.logger.debug("Add a link to Linkitup")
    body = {"link": "http://linkitup.data2semantics.org"}
    headers = {"content-type": "application/json"}

    response = requests.put(
        "http://api.figshare.com/v1/my_data/articles/{}/links".format(article_id),
        data=json.dumps(body),
        headers=headers,
        auth=oauth,
    )

    app.logger.debug("Added enriched with Linkitup tag")

    publish_nanopublication(article, checked_urls, oauth)

    return

 def commit_file_code(self, file_name, obj_details):
     file_content = open(file_name).read()
     self.commit_response = {}
     self.email = obj_details.get("EMAIL")
     params = {}
     content_encoded = base64.b64encode(file_content)
     params['message'] = file_name + " created"
     params['content'] = content_encoded
     params['branch'] = "abap"
     params['path'] = file_name
     params['committer'] = {'name': "1", 'email': self.email}
     url = settings.CONFIG_GITHUB_URL + file_name
     self.check_sleep_and_set_api_count()
     request_status = requests.put(url, auth=(settings.GIT_USERNAME, settings.GIT_PASSWORD), data=json.dumps(params))
     if request_status.status_code == 201:
         self.commit_response = request_status.json()
     elif request_status.status_code == 422:
         new_params = {}
         new_params['ref'] = 'abap'
         new_params['path'] = file_name
         self.check_sleep_and_set_api_count()
         get_file = requests.get(url, auth=(settings.GIT_USERNAME, settings.GIT_PASSWORD), params=new_params).json()
         new_checksum = githash(open(file_name).read())
         if new_checksum != get_file['sha']:
             params['sha'] = get_file['sha']
             params['message'] = file_name + " updated"
             self.check_sleep_and_set_api_count()
             request_status = requests.put(url, auth=(settings.GIT_USERNAME, settings.GIT_PASSWORD), data=json.dumps(params))
             self.commit_response = request_status.json()
     self.log_to_db()

  def upload(filepath):
    # http://api.smugmug.com/services/api/?method=upload&version=1.3.0
    fstat = os.stat(filepath)
    filename = os.path.basename(filepath)
    hash_md5 = hashlib.md5()
    with open(filepath, 'rb') as f:
        for chunk in iter(lambda: f.read(4096), b""):
            hash_md5.update(chunk)
    file_md5 = hash_md5.hexdigest()
 
    params = {
      filenameSize: fstat.ST_SIZE,
      filenameMD5: file_md5,
      'X-Smug-AlbumID': None,
      'X-Smug-Caption': None,
      'X-Smug-Pretty': true,
      'X-Smug-SessionID': None,
      'X-Smug-Version': '1.3.0'
    }
    requests.put('http://upload.smugmug.com/test.jpg')

    payload['APIKey'] = key
    payload['Pretty'] = True
    payload['method'] = method
    #payload['SessionID'] = secret
    #payload = { 'APIKey': 
    req = requests.get(url, params=payload)
    #print "fetched url: %s" % req.url
    return req.json()

 def editProfile(self,gender,bio,website,name,location,username,email,birthday):
     #gender syntax: 0 = male, 1 = female
     #birthday syntax: 1990-02-01 (Y-M-D)
     payload = {
         "user[gender]": gender,
         "user[bio]" : bio,
         "user[website]" : website,
         "user[name]" : name,
         "user[location]" : location,
         "user[username]" : username,
         "user[email]" : email,
         "user[birthday]" : birthday + "T05:00:00Z"
     }
     
     headers = {
         "accept" : "application/json",
         "accept-language" : "en",
         "connection" : "keep-alive",
         "x-user-authentication-token" : self.authToken,
         "x-client-version" : self.clientVersion,
         "x-device-id" : self.deviceId,
         "user-agent" : self.useragent
     }
     if self.proxies == None:
         r = requests.put(self.base + "/users/" + self.info['_id'],headers=headers,data=payload)
     else:
         r = requests.put(self.base + "/users/" + self.info['_id'],headers=headers,data=payload,proxies=self.proxies)
     
     if r.status_code == requests.codes.ok:
         edit_response = r.text
         tmpinfo = json.loads(edit_response.decode('utf8'))
         self.info = tmpinfo
         return True
     else:
         return False

def put_mapping(mapping_dict):
    for index in mapping_dict:
        if not index.startswith('_'):
            # create the index first
            i = config['ELASTIC_SEARCH_HOST']
            i += '/' + index
            ri = requests.put(i)
            if ri.status_code != 200:
                print 'Failed to create Index:', index, ', HTTP Response:', ri.status_code
                print ri.text
                sys.exit(3)
            # now create each type inside the index
            for key, mapping in mapping_dict[index]['mappings'].iteritems():
                im = i + '/' + key + '/_mapping'
                exists = requests.get(im)
                # do not overwrite existing mappings
                if exists.status_code != 200:
                    themapping = {}
                    themapping[key] = mapping
                    r = requests.put(im, json.dumps(themapping))
                    if r.status_code != 200:
                        print 'Failed to do PUT mapping for Index:', index, ', Key:', key, ', HTTP Response:', r.status_code
                        sys.exit(4)
                    else:
                        print 'Mapping OK for Index:', index, ', Key:', key, ', HTTP Response:', r.status_code
                else:
                    print 'Mapping already exists for Index:', index, ', Key:', key
        else:
            print 'Ignoring {0}, no index names start with _'.format(index)

def updateLSPs(linkPathDict, linkDict):
    if len(linkPathDict) == 0:
        return
    r = requests.get('https://10.10.2.25:8443/NorthStar/API/v1/tenant/1/topology/1/te-lsps/', headers=authHeader,
                     verify=False)
    lsp_list = json.loads(json.dumps(r.json()))

    new_lsps = []
    for lsp in lsp_list:
        if lsp['name'] not in linkPathDict:
            continue
        # Fill only the required fields
        ero = []
        path = linkPathDict[lsp['name']]
        for i in range(0, len(path) - 1):
            ero.append({'topoObjectType': 'ipv4', 'address': getZNodeIpAddress(path[i], path[i + 1], linkDict)})

        new_lsp = {}
        for key in ('from', 'to', 'name', 'lspIndex', 'pathType'):
            new_lsp[key] = lsp[key]

        new_lsp['plannedProperties'] = {'ero': ero}
        new_lsps.append(new_lsp)

    requests.put('https://10.10.2.25:8443/NorthStar/API/v1/tenant/1/topology/1/te-lsps/bulk',
                 json=new_lsps, headers=authHeader, verify=False)

    def _push_metadata_software_deployments(
            self, cnxt, server_id, stack_user_project_id):
        rs = db_api.resource_get_by_physical_resource_id(cnxt, server_id)
        if not rs:
            return
        deployments = self.metadata_software_deployments(cnxt, server_id)
        md = rs.rsrc_metadata or {}
        md['deployments'] = deployments
        rows_updated = db_api.resource_update(
            cnxt, rs.id, {'rsrc_metadata': md}, rs.atomic_key)
        if not rows_updated:
            action = "deployments of server %s" % server_id
            raise exception.ConcurrentTransaction(action=action)

        metadata_put_url = None
        metadata_queue_id = None
        for rd in rs.data:
            if rd.key == 'metadata_put_url':
                metadata_put_url = rd.value
            if rd.key == 'metadata_queue_id':
                metadata_queue_id = rd.value
        if metadata_put_url:
            json_md = jsonutils.dumps(md)
            requests.put(metadata_put_url, json_md)
        if metadata_queue_id:
            project = stack_user_project_id
            token = self._get_user_token(cnxt, rs, project)
            zaqar_plugin = cnxt.clients.client_plugin('zaqar')
            zaqar = zaqar_plugin.create_for_tenant(project, token)
            queue = zaqar.queue(metadata_queue_id)
            queue.post({'body': md, 'ttl': zaqar_plugin.DEFAULT_TTL})

    def move_card(self, card, list):
        """ Moves a card to a new list """
        # TODO this doesn't work
        url = BASE_URL + 'cards/' + card['id'] + '/idList'
        params = self.request_params({'value': list['id']})

        requests.put(url, params=params)

def putRequest(queue, payload=None):
    response = {}
    statusCode = {}
    data = {}
    while not queue.empty():
        resourceURI = queue.get(timeout=1)
        response["Node"] = resourceURI
        try:
            if payload is None:
                r = requests.put(resourceURI, timeout=20)
            else:
                r = requests.put(resourceURI, data=payload, timeout=20)
            if r.headers["Content-Type"] == "application/json":
                data = r.json
            else:
                data = r.text
            response["StatusCode"] = r.status_code
            response["Data"] = data
        except requests.exceptions.Timeout:
            response["StatusCode"] = 408
            response["Data"] = data
        except requests.exceptions.ConnectionError:
            response["Node"] = resourceURI
            statusCode["StatusCode"] = 404
            response["Data"] = "n/a"

        GreenletRequests.NodeResponsesPost.append(response)
        print "Threaded PUT with ID " + str(GreenletRequests.npo) + " executed for " + resourceURI
        GreenletRequests.npo += 1
        gevent.sleep(0)

    def geo_locations_to_es(self):
        max_items = self.elastic.max_items_bulk
        current = 0
        bulk_json = ""

        url = self.elastic.url + "/github/geolocations/_bulk"

        logging.debug("Adding geoloc to %s (in %i packs)" % (url, max_items))


        for loc in self.geolocations:
            if current >= max_items:
                requests.put(url, data=bulk_json)
                bulk_json = ""
                current = 0

            geopoint = self.geolocations[loc]
            location = geopoint.copy()
            location["location"] = loc
            # First upload the raw issue data to ES
            data_json = json.dumps(location)
            # Don't include in URL non ascii codes
            safe_loc = str(loc.encode('ascii', 'ignore'),'ascii')
            geo_id = str("%s-%s-%s" % (location["lat"], location["lon"],
                                       safe_loc))
            bulk_json += '{"index" : {"_id" : "%s" } }\n' % (geo_id)
            bulk_json += data_json +"\n"  # Bulk document
            current += 1

        requests.put(url, data = bulk_json)

        logging.debug("Adding geoloc to ES Done")

    def put(self, file_path, environmentObj, container, environment, act_as_user):
        self.fetchUserPass(environment)
        data = open(file_path).read()
        chronos_resource = "scheduler/iso8601"
        if 'parents' in json.loads(data):
            chronos_resource = "scheduler/dependency"

        print(colored("TRIGGERING CHRONOS FRAMEWORK UPDATE FOR JOB: {}".format(container), "cyan"))
        print(colored("curl -X PUT -H 'Content-type: application/json' --data-binary @{} {}/{}".format(
            file_path, environmentObj['chronos_endpoint'], chronos_resource), "cyan"))
        endpoint = environmentObj['chronos_endpoint']
        deploy_url = "{}/{}".format(endpoint, chronos_resource)

        if not act_as_user:
            resp = requests.put(deploy_url, data=data,
                                headers={'Content-type': 'application/json'},
                                auth=(self.user, self.passw),
                                allow_redirects=True)
        else:
            resp = requests.put(deploy_url, data=data,
                                headers={'Content-type': 'application/json', 'act-as-user': act_as_user},
                                auth=(self.user, self.passw),
                                allow_redirects=True)
        chronos_message = "{}".format(resp)
        print(colored(chronos_message, "yellow"))
        task_id = []
        body = json.loads(data)
        if 'name' in body:
            task_id.append(body['name'])

        return resp, task_id

 def upload_image(self, image_id, parent_id, token):
     layer = self.gen_random_string(7 * 1024 * 1024)
     json_obj = {
         'id': image_id
     }
     if parent_id:
         json_obj['parent'] = parent_id
     json_data = json.dumps(json_obj)
     h = hashlib.sha256(json_data + '\n')
     h.update(layer)
     layer_checksum = 'sha256:{0}'.format(h.hexdigest())
     resp = requests.put('{0}/v1/images/{1}/json'.format(
         self.registry_endpoint, image_id),
         data=json_data,
         headers={'Authorization': 'Token ' + token,
                  'X-Docker-Checksum': layer_checksum},
         cookies=self.cookies)
     self.assertEqual(resp.status_code, 200, resp.text)
     self.update_cookies(resp)
     resp = requests.put('{0}/v1/images/{1}/layer'.format(
         self.registry_endpoint, image_id),
         data=self.generate_chunk(layer),
         headers={'Authorization': 'Token ' + token},
         cookies=self.cookies)
     self.assertEqual(resp.status_code, 200, resp.text)
     self.update_cookies(resp)
     return {'id': image_id, 'checksum': layer_checksum}