Python HTTPClient.fetch方法代码示例

# 需要导入模块: from tornado.httpclient import HTTPClient [as 别名]
# 或者: from tornado.httpclient.HTTPClient import fetch [as 别名]
 def get(self):
     name = self.get_argument('name','')
     if(name == "atlas"):
         with open("/var/www/atlas/access.token", 'r') as f:
             token = f.read()
             f.close()
             token = token.rstrip('\n')
             # TODO: Make this asynchronous and move access.token to aswwu/databases git repo
             http_client = HTTPClient()
             try:
                 response = http_client.fetch("https://api.instagram.com/v1/users/self/media/recent/?access_token=" + token)
                 self.write(response.body)
             except Exception as e:
                 self.write("{error: '" + str(e) + "'}")
             http_client.close()
     elif(name == "issuu"):
         http_client = HTTPClient()
         try:
             response = http_client.fetch("http://search.issuu.com/api/2_0/document?username=aswwucollegian&pageSize=1&responseParams=title,description&sortBy=epoch")
             self.write(response.body)
         except Exception as e:
             self.write("{error: '" + str(e) + "'}")
         http_client.close()
     else:
         self.write("Something went wrong.")

# 需要导入模块: from tornado.httpclient import HTTPClient [as 别名]
# 或者: from tornado.httpclient.HTTPClient import fetch [as 别名]
 def reset_results(self, access, secret, group):
     for instance in group.instances:
         try:
             http = HTTPClient()
             http.fetch('http://' + instance.public_dns_name + ':8888/reset')
         except:
             pass

# 需要导入模块: from tornado.httpclient import HTTPClient [as 别名]
# 或者: from tornado.httpclient.HTTPClient import fetch [as 别名]
    def get(self, article_id):
        logging.info("got article_id %r in uri", article_id)
        logging.info(self.request)

        url = "http://" + STP + "/blogs/articles/" + article_id
        http_client = HTTPClient()
        response = http_client.fetch(url, method="GET")
        logging.info("got _article response %r", response.body)
        _article = json_decode(response.body)
        _timestamp = _article["timestamp"]
        _datetime = timestamp_datetime(_timestamp / 1000)
        _article["timestamp"] = _datetime
        try:
            _article['accountNickname']
        except:
            _article['accountNickname'] = "anonymous"

        url = "http://" + STP + "/blogs/my-articles/" + article_id + "/paragraphs"
        http_client = HTTPClient()
        response = http_client.fetch(url, method="GET")
        logging.info("got _paragraphs response %r", response.body)
        _paragraphs = json_decode(response.body)

        self.render('blog/article-edit.html',
                article=_article,
                paragraphs=_paragraphs)

# 需要导入模块: from tornado.httpclient import HTTPClient [as 别名]
# 或者: from tornado.httpclient.HTTPClient import fetch [as 别名]
def newAuthApi(username,password):
	data = {
		'Login.Token1':username,
		'Login.Token2':password
	}
	result = {'code':200,'content':''}
	try:
		client = HTTPClient()
		request = HTTPRequest(
			url = URL,
			method='GET')
		response = client.fetch(request)
		img = Image.open(io.BytesIO(response.body))
		cookie = response.headers['Set-Cookie']
		cookieTemp = cookie.split(";")
		cookie = cookieTemp[0] + ";" + cookieTemp[1].split(",")[1]
		vercode = recognize(img)
		data['captcha'] = vercode
		request = HTTPRequest(
			url = LOGIN_URL,
			method='POST',
			body=urllib.urlencode(data),
			headers = {'Cookie':cookie},
			request_timeout=8
		)
		response = client.fetch(request)
		result['content'] = response.headers['Set-Cookie']
	except HTTPError as e:
		result['code'] = 400
	except Exception,e:
		result['code'] = 500

