CoCalc -- tracing.py

GitHub Repository: wiseplat/python-code
Path: blob/master/ invest-robot-contest_TinkoffBotTwitch-main/venv/lib/python3.8/site-packages/aiohttp/tracing.py
⁷⁷⁶³ views
1
from types import SimpleNamespace
2
from typing import TYPE_CHECKING, Awaitable, Optional, Type, TypeVar
3

4
import attr
5
from aiosignal import Signal
6
from multidict import CIMultiDict
7
from yarl import URL
8

9
from .client_reqrep import ClientResponse
10

11
if TYPE_CHECKING:  # pragma: no cover
12
    from .client import ClientSession
13
    from .typedefs import Protocol
14

15
    _ParamT_contra = TypeVar("_ParamT_contra", contravariant=True)
16

17
    class _SignalCallback(Protocol[_ParamT_contra]):
18
        def __call__(
19
            self,
20
            __client_session: ClientSession,
21
            __trace_config_ctx: SimpleNamespace,
22
            __params: _ParamT_contra,
23
        ) -> Awaitable[None]:
24
            ...
25

26

27
__all__ = (
28
    "TraceConfig",
29
    "TraceRequestStartParams",
30
    "TraceRequestEndParams",
31
    "TraceRequestExceptionParams",
32
    "TraceConnectionQueuedStartParams",
33
    "TraceConnectionQueuedEndParams",
34
    "TraceConnectionCreateStartParams",
35
    "TraceConnectionCreateEndParams",
36
    "TraceConnectionReuseconnParams",
37
    "TraceDnsResolveHostStartParams",
38
    "TraceDnsResolveHostEndParams",
39
    "TraceDnsCacheHitParams",
40
    "TraceDnsCacheMissParams",
41
    "TraceRequestRedirectParams",
42
    "TraceRequestChunkSentParams",
43
    "TraceResponseChunkReceivedParams",
44
    "TraceRequestHeadersSentParams",
45
)
46

47

48
class TraceConfig:
49
    """First-class used to trace requests launched via ClientSession objects."""
50

51
    def __init__(
52
        self, trace_config_ctx_factory: Type[SimpleNamespace] = SimpleNamespace
53
    ) -> None:
54
        self._on_request_start = Signal(
55
            self
56
        )  # type: Signal[_SignalCallback[TraceRequestStartParams]]
57
        self._on_request_chunk_sent = Signal(
58
            self
59
        )  # type: Signal[_SignalCallback[TraceRequestChunkSentParams]]
60
        self._on_response_chunk_received = Signal(
61
            self
62
        )  # type: Signal[_SignalCallback[TraceResponseChunkReceivedParams]]
63
        self._on_request_end = Signal(
64
            self
65
        )  # type: Signal[_SignalCallback[TraceRequestEndParams]]
66
        self._on_request_exception = Signal(
67
            self
68
        )  # type: Signal[_SignalCallback[TraceRequestExceptionParams]]
69
        self._on_request_redirect = Signal(
70
            self
71
        )  # type: Signal[_SignalCallback[TraceRequestRedirectParams]]
72
        self._on_connection_queued_start = Signal(
73
            self
74
        )  # type: Signal[_SignalCallback[TraceConnectionQueuedStartParams]]
75
        self._on_connection_queued_end = Signal(
76
            self
77
        )  # type: Signal[_SignalCallback[TraceConnectionQueuedEndParams]]
78
        self._on_connection_create_start = Signal(
79
            self
80
        )  # type: Signal[_SignalCallback[TraceConnectionCreateStartParams]]
81
        self._on_connection_create_end = Signal(
82
            self
83
        )  # type: Signal[_SignalCallback[TraceConnectionCreateEndParams]]
84
        self._on_connection_reuseconn = Signal(
85
            self
86
        )  # type: Signal[_SignalCallback[TraceConnectionReuseconnParams]]
87
        self._on_dns_resolvehost_start = Signal(
88
            self
89
        )  # type: Signal[_SignalCallback[TraceDnsResolveHostStartParams]]
90
        self._on_dns_resolvehost_end = Signal(
91
            self
92
        )  # type: Signal[_SignalCallback[TraceDnsResolveHostEndParams]]
93
        self._on_dns_cache_hit = Signal(
94
            self
95
        )  # type: Signal[_SignalCallback[TraceDnsCacheHitParams]]
96
        self._on_dns_cache_miss = Signal(
97
            self
98
        )  # type: Signal[_SignalCallback[TraceDnsCacheMissParams]]
