class HttpClient:  
    def __init__(self): ...  

    def send_request(self): ...

class AuthClient:  
    def __init__(self):  
        self._thread = None  
        self._future = Future()  
        self._token = None  
        threading.Thread(target=self._run, daemon=True).start()  

    def _run(self):  
        while True:  
            # Имитируем получение актуального токена,
            # который меняется каждую секунду  
            self._token = uuid.uuid4().hex  
            print(f"Updating token, {self._token}")  
            if not self._future.done():  
                self._future.set_result(self._token)  
            time.sleep(1)  

    def get_token(self, timeout: int = 5):  
        if not self._future.done():  
            self._future.result(timeout=timeout)  

        return self._token

class HttpClient:  
    def __init__(self, auth: AuthClient):  
        self._auth = auth  

    def send_request(self):  
        headers = {"Authorization": f"Bearer {self._auth.get_token()}"}  
        print(f"Sending request with headers: {headers}")

@pytest.fixture(scope="session")  
def auth_client():  
    return AuthClient()  

@pytest.fixture(scope="session")  
def client(auth_client):  
    return HttpClient(auth_client)  

def test_update_token(client: HttpClient):  
    for _ in range(5):  
        # Каждую секунду обновляется токен
        # Каждые две секунды отправляем запрос
        client.send_request()  
        time.sleep(2)

test_update_token 
Updating token, bab545305cd2489bac157a4e902f70ad
Sending request with headers: {'Authorization': 'Bearer bab545305cd2489bac157a4e902f70ad'}
Updating token, a2e00fa7a37c4717b585e448fc74c336
Sending request with headers: {'Authorization': 'Bearer a2e00fa7a37c4717b585e448fc74c336'}
...

import httpx

class LogClient(httpx.Client):
    def request(self, *args, **kwargs):
        print(args, kwargs)
        response = super().request(*args, **kwargs)
        print(response.content)
        return response

class LogClient(httpx.Client):
    def request(self, *args, **kwargs):
        with allure.step(f"Request {args}"):
            print(args, kwargs)
            allure.attach(request, name="Request")
            response = super().request(*args, **kwargs)
            allure.attach(response, name="Response")
            return response

client = httpx.Client(
    event_hooks={
        'request': [log_request],
        'response': [log_response]
    }
)

from typing import Callable
import httpx
from httpx import Request, Response

class Client:
    def __init__(self):
        self._on_request_callbacks = []
        self._on_response_callbacks = []
        self._client = httpx.Client()

    def add_request_hook(
        self, callback: Callable[[Request], None]
    ) -> None:
        self._on_request_callbacks.append(callback)

    def add_response_hook(
        self, callback: Callable[[Response], None]
    ) -> None:
        self._on_response_callbacks.append(callback)

    def _run_hooks(self, value, hooks):
        for hook in hooks:
            try:
                hook(value)
            except Exception as e:
                print(f"Hook error: {e}")

    def request(self, method, url, **kwargs) -> Response:
        request = self._client.build_request(
            method=method, url=url, **kwargs
        )

        self._run_hooks(request, self._on_request_callbacks)
        response = self._client.send(request)
        self._run_hooks(response, self._on_response_callbacks)

        return response

def log_req(request):
    print(f"→ {request.method} {request.url}")

def log_resp(response):
    print(f"← {response.status_code}")

def allure_req(request):
    allure.attach(str(request), name="Request")

def allure_resp(response):
    allure.attach(response.text, name="Response")

client = Client()
client.add_request_hook(log_req)
client.add_request_hook(allure_req)
client.add_response_hook(log_resp)
client.add_response_hook(allure_resp)

client.request("GET", "https://httpbin.org/get")

→ GET https://httpbin.org/get
← 200