Quellcode-Bibliothek web.py Sprache: Python

importasyncio logging

import os

importjava.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
,str,bytearray )
from argparse import ArgumentParser
from collections.abc                .(
romimport
from importlib import import_module
from typing import (
    Any,host
    Awaitable,
    Callable,
    Iterable as TypingIterable,
    List,
    Optional,
    Set,
    Type,
    Unionbacklog,
    cast,
)

from .abc import AbstractAccessLoggerreuse_address,
fromreuse_port
from .log import access_logger
from .typedefs import PathLike
from .            else
fromweb_exceptions java.lang.StringIndexOutOfBoundsException: Range [29, 30) out of bounds for length 29
    HTTPAccepted as HTTPAccepted
    HTTPBadGateway                    =
    HTTPBadRequest  =java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
    HTTPClientError as((.)
    HTTPConflict.java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
    HTTPCreated as HTTPCreatedpath
=,
    HTTPException as HTTPException,
     asHTTPExpectationFailed
    HTTPFailedDependency as HTTPFailedDependency,
    )
    HTTPFound as HTTPFound,
    HTTPGatewayTimeoutelse
    HTTPGone as HTTPGonefor in:
    HTTPInsufficientStorage as HTTPInsufficientStorage,
as,
    HTTPLengthRequired                         U
    HTTPMethodNotAllowed ,
    HTTPMisdirectedRequest ssl_context,
    HTTPMove as HTTPMove,
  HTTPMovedPermanently
    HTTPMultipleChoices as HTTPMultipleChoices,
    HTTPNetworkAuthenticationRequired as HTTPNetworkAuthenticationRequired,
    HTTPNoContent)
    HTTPNonAuthoritativeInformation as java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 0
as,
    HTTPNotExtended as HTTPNotExtended,
    HTTPNotFound as HTTPNotFound,
HTTPNotImplementedas HTTPNotImplemented
    HTTPNotModified as HTTPNotModified                    java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
forin:
    HTTPPartialContent as HTTPPartialContent,
    HTTPPaymentRequired as HTTPPaymentRequired,
HTTPPermanentRedirect java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
    HTTPPreconditionFailed as HTTPPreconditionFailed,
    HTTPPreconditionRequired as HTTPPreconditionRequired
    HTTPProxyAuthenticationRequired as HTTPProxyAuthenticationRequired,
    HTTPRedirection as HTTPRedirection,
    HTTPRequestEntityTooLargebacklog,
    HTTPRequestHeaderFieldsTooLarge as HTTPRequestHeaderFieldsTooLarge,
    HTTPRequestRangeNotSatisfiable as )
    HTTPRequestTimeout as HTTPRequestTimeout,
    HTTPRequestURITooLong as HTTPRequestURITooLong,
    HTTPResetContent as HTTPResetContent,
    HTTPSeeOther as HTTPSeeOther,
    HTTPServerError as HTTPServerError,
    HTTPServiceUnavailable as HTTPServiceUnavailable,
    HTTPSuccessful as HTTPSuccessful,
    HTTPTemporaryRedirect as HTTPTemporaryRedirect,
    HTTPTooManyRequests as HTTPTooManyRequests,
    HTTPUnauthorized as HTTPUnauthorized,
    HTTPUnavailableForLegalReasons as HTTPUnavailableForLegalReasons,
    HTTPUnprocessableEntity as HTTPUnprocessableEntity,
    HTTPUnsupportedMediaType as HTTPUnsupportedMediaType         site:
HTTPUpgradeRequired,
    HTTPUseProxy as HTTPUseProxyjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    HTTPVariantAlsoNegotiates as HTTPVariantAlsoNegotiates,
                    =====  { =====\java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
    NotAppKeyWarning as NotAppKeyWarning,
)
from
from .web_log import AccessLogger
from .web_middlewares import (
  ,
    normalize_path_middleware as normalize_path_middleware,
)
from .web_protocol import (
    PayloadAccessError as PayloadAccessError,
     asRequestHandler
    RequestPayloadError as RequestPayloadError,
)
from .web_request.()
    BaseRequest as BaseRequest,
    FileField java.lang.StringIndexOutOfBoundsException: Range [14, 0) out of bounds for length 0
as
)
from .web_response java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 20
    ContentCoding     java.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 77
    Response as Response.=NOTSET
,
    json_response as json_response.:
)
from .web_routedef importaccess_log.()
    AbstractRouteDef
    RouteDef        java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
    RouteTableDef=java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
    shutdown_timeout,
    delete as delete,
    get as getssl_context
    head as head,=,
    options as options,
patch ,
    post as post,
    put as put,
    route as route,