99
        self._on_request_headers_sent = Signal(
100
            self
101
        )  # type: Signal[_SignalCallback[TraceRequestHeadersSentParams]]
102

103
        self._trace_config_ctx_factory = trace_config_ctx_factory
104

105
    def trace_config_ctx(
106
        self, trace_request_ctx: Optional[SimpleNamespace] = None
107
    ) -> SimpleNamespace:
108
        """Return a new trace_config_ctx instance"""
109
        return self._trace_config_ctx_factory(trace_request_ctx=trace_request_ctx)
110

111
    def freeze(self) -> None:
112
        self._on_request_start.freeze()
113
        self._on_request_chunk_sent.freeze()
114
        self._on_response_chunk_received.freeze()
115
        self._on_request_end.freeze()
116
        self._on_request_exception.freeze()
117
        self._on_request_redirect.freeze()
118
        self._on_connection_queued_start.freeze()
119
        self._on_connection_queued_end.freeze()
120
        self._on_connection_create_start.freeze()
121
        self._on_connection_create_end.freeze()
122
        self._on_connection_reuseconn.freeze()
123
        self._on_dns_resolvehost_start.freeze()
124
        self._on_dns_resolvehost_end.freeze()
125
        self._on_dns_cache_hit.freeze()
126
        self._on_dns_cache_miss.freeze()
127
        self._on_request_headers_sent.freeze()
128

129
    @property
130
    def on_request_start(self) -> "Signal[_SignalCallback[TraceRequestStartParams]]":
131
        return self._on_request_start
132

133
    @property
134
    def on_request_chunk_sent(
135
        self,
136
    ) -> "Signal[_SignalCallback[TraceRequestChunkSentParams]]":
137
        return self._on_request_chunk_sent
138

139
    @property
140
    def on_response_chunk_received(
141
        self,
142
    ) -> "Signal[_SignalCallback[TraceResponseChunkReceivedParams]]":
143
        return self._on_response_chunk_received
144

145
    @property
146
    def on_request_end(self) -> "Signal[_SignalCallback[TraceRequestEndParams]]":
147
        return self._on_request_end
148

149
    @property
150
    def on_request_exception(
151
        self,
152
    ) -> "Signal[_SignalCallback[TraceRequestExceptionParams]]":
153
        return self._on_request_exception
154

155
    @property
156
    def on_request_redirect(
157
        self,
158
    ) -> "Signal[_SignalCallback[TraceRequestRedirectParams]]":
159
        return self._on_request_redirect
160

161
    @property
162
    def on_connection_queued_start(
163
        self,
164
    ) -> "Signal[_SignalCallback[TraceConnectionQueuedStartParams]]":
165
        return self._on_connection_queued_start
166

167
    @property
168
    def on_connection_queued_end(
169
        self,
170
    ) -> "Signal[_SignalCallback[TraceConnectionQueuedEndParams]]":
171
        return self._on_connection_queued_end
172

173
    @property
174
    def on_connection_create_start(
175
        self,
176
    ) -> "Signal[_SignalCallback[TraceConnectionCreateStartParams]]":
177
        return self._on_connection_create_start
178

179
    @property
180
    def on_connection_create_end(
181
        self,
182
    ) -> "Signal[_SignalCallback[TraceConnectionCreateEndParams]]":
183
        return self._on_connection_create_end
184

185
    @property
186
    def on_connection_reuseconn(
187
        self,
188
    ) -> "Signal[_SignalCallback[TraceConnectionReuseconnParams]]":
189
        return self._on_connection_reuseconn
190

191
    @property
192
    def on_dns_resolvehost_start(
193
        self,
194
    ) -> "Signal[_SignalCallback[TraceDnsResolveHostStartParams]]":
195
        return self._on_dns_resolvehost_start
196

197
    @property
198
    def on_dns_resolvehost_end(
199
        self,
200
    ) -> "Signal[_SignalCallback[TraceDnsResolveHostEndParams]]":
201
        return self._on_dns_resolvehost_end
202

203
    @property
204
    def on_dns_cache_hit(self) -> "Signal[_SignalCallback[TraceDnsCacheHitParams]]":
205
        return self._on_dns_cache_hit
206

207
    @property
208
    def on_dns_cache_miss(self) -> "Signal[_SignalCallback[TraceDnsCacheMissParams]]":
209
        return self._on_dns_cache_miss
210

211
    @property
212
    def on_request_headers_sent(
213
        self,
214
    ) -> "Signal[_SignalCallback[TraceRequestHeadersSentParams]]":
215
        return self._on_request_headers_sent
