def _make_session(self): if self._client is None or self._client.closed: self._client = client.ClientSession(timeout=self._timeout, headers=self.default_headers, loop=self.loop) return self._client
async def from_url(cls, url, *, user, connection=None): async with client.ClientSession() as session: async with session.get(url) as response: if response.status != 200: return l = response.content_length if not l or l > 2 ** 23: return content_type = response.content_type if not content_type.startswith('image'): return content = BytesIO(await response.read()) filename = response.url.name exts = mimetypes.guess_all_extensions(content_type) for ext in exts: if filename.endswith(ext): break else: if exts: filename += exts[-1] name = await cls.app.loop.run_in_executor( None, image_storage.save, filename, content) image_uuid = image_storage.uuid(name) return await cls.create( uuid=image_uuid, image=name, mime_type=content_type, created_at=utils.now(), author_id=user.pk, connection=connection )
async def handle(request): async with client.ClientSession() as session: response = await session.post( url=f"https://id.twitch.tv/oauth2/token", params={ "client_id": config["credentials"]["twitch"]["client_id"], "client_secret": config["credentials"]["twitch"]["client_secret"], "code": request.query["code"], "grant_type": "authorization_code", "redirect_uri": "http://127.0.0.1:3333/", }, ) content = await response.json() with secrets_file.open("wt") as fobj: fobj.write(json.dumps(content, indent=4)) raise GracefulExit() return web.Response(text="received!")
async def set(self, key, value, ttl=None, refresh=None, prev_exist=None): """Set the value of the ``key`` or updates it if the ``key`` already exists. """ async with client.ClientSession() as session: _ = await session.put(self._get_url(key), headers=self.client.auth_headers)
def test_POST_MULTIPART(self): with run_server(self.loop, router=Functional) as httpd: url = httpd.url('method', 'post') with MultipartWriter('form-data') as writer: writer.append('foo') writer.append_json({'bar': 'баз'}) writer.append_form([('тест', '4'), ('сетс', '2')]) session = client.ClientSession(loop=self.loop) r = self.loop.run_until_complete( session.request('post', url, data=writer)) content = self.loop.run_until_complete(r.json()) self.assertEqual(3, len(content['multipart-data'])) self.assertEqual({'content-type': 'text/plain', 'data': 'foo'}, content['multipart-data'][0]) self.assertEqual({'content-type': 'application/json', 'data': '{"bar": "\\u0431\\u0430\\u0437"}'}, content['multipart-data'][1]) self.assertEqual( {'content-type': 'application/x-www-form-urlencoded', 'data': '%D1%82%D0%B5%D1%81%D1%82=4&' '%D1%81%D0%B5%D1%82%D1%81=2'}, content['multipart-data'][2]) self.assertEqual(r.status, 200) r.close() session.close()
def test_POST_STREAM_DATA(self): with run_server(self.loop, router=Functional) as httpd: url = httpd.url('method', 'post') here = os.path.dirname(__file__) fname = os.path.join(here, 'sample.key') with open(fname, 'rb') as f: data = f.read() fut = helpers.create_future(self.loop) @aiohttp.streamer def stream(writer): yield from fut writer.write(data) self.loop.call_later(0.01, fut.set_result, True) session = client.ClientSession(loop=self.loop) r = self.loop.run_until_complete( session.request('post', url, data=stream(), headers={'Content-Length': str(len(data))})) content = self.loop.run_until_complete(r.json()) r.close() session.close() self.assertEqual(str(len(data)), content['headers']['Content-Length']) self.assertEqual('application/octet-stream', content['headers']['Content-Type'])
def function588(self): with function147(self.attribute2267, router=Class273) as var4462: var1378 = client.ClientSession(loop=self.attribute2267, auth=helpers.BasicAuth('login', 'pass')) var3192 = {'Authorization': 'Basic b3RoZXJfbG9naW46cGFzcw==', } with self.assertRaises(ValueError): self.attribute2267.run_until_complete(var1378.request('get', var4462.url('method', 'get'), headers=var3192)) var1378.close()
def test_POST_ChunksQueue(self): with run_server(self.loop, router=Functional) as httpd: url = httpd.url('method', 'post') here = os.path.dirname(__file__) fname = os.path.join(here, 'sample.key') with open(fname, 'rb') as f: data = f.read() stream = aiohttp.ChunksQueue(loop=self.loop) stream.feed_data(data[:100], 100) d = data[100:] stream.feed_data(d, len(d)) stream.feed_eof() session = client.ClientSession(loop=self.loop) r = self.loop.run_until_complete( session.request('post', url, data=stream, headers={'Content-Length': str(len(data))})) content = self.loop.run_until_complete(r.json()) r.close() session.close() self.assertEqual(str(len(data)), content['headers']['Content-Length'])
async def guilds_start(websocket, subkey): # tell the bot to send this user's guilds await Redis.send_to_bot("user_guilds", user_id=subkey) # get non gearbot servers headers = {"Authorization": f"Bearer {websocket.auth_info.user.api_token}"} async with client.ClientSession() as session_pool: async with session_pool.get(f"{API_LOCATION}/users/@me/guilds", headers=headers) as resp: guild_list = await resp.json() if not isinstance(guild_list, list): from Utils.Auth import deauth_user await deauth_user(websocket.auth_info.user.id) await websocket.auth_info.delete() return False to_send = dict() for guild in guild_list: if guild["owner"] or guild["permissions"] & 32 == 32: to_send[str(guild["id"])] = { "id": str(guild["id"]), "name": str(guild["name"]), "icon": guild["icon"] } await websocket.send_json({ "type": "guilds", "content": { "type": "all_guilds", "guilds": to_send } }) await session_pool.close()
async def get_messages(): async with client.ClientSession() as session: while True: updates = await get_updates(session) if updates: messages = [update['message'] for update in updates if 'message' in update] return messages
def function535(self): with function147(self.attribute2267, router=Class273) as var4474: var4474['close'] = True var3176 = client.ClientSession(loop=self.attribute2267) with self.assertRaises(aiohttp.ServerDisconnectedError): self.attribute2267.run_until_complete(var3176.request('get', var4474.url('method', 'get'))) var3176.close()
async def test_unauthenticated_data(auth_app): await auth_app.main(blocking=False) try: async with client.ClientSession() as session: rep = await session.request('post', 'http://localhost:8150/') assert rep.status == 401 finally: await auth_app.stop()
async def test_port(context): assert context.prometheus is not None url = f'http://localhost:{context.prometheus.config.port}' async with client.ClientSession() as session: async with session.get(url) as r: assert r.status == 200, await r.text() data = await r.read() assert data
def function171(arg2232): var608 = aiohttp.TCPConnector(loop=self.attribute2267) var862 = client.ClientSession(loop=self.attribute2267, connector=var608) var3989 = yield from var862.request('GET', arg2232) yield from var3989.read() self.assertEqual(1, len(var608._conns)) var608.close() var862.close()
async def finish_link(error: str = None, code: str = None, state: str = None, request: Request = None, state_key: str = Cookie(None)): if error is not None: # They must of denied the auth request if this errors return "You didn't grant us access" if state != state_key or code is None: return "Detected tampering with the request, linking denied" # we got a code, grab auth token session_pool = client.ClientSession() body = { "client_id": config["client_id"], "client_secret": config["client_secret"], "code": code, "redirect_uri": config["redirect_url"], "scope": "identify connections", "grant_type": "authorization_code" } async with session_pool.post("https://discordapp.com/api/v7/oauth2/token", data=body) as token_resp: token_return = await token_resp.json() access_token = token_return["access_token"] # Fetch user info headers = {"Authorization": f"Bearer {access_token}"} async with session_pool.get(f"https://discordapp.com/api/v6/users/@me", headers=headers) as resp: user_info = await resp.json() user_id = int(user_info["id"]) async with session_pool.get( "https://discordapp.com/api/v6/users/@me/connections", headers=headers) as resp: connections = await resp.json() found = False for connection in connections: if connection["type"] == "steam": async with session_pool.get( f"https://api.brawlhalla.com/search?steamid={connection['id']}&api_key={config['api_key']}" ) as bresp: info = await bresp.json() if "brawlhalla_id" in info: found = True await BrawlhallaUser.create( discord_id=user_id, brawlhalla_id=info["brawlhalla_id"]) break await session_pool.close() if found: return "Your brawlhalla account was successfully linked!" else: return "It doesn't have a steam account with brawlhalla linked to your discord account. Please either link one to your discord account and try again or use the <insert command here> command to link your brawlhalla account"
def reset_session(self, **kwargs): session = getattr(self, 'session', None) if session: session.close() if kwargs: kwargs = {**self.session_params, **kwargs} else: kwargs = self.session_params self.session = client.ClientSession(loop=self.loop, **kwargs)
def go(url): connector = aiohttp.TCPConnector(loop=self.loop) session = client.ClientSession(loop=self.loop, connector=connector) r = yield from session.request('GET', url) yield from r.read() self.assertEqual(1, len(connector._conns)) connector.close() session.close()
def test_request_conn_closed(self): with run_server(self.loop, router=Functional) as httpd: httpd['close'] = True session = client.ClientSession(loop=self.loop) with self.assertRaises(aiohttp.ServerDisconnectedError): self.loop.run_until_complete( session.request('get', httpd.url('method', 'get'))) session.close()
def function2020(self): with function147(self.attribute2267, router=Class273) as var301: var1002 = client.ClientSession(loop=self.attribute2267, headers={'X-Real-IP': '192.168.0.1', }) var1321 = self.attribute2267.run_until_complete(var1002.request('get', var301.url('method', 'get'))) self.assertEqual(var1321.status, 200) var1602 = self.attribute2267.run_until_complete(var1321.json()) self.assertIn('X-Real-Ip', var1602['headers']) self.assertEqual(var1602['headers']['X-Real-Ip'], '192.168.0.1') var1321.close() var1002.close()
async def get_user_info(authorization): async with client.ClientSession(headers={ "Authorization": authorization, }) as session: async with session.get(TOKEN_INFO) as response: token_json = await response.json() if True or "openid" in ((token_json or {}).get("scope") or []): async with session.get(USER_INFO) as response: return await response.json() or {} return {}
def function659(self): with function147(self.attribute2267, router=Class273) as var3816: var1840 = client.ClientSession(loop=self.attribute2267, auth=helpers.BasicAuth('login', 'pass')) var2341 = self.attribute2267.run_until_complete(var1840.request('get', var3816.url('method', 'get'))) self.assertEqual(var2341.status, 200) var4209 = self.attribute2267.run_until_complete(var2341.json()) self.assertIn('Authorization', var4209['headers']) self.assertEqual(var4209['headers']['Authorization'], 'Basic bG9naW46cGFzcw==') var2341.close() var1840.close()
async def go(): self.session = client.ClientSession(loop=self.loop) response = await self.session.request(method, self.url + path, data=data, headers=headers) bytes = await response.read() body = bytes.decode() self.session.close() return response, body
def function248(self): with function147(self.attribute2267, router=Class273) as var1255: var4057 = client.ClientSession(loop=self.attribute2267, auth=helpers.BasicAuth('login', 'pass')) var2920 = self.attribute2267.run_until_complete(var4057.request('get', var1255.url('method', 'get'), auth=helpers.BasicAuth('other_login', 'pass'))) self.assertEqual(var2920.status, 200) var4442 = self.attribute2267.run_until_complete(var2920.json()) self.assertIn('Authorization', var4442['headers']) self.assertEqual(var4442['headers']['Authorization'], 'Basic b3RoZXJfbG9naW46cGFzcw==') var2920.close() var4057.close()
def __init__( self, url: str, session_args: Optional[Dict[str, Any]] = None, session: Optional[client.ClientSession] = None, **kwargs: Any, ): super().__init__(**kwargs) self._endpoint = url self._session = session or client.ClientSession(**(session_args or {}))
def function2388(self): var2908 = client.ClientSession(loop=self.attribute2267) with function147(self.attribute2267, router=Class273) as var4573: var445 = var4573.var445('method', 'post') var1077 = b'sample data' var600 = self.attribute2267.run_until_complete(var2908.request('post', var445, data=var1077, headers=MultiDict({'Content-Length': str(len(var1077)), }))) var1221 = self.attribute2267.run_until_complete(var600.json()) var600.close() self.assertEqual(str(len(var1077)), var1221['headers']['Content-Length']) var2908.close()
async def remove_webhook(): logger.info(f'Removing webhook.') async with client.ClientSession() as session: request_data = {'url': ''} response = await session.post(telegram_api_url + 'deleteWebhook', data=request_data) response_data = await response.json() logger.debug(f'delete Webhook return result: {response_data}') if response_data['ok']: if response_data['result'] is True: logger.info('Webhook was deleted.')
async def respond(response): if 'text' not in response: return async with client.ClientSession() as session: logger.debug(f'Sending message {response}') data = response async with session.post(api_base_url + 'sendMessage', data=data) as response: response_data = await response.json() logger.debug(f'Response from server: {response_data}')
def test_session_auth_header_conflict(self): with run_server(self.loop, router=Functional) as httpd: session = client.ClientSession( loop=self.loop, auth=helpers.BasicAuth("login", "pass")) headers = {'Authorization': "Basic b3RoZXJfbG9naW46cGFzcw=="} with self.assertRaises(ValueError): self.loop.run_until_complete( session.request('get', httpd.url('method', 'get'), headers=headers)) session.close()
async def get_starwars_data(url): try: async with async_http_client.ClientSession() as session: async with session.get(url) as response: if response.status == 200: return await response.json() else: raise MyError(msg="error-custom") except Exception as e: print("Error reading from {} ".format(url))
async def index(request): path = request.path site_link = f'http://{SITE_DOMAIN}{path}' async with client.ClientSession(connector=TCPConnector( verify_ssl=False)) as sessiin: async with sessiin.request('GET', site_link) as remote_request: body = await remote_request.read() body = body.replace(b'https://habr.com', b'http://localhost:8232') response = web.Response(body=body, headers={'Content-Type': 'text/html'}) return response