FM / aiohttp

/usr/local/lib64/python3.6/site-packages/aiohttp/

/usr/local/lib64/python3.6/site-packages/aiohttp

Name	Size	Mode	Actions
.hash/	-	0755	rm
__pycache__/	-	0755	rm
abc.py	5505	0644	edit dl rm
base_protocol.py	2741	0644	edit dl rm
client.py	45872	0644	edit dl rm
client_exceptions.py	9270	0644	edit dl rm
client_proto.py	8170	0644	edit dl rm
client_reqrep.py	37151	0644	edit dl rm
client_ws.py	10516	0644	edit dl rm
connector.py	51367	0644	edit dl rm
cookiejar.py	13768	0644	edit dl rm
formdata.py	6106	0644	edit dl rm
hdrs.py	4724	0644	edit dl rm
helpers.py	26527	0644	edit dl rm
http.py	1800	0644	edit dl rm
http_exceptions.py	2715	0644	edit dl rm
http_parser.py	35434	0644	edit dl rm
http_websocket.py	25299	0644	edit dl rm
http_writer.py	5933	0644	edit dl rm
locks.py	1136	0644	edit dl rm
log.py	325	0644	edit dl rm
multipart.py	32313	0644	edit dl rm
payload.py	13632	0644	edit dl rm
payload_streamer.py	2112	0644	edit dl rm
py.typed	7	0644	edit dl rm
pytest_plugin.py	11772	0644	edit dl rm
resolver.py	5092	0644	edit dl rm
streams.py	20758	0644	edit dl rm
tcp_helpers.py	961	0644	edit dl rm
test_utils.py	21434	0644	edit dl rm
tracing.py	15177	0644	edit dl rm
typedefs.py	1766	0644	edit dl rm
web.py	18081	0644	edit dl rm
web_app.py	17170	0644	edit dl rm
web_exceptions.py	10098	0644	edit dl rm
web_fileresponse.py	10784	0644	edit dl rm
web_log.py	7557	0644	edit dl rm
web_middlewares.py	4137	0644	edit dl rm
web_protocol.py	22399	0644	edit dl rm
web_request.py	28187	0644	edit dl rm
web_response.py	27471	0644	edit dl rm
web_routedef.py	6152	0644	edit dl rm
web_runner.py	11157	0644	edit dl rm
web_server.py	2050	0644	edit dl rm
web_urldispatcher.py	39483	0644	edit dl rm
web_ws.py	17144	0644	edit dl rm
worker.py	8755	0644	edit dl rm
_cparser.pxd	4318	0644	edit dl rm
_find_header.pxd	68	0644	edit dl rm
_headers.pxi	2007	0644	edit dl rm
_helpers.cpython-36m-x86_64-linux-gnu.so	309600	0755	edit dl rm
_helpers.pyi	202	0644	edit dl rm
_helpers.pyx	1049	0644	edit dl rm
_http_parser.cpython-36m-x86_64-linux-gnu.so	2218424	0755	edit dl rm
_http_parser.pyx	28058	0644	edit dl rm
_http_writer.cpython-36m-x86_64-linux-gnu.so	292576	0755	edit dl rm
_http_writer.pyx	4575	0644	edit dl rm
_websocket.cpython-36m-x86_64-linux-gnu.so	113776	0755	edit dl rm
_websocket.pyx	1561	0644	edit dl rm
__init__.py	6870	0644	edit dl rm

Edit: /usr/local/lib64/python3.6/site-packages/aiohttp/abc.py (5505B)

import asyncio
import logging
from abc import ABC, abstractmethod
from collections.abc import Sized
from http.cookies import BaseCookie, Morsel
from typing import (
    TYPE_CHECKING,
    Any,
    Awaitable,
    Callable,
    Dict,
    Generator,
    Iterable,
    List,
    Optional,
    Tuple,
)

from multidict import CIMultiDict
from yarl import URL

from .helpers import get_running_loop
from .typedefs import LooseCookies

if TYPE_CHECKING:  # pragma: no cover
    from .web_app import Application
    from .web_exceptions import HTTPException
    from .web_request import BaseRequest, Request
    from .web_response import StreamResponse
else:
    BaseRequest = Request = Application = StreamResponse = None
    HTTPException = None

class AbstractRouter(ABC):
    def __init__(self) -> None:
        self._frozen = False

