hmdev-cli 1.0.1 → 1.0.3

package/python/.venv/Lib/site-packages/h11/_state.py

@@ -1,365 +0,0 @@
-################################################################
-# The core state machine
-################################################################
-#
-# Rule 1: everything that affects the state machine and state transitions must
-# live here in this file. As much as possible goes into the table-based
-# representation, but for the bits that don't quite fit, the actual code and
-# state must nonetheless live here.
-#
-# Rule 2: this file does not know about what role we're playing; it only knows
-# about HTTP request/response cycles in the abstract. This ensures that we
-# don't cheat and apply different rules to local and remote parties.
-#
-#
-# Theory of operation
-# ===================
-#
-# Possibly the simplest way to think about this is that we actually have 5
-# different state machines here. Yes, 5. These are:
-#
-# 1) The client state, with its complicated automaton (see the docs)
-# 2) The server state, with its complicated automaton (see the docs)
-# 3) The keep-alive state, with possible states {True, False}
-# 4) The SWITCH_CONNECT state, with possible states {False, True}
-# 5) The SWITCH_UPGRADE state, with possible states {False, True}
-#
-# For (3)-(5), the first state listed is the initial state.
-#
-# (1)-(3) are stored explicitly in member variables. The last
-# two are stored implicitly in the pending_switch_proposals set as:
-#   (state of 4) == (_SWITCH_CONNECT in pending_switch_proposals)
-#   (state of 5) == (_SWITCH_UPGRADE in pending_switch_proposals)
-#
-# And each of these machines has two different kinds of transitions:
-#
-# a) Event-triggered
-# b) State-triggered
-#
-# Event triggered is the obvious thing that you'd think it is: some event
-# happens, and if it's the right event at the right time then a transition
-# happens. But there are somewhat complicated rules for which machines can
-# "see" which events. (As a rule of thumb, if a machine "sees" an event, this
-# means two things: the event can affect the machine, and if the machine is
-# not in a state where it expects that event then it's an error.) These rules
-# are:
-#
-# 1) The client machine sees all h11.events objects emitted by the client.
-#
-# 2) The server machine sees all h11.events objects emitted by the server.
-#
-#    It also sees the client's Request event.
-#
-#    And sometimes, server events are annotated with a _SWITCH_* event. For
-#    example, we can have a (Response, _SWITCH_CONNECT) event, which is
-#    different from a regular Response event.
-#
-# 3) The keep-alive machine sees the process_keep_alive_disabled() event
-#    (which is derived from Request/Response events), and this event
-#    transitions it from True -> False, or from False -> False. There's no way
-#    to transition back.
-#
-# 4&5) The _SWITCH_* machines transition from False->True when we get a
-#    Request that proposes the relevant type of switch (via
-#    process_client_switch_proposals), and they go from True->False when we
-#    get a Response that has no _SWITCH_* annotation.
-#
-# So that's event-triggered transitions.
-#
-# State-triggered transitions are less standard. What they do here is couple
-# the machines together. The way this works is, when certain *joint*
-# configurations of states are achieved, then we automatically transition to a
-# new *joint* state. So, for example, if we're ever in a joint state with
-#
-#   client: DONE
-#   keep-alive: False
-#
-# then the client state immediately transitions to:
-#
-#   client: MUST_CLOSE
-#
-# This is fundamentally different from an event-based transition, because it
-# doesn't matter how we arrived at the {client: DONE, keep-alive: False} state
-# -- maybe the client transitioned SEND_BODY -> DONE, or keep-alive
-# transitioned True -> False. Either way, once this precondition is satisfied,
-# this transition is immediately triggered.
-#
-# What if two conflicting state-based transitions get enabled at the same
-# time?  In practice there's only one case where this arises (client DONE ->
-# MIGHT_SWITCH_PROTOCOL versus DONE -> MUST_CLOSE), and we resolve it by
-# explicitly prioritizing the DONE -> MIGHT_SWITCH_PROTOCOL transition.
-#
-# Implementation
-# --------------
-#
-# The event-triggered transitions for the server and client machines are all
-# stored explicitly in a table. Ditto for the state-triggered transitions that
-# involve just the server and client state.
-#
-# The transitions for the other machines, and the state-triggered transitions
-# that involve the other machines, are written out as explicit Python code.
-#
-# It'd be nice if there were some cleaner way to do all this. This isn't
-# *too* terrible, but I feel like it could probably be better.
-#
-# WARNING
-# -------
-#
-# The script that generates the state machine diagrams for the docs knows how
-# to read out the EVENT_TRIGGERED_TRANSITIONS and STATE_TRIGGERED_TRANSITIONS
-# tables. But it can't automatically read the transitions that are written
-# directly in Python code. So if you touch those, you need to also update the
-# script to keep it in sync!
-from typing import cast, Dict, Optional, Set, Tuple, Type, Union
-
-from ._events import *
-from ._util import LocalProtocolError, Sentinel
-
-# Everything in __all__ gets re-exported as part of the h11 public API.
-__all__ = [
-    "CLIENT",
-    "SERVER",
-    "IDLE",
-    "SEND_RESPONSE",
-    "SEND_BODY",
-    "DONE",
-    "MUST_CLOSE",
-    "CLOSED",
-    "MIGHT_SWITCH_PROTOCOL",
-    "SWITCHED_PROTOCOL",
-    "ERROR",
-]
-
-
-class CLIENT(Sentinel, metaclass=Sentinel):
-    pass
-
-
-class SERVER(Sentinel, metaclass=Sentinel):
-    pass
-
-
-# States
-class IDLE(Sentinel, metaclass=Sentinel):
-    pass
-
-
-class SEND_RESPONSE(Sentinel, metaclass=Sentinel):
-    pass
-
-
-class SEND_BODY(Sentinel, metaclass=Sentinel):
-    pass
-
-
-class DONE(Sentinel, metaclass=Sentinel):
-    pass
-
-
-class MUST_CLOSE(Sentinel, metaclass=Sentinel):
-    pass
-
-
-class CLOSED(Sentinel, metaclass=Sentinel):
-    pass
-
-
-class ERROR(Sentinel, metaclass=Sentinel):
-    pass
-
-
-# Switch types
-class MIGHT_SWITCH_PROTOCOL(Sentinel, metaclass=Sentinel):
-    pass
-
-
-class SWITCHED_PROTOCOL(Sentinel, metaclass=Sentinel):
-    pass
-
-
-class _SWITCH_UPGRADE(Sentinel, metaclass=Sentinel):
-    pass
-
-
-class _SWITCH_CONNECT(Sentinel, metaclass=Sentinel):
-    pass
-
-
-EventTransitionType = Dict[
-    Type[Sentinel],
-    Dict[
-        Type[Sentinel],
-        Dict[Union[Type[Event], Tuple[Type[Event], Type[Sentinel]]], Type[Sentinel]],
-    ],
-]
-
-EVENT_TRIGGERED_TRANSITIONS: EventTransitionType = {
-    CLIENT: {
-        IDLE: {Request: SEND_BODY, ConnectionClosed: CLOSED},
-        SEND_BODY: {Data: SEND_BODY, EndOfMessage: DONE},
-        DONE: {ConnectionClosed: CLOSED},
-        MUST_CLOSE: {ConnectionClosed: CLOSED},
-        CLOSED: {ConnectionClosed: CLOSED},
-        MIGHT_SWITCH_PROTOCOL: {},
-        SWITCHED_PROTOCOL: {},
-        ERROR: {},
-    },
-    SERVER: {
-        IDLE: {
-            ConnectionClosed: CLOSED,
-            Response: SEND_BODY,
-            # Special case: server sees client Request events, in this form
-            (Request, CLIENT): SEND_RESPONSE,
-        },
-        SEND_RESPONSE: {
-            InformationalResponse: SEND_RESPONSE,
-            Response: SEND_BODY,
-            (InformationalResponse, _SWITCH_UPGRADE): SWITCHED_PROTOCOL,
-            (Response, _SWITCH_CONNECT): SWITCHED_PROTOCOL,
-        },
-        SEND_BODY: {Data: SEND_BODY, EndOfMessage: DONE},
-        DONE: {ConnectionClosed: CLOSED},
-        MUST_CLOSE: {ConnectionClosed: CLOSED},
-        CLOSED: {ConnectionClosed: CLOSED},
-        SWITCHED_PROTOCOL: {},
-        ERROR: {},
-    },
-}
-
-StateTransitionType = Dict[
-    Tuple[Type[Sentinel], Type[Sentinel]], Dict[Type[Sentinel], Type[Sentinel]]
-]
-
-# NB: there are also some special-case state-triggered transitions hard-coded
-# into _fire_state_triggered_transitions below.
-STATE_TRIGGERED_TRANSITIONS: StateTransitionType = {
-    # (Client state, Server state) -> new states
-    # Protocol negotiation
-    (MIGHT_SWITCH_PROTOCOL, SWITCHED_PROTOCOL): {CLIENT: SWITCHED_PROTOCOL},
-    # Socket shutdown
-    (CLOSED, DONE): {SERVER: MUST_CLOSE},
-    (CLOSED, IDLE): {SERVER: MUST_CLOSE},
-    (ERROR, DONE): {SERVER: MUST_CLOSE},
-    (DONE, CLOSED): {CLIENT: MUST_CLOSE},
-    (IDLE, CLOSED): {CLIENT: MUST_CLOSE},
-    (DONE, ERROR): {CLIENT: MUST_CLOSE},
-}
-
-
-class ConnectionState:
-    def __init__(self) -> None:
-        # Extra bits of state that don't quite fit into the state model.
-
-        # If this is False then it enables the automatic DONE -> MUST_CLOSE
-        # transition. Don't set this directly; call .keep_alive_disabled()
-        self.keep_alive = True
-
-        # This is a subset of {UPGRADE, CONNECT}, containing the proposals
-        # made by the client for switching protocols.
-        self.pending_switch_proposals: Set[Type[Sentinel]] = set()
-
-        self.states: Dict[Type[Sentinel], Type[Sentinel]] = {CLIENT: IDLE, SERVER: IDLE}
-
-    def process_error(self, role: Type[Sentinel]) -> None:
-        self.states[role] = ERROR
-        self._fire_state_triggered_transitions()
-
-    def process_keep_alive_disabled(self) -> None:
-        self.keep_alive = False
-        self._fire_state_triggered_transitions()
-
-    def process_client_switch_proposal(self, switch_event: Type[Sentinel]) -> None:
-        self.pending_switch_proposals.add(switch_event)
-        self._fire_state_triggered_transitions()
-
-    def process_event(
-        self,
-        role: Type[Sentinel],
-        event_type: Type[Event],
-        server_switch_event: Optional[Type[Sentinel]] = None,
-    ) -> None:
-        _event_type: Union[Type[Event], Tuple[Type[Event], Type[Sentinel]]] = event_type
-        if server_switch_event is not None:
-            assert role is SERVER
-            if server_switch_event not in self.pending_switch_proposals:
-                raise LocalProtocolError(
-                    "Received server _SWITCH_UPGRADE event without a pending proposal"
-                )
-            _event_type = (event_type, server_switch_event)
-        if server_switch_event is None and _event_type is Response:
-            self.pending_switch_proposals = set()
-        self._fire_event_triggered_transitions(role, _event_type)
-        # Special case: the server state does get to see Request
-        # events.
-        if _event_type is Request:
-            assert role is CLIENT
-            self._fire_event_triggered_transitions(SERVER, (Request, CLIENT))
-        self._fire_state_triggered_transitions()
-
-    def _fire_event_triggered_transitions(
-        self,
-        role: Type[Sentinel],
-        event_type: Union[Type[Event], Tuple[Type[Event], Type[Sentinel]]],
-    ) -> None:
-        state = self.states[role]
-        try:
-            new_state = EVENT_TRIGGERED_TRANSITIONS[role][state][event_type]
-        except KeyError:
-            event_type = cast(Type[Event], event_type)
-            raise LocalProtocolError(
-                "can't handle event type {} when role={} and state={}".format(
-                    event_type.__name__, role, self.states[role]
-                )
-            ) from None
-        self.states[role] = new_state
-
-    def _fire_state_triggered_transitions(self) -> None:
-        # We apply these rules repeatedly until converging on a fixed point
-        while True:
-            start_states = dict(self.states)
-
-            # It could happen that both these special-case transitions are
-            # enabled at the same time:
-            #
-            #    DONE -> MIGHT_SWITCH_PROTOCOL
-            #    DONE -> MUST_CLOSE
-            #
-            # For example, this will always be true of a HTTP/1.0 client
-            # requesting CONNECT.  If this happens, the protocol switch takes
-            # priority. From there the client will either go to
-            # SWITCHED_PROTOCOL, in which case it's none of our business when
-            # they close the connection, or else the server will deny the
-            # request, in which case the client will go back to DONE and then
-            # from there to MUST_CLOSE.
-            if self.pending_switch_proposals:
-                if self.states[CLIENT] is DONE:
-                    self.states[CLIENT] = MIGHT_SWITCH_PROTOCOL
-
-            if not self.pending_switch_proposals:
-                if self.states[CLIENT] is MIGHT_SWITCH_PROTOCOL:
-                    self.states[CLIENT] = DONE
-
-            if not self.keep_alive:
-                for role in (CLIENT, SERVER):
-                    if self.states[role] is DONE:
-                        self.states[role] = MUST_CLOSE
-
-            # Tabular state-triggered transitions
-            joint_state = (self.states[CLIENT], self.states[SERVER])
-            changes = STATE_TRIGGERED_TRANSITIONS.get(joint_state, {})
-            self.states.update(changes)
-
-            if self.states == start_states:
-                # Fixed point reached
-                return
-
-    def start_next_cycle(self) -> None:
-        if self.states != {CLIENT: DONE, SERVER: DONE}:
-            raise LocalProtocolError(
-                f"not in a reusable state. self.states={self.states}"
-            )
-        # Can't reach DONE/DONE with any of these active, but still, let's be
-        # sure.
-        assert self.keep_alive
-        assert not self.pending_switch_proposals
-        self.states = {CLIENT: IDLE, SERVER: IDLE}