216

217

218
@attr.s(auto_attribs=True, frozen=True, slots=True)
219
class TraceRequestStartParams:
220
    """Parameters sent by the `on_request_start` signal"""
221

222
    method: str
223
    url: URL
224
    headers: "CIMultiDict[str]"
225

226

227
@attr.s(auto_attribs=True, frozen=True, slots=True)
228
class TraceRequestChunkSentParams:
229
    """Parameters sent by the `on_request_chunk_sent` signal"""
230

231
    method: str
232
    url: URL
233
    chunk: bytes
234

235

236
@attr.s(auto_attribs=True, frozen=True, slots=True)
237
class TraceResponseChunkReceivedParams:
238
    """Parameters sent by the `on_response_chunk_received` signal"""
239

240
    method: str
241
    url: URL
242
    chunk: bytes
243

244

245
@attr.s(auto_attribs=True, frozen=True, slots=True)
246
class TraceRequestEndParams:
247
    """Parameters sent by the `on_request_end` signal"""
248

249
    method: str
250
    url: URL
251
    headers: "CIMultiDict[str]"
252
    response: ClientResponse
253

254

255
@attr.s(auto_attribs=True, frozen=True, slots=True)
256
class TraceRequestExceptionParams:
257
    """Parameters sent by the `on_request_exception` signal"""
258

259
    method: str
260
    url: URL
261
    headers: "CIMultiDict[str]"
262
    exception: BaseException
263

264

265
@attr.s(auto_attribs=True, frozen=True, slots=True)
266
class TraceRequestRedirectParams:
267
    """Parameters sent by the `on_request_redirect` signal"""
268

269
    method: str
270
    url: URL
271
    headers: "CIMultiDict[str]"
272
    response: ClientResponse
273

274

275
@attr.s(auto_attribs=True, frozen=True, slots=True)
276
class TraceConnectionQueuedStartParams:
277
    """Parameters sent by the `on_connection_queued_start` signal"""
278

279

280
@attr.s(auto_attribs=True, frozen=True, slots=True)
281
class TraceConnectionQueuedEndParams:
282
    """Parameters sent by the `on_connection_queued_end` signal"""
283

284

285
@attr.s(auto_attribs=True, frozen=True, slots=True)
286
class TraceConnectionCreateStartParams:
287
    """Parameters sent by the `on_connection_create_start` signal"""
288

289

290
@attr.s(auto_attribs=True, frozen=True, slots=True)
291
class TraceConnectionCreateEndParams:
292
    """Parameters sent by the `on_connection_create_end` signal"""
293

294

295
@attr.s(auto_attribs=True, frozen=True, slots=True)
296
class TraceConnectionReuseconnParams:
297
    """Parameters sent by the `on_connection_reuseconn` signal"""
298

299

300
@attr.s(auto_attribs=True, frozen=True, slots=True)
301
class TraceDnsResolveHostStartParams:
302
    """Parameters sent by the `on_dns_resolvehost_start` signal"""
303

304
    host: str
305

306

307
@attr.s(auto_attribs=True, frozen=True, slots=True)
308
class TraceDnsResolveHostEndParams:
309
    """Parameters sent by the `on_dns_resolvehost_end` signal"""
310

311
    host: str
312

313

314
@attr.s(auto_attribs=True, frozen=True, slots=True)
315
class TraceDnsCacheHitParams:
316
    """Parameters sent by the `on_dns_cache_hit` signal"""
317

318
    host: str
319

320

321
@attr.s(auto_attribs=True, frozen=True, slots=True)
322
class TraceDnsCacheMissParams:
323
    """Parameters sent by the `on_dns_cache_miss` signal"""
324

325
    host: str
326

327

328
@attr.s(auto_attribs=True, frozen=True, slots=True)
329
class TraceRequestHeadersSentParams:
330
    """Parameters sent by the `on_request_headers_sent` signal"""
331

332
    method: str
333
    url: URL
334
    headers: "CIMultiDict[str]"
335

336

337
class Trace:
338
    """Internal dependency holder class.
339

340
    Used to keep together the main dependencies used
341
    at the moment of send a signal.
342
    """
343

344
    def __init__(
345
        self,
346
        session: "ClientSession",
347
        trace_config: TraceConfig,
348
        trace_config_ctx: SimpleNamespace,
349
    ) -> None:
350
        self._trace_config = trace_config
351
        self._trace_config_ctx = trace_config_ctx
352
        self._session = session
353

354
    async def send_request_start(
355
        self, method: str, url: URL, headers: "CIMultiDict[str]"
356
    ) -> None:
357
        return await self._trace_config.on_request_start.send(
358
            self._session,
359
            self._trace_config_ctx,
360
            TraceRequestStartParams(method, url, headers),
361
        )
362

363
    async def send_request_chunk_sent(
364
        self, method: str, url: URL, chunk: bytes
365
    ) -> None:
366
        return await self._trace_config.on_request_chunk_sent.send(
367
            self._session,
368
            self._trace_config_ctx,
369
            TraceRequestChunkSentParams(method, url, chunk),
370
        )
371

372
    async def send_response_chunk_received(
373
        self, method: str, url: URL, chunk: bytes
374
    ) -> None:
375
        return await self._trace_config.on_response_chunk_received.send(
376
            self._session,
377
            self._trace_config_ctx,
378
            TraceResponseChunkReceivedParams(method, url, chunk),
379
        )
380

381
    async def send_request_end(
382
        self,
383
        method: str,
384
        url: URL,
385
        headers: "CIMultiDict[str]",
386
        response: ClientResponse,
387
    ) -> None:
388
        return await self._trace_config.on_request_end.send(
389
            self._session,
390
            self._trace_config_ctx,
391
            TraceRequestEndParams(method, url, headers, response),
392
        )
393

394
    async def send_request_exception(
395
        self,
396
        method: str,
397
        url: URL,
398
        headers: "CIMultiDict[str]",
399
        exception: BaseException,
400
    ) -> None:
401
        return await self._trace_config.on_request_exception.send(
402
            self._session,
403
            self._trace_config_ctx,
404
            TraceRequestExceptionParams(method, url, headers, exception),
405
        )
406

407
    async def send_request_redirect(
408
        self,
409
        method: str,
410
        url: URL,
411
        headers: "CIMultiDict[str]",
412
        response: ClientResponse,
413
    ) -> None:
414
        return await self._trace_config._on_request_redirect.send(
415
            self._session,
416
            self._trace_config_ctx,
417
            TraceRequestRedirectParams(method, url, headers, response),
418
        )
419

420
    async def send_connection_queued_start(self) -> None:
421
        return await self._trace_config.on_connection_queued_start.send(
422
            self._session, self._trace_config_ctx, TraceConnectionQueuedStartParams()
423
        )
424

425
    async def send_connection_queued_end(self) -> None:
426
        return await self._trace_config.on_connection_queued_end.send(
427
            self._session, self._trace_config_ctx, TraceConnectionQueuedEndParams()
428
        )
429

430
    async def send_connection_create_start(self) -> None:
431
        return await self._trace_config.on_connection_create_start.send(
432
            self._session, self._trace_config_ctx, TraceConnectionCreateStartParams()
433
        )
434

435
    async def send_connection_create_end(self) -> None:
436
        return await self._trace_config.on_connection_create_end.send(
437
            self._session, self._trace_config_ctx, TraceConnectionCreateEndParams()
438
        )
439

440
    async def send_connection_reuseconn(self) -> None:
441
        return await self._trace_config.on_connection_reuseconn.send(
442
            self._session, self._trace_config_ctx, TraceConnectionReuseconnParams()
443
        )
444

445
    async def send_dns_resolvehost_start(self, host: str) -> None:
446
        return await self._trace_config.on_dns_resolvehost_start.send(
447
            self._session, self._trace_config_ctx, TraceDnsResolveHostStartParams(host)
448
        )
449

450
    async def send_dns_resolvehost_end(self, host: str) -> None:
451
        return await self._trace_config.on_dns_resolvehost_end.send(
452
            self._session, self._trace_config_ctx, TraceDnsResolveHostEndParams(host)
453
        )
454

455
    async def send_dns_cache_hit(self, host: str) -> None:
456
        return await self._trace_config.on_dns_cache_hit.send(
457
            self._session, self._trace_config_ctx, TraceDnsCacheHitParams(host)
458
        )
459

460
    async def send_dns_cache_miss(self, host: str) -> None:
461
        return await self._trace_config.on_dns_cache_miss.send(
462
            self._session, self._trace_config_ctx, TraceDnsCacheMissParams(host)
463
        )
464

465
    async def send_request_headers(
466
        self, method: str, url: URL, headers: "CIMultiDict[str]"
467
    ) -> None:
468
        return await self._trace_config._on_request_headers_sent.send(
469
            self._session,
470
            self._trace_config_ctx,
471
            TraceRequestHeadersSentParams(method, url, headers),
472
        )
473

474
Product

Resources

Company
