from .api import delete, get, head, options, patch, post, put, request
from .client import AsyncClient, Client
from .concurrency.asyncio import AsyncioBackend
+from .concurrency.base import (
+ BaseBackgroundManager,
+ BasePoolSemaphore,
+ BaseReader,
+ BaseWriter,
+ ConcurrencyBackend,
+)
from .config import (
USER_AGENT,
CertTypes,
TimeoutTypes,
VerifyTypes,
)
+from .dispatch.base import AsyncDispatcher, Dispatcher
from .dispatch.connection import HTTPConnection
from .dispatch.connection_pool import ConnectionPool
from .exceptions import (
TooManyRedirects,
WriteTimeout,
)
-from .interfaces import (
- AsyncDispatcher,
- BaseBackgroundManager,
- BasePoolSemaphore,
- BaseReader,
- BaseWriter,
- ConcurrencyBackend,
- Dispatcher,
-)
from .models import (
URL,
AsyncRequest,
from .auth import HTTPBasicAuth
from .concurrency.asyncio import AsyncioBackend
+from .concurrency.base import ConcurrencyBackend
from .config import (
DEFAULT_MAX_REDIRECTS,
DEFAULT_POOL_LIMITS,
VerifyTypes,
)
from .dispatch.asgi import ASGIDispatch
+from .dispatch.base import AsyncDispatcher, Dispatcher
from .dispatch.connection_pool import ConnectionPool
from .dispatch.threaded import ThreadedDispatcher
from .dispatch.wsgi import WSGIDispatch
RedirectLoop,
TooManyRedirects,
)
-from .interfaces import AsyncDispatcher, ConcurrencyBackend, Dispatcher
from .models import (
URL,
AsyncRequest,
import typing
from types import TracebackType
-from ..config import PoolLimits, TimeoutConfig
-from ..exceptions import ConnectTimeout, PoolTimeout, ReadTimeout, WriteTimeout
-from ..interfaces import (
+from .base import (
BaseBackgroundManager,
BasePoolSemaphore,
BaseQueue,
BaseReader,
BaseWriter,
ConcurrencyBackend,
+ TimeoutFlag,
)
+from ..config import PoolLimits, TimeoutConfig
+from ..exceptions import ConnectTimeout, PoolTimeout, ReadTimeout, WriteTimeout
SSL_MONKEY_PATCH_APPLIED = False
MonkeyPatch.write = _fixed_write
-class TimeoutFlag:
- """
- A timeout flag holds a state of either read-timeout or write-timeout mode.
-
- We use this so that we can attempt both reads and writes concurrently, while
- only enforcing timeouts in one direction.
-
- During a request/response cycle we start in write-timeout mode.
-
- Once we've sent a request fully, or once we start seeing a response,
- then we switch to read-timeout mode instead.
- """
-
- def __init__(self) -> None:
- self.raise_on_read_timeout = False
- self.raise_on_write_timeout = True
-
- def set_read_timeouts(self) -> None:
- """
- Set the flag to read-timeout mode.
- """
- self.raise_on_read_timeout = True
- self.raise_on_write_timeout = False
-
- def set_write_timeouts(self) -> None:
- """
- Set the flag to write-timeout mode.
- """
- self.raise_on_read_timeout = False
- self.raise_on_write_timeout = True
-
-
class Reader(BaseReader):
def __init__(
self, stream_reader: asyncio.StreamReader, timeout: TimeoutConfig
import typing
from types import TracebackType
-from .config import CertTypes, PoolLimits, TimeoutConfig, TimeoutTypes, VerifyTypes
-from .models import (
- AsyncRequest,
- AsyncRequestData,
- AsyncResponse,
- HeaderTypes,
- QueryParamTypes,
- Request,
- RequestData,
- Response,
- URLTypes,
-)
-
-
-class AsyncDispatcher:
- """
- Base class for async dispatcher classes, that handle sending the request.
-
- Stubs out the interface, as well as providing a `.request()` convenience
- implementation, to make it easy to use or test stand-alone dispatchers,
- without requiring a complete `Client` instance.
- """
-
- async def request(
- self,
- method: str,
- url: URLTypes,
- *,
- data: AsyncRequestData = b"",
- params: QueryParamTypes = None,
- headers: HeaderTypes = None,
- verify: VerifyTypes = None,
- cert: CertTypes = None,
- timeout: TimeoutTypes = None,
- ) -> AsyncResponse:
- request = AsyncRequest(method, url, data=data, params=params, headers=headers)
- return await self.send(request, verify=verify, cert=cert, timeout=timeout)
-
- async def send(
- self,
- request: AsyncRequest,
- verify: VerifyTypes = None,
- cert: CertTypes = None,
- timeout: TimeoutTypes = None,
- ) -> AsyncResponse:
- raise NotImplementedError() # pragma: nocover
-
- async def close(self) -> None:
- pass # pragma: nocover
-
- async def __aenter__(self) -> "AsyncDispatcher":
- return self
-
- async def __aexit__(
- self,
- exc_type: typing.Type[BaseException] = None,
- exc_value: BaseException = None,
- traceback: TracebackType = None,
- ) -> None:
- await self.close()
+from ..config import PoolLimits, TimeoutConfig
-class Dispatcher:
+class TimeoutFlag:
"""
- Base class for synchronous dispatcher classes, that handle sending the request.
+ A timeout flag holds a state of either read-timeout or write-timeout mode.
- Stubs out the interface, as well as providing a `.request()` convenience
- implementation, to make it easy to use or test stand-alone dispatchers,
- without requiring a complete `Client` instance.
- """
-
- def request(
- self,
- method: str,
- url: URLTypes,
- *,
- data: RequestData = b"",
- params: QueryParamTypes = None,
- headers: HeaderTypes = None,
- verify: VerifyTypes = None,
- cert: CertTypes = None,
- timeout: TimeoutTypes = None,
- ) -> Response:
- request = Request(method, url, data=data, params=params, headers=headers)
- return self.send(request, verify=verify, cert=cert, timeout=timeout)
-
- def send(
- self,
- request: Request,
- verify: VerifyTypes = None,
- cert: CertTypes = None,
- timeout: TimeoutTypes = None,
- ) -> Response:
- raise NotImplementedError() # pragma: nocover
+ We use this so that we can attempt both reads and writes concurrently, while
+ only enforcing timeouts in one direction.
- def close(self) -> None:
- pass # pragma: nocover
+ During a request/response cycle we start in write-timeout mode.
- def __enter__(self) -> "Dispatcher":
- return self
+ Once we've sent a request fully, or once we start seeing a response,
+ then we switch to read-timeout mode instead.
+ """
- def __exit__(
- self,
- exc_type: typing.Type[BaseException] = None,
- exc_value: BaseException = None,
- traceback: TracebackType = None,
- ) -> None:
- self.close()
+ def __init__(self) -> None:
+ self.raise_on_read_timeout = False
+ self.raise_on_write_timeout = True
+
+ def set_read_timeouts(self) -> None:
+ """
+ Set the flag to read-timeout mode.
+ """
+ self.raise_on_read_timeout = True
+ self.raise_on_write_timeout = False
+
+ def set_write_timeouts(self) -> None:
+ """
+ Set the flag to write-timeout mode.
+ """
+ self.raise_on_read_timeout = False
+ self.raise_on_write_timeout = True
class BaseReader:
import asyncio
import typing
+from .base import AsyncDispatcher
+from ..concurrency.base import ConcurrencyBackend
from ..concurrency.asyncio import AsyncioBackend
from ..config import CertTypes, TimeoutTypes, VerifyTypes
-from ..interfaces import AsyncDispatcher, ConcurrencyBackend
from ..models import AsyncRequest, AsyncResponse
--- /dev/null
+import typing
+from types import TracebackType
+
+from ..config import CertTypes, TimeoutTypes, VerifyTypes
+from ..models import (
+ AsyncRequest,
+ AsyncRequestData,
+ AsyncResponse,
+ HeaderTypes,
+ QueryParamTypes,
+ Request,
+ RequestData,
+ Response,
+ URLTypes,
+)
+
+
+class AsyncDispatcher:
+ """
+ Base class for async dispatcher classes, that handle sending the request.
+
+ Stubs out the interface, as well as providing a `.request()` convenience
+ implementation, to make it easy to use or test stand-alone dispatchers,
+ without requiring a complete `Client` instance.
+ """
+
+ async def request(
+ self,
+ method: str,
+ url: URLTypes,
+ *,
+ data: AsyncRequestData = b"",
+ params: QueryParamTypes = None,
+ headers: HeaderTypes = None,
+ verify: VerifyTypes = None,
+ cert: CertTypes = None,
+ timeout: TimeoutTypes = None,
+ ) -> AsyncResponse:
+ request = AsyncRequest(method, url, data=data, params=params, headers=headers)
+ return await self.send(request, verify=verify, cert=cert, timeout=timeout)
+
+ async def send(
+ self,
+ request: AsyncRequest,
+ verify: VerifyTypes = None,
+ cert: CertTypes = None,
+ timeout: TimeoutTypes = None,
+ ) -> AsyncResponse:
+ raise NotImplementedError() # pragma: nocover
+
+ async def close(self) -> None:
+ pass # pragma: nocover
+
+ async def __aenter__(self) -> "AsyncDispatcher":
+ return self
+
+ async def __aexit__(
+ self,
+ exc_type: typing.Type[BaseException] = None,
+ exc_value: BaseException = None,
+ traceback: TracebackType = None,
+ ) -> None:
+ await self.close()
+
+
+class Dispatcher:
+ """
+ Base class for synchronous dispatcher classes, that handle sending the request.
+
+ Stubs out the interface, as well as providing a `.request()` convenience
+ implementation, to make it easy to use or test stand-alone dispatchers,
+ without requiring a complete `Client` instance.
+ """
+
+ def request(
+ self,
+ method: str,
+ url: URLTypes,
+ *,
+ data: RequestData = b"",
+ params: QueryParamTypes = None,
+ headers: HeaderTypes = None,
+ verify: VerifyTypes = None,
+ cert: CertTypes = None,
+ timeout: TimeoutTypes = None,
+ ) -> Response:
+ request = Request(method, url, data=data, params=params, headers=headers)
+ return self.send(request, verify=verify, cert=cert, timeout=timeout)
+
+ def send(
+ self,
+ request: Request,
+ verify: VerifyTypes = None,
+ cert: CertTypes = None,
+ timeout: TimeoutTypes = None,
+ ) -> Response:
+ raise NotImplementedError() # pragma: nocover
+
+ def close(self) -> None:
+ pass # pragma: nocover
+
+ def __enter__(self) -> "Dispatcher":
+ return self
+
+ def __exit__(
+ self,
+ exc_type: typing.Type[BaseException] = None,
+ exc_value: BaseException = None,
+ traceback: TracebackType = None,
+ ) -> None:
+ self.close()
import ssl
import typing
+from .base import AsyncDispatcher
from ..concurrency.asyncio import AsyncioBackend
+from ..concurrency.base import ConcurrencyBackend
from ..config import (
DEFAULT_TIMEOUT_CONFIG,
CertTypes,
TimeoutTypes,
VerifyTypes,
)
-from ..interfaces import AsyncDispatcher, ConcurrencyBackend
from ..models import AsyncRequest, AsyncResponse, Origin
from .http2 import HTTP2Connection
from .http11 import HTTP11Connection
import typing
+from .base import AsyncDispatcher
from ..concurrency.asyncio import AsyncioBackend
+from ..concurrency.base import ConcurrencyBackend
from ..config import (
DEFAULT_POOL_LIMITS,
DEFAULT_TIMEOUT_CONFIG,
TimeoutTypes,
VerifyTypes,
)
-from ..interfaces import AsyncDispatcher, ConcurrencyBackend
from ..models import AsyncRequest, AsyncResponse, Origin
from .connection import HTTPConnection
import h11
-from ..concurrency.asyncio import TimeoutFlag
+from ..concurrency.base import BaseReader, BaseWriter, ConcurrencyBackend, TimeoutFlag
from ..config import TimeoutConfig, TimeoutTypes
-from ..interfaces import BaseReader, BaseWriter, ConcurrencyBackend
from ..models import AsyncRequest, AsyncResponse
H11Event = typing.Union[
import h2.connection
import h2.events
-from ..concurrency.asyncio import TimeoutFlag
+from ..concurrency.base import BaseReader, BaseWriter, ConcurrencyBackend, TimeoutFlag
from ..config import TimeoutConfig, TimeoutTypes
-from ..interfaces import BaseReader, BaseWriter, ConcurrencyBackend
from ..models import AsyncRequest, AsyncResponse
+from .base import AsyncDispatcher, Dispatcher
+from ..concurrency.base import ConcurrencyBackend
from ..config import CertTypes, TimeoutTypes, VerifyTypes
-from ..interfaces import AsyncDispatcher, ConcurrencyBackend, Dispatcher
from ..models import (
AsyncRequest,
AsyncRequestData,
import io
import typing
+from .base import Dispatcher
from ..config import CertTypes, TimeoutTypes, VerifyTypes
-from ..interfaces import Dispatcher
from ..models import Request, Response
projects / thirdparty / httpx.git / commitdiff