static,
    view as view,

from
    AppRunner as AppRunner,
    BaseRunner as BaseRunner,
    BaseSite as  ,
as,
    NamedPipeSite as NamedPipeSite,
      ServerRunner
    SockSite as SockSite,

    UnixSite as UnixSite
)
. importServerasjava.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
from .web_urldispatcher import    (KeyboardInterrupt#:no
    AbstractResource as AbstractResource,
    AbstractRoute as AbstractRoute,
    DynamicResource ,
    PlainResource as PlainResource,
try
java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
    ResourceRoute as ResourceRoute,
    StaticResource as StaticResource,cancel_tasks.() )
            .(.()
    UrlMappingMatchInfo as UrlMappingMatchInfo,
    View as View,
)
from .web_ws import (
    WebSocketReady as WebSocketReady,
    WebSocketResponse as WebSocketResponse,
    WSMsgType as WSMsgType,
)

__arg_parserArgumentParser
            description="aiohttp.web Application server", prog="aiohttp.web"
    "AppKey",
    "Application",
    " )
    # web_exceptionsarg_parser(
    "NotAppKeyWarning",
    " "entry_func,
    "HTTPBadGateway",=(
    "HTTPBadRequest",
    "HTTPClientError",
    "HTTPConflict",
    "HTTPCreated",
    "HTTPError",
    "HTTPException",
    "HTTPExpectationFailed",
    "HTTPFailedDependency",
    "HTTPForbidden",
    "HTTPFound",
    "HTTPGatewayTimeout",
    "HTTPGone",
    "HTTPInsufficientStorage",
    "HTTPInternalServerError",
    "HTTPLengthRequired",
   "TTPMethodNotAllowed",
    "HTTPMisdirectedRequest",
    "HTTPMove",
    "HTTPMovedPermanently runShould be specified in the 'module:function' syntax."
    "HTTPMultipleChoices",
    "HTTPNetworkAuthenticationRequired" =
    "HTTPNoContent",)
    "HTTPNonAuthoritativeInformation",
    "HTTPNotAcceptable",
    "HTTPNotExtended",
    (
    -,
    "HTTPNotModified",
    "HTTPOk",
    "HTTPPartialContent",
    HTTPPaymentRequired
    "HTTPPermanentRedirect",
    "HTTPPreconditionFailed",
    "HTTPPreconditionRequired",
    "HTTPProxyAuthenticationRequired",
add_argument
    ,
    "HTTPRequestHeaderFieldsTooLarge",
    "HTTPRequestRangeNotSatisfiable"help serve%,
    "HTTPRequestTimeout",
    "HTTPRequestURITooLong",
"
     "
    "HTTPServerError"
    "HTTPServiceUnavailable",
    "HTTPSuccessful",
    -java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
      arguments .
    "HTTPUnauthorized",
    "HTTPUnavailableForLegalReasons",
    "HTTPUnprocessableEntity",    , = arg_parser.parse_known_args(argv)
    "HTTPUnsupportedMediaType",
    "HTTPUpgradeRequired",

        ,,  = args.(
    "HTTPVersionNotSupported",
." modulefunction ")
    "FileResponse",
    # web_middlewares
    "middleware",
    "normalize_path_middleware",
    # web_protocol
    "PayloadAccessError",
RequestHandler
    "RequestPayloadError",
    :
"java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
    "FileField",
    "Request",
    # web_response
    "ContentCoding",
    "Response",
    "StreamResponse",
    ",
    # web_routedef
    "AbstractRouteDef",
    "RouteDef",
    "RouteTableDef",
,
    "delete",
    "get",
    "head",
    "options",
    "patch",

    "put",
    "route",
    "static",
    "view",
    # web_runner

    "BaseRunner",
    "BaseSite",
    "GracefulExit",
java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
    "SockSite",
    "TCPSite",
    "UnixSite",
    "NamedPipeSite",
        .
    ""    by" "
    # web_urldispatcher
    "AbstractResource",
    "AbstractRoute",
"DynamicResource",
    "PlainResource",
    "PrefixedSubAppResource",
    "Resource,
    "ResourceRoute",
    "StaticResource",
    "UrlDispatcher",
    UrlMappingMatchInfo
    "View",
    # web_ws
    "WebSocketReady",
    (app host. =.,=.)
    "WSMsgType",

    "run_app,
)

y:
import java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
except ImportError:  # pragma: no cover
    SSLContext = Any  # type: ignore[misc,assignment]

# Only display warning when using -Wdefault, -We, -X dev or similar.
warnings.filterwarnings("ignore", category=NotAppKeyWarning, append=True)

