Python requests.post函数代码示例

    def worker(self):
        if not ENDPOINT:
            return
        while True:
            datapack = {'sensors': {}}

            for sensor in Sensor.get_all():
                data = {}
                for variant in sensor.get_variants():
                    data[variant] = sensor.value(variant)
                datapack['sensors'][sensor.id] = data

            gevent.sleep(3)
            url = ENDPOINT % ajenti.config.tree.installation_id

            if not self.get_key():
                continue

            try:
                requests.post(url, data={
                    'data': json.dumps(datapack),
                    'key': self.get_key()
                })
                self.last_report = datetime.now()
                self.last_error = None
            except Exception, e:
                self.last_error = e

def test_Anrufer_sperren_in_web():
    u = inte_testutils.TestUtil()
    u.unblock_callerid(TelephoneNumber('0790000003'))

    assert not u.is_blocked_callerid(TelephoneNumber('0790000003'))
    requests.post('http://localhost/block_caller', data={'telephone_number': '0790000003'})
    assert u.is_blocked_callerid(TelephoneNumber('0790000003'))

    def test_api_fire_event_with_invalid_json(self):
        """Test if the API allows us to fire an event."""
        test_value = []

        def listener(event):
            """Helper method that will verify our event got called."""
            test_value.append(1)

        hass.bus.listen_once("test_event_bad_data", listener)

        req = requests.post(
            _url(const.URL_API_EVENTS_EVENT.format("test_event_bad_data")),
            data=json.dumps('not an object'),
            headers=HA_HEADERS)

        hass.pool.block_till_done()

        self.assertEqual(400, req.status_code)
        self.assertEqual(0, len(test_value))

        # Try now with valid but unusable JSON
        req = requests.post(
            _url(const.URL_API_EVENTS_EVENT.format("test_event_bad_data")),
            data=json.dumps([1, 2, 3]),
            headers=HA_HEADERS)

        hass.pool.block_till_done()

        self.assertEqual(400, req.status_code)
        self.assertEqual(0, len(test_value))

    def csv_upload(self, filename, operation):
        # create the request url for init.
        rest_url_pre = 'https://' + self.iba_host + '/wapi/v' + self.iba_wapi_version

        try:
            init_url = rest_url_pre + '/fileop?_function=uploadinit'
            # send request to the server to establish the object, with token and url.
            r = requests.post(url=init_url, auth=(self.iba_user, self.iba_password), verify=self.iba_verify_ssl)
            r_json = r.json()

            # need to do escaping or we will have issues when it's sent to the requests.post
            token = r_json['token'].encode('unicode-escape')
            req_url = r_json['url']
            files = {'file': (filename, open(filename, 'rb')) }
            file_r = requests.post(url=req_url, auth=(self.iba_user, self.iba_password), verify=self.iba_verify_ssl, files=files)

            # Use the token to tell the server to process the file as a csv_import
            csv_url = rest_url_pre + '/fileop?_function=csv_import'
            payload = '{ "token": "' + token + '", "operation": "' + operation + '" }'
            requests.post(url=csv_url, auth=(self.iba_user, self.iba_password), verify=self.iba_verify_ssl, data=payload)

        except ValueError:
            raise Exception(r)
        except Exception:
            raise

 def merge_kitchens_improved(self, from_kitchen, to_kitchen, resolved_conflicts=None):
     """
     merges kitchens
     '/v2/kitchen/merge/<string:kitchenname>/<string:kitchenname>', methods=['POST']
     :param resolved_conflicts:
     :param self: DKCloudAPI
     :param from_kitchen: string
     :param to_kitchen: string
     :rtype: dict
     """
     rc = DKReturnCode()
     if from_kitchen is None or isinstance(from_kitchen, basestring) is False:
         rc.set(rc.DK_FAIL, 'issue with from kitchen')
         return rc
     if to_kitchen is None or isinstance(to_kitchen, basestring) is False:
         rc.set(rc.DK_FAIL, 'issue with to kitchen')
         return rc
     url = '%s/v2/kitchen/merge/%s/%s' % (self.get_url_for_direct_rest_call(), from_kitchen, to_kitchen)
     try:
         if resolved_conflicts is not None and len(resolved_conflicts) > 0:
             data = dict()
             data['resolved_conflicts'] = resolved_conflicts
             response = requests.post(url, data=json.dumps(data), headers=self._get_common_headers())
         else:
             response = requests.post(url, headers=self._get_common_headers())
         rdict = self._get_json(response)
     except (RequestException, ValueError, TypeError), c:
         rc.set("merge_kitchens: exception: %s" % str(c))
         return rc

    def upload(self, path):
        """
        Uploads a file to the current folder. Takes a file location as an
        argument, either relative or absolute. If a file of the same name is
        already in the current folder, a new version is uploaded.

        Returns True if file upload is successful, False otherwise.
        """
        parent_id = self.current_folder.get('id')
        item_id = None
        filename = path.split('/')[-1]
        for entry in self.current_folder.get('item_collection').get('entries'):
            if (entry.get('name') == filename and entry.get('type') == 'file'):
                item_id = entry.get('id')
                break
        if (item_id == None):
            f = requests.post('https://upload.box.com/api/2.0/files/content', 
                headers = { 'Authorization': 'Bearer ' + self.token }, 
                data = { 'filename': filename, 'parent_id':parent_id }, 
                files = { filename: open(path, 'rb')})
        else:
            f = requests.post('https://upload.box.com/api/2.0/files/' + 
                item_id + '/content', headers = { 'Authorization': 'Bearer ' + 
                self.token }, data = { 'filename': filename }, files = { 
                filename: open(path, 'rb')})
        if (f.status_code == 409):
            print "File upload caused a conflict"
            return False
        elif (f.status_code != 201):
            print "Problem uploading the file"
            return False
        else:
            print "File uploaded"
            return True

	def post_to_slack(self, file_name, file_content, bot_callback=None, title=None):
		slack = getSecrets('slack')

		data = {
			'token' : slack['api_token'],
			'title' : "i deepdreamed..." if title is None else title,
			'channels' : slack['channel_id']
		}

		try:
			r = requests.post("https://slack.com/api/files.upload", data=data, files={ 'file' : file_content})
			res = json.loads(r.content)

			if not res['ok']:
				return False

			if bot_callback is not None:
				r = requests.post(slack['webhook_url'], data={'payload' : json.dumps({ 'text' : bot_callback })})
				print r.content

			return True

		except Exception as e:
			print e, type(e)

		return False

    def test_diff(self):
        r = requests.post(self.url("/test_diff?edit"), data={
            "body": "# test diff\n\n"
        })
        self.assertGreaterEqual(r.status_code, 200)
        self.assertLess(r.status_code, 300)

        r = requests.post(self.url("/test_diff?edit"), data={
            "body": "# test diff\n\nadd an newline here \n"
        })
        self.assertGreaterEqual(r.status_code, 200)
        self.assertLess(r.status_code, 300)

        r = requests.get(self.url("/test_diff?history"))
        self.assertRegexpMatches(r.text, r'<a href="\?version=[0-9a-f]{40}">')

        version_re = re.compile(r'<a href="\?version=([0-9a-f]{40})">')
        versions = version_re.findall(r.text)

        self.assertEqual(len(versions), 2)

        r = requests.get(self.url("/test_diff?diff=%s,%s" % (versions[0], versions[1])))
        self.assertGreaterEqual(r.status_code, 200)
        self.assertLess(r.status_code, 300)
        self.assertIn(r'Diff for file from %s to %s' % (versions[0], versions[1]), r.text)

        r = requests.get(self.url("/test_diff?diff=%s,%s" % (versions[0][:13], versions[1][:13])))
        self.assertGreaterEqual(r.status_code, 200)
        self.assertLess(r.status_code, 300)
        self.assertIn(r'Diff for file from %s to %s' % (versions[0][:13], versions[1][:13]), r.text)

        r = requests.get(self.url("/test_diff?diff=%syyyy,xxxx%s" % (versions[0][:13], versions[1][:13])))
        self.assertGreaterEqual(r.status_code, 400)
        self.assertLess(r.status_code, 500)

    def test_file_dir_with_same_name(self):
        text = u"file a content"
        r = requests.post(self.url("a?edit"), data={
            "body": text
        })
        self.assertIn(text, r.text)
        self.assertIn("strapdown.min.js", r.text)

        text2 = "does not matter"
        r = requests.post(self.url("a/b?edit"), data={
            "body": text2
        })
        self.assertIn(text2, r.text)
        self.assertIn("strapdown.min.js", r.text)

        # should be the file
        r = requests.get(self.url("a"))
        self.assertIn(text, r.text)
        self.assertGreaterEqual(r.status_code, 200)
        self.assertLess(r.status_code, 300)

        # should be the directory
        r = requests.get(self.url("a/"))
        self.assertNotIn(text, r.text)
        self.assertGreaterEqual(r.status_code, 200)
        self.assertLess(r.status_code, 300)
        self.assertIn('Directory Listing', r.text)
        self.assertIn('b.md', r.text)

        # should be file b
        r = requests.get(self.url("a/b"))
        self.assertIn(text2, r.text)
        self.assertGreaterEqual(r.status_code, 200)
        self.assertLess(r.status_code, 300)

 def send_mail(self, request):
     fn = self.cleaned_data['firstname']
     ln = self.cleaned_data['lastname']
     subj = self.cleaned_data['subject']
     fr = self.cleaned_data['email']
     msg = self.cleaned_data['message']
     try:
         requests.post(
             "https://api.mailgun.net/v2/neumerance.mailgun.org/messages",
             auth= ("api", "key-85jxyi84br32xu0cizfihmmbbxv576j5"),
             data={
                   "from":fr,
                   "to": ["[email protected]",],
                   "subject": subj,
                   "text": msg
             }
          )
         messages.info(request, 
                       "Thank you for sending me your feedback, I will get back to you as soon as possible.",
                       extra_tags="success"
                       )
     except:
         messages.info(request, 
                       "Unable to send your message at this time, Please try again later.",
                       extra_tags="error"
                       )

    def test_save_option(self):
        data = {"Title": "title", "Toc": "false", "HeadingNumber": "i.a.a.i"}
        # dir does not exists
        r = requests.post(self.url("test") + "/test_dir_not_exists?option", data=json.dumps(data))
        self.assertEqual(r.status_code, 400)
        self.assertEqual(json.loads(r.content), {"code": 1})

        # missing Title field
        r = requests.post(self.url("test.md") + "?option", data=json.dumps({"Toc": "false", "HeadingNumber": "i.a.a.i"}))
        self.assertEqual(r.status_code, 400)
        self.assertEqual(json.loads(r.content), {"code": 1})

        # Toc show be either `true` or `false`
        r = requests.post(self.url("test.md") + "?option", data=json.dumps({"Title": "test", "Toc": "falsexxx", "HeadingNumber": "i.a.a.i"}))
        self.assertEqual(r.status_code, 400)
        self.assertEqual(json.loads(r.content), {"code": 1})

        # HeadingNumber format shoule be `i.a.a.i`
        r = requests.post(self.url("test.md") + "?option", data=json.dumps({"Title": "test", "Toc": "false", "HeadingNumber": "i.a.a.iiii"}))
        self.assertEqual(r.status_code, 400)
        self.assertEqual(json.loads(r.content), {"code": 1})

        # succeeded
        r = requests.post(self.url("test1xxx") + "?option", data=json.dumps({"Title": "test", "Toc": "false", "HeadingNumber": "i.a.a.i"}))
        self.assertEqual(r.status_code, 200)
        self.assertEqual(r.headers["Content-Type"], "application/json")
        self.assertEqual(json.loads(r.content), {"code": 0})
        self.assertEqual(json.loads(open(self.cwd + "/test1xxx.md.option.json", "r").read()), {"Title": "test", "Toc": "false", "HeadingNumber": "i.a.a.i", "Theme": "", "Host": ""})

