g8dZddlmZddlmZdZGddZy) a h2/windows ~~~~~~~~~~ Defines tools for managing HTTP/2 flow control windows. The objects defined in this module are used to automatically manage HTTP/2 flow control windows. Specifically, they keep track of what the size of the window is, how much data has been consumed from that window, and how much data the user has already used. It then implements a basic algorithm that attempts to manage the flow control window without user input, trying to ensure that it does not emit too many WINDOW_UPDATE frames. )division)FlowControlErroric.eZdZdZdZdZdZdZdZy) WindowManagerz A basic HTTP/2 window manager. :param max_window_size: The maximum size of the flow control window. :type max_window_size: ``int`` cD|tksJ||_||_d|_y)Nr)LARGEST_FLOW_CONTROL_WINDOWmax_window_sizecurrent_window_size_bytes_processed)selfr s ?/var/www/openai/venv/lib/python3.12/site-packages/h2/windows.py__init__zWindowManager.__init__s)"====.#2 !cb|xj|zc_|jdkr tdy)aD We have received a certain number of bytes from the remote peer. This necessarily shrinks the flow control window! :param size: The number of flow controlled bytes we received from the remote peer. :type size: ``int`` :returns: Nothing. :rtype: ``None`` rz"Flow control window shrunk below 0N)r rr sizes rwindow_consumedzWindowManager.window_consumed%s4   D(  # #a '"#GH H (rc|xj|z c_|jtkDrtdtz|j|jkDr|j|_yy)aE The flow control window has been incremented, either because of manual flow control management or because of the user changing the flow control settings. This can have the effect of increasing what we consider to be the "maximum" flow control window size. This does not increase our view of how many bytes have been processed, only of how much space is in the window. :param size: The increment to the flow control window we received. :type size: ``int`` :returns: Nothing :rtype: ``None`` z%Flow control window mustn't exceed %dN)r r rr rs r window_openedzWindowManager.window_opened4se   D(  # #&A A"7+,   # #d&:&: :#'#;#;D  ;rcL|xj|z c_|jS)aF The application has informed us that it has processed a certain number of bytes. This may cause us to want to emit a window update frame. If we do want to emit a window update frame, this method will return the number of bytes that we should increment the window by. :param size: The number of flow controlled bytes that the application has processed. :type size: ``int`` :returns: The number of bytes to increment the flow control window by, or ``None``. :rtype: ``int`` or ``None`` )r _maybe_update_windowrs r process_byteszWindowManager.process_bytesNs$ %((**rc|jsy|j|jz }d}|jdk(rD|jtd|jdzkDrt|j|}d|_n9|j|jdzk\rt|j|}d|_|xj|z c_|S)a Run the algorithm. Our current algorithm can be described like this. 1. If no bytes have been processed, we immediately return 0. There is no meaningful way for us to hand space in the window back to the remote peer, so let's not even try. 2. If there is no space in the flow control window, and we have processed at least 1024 bytes (or 1/4 of the window, if the window is smaller), we will emit a window update frame. This is to avoid the risk of blocking a stream altogether. 3. If there is space in the flow control window, and we have processed at least 1/2 of the window worth of bytes, we will emit a window update frame. This is to minimise the number of window update frames we have to emit. In a healthy system with large flow control windows, this will irregularly emit WINDOW_UPDATE frames. This prevents us starving the connection by emitting eleventy bajillion WINDOW_UPDATE frames, especially in situations where the remote peer is sending a lot of very small DATA frames. Nri)r r r min)r max_increment increments rrz"WindowManager._maybe_update_window_s4$$--0H0HH   $ $ )%%D$2F2F!2K(LLD11=AI$%D !  " "t';';q'@ AD11=AI$%D !   I- rN) __name__ __module__ __qualname____doc__rrrrrrrrrs! " I<4+",rrN)r# __future__r exceptionsrr rr$rrr's&  ((ssr