package/python/.venv/Lib/site-packages/h11/_util.py

@@ -1,135 +0,0 @@
-from typing import Any, Dict, NoReturn, Pattern, Tuple, Type, TypeVar, Union
-
-__all__ = [
-    "ProtocolError",
-    "LocalProtocolError",
-    "RemoteProtocolError",
-    "validate",
-    "bytesify",
-]
-
-
-class ProtocolError(Exception):
-    """Exception indicating a violation of the HTTP/1.1 protocol.
-
-    This as an abstract base class, with two concrete base classes:
-    :exc:`LocalProtocolError`, which indicates that you tried to do something
-    that HTTP/1.1 says is illegal, and :exc:`RemoteProtocolError`, which
-    indicates that the remote peer tried to do something that HTTP/1.1 says is
-    illegal. See :ref:`error-handling` for details.
-
-    In addition to the normal :exc:`Exception` features, it has one attribute:
-
-    .. attribute:: error_status_hint
-
-       This gives a suggestion as to what status code a server might use if
-       this error occurred as part of a request.
-
-       For a :exc:`RemoteProtocolError`, this is useful as a suggestion for
-       how you might want to respond to a misbehaving peer, if you're
-       implementing a server.
-
-       For a :exc:`LocalProtocolError`, this can be taken as a suggestion for
-       how your peer might have responded to *you* if h11 had allowed you to
-       continue.
-
-       The default is 400 Bad Request, a generic catch-all for protocol
-       violations.
-
-    """
-
-    def __init__(self, msg: str, error_status_hint: int = 400) -> None:
-        if type(self) is ProtocolError:
-            raise TypeError("tried to directly instantiate ProtocolError")
-        Exception.__init__(self, msg)
-        self.error_status_hint = error_status_hint
-
-
-# Strategy: there are a number of public APIs where a LocalProtocolError can
-# be raised (send(), all the different event constructors, ...), and only one
-# public API where RemoteProtocolError can be raised
-# (receive_data()). Therefore we always raise LocalProtocolError internally,
-# and then receive_data will translate this into a RemoteProtocolError.
-#
-# Internally:
-#   LocalProtocolError is the generic "ProtocolError".
-# Externally:
-#   LocalProtocolError is for local errors and RemoteProtocolError is for
-#   remote errors.
-class LocalProtocolError(ProtocolError):
-    def _reraise_as_remote_protocol_error(self) -> NoReturn:
-        # After catching a LocalProtocolError, use this method to re-raise it
-        # as a RemoteProtocolError. This method must be called from inside an
-        # except: block.
-        #
-        # An easy way to get an equivalent RemoteProtocolError is just to
-        # modify 'self' in place.
-        self.__class__ = RemoteProtocolError  # type: ignore
-        # But the re-raising is somewhat non-trivial -- you might think that
-        # now that we've modified the in-flight exception object, that just
-        # doing 'raise' to re-raise it would be enough. But it turns out that
-        # this doesn't work, because Python tracks the exception type
-        # (exc_info[0]) separately from the exception object (exc_info[1]),
-        # and we only modified the latter. So we really do need to re-raise
-        # the new type explicitly.
-        # On py3, the traceback is part of the exception object, so our
-        # in-place modification preserved it and we can just re-raise:
-        raise self
-
-
-class RemoteProtocolError(ProtocolError):
-    pass
-
-
-def validate(
-    regex: Pattern[bytes], data: bytes, msg: str = "malformed data", *format_args: Any
-) -> Dict[str, bytes]:
-    match = regex.fullmatch(data)
-    if not match:
-        if format_args:
-            msg = msg.format(*format_args)
-        raise LocalProtocolError(msg)
-    return match.groupdict()
-
-
-# Sentinel values
-#
-# - Inherit identity-based comparison and hashing from object
-# - Have a nice repr
-# - Have a *bonus property*: type(sentinel) is sentinel
-#
-# The bonus property is useful if you want to take the return value from
-# next_event() and do some sort of dispatch based on type(event).
-
-_T_Sentinel = TypeVar("_T_Sentinel", bound="Sentinel")
-
-
-class Sentinel(type):
-    def __new__(
-        cls: Type[_T_Sentinel],
-        name: str,
-        bases: Tuple[type, ...],
-        namespace: Dict[str, Any],
-        **kwds: Any
-    ) -> _T_Sentinel:
-        assert bases == (Sentinel,)
-        v = super().__new__(cls, name, bases, namespace, **kwds)
-        v.__class__ = v  # type: ignore
-        return v
-
-    def __repr__(self) -> str:
-        return self.__name__
-
-
-# Used for methods, request targets, HTTP versions, header names, and header
-# values. Accepts ascii-strings, or bytes/bytearray/memoryview/..., and always
-# returns bytes.
-def bytesify(s: Union[bytes, bytearray, memoryview, int, str]) -> bytes:
-    # Fast-path:
-    if type(s) is bytes:
-        return s
-    if isinstance(s, str):
-        s = s.encode("ascii")
-    if isinstance(s, int):
-        raise TypeError("expected bytes-like object, not int")
-    return bytes(s)