def analyze(result_directory=None, upload=False, compute_cheapest=0, compute_average_per_day=False, compute_average_per_trip_length=False, compute_average_per_days_in_advance=False):
    data, meta_data = read_results(result_directory)

    result = []

    result.append("Leaving from %s going to %s" % (meta_data['from'], meta_data['to']))
    result.append("Size of date range: %s (days)" % meta_data['window_size'])
    result.append("Minimum trip length: %s (days)" % meta_data['min_trip'])
    result.append("Maximum trip length: %s (days)" % meta_data['max_trip'])

    if compute_cheapest:
        result.extend(get_cheapest(data, compute_cheapest))

    if compute_average_per_day:
        result.extend(get_average_per_day(data))

    if compute_average_per_trip_length:
        result.extend(get_average_per_trip_length(data))

    if compute_average_per_days_in_advance:
        result.extend(get_average_per_days_in_advance(data))

    if upload:
        upload_url = settings.DEBUG_UPLOAD_URL if settings.DEBUG else settings.UPLOAD_URL
        requests.post(upload_url, data={'content': json.dumps(result)})

    print "\n".join(result)

def verify_signature(engine, signature, remote, payload, concurrency):
  if concurrency > 1:
    busy_process = subprocess.Popen([engine], stdin=subprocess.PIPE, stdout=subprocess.PIPE)
    busy_process.stdin.write('setoption name Threads value %d\n' % (concurrency-1))
    busy_process.stdin.write('go infinite\n')

  try:
    bench_sig = ''
    print 'Verifying signature of %s ...' % (os.path.basename(engine))
    with open(os.devnull, 'wb') as f:
      p = subprocess.Popen([engine, 'bench'], stderr=subprocess.PIPE, stdout=f, universal_newlines=True)
    for line in iter(p.stderr.readline,''):
      if 'Nodes searched' in line:
        bench_sig = line.split(': ')[1].strip()
      if 'Nodes/second' in line:
        bench_nps = float(line.split(': ')[1].strip())

    p.wait()
    if p.returncode != 0:
      raise Exception('Bench exited with non-zero code %d' % (p.returncode))

    if int(bench_sig) != int(signature):
      requests.post(remote + '/api/stop_run', data=json.dumps(payload))
      raise Exception('Wrong bench in %s Expected: %s Got: %s' % (engine, signature, bench_sig))

  finally:
    if concurrency > 1:
      busy_process.stdin.write('quit\n')
      busy_process.kill()

  return bench_nps

    def setUp(self):
        """
        # Create a db
        """
        headers = {'Content-Type': 'application/json; charset=utf-8'}
        db_data = {'name': 'testDB'}
        response = requests.post(__db_url__, json=db_data, headers=headers)
        if response.status_code == 201:
            self.assertEqual(response.status_code, 201)
        else:
            self.assertEqual(response.status_code, 404)
        # Create a server
        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/servers/' % \
                (__host_or_ip__,last_db_id)

            data = {'description': 'test', 'hostname': __host_or_ip__, 'name': 'test'}
            response = requests.post(url, json=data, headers=headers)
            if response.status_code == 201:
                self.assertEqual(response.status_code, 201)
            else:
                self.assertEqual(response.status_code, 404)
        else:
            print "The database list is empty"

def getTrackIDs(performer):
	r = requests.post('http://muzis.ru/api/search.api', data = {'q_performer':performer})
	artId = json.loads(r.text)["performers"][0]["id"]
	r = requests.post('http://muzis.ru/api/get_songs_by_performer.api', data = {'performer_id':artId,'type':'3'})
	listOfSongs = json.loads(r.text)['songs']
	#a = [x["file_mp3"] for x in listOfSongs]
	return(listOfSongs[:5])