CodeBlanks Logo Icon CodeBlanks
Login Register

Summary - HTTP and aiohttp

Combine ClientSession, get and json to write a weather client.

Summary - HTTP and aiohttp

In this group you learned HTTP requests. With urllib.request you make synchronous requests; with aiohttp.ClientSession you make asynchronous ones. session.get and session.post give different request types; await resp.text() gives the body; json.loads parses structured data.

async with aiohttp.ClientSession() as session:
    async with session.get(url) as resp:
        data = json.loads(await resp.text())

In the final step you will combine all of these to write a weather client.

Practice Weather client

Start with import asyncio, import aiohttp and import json. Inside async def main() open async with aiohttp.ClientSession() as session:. Make a GET request with async with session.get("https://example.com") as resp:. Get the body with text = await resp.text(). Turn it into a dict with data = json.loads(text). Print the city with print(data["sehir"]). Add asyncio.run(main()).

Starter code

main.py
# load asyncio, aiohttp and the structured-data module
# open a session with async with
# make a get request on the session
# read the body with await and parse with the loads function
# print the city from the dict
# run main with asyncio.run

Sample solution

main.py
import asyncio
import aiohttp
import json

class _S:
    async def __aenter__(self): return self
    async def __aexit__(self, *a): return False
    def get(self, url): return self
    async def text(self): return '{"sehir": "İstanbul"}'

aiohttp.ClientSession = _S

async def main():
    async with aiohttp.ClientSession() as session:
        async with session.get('https://example.com') as resp:
            text = await resp.text()
            data = json.loads(text)
            print(data['sehir'])

asyncio.run(main())

Expected output

İstanbul

Questions and answers

Review the lesson questions together with their answers. To test yourself, solve the lesson interactively.

1 Which function parses the response body as structured data?

  • urlopen
  • json.loads Correct answer
  • session.get
  • asyncio.run

Explanation: json.loads(string) turns structured data into a dict.

2 Match the group tools

Term Meaning
urllib.request Synchronous request
aiohttp.ClientSession Async session
session.get GET request
json.loads Parses structured data

All lessons in Advanced

1 Advanced decorators

  1. Parameterized decorator
  2. Class decorator
  3. functools
  4. functools.partial
  5. functools.reduce
  6. Summary - Advanced decorators

2 Type hints

  1. Basic hints
  2. Optional and Union
  3. typing.List and Dict
  4. Callable
  5. TypeVar
  6. Summary - Type hints

3 Pytest

  1. pytest basics
  2. assert
  3. fixture
  4. parametrize
  5. monkeypatch
  6. Summary - Pytest

4 Mocking

  1. unittest.mock
  2. patch
  3. MagicMock
  4. side_effect
  5. assert_called
  6. Summary - Mocking

5 Async basics

  1. async/await
  2. asyncio.run
  3. async def
  4. await asyncio.sleep
  5. create_task
  6. Summary - Async basics

6 Asyncio

  1. gather
  2. wait
  3. Queue
  4. Lock
  5. Semaphore
  6. Summary - Asyncio

7 HTTP and aiohttp

  1. urllib
  2. aiohttp.ClientSession
  3. async get
  4. async post
  5. JSON response
  6. Summary - HTTP and aiohttp

8 SQLAlchemy

  1. Engine
  2. Session
  3. Defining models
  4. Column and type
  5. Query
  6. Summary - SQLAlchemy

9 FastAPI

  1. FastAPI app
  2. @app.get
  3. Pydantic model
  4. Path parameter
  5. Query parameter
  6. Summary - FastAPI

10 Pydantic

  1. BaseModel
  2. Field
  3. validator
  4. Config
  5. parse_obj
  6. Summary - Pydantic

11 Design patterns

  1. Singleton
  2. Factory
  3. Strategy
  4. Observer
  5. Decorator
  6. Summary - Design patterns

12 Logging

  1. logging.getLogger
  2. Log levels
  3. basicConfig
  4. FileHandler
  5. dictConfig
  6. Summary - Logging

13 Packaging

  1. pyproject.toml
  2. setuptools
  3. Virtual environment
  4. pip install
  5. requirements.txt
  6. Summary - Packaging

14 Advanced final

  1. Project design
  2. Async layer
  3. SQLAlchemy layer
  4. FastAPI layer
  5. Putting it together