# 需要导入模块: from tornado.httpclient import HTTPClient [as 别名]
# 或者: from tornado.httpclient.HTTPClient import fetch [as 别名]
def main(url,downloadto):
	#url = "http://www.imagefap.com/pictures/4148883/Waiting-for-Daddy?gid=4148883&view=2"
	client = HTTPClient()
	print "Gathering links from Gallery"
	gallery_response = client.fetch(url)
	gallery_pool = BeautifulSoup(gallery_response.body)
	gallery_links = gallery_pool.findAll("a")
	for gallery_link in gallery_links:
		if "/photo" in gallery_link["href"]:
			photo_page_url = "".join(["http://imagefap.com",gallery_link["href"]])
			gallery_list.append(photo_page_url)

	print "Parsing individual pages for actual image"
	for link in gallery_list:
		photo_response = client.fetch(link)
		photo_pool = BeautifulSoup(photo_response.body)
		photo_images = photo_pool.findAll("img",src=True)
		for image in photo_images:
			if image["src"].startswith("http://fap.to"):
				image_src = image["src"]
				filename = image_src.split("/")[-1:][0]
				image_response = client.fetch(image_src)
				print "Downloading %s" % filename
				dest = "".join([downloadto,"/",filename])
				with open(dest,"wb") as f:
					f.write(image_response.body)

# 需要导入模块: from tornado.httpclient import HTTPClient [as 别名]
# 或者: from tornado.httpclient.HTTPClient import fetch [as 别名]
    def call(self, method, params, okay=None, fail=None):
        """Make an asynchronous JSON-RPC method call. """
        body = tornado.escape.json_encode({
            'jsonrpc': '2.0',
            'method': method,
            'params': params,
            'id': uuid.uuid4().hex,
        });

        logging.info("JSON-RPC: call '%s' method on %s" % (method, self.url))

        headers = HTTPHeaders({'Content-Type': 'application/json'})
        request = HTTPRequest(self.url, method='POST', body=body,
            headers=headers, request_timeout=0)

        if okay is None and fail is None:
            client = HTTPClient()
            response = client.fetch(request)

            if response.code != 200 or not response.body:
                return None

            try:
                data = tornado.escape.json_decode(response.body)
            except ValueError:
                return None
            else:
                return data
        else:
            client = AsyncHTTPClient()
            client.fetch(request, functools.partial(self._on_response, okay, fail))

# 需要导入模块: from tornado.httpclient import HTTPClient [as 别名]
# 或者: from tornado.httpclient.HTTPClient import fetch [as 别名]
class SyncHTTPClientTest(unittest.TestCase):
    def setUp(self):
        self.server_ioloop = IOLoop()
        event = threading.Event()

        @gen.coroutine
        def init_server():
            sock, self.port = bind_unused_port()
            app = Application([("/", HelloWorldHandler)])
            self.server = HTTPServer(app)
            self.server.add_socket(sock)
            event.set()

        def start():
            self.server_ioloop.run_sync(init_server)
            self.server_ioloop.start()

        self.server_thread = threading.Thread(target=start)
        self.server_thread.start()
        event.wait()

        self.http_client = HTTPClient()

    def tearDown(self):
        def stop_server():
            self.server.stop()
            # Delay the shutdown of the IOLoop by several iterations because
            # the server may still have some cleanup work left when
            # the client finishes with the response (this is noticeable
            # with http/2, which leaves a Future with an unexamined
            # StreamClosedError on the loop).

            @gen.coroutine
            def slow_stop():
                # The number of iterations is difficult to predict. Typically,
                # one is sufficient, although sometimes it needs more.
                for i in range(5):
                    yield
                self.server_ioloop.stop()

            self.server_ioloop.add_callback(slow_stop)

        self.server_ioloop.add_callback(stop_server)
        self.server_thread.join()
        self.http_client.close()
        self.server_ioloop.close(all_fds=True)

    def get_url(self, path):
        return "http://127.0.0.1:%d%s" % (self.port, path)

    def test_sync_client(self):
        response = self.http_client.fetch(self.get_url("/"))
        self.assertEqual(b"Hello world!", response.body)

    def test_sync_client_error(self):
        # Synchronous HTTPClient raises errors directly; no need for
        # response.rethrow()
        with self.assertRaises(HTTPError) as assertion:
            self.http_client.fetch(self.get_url("/notfound"))
        self.assertEqual(assertion.exception.code, 404)

