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