package/python/.venv/Lib/site-packages/h11/_version.py

@@ -1,16 +0,0 @@
-# This file must be kept very simple, because it is consumed from several
-# places -- it is imported by h11/__init__.py, execfile'd by setup.py, etc.
-
-# We use a simple scheme:
-#   1.0.0 -> 1.0.0+dev -> 1.1.0 -> 1.1.0+dev
-# where the +dev versions are never released into the wild, they're just what
-# we stick into the VCS in between releases.
-#
-# This is compatible with PEP 440:
-#   http://legacy.python.org/dev/peps/pep-0440/
-# via the use of the "local suffix" "+dev", which is disallowed on index
-# servers and causes 1.0.0+dev to sort after plain 1.0.0, which is what we
-# want. (Contrast with the special suffix 1.0.0.dev, which sorts *before*
-# 1.0.0.)
-
-__version__ = "0.16.0"

package/python/.venv/Lib/site-packages/h11/_writers.py

@@ -1,145 +0,0 @@
-# Code to read HTTP data
-#
-# Strategy: each writer takes an event + a write-some-bytes function, which is
-# calls.
-#
-# WRITERS is a dict describing how to pick a reader. It maps states to either:
-# - a writer
-# - or, for body writers, a dict of framin-dependent writer factories
-
-from typing import Any, Callable, Dict, List, Tuple, Type, Union
-
-from ._events import Data, EndOfMessage, Event, InformationalResponse, Request, Response
-from ._headers import Headers
-from ._state import CLIENT, IDLE, SEND_BODY, SEND_RESPONSE, SERVER
-from ._util import LocalProtocolError, Sentinel
-
-__all__ = ["WRITERS"]
-
-Writer = Callable[[bytes], Any]
-
-
-def write_headers(headers: Headers, write: Writer) -> None:
-    # "Since the Host field-value is critical information for handling a
-    # request, a user agent SHOULD generate Host as the first header field
-    # following the request-line." - RFC 7230
-    raw_items = headers._full_items
-    for raw_name, name, value in raw_items:
-        if name == b"host":
-            write(b"%s: %s\r\n" % (raw_name, value))
-    for raw_name, name, value in raw_items:
-        if name != b"host":
-            write(b"%s: %s\r\n" % (raw_name, value))
-    write(b"\r\n")
-
-
-def write_request(request: Request, write: Writer) -> None:
-    if request.http_version != b"1.1":
-        raise LocalProtocolError("I only send HTTP/1.1")
-    write(b"%s %s HTTP/1.1\r\n" % (request.method, request.target))
-    write_headers(request.headers, write)
-
-
-# Shared between InformationalResponse and Response
-def write_any_response(
-    response: Union[InformationalResponse, Response], write: Writer
-) -> None:
-    if response.http_version != b"1.1":
-        raise LocalProtocolError("I only send HTTP/1.1")
-    status_bytes = str(response.status_code).encode("ascii")
-    # We don't bother sending ascii status messages like "OK"; they're
-    # optional and ignored by the protocol. (But the space after the numeric
-    # status code is mandatory.)
-    #
-    # XX FIXME: could at least make an effort to pull out the status message
-    # from stdlib's http.HTTPStatus table. Or maybe just steal their enums
-    # (either by import or copy/paste). We already accept them as status codes
-    # since they're of type IntEnum < int.
-    write(b"HTTP/1.1 %s %s\r\n" % (status_bytes, response.reason))
-    write_headers(response.headers, write)
-
-
-class BodyWriter:
-    def __call__(self, event: Event, write: Writer) -> None:
-        if type(event) is Data:
-            self.send_data(event.data, write)
-        elif type(event) is EndOfMessage:
-            self.send_eom(event.headers, write)
-        else:  # pragma: no cover
-            assert False
-
-    def send_data(self, data: bytes, write: Writer) -> None:
-        pass
-
-    def send_eom(self, headers: Headers, write: Writer) -> None:
-        pass
-
-
-#
-# These are all careful not to do anything to 'data' except call len(data) and
-# write(data). This allows us to transparently pass-through funny objects,
-# like placeholder objects referring to files on disk that will be sent via
-# sendfile(2).
-#
-class ContentLengthWriter(BodyWriter):
-    def __init__(self, length: int) -> None:
-        self._length = length
-
-    def send_data(self, data: bytes, write: Writer) -> None:
-        self._length -= len(data)
-        if self._length < 0:
-            raise LocalProtocolError("Too much data for declared Content-Length")
-        write(data)
-
-    def send_eom(self, headers: Headers, write: Writer) -> None:
-        if self._length != 0:
-            raise LocalProtocolError("Too little data for declared Content-Length")
-        if headers:
-            raise LocalProtocolError("Content-Length and trailers don't mix")
-
-
-class ChunkedWriter(BodyWriter):
-    def send_data(self, data: bytes, write: Writer) -> None:
-        # if we encoded 0-length data in the naive way, it would look like an
-        # end-of-message.
-        if not data:
-            return
-        write(b"%x\r\n" % len(data))
-        write(data)
-        write(b"\r\n")
-
-    def send_eom(self, headers: Headers, write: Writer) -> None:
-        write(b"0\r\n")
-        write_headers(headers, write)
-
-
-class Http10Writer(BodyWriter):
-    def send_data(self, data: bytes, write: Writer) -> None:
-        write(data)
-
-    def send_eom(self, headers: Headers, write: Writer) -> None:
-        if headers:
-            raise LocalProtocolError("can't send trailers to HTTP/1.0 client")
-        # no need to close the socket ourselves, that will be taken care of by
-        # Connection: close machinery
-
-
-WritersType = Dict[
-    Union[Tuple[Type[Sentinel], Type[Sentinel]], Type[Sentinel]],
-    Union[
-        Dict[str, Type[BodyWriter]],
-        Callable[[Union[InformationalResponse, Response], Writer], None],
-        Callable[[Request, Writer], None],
-    ],
-]
-
-WRITERS: WritersType = {
-    (CLIENT, IDLE): write_request,
-    (SERVER, IDLE): write_any_response,
-    (SERVER, SEND_RESPONSE): write_any_response,
-    SEND_BODY: {
-        "chunked": ChunkedWriter,
-        "content-length": ContentLengthWriter,
-        "http/1.0": Http10Writer,
-    },
-}

package/python/.venv/Lib/site-packages/h11/py.typed

@@ -1 +0,0 @@
-Marker

package/python/.venv/Lib/site-packages/h11-0.16.0.dist-info/INSTALLER

@@ -1 +0,0 @@
-pip