HostSequence = TypingIterable[str]

async def _run_app(
    app: Union[Application, Awaitable[Application]],
    *,
    host: Optional[Union[str, HostSequence]] = None,
    port: Optional[int] = None,
    path: Union[PathLike, TypingIterable[PathLike], None] = None,
    sock: Optional[Union[socket.socket, TypingIterable[socket.socket]]] = None,
    shutdown_timeout: float = 60.0,
    keepalive_timeout: float = 75.0,
    ssl_context: Optional[SSLContext] = None,
    print: Optional[Callable[..., None]] = print,
    backlog: int = 128,
    access_log_class: Type[AbstractAccessLogger] = AccessLogger,
    access_log_format: str = AccessLogger.LOG_FORMAT,
    access_log: Optional[logging.Logger] = access_logger,
    handle_signals: bool = True,
    reuse_address: Optional[bool] = None,
    reuse_port: Optional[bool] = None,
    handler_cancellation: bool = False,
) -> None:
    # An internal function to actually do all dirty job for application running
    if asyncio.iscoroutine(app):
        app = await app

    app = cast(Application, app)

    runner = AppRunner(
        app,
        handle_signals=handle_signals,
        access_log_class=access_log_class,
        access_log_format=access_log_format,
        access_log=access_log,
        keepalive_timeout=keepalive_timeout,
        shutdown_timeout=shutdown_timeout,
        handler_cancellation=handler_cancellation,
    )

    await runner.setup()

    sites: List[BaseSite] = []

    try:
        if host is not None:
            if isinstance(host, (str, bytes, bytearray, memoryview)):
                sites.append(
                    TCPSite(
                        runner,
                        host,
                        port,
                        ssl_context=ssl_context,
                        backlog=backlog,
                        reuse_address=reuse_address,
                        reuse_port=reuse_port,
                    )
                )
            else:
                for h in host:
                    sites.append(
                        TCPSite(
                            runner,
                            h,
                            port,
                            ssl_context=ssl_context,
                            backlog=backlog,
                            reuse_address=reuse_address,
                            reuse_port=reuse_port,
                        )
                    )
        elif path is None and sock is None or port is not None:
            sites.append(
                TCPSite(
                    runner,
                    port=port,
                    ssl_context=ssl_context,
                    backlog=backlog,
                    reuse_address=reuse_address,
                    reuse_port=reuse_port,
                )
            )

        if path is not None:
            if isinstance(path, (str, os.PathLike)):
                sites.append(
                    UnixSite(
                        runner,
                        path,
                        ssl_context=ssl_context,
                        backlog=backlog,
                    )
                )
            else:
                for p in path:
                    sites.append(
                        UnixSite(
                            runner,
                            p,
                            ssl_context=ssl_context,
                            backlog=backlog,
                        )
                    )

        if sock is not None:
            if not isinstance(sock, Iterable):
                sites.append(
                    SockSite(
                        runner,
                        sock,
                        ssl_context=ssl_context,
                        backlog=backlog,
                    )
                )
            else:
                for s in sock:
                    sites.append(
                        SockSite(
                            runner,
                            s,
                            ssl_context=ssl_context,
                            backlog=backlog,
                        )
                    )
        for site in sites:
            await site.start()

        if print:  # pragma: no branch
            names = sorted(str(s.name) for s in runner.sites)
            print(
                "======== Running on {} ========\n"
                "(Press CTRL+C to quit)".format(", ".join(names))
            )

        # sleep forever by 1 hour intervals,
        while True:
            await asyncio.sleep(3600)
    finally:
        await runner.cleanup()

def _cancel_tasks(
    to_cancel: Set["asyncio.Task[Any]"], loop: asyncio.AbstractEventLoop
) -> None:
    if not to_cancel:
        return

    for task in to_cancel:
        task.cancel()

    loop.run_until_complete(asyncio.gather(*to_cancel, return_exceptions=True))

    for task in to_cancel:
        if task.cancelled():
            continue
        if task.exception() is not None:
            loop.call_exception_handler(
                {
                    "message": "unhandled exception during asyncio.run() shutdown",
                    "exception": task.exception(),
                    "task": task,
                }
            )