# 需要导入模块: from tornado.httpclient import HTTPClient [as 别名]
# 或者: from tornado.httpclient.HTTPClient import fetch [as 别名]
 def change_status(self, data):
     req = HTTPClient()
     try:
         req.fetch('http://%s:%d/change_status/' % (SERVER_ADDRESS, SERVER_PORT),
                   method='POST',
                   body=json_dumps({'username': self.username, 'data': data}))
     except Exception as E:
         print traceback.format_exc()

# 需要导入模块: from tornado.httpclient import HTTPClient [as 别名]
# 或者: from tornado.httpclient.HTTPClient import fetch [as 别名]
class TargetHandler(RequestHandler):
    def initialize(self, targets):
        self.targets = targets
        self.http_client = HTTPClient()

    def post(self, target):
        url, (x, y) = self.targets[target]
        print("Firing on {} at {} (coords {}/{})".format(target, url, x, y))
        self.http_client.fetch("{}/fire_at/{}/{}".format(url, x, y), method="POST", body="A Rocket")

# 需要导入模块: from tornado.httpclient import HTTPClient [as 别名]
# 或者: from tornado.httpclient.HTTPClient import fetch [as 别名]
class SyncHTTPClientTest(unittest.TestCase):
    def setUp(self):
        if IOLoop.configured_class().__name__ in ('TwistedIOLoop',
                                                  'AsyncIOMainLoop'):
            # TwistedIOLoop only supports the global reactor, so we can't have
            # separate IOLoops for client and server threads.
            # AsyncIOMainLoop doesn't work with the default policy
            # (although it could with some tweaks to this test and a
            # policy that created loops for non-main threads).
            raise unittest.SkipTest(
                'Sync HTTPClient not compatible with TwistedIOLoop or '
                'AsyncIOMainLoop')
        self.server_ioloop = IOLoop()

        sock, self.port = bind_unused_port()
        app = Application([('/', HelloWorldHandler)])
        self.server = HTTPServer(app, io_loop=self.server_ioloop)
        self.server.add_socket(sock)

        self.server_thread = threading.Thread(target=self.server_ioloop.start)
        self.server_thread.start()

        self.http_client = HTTPClient()

    def tearDown(self):
        def stop_server():
            self.server.stop()
            # Delay the shutdown of the IOLoop by one iteration because
            # the server may still have some cleanup work left when
            # the client finishes with the response (this is noticable
            # with http/2, which leaves a Future with an unexamined
            # StreamClosedError on the loop).
            self.server_ioloop.add_callback(self.server_ioloop.stop)
        self.server_ioloop.add_callback(stop_server)
        self.server_thread.join()
        self.http_client.close()
        self.server_ioloop.close(all_fds=True)

    def get_url(self, path):
        return 'http://127.0.0.1:%d%s' % (self.port, path)

    def test_sync_client(self):
        response = self.http_client.fetch(self.get_url('/'))
        self.assertEqual(b'Hello world!', response.body)

    def test_sync_client_error(self):
        # Synchronous HTTPClient raises errors directly; no need for
        # response.rethrow()
        with self.assertRaises(HTTPError) as assertion:
            self.http_client.fetch(self.get_url('/notfound'))
        self.assertEqual(assertion.exception.code, 404)

# 需要导入模块: from tornado.httpclient import HTTPClient [as 别名]
# 或者: from tornado.httpclient.HTTPClient import fetch [as 别名]
    def delete(self, *args, **kwargs):
        self.product_cache.clear()
        client = HTTPClient()
        url_suggest_clear = "%s/cache" % SUGGEST_URL
        self.logger.debug("clear suggest_cache,url=%s", url_suggest_clear)
        suggest_request = HTTPRequest(url_suggest_clear, method="DELETE")
        client.fetch(suggest_request)

        url_detect_clear = "%s/refresh" % DETECT_URL
        self.logger.debug("clear detect_cache,url=%s", url_detect_clear)
        detect_request = HTTPRequest(url_detect_clear, method="GET")
        client.fetch(detect_request)

        self.logger.debug("clear cache completed")
        self.finish()

