File Manager

Hackfut Security File Manager

Current Path: /opt/alt/python38/lib64/python3.8/site-packages/aiohttp

opt / alt / python38 / lib64 / python3.8 / site-packages / aiohttp /

📁 ..
📁 .hash
📄 __init__.py(6.77 KB)
📁 __pycache__
📄 _cparser.pxd(3.87 KB)
📄 _find_header.c(183.17 KB)
📄 _find_header.h(170 B)
📄 _find_header.pxd(68 B)
📄 _frozenlist.c(287.3 KB)
📄 _frozenlist.pyx(2.54 KB)
📄 _headers.pxi(1.96 KB)
📄 _helpers.c(207.02 KB)
📄 _helpers.pyi(202 B)
📄 _helpers.pyx(1.02 KB)
📄 _http_parser.c(987.82 KB)
📄 _http_parser.pyx(28.34 KB)
📄 _http_writer.c(208.03 KB)
📄 _http_writer.pyx(4.1 KB)
📄 _websocket.c(134.21 KB)
📄 _websocket.pyx(1.52 KB)
📄 abc.py(5.12 KB)
📄 base_protocol.py(2.64 KB)
📄 client.py(42.89 KB)
📄 client_exceptions.py(8.33 KB)
📄 client_proto.py(7.97 KB)
📄 client_reqrep.py(35.58 KB)
📄 client_ws.py(10.05 KB)
📄 connector.py(41.96 KB)
📄 cookiejar.py(11.88 KB)
📄 formdata.py(5.94 KB)
📄 frozenlist.py(1.68 KB)
📄 frozenlist.pyi(1.4 KB)
📄 hdrs.py(3.37 KB)
📄 helpers.py(22.38 KB)
📄 http.py(1.78 KB)
📄 http_exceptions.py(2.53 KB)
📄 http_parser.py(30.06 KB)
📄 http_websocket.py(24.51 KB)
📄 http_writer.py(5.22 KB)
📄 locks.py(1.19 KB)
📄 log.py(325 B)
📄 multipart.py(31.5 KB)
📄 payload.py(13.02 KB)
📄 payload_streamer.py(2.05 KB)
📄 py.typed(7 B)
📄 pytest_plugin.py(10.75 KB)
📄 resolver.py(4.5 KB)
📄 signals.py(852 B)
📄 signals.pyi(319 B)
📄 streams.py(20.05 KB)
📄 tcp_helpers.py(962 B)
📄 test_utils.py(19.78 KB)
📄 tracing.py(14.03 KB)
📄 typedefs.py(1.34 KB)
📄 web.py(17.46 KB)
📄 web_app.py(16.65 KB)
📄 web_exceptions.py(9.87 KB)
📄 web_fileresponse.py(8.81 KB)
📄 web_log.py(7.32 KB)
📄 web_middlewares.py(4.09 KB)
📄 web_protocol.py(22.71 KB)
📄 web_request.py(25.83 KB)
📄 web_response.py(25.59 KB)
📄 web_routedef.py(5.97 KB)
📄 web_runner.py(10.93 KB)
📄 web_server.py(2.01 KB)
📄 web_urldispatcher.py(38.61 KB)
📄 web_ws.py(16.39 KB)
📄 worker.py(7.83 KB)

Editing: web_routedef.py

import abc
import os  # noqa
from typing import (
    TYPE_CHECKING,
    Any,
    Awaitable,
    Callable,
    Dict,
    Iterator,
    List,
    Optional,
    Sequence,
    Type,
    Union,
    overload,
)

import attr

from . import hdrs
from .abc import AbstractView
from .typedefs import PathLike

if TYPE_CHECKING:  # pragma: no cover
    from .web_request import Request
    from .web_response import StreamResponse
    from .web_urldispatcher import AbstractRoute, UrlDispatcher
else:
    Request = StreamResponse = UrlDispatcher = AbstractRoute = None

__all__ = (
    "AbstractRouteDef",
    "RouteDef",
    "StaticDef",
    "RouteTableDef",
    "head",
    "options",
    "get",
    "post",
    "patch",
    "put",
    "delete",
    "route",
    "view",
    "static",
)

class AbstractRouteDef(abc.ABC):
    @abc.abstractmethod
    def register(self, router: UrlDispatcher) -> List[AbstractRoute]:
        pass  # pragma: no cover

_SimpleHandler = Callable[[Request], Awaitable[StreamResponse]]
_HandlerType = Union[Type[AbstractView], _SimpleHandler]

@attr.s(auto_attribs=True, frozen=True, repr=False, slots=True)
class RouteDef(AbstractRouteDef):
    method: str
    path: str
    handler: _HandlerType
    kwargs: Dict[str, Any]

def __repr__(self) -> str:
        info = []
        for name, value in sorted(self.kwargs.items()):
            info.append(f", {name}={value!r}")
        return "<RouteDef {method} {path} -> {handler.__name__!r}" "{info}>".format(
            method=self.method, path=self.path, handler=self.handler, info="".join(info)
        )

def register(self, router: UrlDispatcher) -> List[AbstractRoute]:
        if self.method in hdrs.METH_ALL:
            reg = getattr(router, "add_" + self.method.lower())
            return [reg(self.path, self.handler, **self.kwargs)]
        else:
            return [
                router.add_route(self.method, self.path, self.handler, **self.kwargs)
            ]

@attr.s(auto_attribs=True, frozen=True, repr=False, slots=True)
class StaticDef(AbstractRouteDef):
    prefix: str
    path: PathLike
    kwargs: Dict[str, Any]

def __repr__(self) -> str:
        info = []
        for name, value in sorted(self.kwargs.items()):
            info.append(f", {name}={value!r}")
        return "<StaticDef {prefix} -> {path}" "{info}>".format(
            prefix=self.prefix, path=self.path, info="".join(info)
        )

def register(self, router: UrlDispatcher) -> List[AbstractRoute]:
        resource = router.add_static(self.prefix, self.path, **self.kwargs)
        routes = resource.get_info().get("routes", {})
        return list(routes.values())

def route(method: str, path: str, handler: _HandlerType, **kwargs: Any) -> RouteDef:
    return RouteDef(method, path, handler, kwargs)

def head(path: str, handler: _HandlerType, **kwargs: Any) -> RouteDef:
    return route(hdrs.METH_HEAD, path, handler, **kwargs)

def options(path: str, handler: _HandlerType, **kwargs: Any) -> RouteDef:
    return route(hdrs.METH_OPTIONS, path, handler, **kwargs)

def get(
    path: str,
    handler: _HandlerType,
    *,
    name: Optional[str] = None,
    allow_head: bool = True,
    **kwargs: Any,
) -> RouteDef:
    return route(
        hdrs.METH_GET, path, handler, name=name, allow_head=allow_head, **kwargs
    )

def post(path: str, handler: _HandlerType, **kwargs: Any) -> RouteDef:
    return route(hdrs.METH_POST, path, handler, **kwargs)

def put(path: str, handler: _HandlerType, **kwargs: Any) -> RouteDef:
    return route(hdrs.METH_PUT, path, handler, **kwargs)

def patch(path: str, handler: _HandlerType, **kwargs: Any) -> RouteDef:
    return route(hdrs.METH_PATCH, path, handler, **kwargs)

def delete(path: str, handler: _HandlerType, **kwargs: Any) -> RouteDef:
    return route(hdrs.METH_DELETE, path, handler, **kwargs)

def view(path: str, handler: Type[AbstractView], **kwargs: Any) -> RouteDef:
    return route(hdrs.METH_ANY, path, handler, **kwargs)

def static(prefix: str, path: PathLike, **kwargs: Any) -> StaticDef:
    return StaticDef(prefix, path, kwargs)

_Deco = Callable[[_HandlerType], _HandlerType]

class RouteTableDef(Sequence[AbstractRouteDef]):
    """Route definition table"""

def __init__(self) -> None:
        self._items = []  # type: List[AbstractRouteDef]

def __repr__(self) -> str:
        return "<RouteTableDef count={}>".format(len(self._items))

@overload
    def __getitem__(self, index: int) -> AbstractRouteDef:
        ...

@overload
    def __getitem__(self, index: slice) -> List[AbstractRouteDef]:
        ...

def __getitem__(self, index):  # type: ignore
        return self._items[index]

def __iter__(self) -> Iterator[AbstractRouteDef]:
        return iter(self._items)

def __len__(self) -> int:
        return len(self._items)

def __contains__(self, item: object) -> bool:
        return item in self._items

def route(self, method: str, path: str, **kwargs: Any) -> _Deco:
        def inner(handler: _HandlerType) -> _HandlerType:
            self._items.append(RouteDef(method, path, handler, kwargs))
            return handler

return inner

def head(self, path: str, **kwargs: Any) -> _Deco:
        return self.route(hdrs.METH_HEAD, path, **kwargs)

def get(self, path: str, **kwargs: Any) -> _Deco:
        return self.route(hdrs.METH_GET, path, **kwargs)

def post(self, path: str, **kwargs: Any) -> _Deco:
        return self.route(hdrs.METH_POST, path, **kwargs)

def put(self, path: str, **kwargs: Any) -> _Deco:
        return self.route(hdrs.METH_PUT, path, **kwargs)

def patch(self, path: str, **kwargs: Any) -> _Deco:
        return self.route(hdrs.METH_PATCH, path, **kwargs)

def delete(self, path: str, **kwargs: Any) -> _Deco:
        return self.route(hdrs.METH_DELETE, path, **kwargs)

def view(self, path: str, **kwargs: Any) -> _Deco:
        return self.route(hdrs.METH_ANY, path, **kwargs)

def static(self, prefix: str, path: PathLike, **kwargs: Any) -> None:
        self._items.append(StaticDef(prefix, path, kwargs))

Hackfut Security File Manager

Editing: web_routedef.py

Upload File

Create Folder