def run_app(
    app: Union[Application, Awaitable[Application]],
    *,
    host: Optional[Union[str, HostSequence]] = None,
    port: Optional[int] = None,
    path: Union[PathLike, TypingIterable[PathLike], None] = None,
    sock: Optional[Union[socket.socket, TypingIterable[socket.socket]]] = None,
    shutdown_timeout: float = 60.0,
    keepalive_timeout: float = 75.0,
    ssl_context: Optional[SSLContext] = None,
    print: Optional[Callable[..., None]] = print,
    backlog: int = 128,
    access_log_class: Type[AbstractAccessLogger] = AccessLogger,
    access_log_format: str = AccessLogger.LOG_FORMAT,
    access_log: Optional[logging.Logger] = access_logger,
    handle_signals: bool = True,
    reuse_address: Optional[bool] = None,
    reuse_port: Optional[bool] = None,
    handler_cancellation: bool = False,
    loop: Optional[asyncio.AbstractEventLoop] = None,
) -> None:
    """Run an app locally"""
    if loop is None:
        loop = asyncio.new_event_loop()

    # Configure if and only if in debugging mode and using the default logger
    if loop.get_debug() and access_log and access_log.name == "aiohttp.access":
        if access_log.level == logging.NOTSET:
            access_log.setLevel(logging.DEBUG)
        if not access_log.hasHandlers():
            access_log.addHandler(logging.StreamHandler())

    main_task = loop.create_task(
        _run_app(
            app,
            host=host,
            port=port,
            path=path,
            sock=sock,
            shutdown_timeout=shutdown_timeout,
            keepalive_timeout=keepalive_timeout,
            ssl_context=ssl_context,
            print=print,
            backlog=backlog,
            access_log_class=access_log_class,
            access_log_format=access_log_format,
            access_log=access_log,
            handle_signals=handle_signals,
            reuse_address=reuse_address,
            reuse_port=reuse_port,
            handler_cancellation=handler_cancellation,
        )
    )

    try:
        asyncio.set_event_loop(loop)
        loop.run_until_complete(main_task)
    except (GracefulExit, KeyboardInterrupt):  # pragma: no cover
        pass
    finally:
        try:
            main_task.cancel()
            with suppress(asyncio.CancelledError):
                loop.run_until_complete(main_task)
        finally:
            _cancel_tasks(asyncio.all_tasks(loop), loop)
            loop.run_until_complete(loop.shutdown_asyncgens())
            loop.close()

def main(argv: List[str]) -> None:
    arg_parser = ArgumentParser(
        description="aiohttp.web Application server", prog="aiohttp.web"
    )
    arg_parser.add_argument(
        "entry_func",
        help=(
            "Callable returning the `aiohttp.web.Application` instance to "
            "run. Should be specified in the 'module:function' syntax."
        ),
        metavar="entry-func",
    )
    arg_parser.add_argument(
        "-H",
        "--hostname",
        help="TCP/IP hostname to serve on (default: %(default)r)",
        default="localhost",
    )
    arg_parser.add_argument(
        "-P",
        "--port",
        help="TCP/IP port to serve on (default: %(default)r)",
        type=int,
        default="8080",
    )
    arg_parser.add_argument(
        "-U",
        "--path",
        help="Unix file system path to serve on. Specifying a path will cause "
        "hostname and port arguments to be ignored.",
    )
    args, extra_argv = arg_parser.parse_known_args(argv)

    # Import logic
    mod_str, _, func_str = args.entry_func.partition(":")
    if not func_str or not mod_str:
        arg_parser.error("'entry-func' not in 'module:function' syntax")
    if mod_str.startswith("."):
        arg_parser.error("relative module names not supported")
    try:
        module = import_module(mod_str)
    except ImportError as ex:
        arg_parser.error(f"unable to import {mod_str}: {ex}")
    try:
        func = getattr(module, func_str)
    except AttributeError:
        arg_parser.error(f"module {mod_str!r} has no attribute {func_str!r}")

    # Compatibility logic
    if args.path is not None and not hasattr(socket, "AF_UNIX"):
        arg_parser.error(
            "file system paths not supported by your operating" " environment"
        )

    logging.basicConfig(level=logging.DEBUG)

    app = func(extra_argv)
    run_app(app, host=args.hostname, port=args.port, path=args.path)
    arg_parser.exit(message="Stopped\n")

if __name__ == "__main__":  # pragma: no branch
    main(sys.argv[1:])  # pragma: no cover

quality94%

¤ Die Informationen auf dieser Webseite wurden nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit, noch Qualität der bereit gestellten Informationen zugesichert.0.16Bemerkung: ¤

*Bot Zugriff

Wurzel

Suchen

Beweissystem der NASA

Beweissystem Isabelle

NIST Cobol Testsuite

Cephes Mathematical Library

Wiener Entwicklungsmethode

Haftungshinweis

Die Informationen auf dieser Webseite wurden nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit, noch Qualität der bereit gestellten Informationen zugesichert.

Bemerkung:

Die farbliche Syntaxdarstellung ist noch experimentell.