# 需要导入模块: from tornado.httpclient import HTTPClient [as 别名]
# 或者: from tornado.httpclient.HTTPClient import fetch [as 别名]
    def get_current_user(self):
        # return self.get_secure_cookie("session_token")

        session_token = self.get_secure_cookie("session_token")
        logging.info("got session_token %r", session_token)
        expires_at = self.get_secure_cookie("expires_at")
        if expires_at is None or expires_at == "":
            expires_at = 0
        refresh_token = self.get_secure_cookie("refresh_token")

        _timestamp = int(time.time())
        if _timestamp > int(expires_at):
            return session_token
        else:
            url = "http://" + AUTH_HOST + "/auth/refresh-token"
            http_client = HTTPClient()
            response = http_client.fetch(url, method="GET", headers={"Authorization":"Bearer "+refresh_token})
            logging.info("got refresh-token response %r", response.body)

            token = json_decode(response.body)
            expires_at = _timestamp + token['expires_in']
            session_token = token['access_token']
            self.set_secure_cookie("session_token", session_token)
            self.set_secure_cookie("expires_at", str(expires_at))
            self.set_secure_cookie("refresh_token", token['refresh_token'])
            self.set_secure_cookie("account_id", token['account_id'])

            return session_token

# 需要导入模块: from tornado.httpclient import HTTPClient [as 别名]
# 或者: from tornado.httpclient.HTTPClient import fetch [as 别名]
 def getData(self,url,method,data,cookie):
     try:
         client = HTTPClient()
         request = HTTPRequest(
                 url,
                 method=method,
                 headers={
                     'Cookie':cookie
                 }
             )
         if data and method=="GET":
             data = json.loads(data)
             url = url_concat(url,data)
             request.url = url
         elif data and method=="POST":
             data = json.loads(data)
             print data
             data = urllib.urlencode(data)
             request.body = data
         # print request.url
         response = client.fetch(request)
         return response.body
     except Exception,e:
         # print str(e)
         return None

# 需要导入模块: from tornado.httpclient import HTTPClient [as 别名]
# 或者: from tornado.httpclient.HTTPClient import fetch [as 别名]
    def post(self):
        logging.info(self.request)

        random = random_x(8)
        logging.info("got random %r", random)

        image = self.get_argument("filename", "")
        logging.info("got image %r", image)
        title = self.get_argument("article_title", "")
        logging.info("got article_title %r", title)
        desc = self.get_argument("article_desc", "")
        logging.info("got article_desc %r", desc)

        session_token = self.get_secure_cookie("session_token")
        logging.info("got session_token %r from cookie", session_token)

        url = "http://" + AUTH_HOST + "/blog/articles"
        body_data = {'type':'blog', 'image':image, 'title':title, 'desc':desc}
        logging.info("post body %r", body_data)
        _json = json_encode(body_data)
        http_client = HTTPClient()
        response = http_client.fetch(url, method="POST", body=_json, headers={"Authorization":"Bearer "+session_token})
        logging.info("got token response %r", response.body)

        self.redirect('/blog/articles/mine?random=' + random)

# 需要导入模块: from tornado.httpclient import HTTPClient [as 别名]
# 或者: from tornado.httpclient.HTTPClient import fetch [as 别名]
 def parser(self):
     retjson = {'code':200,'content':''}
     header = { 
         'User-Agent': 'Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/45.0.2454.101 Safari/537.36',
         'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8',
         'Accept-Encoding': 'gzip, deflate, sdch',
         'Accept-Language': 'zh-CN,zh;q=0.8',
         'Host':'jwc.seu.edu.cn',
         'Connection':'keep-alive',
         'Upgrade-Insecure-Requests':'1'
     }
     try:
         client = HTTPClient()
         request = HTTPRequest(JWC_URL, method='GET',headers=header,request_timeout=TIME_OUT)
         response = client.fetch(request)
         html = response.body
         soup = BeautifulSoup(html)
         items = soup.findAll('table', {'width':"100%"})
         info = {
             '最新动态': self.abstract(items[12:17],1), 
             '教务信息': self.abstract(items[34:34+7],0), 
             '学籍管理': self.abstract(items[45:45+7],0), 
             '实践教学': self.abstract(items[56:56+7],0), 
             '合作办学': self.abstract(items[67:67+4],0),
             }
         retjson = {'code':200, 'content':info}
     except:
         retjson['code'] = 400
         # print traceback.print_exc()
     return retjson