def post_init(self, app: Application) -> None:
        """Post init stage.

Not an abstract method for sake of backward compatibility,
        but if the router wants to be aware of the application
        it can override this.
        """

@property
    def frozen(self) -> bool:
        return self._frozen

def freeze(self) -> None:
        """Freeze router."""
        self._frozen = True

@abstractmethod
    async def resolve(self, request: Request) -> "AbstractMatchInfo":
        """Return MATCH_INFO for given request"""

class AbstractMatchInfo(ABC):
    @property  # pragma: no branch
    @abstractmethod
    def handler(self) -> Callable[[Request], Awaitable[StreamResponse]]:
        """Execute matched request handler"""

@property
    @abstractmethod
    def expect_handler(self) -> Callable[[Request], Awaitable[None]]:
        """Expect handler for 100-continue processing"""

@property  # pragma: no branch
    @abstractmethod
    def http_exception(self) -> Optional[HTTPException]:
        """HTTPException instance raised on router's resolving, or None"""

@abstractmethod  # pragma: no branch
    def get_info(self) -> Dict[str, Any]:
        """Return a dict with additional info useful for introspection"""

@property  # pragma: no branch
    @abstractmethod
    def apps(self) -> Tuple[Application, ...]:
        """Stack of nested applications.

Top level application is left-most element.

"""

@abstractmethod
    def add_app(self, app: Application) -> None:
        """Add application to the nested apps stack."""

@abstractmethod
    def freeze(self) -> None:
        """Freeze the match info.

The method is called after route resolution.

After the call .add_app() is forbidden.

"""

class AbstractView(ABC):
    """Abstract class based view."""

def __init__(self, request: Request) -> None:
        self._request = request

@property
    def request(self) -> Request:
        """Request instance."""
        return self._request

@abstractmethod
    def __await__(self) -> Generator[Any, None, StreamResponse]:
        """Execute the view handler."""

class AbstractResolver(ABC):
    """Abstract DNS resolver."""

@abstractmethod
    async def resolve(self, host: str, port: int, family: int) -> List[Dict[str, Any]]:
        """Return IP address for given hostname"""

@abstractmethod
    async def close(self) -> None:
        """Release resolver"""

if TYPE_CHECKING:  # pragma: no cover
    IterableBase = Iterable[Morsel[str]]
else:
    IterableBase = Iterable

ClearCookiePredicate = Callable[["Morsel[str]"], bool]

class AbstractCookieJar(Sized, IterableBase):
    """Abstract Cookie Jar."""

def __init__(self, *, loop: Optional[asyncio.AbstractEventLoop] = None) -> None:
        self._loop = get_running_loop(loop)

@abstractmethod
    def clear(self, predicate: Optional[ClearCookiePredicate] = None) -> None:
        """Clear all cookies if no predicate is passed."""

@abstractmethod
    def clear_domain(self, domain: str) -> None:
        """Clear all cookies for domain and all subdomains."""

@abstractmethod
    def update_cookies(self, cookies: LooseCookies, response_url: URL = URL()) -> None:
        """Update cookies."""

@abstractmethod
    def filter_cookies(self, request_url: URL) -> "BaseCookie[str]":
        """Return the jar's cookies filtered by their attributes."""

class AbstractStreamWriter(ABC):
    """Abstract stream writer."""

buffer_size = 0
    output_size = 0
    length: Optional[int] = 0

@abstractmethod
    async def write(self, chunk: bytes) -> None:
        """Write chunk into stream."""

@abstractmethod
    async def write_eof(self, chunk: bytes = b"") -> None:
        """Write last chunk."""

@abstractmethod
    async def drain(self) -> None:
        """Flush the write buffer."""

@abstractmethod
    def enable_compression(self, encoding: str = "deflate") -> None:
        """Enable HTTP body compression"""

@abstractmethod
    def enable_chunking(self) -> None:
        """Enable HTTP chunked mode"""

@abstractmethod
    async def write_headers(
        self, status_line: str, headers: "CIMultiDict[str]"
    ) -> None:
        """Write HTTP headers"""

class AbstractAccessLogger(ABC):
    """Abstract writer to access log."""

def __init__(self, logger: logging.Logger, log_format: str) -> None:
        self.logger = logger
        self.log_format = log_format

@abstractmethod
    def log(self, request: BaseRequest, response: StreamResponse, time: float) -> None:
        """Emit log to logger."""

cmd: