Add files using upload-large-folder tool

.venv/Lib/site-packages/unidic_lite/dicdir/char.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:dd31396563d8924645b80fd3c9aa7b13ca089d7748f25553a1d6bc3f9b511ae8
+size 262496

.venv/Lib/site-packages/urllib3/contrib/emscripten/__init__.py

@@ -0,0 +1,16 @@
+from __future__ import annotations
+
+import urllib3.connection
+
+from ...connectionpool import HTTPConnectionPool, HTTPSConnectionPool
+from .connection import EmscriptenHTTPConnection, EmscriptenHTTPSConnection
+
+
+def inject_into_urllib3() -> None:
+    # override connection classes to use emscripten specific classes
+    # n.b. mypy complains about the overriding of classes below
+    # if it isn't ignored
+    HTTPConnectionPool.ConnectionCls = EmscriptenHTTPConnection
+    HTTPSConnectionPool.ConnectionCls = EmscriptenHTTPSConnection
+    urllib3.connection.HTTPConnection = EmscriptenHTTPConnection  # type: ignore[misc,assignment]
+    urllib3.connection.HTTPSConnection = EmscriptenHTTPSConnection  # type: ignore[misc,assignment]

.venv/Lib/site-packages/urllib3/contrib/emscripten/connection.py

@@ -0,0 +1,254 @@
+from __future__ import annotations
+
+import os
+import typing
+
+# use http.client.HTTPException for consistency with non-emscripten
+from http.client import HTTPException as HTTPException  # noqa: F401
+from http.client import ResponseNotReady
+
+from ..._base_connection import _TYPE_BODY
+from ...connection import HTTPConnection, ProxyConfig, port_by_scheme
+from ...exceptions import TimeoutError
+from ...response import BaseHTTPResponse
+from ...util.connection import _TYPE_SOCKET_OPTIONS
+from ...util.timeout import _DEFAULT_TIMEOUT, _TYPE_TIMEOUT
+from ...util.url import Url
+from .fetch import _RequestError, _TimeoutError, send_request, send_streaming_request
+from .request import EmscriptenRequest
+from .response import EmscriptenHttpResponseWrapper, EmscriptenResponse
+
+if typing.TYPE_CHECKING:
+    from ..._base_connection import BaseHTTPConnection, BaseHTTPSConnection
+
+
+class EmscriptenHTTPConnection:
+    default_port: typing.ClassVar[int] = port_by_scheme["http"]
+    default_socket_options: typing.ClassVar[_TYPE_SOCKET_OPTIONS]
+
+    timeout: None | (float)
+
+    host: str
+    port: int
+    blocksize: int
+    source_address: tuple[str, int] | None
+    socket_options: _TYPE_SOCKET_OPTIONS | None
+
+    proxy: Url | None
+    proxy_config: ProxyConfig | None
+
+    is_verified: bool = False
+    proxy_is_verified: bool | None = None
+
+    _response: EmscriptenResponse | None
+
+    def __init__(
+        self,
+        host: str,
+        port: int = 0,
+        *,
+        timeout: _TYPE_TIMEOUT = _DEFAULT_TIMEOUT,
+        source_address: tuple[str, int] | None = None,
+        blocksize: int = 8192,
+        socket_options: _TYPE_SOCKET_OPTIONS | None = None,
+        proxy: Url | None = None,
+        proxy_config: ProxyConfig | None = None,
+    ) -> None:
+        self.host = host
+        self.port = port
+        self.timeout = timeout if isinstance(timeout, float) else 0.0
+        self.scheme = "http"
+        self._closed = True
+        self._response = None
+        # ignore these things because we don't
+        # have control over that stuff
+        self.proxy = None
+        self.proxy_config = None
+        self.blocksize = blocksize
+        self.source_address = None
+        self.socket_options = None
+        self.is_verified = False
+
+    def set_tunnel(
+        self,
+        host: str,
+        port: int | None = 0,
+        headers: typing.Mapping[str, str] | None = None,
+        scheme: str = "http",
+    ) -> None:
+        pass
+
+    def connect(self) -> None:
+        pass
+
+    def request(
+        self,
+        method: str,
+        url: str,
+        body: _TYPE_BODY | None = None,
+        headers: typing.Mapping[str, str] | None = None,
+        # We know *at least* botocore is depending on the order of the
+        # first 3 parameters so to be safe we only mark the later ones
+        # as keyword-only to ensure we have space to extend.
+        *,
+        chunked: bool = False,
+        preload_content: bool = True,
+        decode_content: bool = True,
+        enforce_content_length: bool = True,
+    ) -> None:
+        self._closed = False
+        if url.startswith("/"):
+            # no scheme / host / port included, make a full url
+            url = f"{self.scheme}://{self.host}:{self.port}" + url
+        request = EmscriptenRequest(
+            url=url,
+            method=method,
+            timeout=self.timeout if self.timeout else 0,
+            decode_content=decode_content,
+        )
+        request.set_body(body)
+        if headers:
+            for k, v in headers.items():
+                request.set_header(k, v)
+        self._response = None
+        try:
+            if not preload_content:
+                self._response = send_streaming_request(request)
+            if self._response is None:
+                self._response = send_request(request)
+        except _TimeoutError as e:
+            raise TimeoutError(e.message) from e
+        except _RequestError as e:
+            raise HTTPException(e.message) from e
+
+    def getresponse(self) -> BaseHTTPResponse:
+        if self._response is not None:
+            return EmscriptenHttpResponseWrapper(
+                internal_response=self._response,
+                url=self._response.request.url,
+                connection=self,
+            )
+        else:
+            raise ResponseNotReady()
+
+    def close(self) -> None:
+        self._closed = True
+        self._response = None
+
+    @property
+    def is_closed(self) -> bool:
+        """Whether the connection either is brand new or has been previously closed.
+        If this property is True then both ``is_connected`` and ``has_connected_to_proxy``
+        properties must be False.
+        """
+        return self._closed
+
+    @property
+    def is_connected(self) -> bool:
+        """Whether the connection is actively connected to any origin (proxy or target)"""
+        return True
+
+    @property
+    def has_connected_to_proxy(self) -> bool:
+        """Whether the connection has successfully connected to its proxy.
+        This returns False if no proxy is in use. Used to determine whether
+        errors are coming from the proxy layer or from tunnelling to the target origin.
+        """
+        return False
+
+
+class EmscriptenHTTPSConnection(EmscriptenHTTPConnection):
+    default_port = port_by_scheme["https"]
+    # all this is basically ignored, as browser handles https
+    cert_reqs: int | str | None = None
+    ca_certs: str | None = None
+    ca_cert_dir: str | None = None
+    ca_cert_data: None | str | bytes = None
+    cert_file: str | None
+    key_file: str | None
+    key_password: str | None
+    ssl_context: typing.Any | None
+    ssl_version: int | str | None = None
+    ssl_minimum_version: int | None = None
+    ssl_maximum_version: int | None = None
+    assert_hostname: None | str | typing.Literal[False]
+    assert_fingerprint: str | None = None
+
+    def __init__(
+        self,
+        host: str,
+        port: int = 0,
+        *,
+        timeout: _TYPE_TIMEOUT = _DEFAULT_TIMEOUT,
+        source_address: tuple[str, int] | None = None,
+        blocksize: int = 16384,
+        socket_options: None
+        | _TYPE_SOCKET_OPTIONS = HTTPConnection.default_socket_options,
+        proxy: Url | None = None,
+        proxy_config: ProxyConfig | None = None,
+        cert_reqs: int | str | None = None,
+        assert_hostname: None | str | typing.Literal[False] = None,
+        assert_fingerprint: str | None = None,
+        server_hostname: str | None = None,
+        ssl_context: typing.Any | None = None,
+        ca_certs: str | None = None,
+        ca_cert_dir: str | None = None,
+        ca_cert_data: None | str | bytes = None,
+        ssl_minimum_version: int | None = None,
+        ssl_maximum_version: int | None = None,
+        ssl_version: int | str | None = None,  # Deprecated
+        cert_file: str | None = None,
+        key_file: str | None = None,
+        key_password: str | None = None,
+    ) -> None:
+        super().__init__(
+            host,
+            port=port,
+            timeout=timeout,
+            source_address=source_address,
+            blocksize=blocksize,
+            socket_options=socket_options,
+            proxy=proxy,
+            proxy_config=proxy_config,
+        )
+        self.scheme = "https"
+
+        self.key_file = key_file
+        self.cert_file = cert_file
+        self.key_password = key_password
+        self.ssl_context = ssl_context
+        self.server_hostname = server_hostname
+        self.assert_hostname = assert_hostname
+        self.assert_fingerprint = assert_fingerprint
+        self.ssl_version = ssl_version
+        self.ssl_minimum_version = ssl_minimum_version
+        self.ssl_maximum_version = ssl_maximum_version
+        self.ca_certs = ca_certs and os.path.expanduser(ca_certs)
+        self.ca_cert_dir = ca_cert_dir and os.path.expanduser(ca_cert_dir)
+        self.ca_cert_data = ca_cert_data
+
+        self.cert_reqs = None
+
+        # The browser will automatically verify all requests.
+        # We have no control over that setting.
+        self.is_verified = True
+
+    def set_cert(
+        self,
+        key_file: str | None = None,
+        cert_file: str | None = None,
+        cert_reqs: int | str | None = None,
+        key_password: str | None = None,
+        ca_certs: str | None = None,
+        assert_hostname: None | str | typing.Literal[False] = None,
+        assert_fingerprint: str | None = None,
+        ca_cert_dir: str | None = None,
+        ca_cert_data: None | str | bytes = None,
+    ) -> None:
+        pass
+
+
+# verify that this class implements BaseHTTP(s) connection correctly
+if typing.TYPE_CHECKING:
+    _supports_http_protocol: BaseHTTPConnection = EmscriptenHTTPConnection("", 0)
+    _supports_https_protocol: BaseHTTPSConnection = EmscriptenHTTPSConnection("", 0)

.venv/Lib/site-packages/urllib3/contrib/emscripten/emscripten_fetch_worker.js

@@ -0,0 +1,110 @@
+let Status = {
+  SUCCESS_HEADER: -1,
+  SUCCESS_EOF: -2,
+  ERROR_TIMEOUT: -3,
+  ERROR_EXCEPTION: -4,
+};
+
+let connections = {};
+let nextConnectionID = 1;
+const encoder = new TextEncoder();
+
+self.addEventListener("message", async function (event) {
+  if (event.data.close) {
+    let connectionID = event.data.close;
+    delete connections[connectionID];
+    return;
+  } else if (event.data.getMore) {
+    let connectionID = event.data.getMore;
+    let { curOffset, value, reader, intBuffer, byteBuffer } =
+      connections[connectionID];
+    // if we still have some in buffer, then just send it back straight away
+    if (!value || curOffset >= value.length) {
+      // read another buffer if required
+      try {
+        let readResponse = await reader.read();
+
+        if (readResponse.done) {
+          // read everything - clear connection and return
+          delete connections[connectionID];
+          Atomics.store(intBuffer, 0, Status.SUCCESS_EOF);
+          Atomics.notify(intBuffer, 0);
+          // finished reading successfully
+          // return from event handler
+          return;
+        }
+        curOffset = 0;
+        connections[connectionID].value = readResponse.value;
+        value = readResponse.value;
+      } catch (error) {
+        console.log("Request exception:", error);
+        let errorBytes = encoder.encode(error.message);
+        let written = errorBytes.length;
+        byteBuffer.set(errorBytes);
+        intBuffer[1] = written;
+        Atomics.store(intBuffer, 0, Status.ERROR_EXCEPTION);
+        Atomics.notify(intBuffer, 0);
+      }
+    }
+
+    // send as much buffer as we can
+    let curLen = value.length - curOffset;
+    if (curLen > byteBuffer.length) {
+      curLen = byteBuffer.length;
+    }
+    byteBuffer.set(value.subarray(curOffset, curOffset + curLen), 0);
+
+    Atomics.store(intBuffer, 0, curLen); // store current length in bytes
+    Atomics.notify(intBuffer, 0);
+    curOffset += curLen;
+    connections[connectionID].curOffset = curOffset;
+
+    return;
+  } else {
+    // start fetch
+    let connectionID = nextConnectionID;
+    nextConnectionID += 1;
+    const intBuffer = new Int32Array(event.data.buffer);
+    const byteBuffer = new Uint8Array(event.data.buffer, 8);
+    try {
+      const response = await fetch(event.data.url, event.data.fetchParams);
+      // return the headers first via textencoder
+      var headers = [];
+      for (const pair of response.headers.entries()) {
+        headers.push([pair[0], pair[1]]);
+      }
+      let headerObj = {
+        headers: headers,
+        status: response.status,
+        connectionID,
+      };
+      const headerText = JSON.stringify(headerObj);
+      let headerBytes = encoder.encode(headerText);
+      let written = headerBytes.length;
+      byteBuffer.set(headerBytes);
+      intBuffer[1] = written;
+      // make a connection
+      connections[connectionID] = {
+        reader: response.body.getReader(),
+        intBuffer: intBuffer,
+        byteBuffer: byteBuffer,
+        value: undefined,
+        curOffset: 0,
+      };
+      // set header ready
+      Atomics.store(intBuffer, 0, Status.SUCCESS_HEADER);
+      Atomics.notify(intBuffer, 0);
+      // all fetching after this goes through a new postmessage call with getMore
+      // this allows for parallel requests
+    } catch (error) {
+      console.log("Request exception:", error);
+      let errorBytes = encoder.encode(error.message);
+      let written = errorBytes.length;
+      byteBuffer.set(errorBytes);
+      intBuffer[1] = written;
+      Atomics.store(intBuffer, 0, Status.ERROR_EXCEPTION);
+      Atomics.notify(intBuffer, 0);
+    }
+  }
+});
+self.postMessage({ inited: true });

.venv/Lib/site-packages/urllib3/contrib/emscripten/fetch.py

@@ -0,0 +1,418 @@
+"""
+Support for streaming http requests in emscripten.
+
+A few caveats -
+
+Firstly, you can't do streaming http in the main UI thread, because atomics.wait isn't allowed.
+Streaming only works if you're running pyodide in a web worker.
+
+Secondly, this uses an extra web worker and SharedArrayBuffer to do the asynchronous fetch
+operation, so it requires that you have crossOriginIsolation enabled, by serving over https
+(or from localhost) with the two headers below set:
+
+    Cross-Origin-Opener-Policy: same-origin
+    Cross-Origin-Embedder-Policy: require-corp
+
+You can tell if cross origin isolation is successfully enabled by looking at the global crossOriginIsolated variable in
+javascript console. If it isn't, streaming requests will fallback to XMLHttpRequest, i.e. getting the whole
+request into a buffer and then returning it. it shows a warning in the javascript console in this case.
+
+Finally, the webworker which does the streaming fetch is created on initial import, but will only be started once
+control is returned to javascript. Call `await wait_for_streaming_ready()` to wait for streaming fetch.
+
+NB: in this code, there are a lot of javascript objects. They are named js_*
+to make it clear what type of object they are.
+"""
+from __future__ import annotations
+
+import io
+import json
+from email.parser import Parser
+from importlib.resources import files
+from typing import TYPE_CHECKING, Any
+
+import js  # type: ignore[import-not-found]
+from pyodide.ffi import (  # type: ignore[import-not-found]
+    JsArray,
+    JsException,
+    JsProxy,
+    to_js,
+)
+
+if TYPE_CHECKING:
+    from typing_extensions import Buffer
+
+from .request import EmscriptenRequest
+from .response import EmscriptenResponse
+
+"""
+There are some headers that trigger unintended CORS preflight requests.
+See also https://github.com/koenvo/pyodide-http/issues/22
+"""
+HEADERS_TO_IGNORE = ("user-agent",)
+
+SUCCESS_HEADER = -1
+SUCCESS_EOF = -2
+ERROR_TIMEOUT = -3
+ERROR_EXCEPTION = -4
+
+_STREAMING_WORKER_CODE = (
+    files(__package__)
+    .joinpath("emscripten_fetch_worker.js")
+    .read_text(encoding="utf-8")
+)
+
+
+class _RequestError(Exception):
+    def __init__(
+        self,
+        message: str | None = None,
+        *,
+        request: EmscriptenRequest | None = None,
+        response: EmscriptenResponse | None = None,
+    ):
+        self.request = request
+        self.response = response
+        self.message = message
+        super().__init__(self.message)
+
+
+class _StreamingError(_RequestError):
+    pass
+
+
+class _TimeoutError(_RequestError):
+    pass
+
+
+def _obj_from_dict(dict_val: dict[str, Any]) -> JsProxy:
+    return to_js(dict_val, dict_converter=js.Object.fromEntries)
+
+
+class _ReadStream(io.RawIOBase):
+    def __init__(
+        self,
+        int_buffer: JsArray,
+        byte_buffer: JsArray,
+        timeout: float,
+        worker: JsProxy,
+        connection_id: int,
+        request: EmscriptenRequest,
+    ):
+        self.int_buffer = int_buffer
+        self.byte_buffer = byte_buffer
+        self.read_pos = 0
+        self.read_len = 0
+        self.connection_id = connection_id
+        self.worker = worker
+        self.timeout = int(1000 * timeout) if timeout > 0 else None
+        self.is_live = True
+        self._is_closed = False
+        self.request: EmscriptenRequest | None = request
+
+    def __del__(self) -> None:
+        self.close()
+
+    # this is compatible with _base_connection
+    def is_closed(self) -> bool:
+        return self._is_closed
+
+    # for compatibility with RawIOBase
+    @property
+    def closed(self) -> bool:
+        return self.is_closed()
+
+    def close(self) -> None:
+        if not self.is_closed():
+            self.read_len = 0
+            self.read_pos = 0
+            self.int_buffer = None
+            self.byte_buffer = None
+            self._is_closed = True
+            self.request = None
+            if self.is_live:
+                self.worker.postMessage(_obj_from_dict({"close": self.connection_id}))
+                self.is_live = False
+            super().close()
+
+    def readable(self) -> bool:
+        return True
+
+    def writable(self) -> bool:
+        return False
+
+    def seekable(self) -> bool:
+        return False
+
+    def readinto(self, byte_obj: Buffer) -> int:
+        if not self.int_buffer:
+            raise _StreamingError(
+                "No buffer for stream in _ReadStream.readinto",
+                request=self.request,
+                response=None,
+            )
+        if self.read_len == 0:
+            # wait for the worker to send something
+            js.Atomics.store(self.int_buffer, 0, ERROR_TIMEOUT)
+            self.worker.postMessage(_obj_from_dict({"getMore": self.connection_id}))
+            if (
+                js.Atomics.wait(self.int_buffer, 0, ERROR_TIMEOUT, self.timeout)
+                == "timed-out"
+            ):
+                raise _TimeoutError
+            data_len = self.int_buffer[0]
+            if data_len > 0:
+                self.read_len = data_len
+                self.read_pos = 0
+            elif data_len == ERROR_EXCEPTION:
+                string_len = self.int_buffer[1]
+                # decode the error string
+                js_decoder = js.TextDecoder.new()
+                json_str = js_decoder.decode(self.byte_buffer.slice(0, string_len))
+                raise _StreamingError(
+                    f"Exception thrown in fetch: {json_str}",
+                    request=self.request,
+                    response=None,
+                )
+            else:
+                # EOF, free the buffers and return zero
+                # and free the request
+                self.is_live = False
+                self.close()
+                return 0
+        # copy from int32array to python bytes
+        ret_length = min(self.read_len, len(memoryview(byte_obj)))
+        subarray = self.byte_buffer.subarray(
+            self.read_pos, self.read_pos + ret_length
+        ).to_py()
+        memoryview(byte_obj)[0:ret_length] = subarray
+        self.read_len -= ret_length
+        self.read_pos += ret_length
+        return ret_length
+
+
+class _StreamingFetcher:
+    def __init__(self) -> None:
+        # make web-worker and data buffer on startup
+        self.streaming_ready = False
+
+        js_data_blob = js.Blob.new(
+            [_STREAMING_WORKER_CODE], _obj_from_dict({"type": "application/javascript"})
+        )
+
+        def promise_resolver(js_resolve_fn: JsProxy, js_reject_fn: JsProxy) -> None:
+            def onMsg(e: JsProxy) -> None:
+                self.streaming_ready = True
+                js_resolve_fn(e)
+
+            def onErr(e: JsProxy) -> None:
+                js_reject_fn(e)  # Defensive: never happens in ci
+
+            self.js_worker.onmessage = onMsg
+            self.js_worker.onerror = onErr
+
+        js_data_url = js.URL.createObjectURL(js_data_blob)
+        self.js_worker = js.globalThis.Worker.new(js_data_url)
+        self.js_worker_ready_promise = js.globalThis.Promise.new(promise_resolver)
+
+    def send(self, request: EmscriptenRequest) -> EmscriptenResponse:
+        headers = {
+            k: v for k, v in request.headers.items() if k not in HEADERS_TO_IGNORE
+        }
+
+        body = request.body
+        fetch_data = {"headers": headers, "body": to_js(body), "method": request.method}
+        # start the request off in the worker
+        timeout = int(1000 * request.timeout) if request.timeout > 0 else None
+        js_shared_buffer = js.SharedArrayBuffer.new(1048576)
+        js_int_buffer = js.Int32Array.new(js_shared_buffer)
+        js_byte_buffer = js.Uint8Array.new(js_shared_buffer, 8)
+
+        js.Atomics.store(js_int_buffer, 0, ERROR_TIMEOUT)
+        js.Atomics.notify(js_int_buffer, 0)
+        js_absolute_url = js.URL.new(request.url, js.location).href
+        self.js_worker.postMessage(
+            _obj_from_dict(
+                {
+                    "buffer": js_shared_buffer,
+                    "url": js_absolute_url,
+                    "fetchParams": fetch_data,
+                }
+            )
+        )
+        # wait for the worker to send something
+        js.Atomics.wait(js_int_buffer, 0, ERROR_TIMEOUT, timeout)
+        if js_int_buffer[0] == ERROR_TIMEOUT:
+            raise _TimeoutError(
+                "Timeout connecting to streaming request",
+                request=request,
+                response=None,
+            )
+        elif js_int_buffer[0] == SUCCESS_HEADER:
+            # got response
+            # header length is in second int of intBuffer
+            string_len = js_int_buffer[1]
+            # decode the rest to a JSON string
+            js_decoder = js.TextDecoder.new()
+            # this does a copy (the slice) because decode can't work on shared array
+            # for some silly reason
+            json_str = js_decoder.decode(js_byte_buffer.slice(0, string_len))
+            # get it as an object
+            response_obj = json.loads(json_str)
+            return EmscriptenResponse(
+                request=request,
+                status_code=response_obj["status"],
+                headers=response_obj["headers"],
+                body=_ReadStream(
+                    js_int_buffer,
+                    js_byte_buffer,
+                    request.timeout,
+                    self.js_worker,
+                    response_obj["connectionID"],
+                    request,
+                ),
+            )
+        elif js_int_buffer[0] == ERROR_EXCEPTION:
+            string_len = js_int_buffer[1]
+            # decode the error string
+            js_decoder = js.TextDecoder.new()
+            json_str = js_decoder.decode(js_byte_buffer.slice(0, string_len))
+            raise _StreamingError(
+                f"Exception thrown in fetch: {json_str}", request=request, response=None
+            )
+        else:
+            raise _StreamingError(
+                f"Unknown status from worker in fetch: {js_int_buffer[0]}",
+                request=request,
+                response=None,
+            )
+
+
+# check if we are in a worker or not
+def is_in_browser_main_thread() -> bool:
+    return hasattr(js, "window") and hasattr(js, "self") and js.self == js.window
+
+
+def is_cross_origin_isolated() -> bool:
+    return hasattr(js, "crossOriginIsolated") and js.crossOriginIsolated
+
+
+def is_in_node() -> bool:
+    return (
+        hasattr(js, "process")
+        and hasattr(js.process, "release")
+        and hasattr(js.process.release, "name")
+        and js.process.release.name == "node"
+    )
+
+
+def is_worker_available() -> bool:
+    return hasattr(js, "Worker") and hasattr(js, "Blob")
+
+
+_fetcher: _StreamingFetcher | None = None
+
+if is_worker_available() and (
+    (is_cross_origin_isolated() and not is_in_browser_main_thread())
+    and (not is_in_node())
+):
+    _fetcher = _StreamingFetcher()
+else:
+    _fetcher = None
+
+
+def send_streaming_request(request: EmscriptenRequest) -> EmscriptenResponse | None:
+    if _fetcher and streaming_ready():
+        return _fetcher.send(request)
+    else:
+        _show_streaming_warning()
+        return None
+
+
+_SHOWN_TIMEOUT_WARNING = False
+
+
+def _show_timeout_warning() -> None:
+    global _SHOWN_TIMEOUT_WARNING
+    if not _SHOWN_TIMEOUT_WARNING:
+        _SHOWN_TIMEOUT_WARNING = True
+        message = "Warning: Timeout is not available on main browser thread"
+        js.console.warn(message)
+
+
+_SHOWN_STREAMING_WARNING = False
+
+
+def _show_streaming_warning() -> None:
+    global _SHOWN_STREAMING_WARNING
+    if not _SHOWN_STREAMING_WARNING:
+        _SHOWN_STREAMING_WARNING = True
+        message = "Can't stream HTTP requests because: \n"
+        if not is_cross_origin_isolated():
+            message += "  Page is not cross-origin isolated\n"
+        if is_in_browser_main_thread():
+            message += "  Python is running in main browser thread\n"
+        if not is_worker_available():
+            message += " Worker or Blob classes are not available in this environment."  # Defensive: this is always False in browsers that we test in
+        if streaming_ready() is False:
+            message += """ Streaming fetch worker isn't ready. If you want to be sure that streaming fetch
+is working, you need to call: 'await urllib3.contrib.emscripten.fetch.wait_for_streaming_ready()`"""
+        from js import console
+
+        console.warn(message)
+
+
+def send_request(request: EmscriptenRequest) -> EmscriptenResponse:
+    try:
+        js_xhr = js.XMLHttpRequest.new()
+
+        if not is_in_browser_main_thread():
+            js_xhr.responseType = "arraybuffer"
+            if request.timeout:
+                js_xhr.timeout = int(request.timeout * 1000)
+        else:
+            js_xhr.overrideMimeType("text/plain; charset=ISO-8859-15")
+            if request.timeout:
+                # timeout isn't available on the main thread - show a warning in console
+                # if it is set
+                _show_timeout_warning()
+
+        js_xhr.open(request.method, request.url, False)
+        for name, value in request.headers.items():
+            if name.lower() not in HEADERS_TO_IGNORE:
+                js_xhr.setRequestHeader(name, value)
+
+        js_xhr.send(to_js(request.body))
+
+        headers = dict(Parser().parsestr(js_xhr.getAllResponseHeaders()))
+
+        if not is_in_browser_main_thread():
+            body = js_xhr.response.to_py().tobytes()
+        else:
+            body = js_xhr.response.encode("ISO-8859-15")
+        return EmscriptenResponse(
+            status_code=js_xhr.status, headers=headers, body=body, request=request
+        )
+    except JsException as err:
+        if err.name == "TimeoutError":
+            raise _TimeoutError(err.message, request=request)
+        elif err.name == "NetworkError":
+            raise _RequestError(err.message, request=request)
+        else:
+            # general http error
+            raise _RequestError(err.message, request=request)
+
+
+def streaming_ready() -> bool | None:
+    if _fetcher:
+        return _fetcher.streaming_ready
+    else:
+        return None  # no fetcher, return None to signify that
+
+
+async def wait_for_streaming_ready() -> bool:
+    if _fetcher:
+        await _fetcher.js_worker_ready_promise
+        return True
+    else:
+        return False

.venv/Lib/site-packages/urllib3/contrib/emscripten/request.py

@@ -0,0 +1,22 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+from ..._base_connection import _TYPE_BODY
+
+
+@dataclass
+class EmscriptenRequest:
+    method: str
+    url: str
+    params: dict[str, str] | None = None
+    body: _TYPE_BODY | None = None
+    headers: dict[str, str] = field(default_factory=dict)
+    timeout: float = 0
+    decode_content: bool = True
+
+    def set_header(self, name: str, value: str) -> None:
+        self.headers[name.capitalize()] = value
+
+    def set_body(self, body: _TYPE_BODY | None) -> None:
+        self.body = body

.venv/Lib/site-packages/urllib3/contrib/emscripten/response.py

@@ -0,0 +1,285 @@
+from __future__ import annotations
+
+import json as _json
+import logging
+import typing
+from contextlib import contextmanager
+from dataclasses import dataclass
+from http.client import HTTPException as HTTPException
+from io import BytesIO, IOBase
+
+from ...exceptions import InvalidHeader, TimeoutError
+from ...response import BaseHTTPResponse
+from ...util.retry import Retry
+from .request import EmscriptenRequest
+
+if typing.TYPE_CHECKING:
+    from ..._base_connection import BaseHTTPConnection, BaseHTTPSConnection
+
+log = logging.getLogger(__name__)
+
+
+@dataclass
+class EmscriptenResponse:
+    status_code: int
+    headers: dict[str, str]
+    body: IOBase | bytes
+    request: EmscriptenRequest
+
+
+class EmscriptenHttpResponseWrapper(BaseHTTPResponse):
+    def __init__(
+        self,
+        internal_response: EmscriptenResponse,
+        url: str | None = None,
+        connection: BaseHTTPConnection | BaseHTTPSConnection | None = None,
+    ):
+        self._pool = None  # set by pool class
+        self._body = None
+        self._response = internal_response
+        self._url = url
+        self._connection = connection
+        self._closed = False
+        super().__init__(
+            headers=internal_response.headers,
+            status=internal_response.status_code,
+            request_url=url,
+            version=0,
+            version_string="HTTP/?",
+            reason="",
+            decode_content=True,
+        )
+        self.length_remaining = self._init_length(self._response.request.method)
+        self.length_is_certain = False
+
+    @property
+    def url(self) -> str | None:
+        return self._url
+
+    @url.setter
+    def url(self, url: str | None) -> None:
+        self._url = url
+
+    @property
+    def connection(self) -> BaseHTTPConnection | BaseHTTPSConnection | None:
+        return self._connection
+
+    @property
+    def retries(self) -> Retry | None:
+        return self._retries
+
+    @retries.setter
+    def retries(self, retries: Retry | None) -> None:
+        # Override the request_url if retries has a redirect location.
+        self._retries = retries
+
+    def stream(
+        self, amt: int | None = 2**16, decode_content: bool | None = None
+    ) -> typing.Generator[bytes, None, None]:
+        """
+        A generator wrapper for the read() method. A call will block until
+        ``amt`` bytes have been read from the connection or until the
+        connection is closed.
+
+        :param amt:
+            How much of the content to read. The generator will return up to
+            much data per iteration, but may return less. This is particularly
+            likely when using compressed data. However, the empty string will
+            never be returned.
+
+        :param decode_content:
+            If True, will attempt to decode the body based on the
+            'content-encoding' header.
+        """
+        while True:
+            data = self.read(amt=amt, decode_content=decode_content)
+
+            if data:
+                yield data
+            else:
+                break
+
+    def _init_length(self, request_method: str | None) -> int | None:
+        length: int | None
+        content_length: str | None = self.headers.get("content-length")
+
+        if content_length is not None:
+            try:
+                # RFC 7230 section 3.3.2 specifies multiple content lengths can
+                # be sent in a single Content-Length header
+                # (e.g. Content-Length: 42, 42). This line ensures the values
+                # are all valid ints and that as long as the `set` length is 1,
+                # all values are the same. Otherwise, the header is invalid.
+                lengths = {int(val) for val in content_length.split(",")}
+                if len(lengths) > 1:
+                    raise InvalidHeader(
+                        "Content-Length contained multiple "
+                        "unmatching values (%s)" % content_length
+                    )
+                length = lengths.pop()
+            except ValueError:
+                length = None
+            else:
+                if length < 0:
+                    length = None
+
+        else:  # if content_length is None
+            length = None
+
+        # Check for responses that shouldn't include a body
+        if (
+            self.status in (204, 304)
+            or 100 <= self.status < 200
+            or request_method == "HEAD"
+        ):
+            length = 0
+
+        return length
+
+    def read(
+        self,
+        amt: int | None = None,
+        decode_content: bool | None = None,  # ignored because browser decodes always
+        cache_content: bool = False,
+    ) -> bytes:
+        if (
+            self._closed
+            or self._response is None
+            or (isinstance(self._response.body, IOBase) and self._response.body.closed)
+        ):
+            return b""
+
+        with self._error_catcher():
+            # body has been preloaded as a string by XmlHttpRequest
+            if not isinstance(self._response.body, IOBase):
+                self.length_remaining = len(self._response.body)
+                self.length_is_certain = True
+                # wrap body in IOStream
+                self._response.body = BytesIO(self._response.body)
+            if amt is not None and amt >= 0:
+                # don't cache partial content
+                cache_content = False
+                data = self._response.body.read(amt)
+                if self.length_remaining is not None:
+                    self.length_remaining = max(self.length_remaining - len(data), 0)
+                if (self.length_is_certain and self.length_remaining == 0) or len(
+                    data
+                ) < amt:
+                    # definitely finished reading, close response stream
+                    self._response.body.close()
+                return typing.cast(bytes, data)
+            else:  # read all we can (and cache it)
+                data = self._response.body.read()
+                if cache_content:
+                    self._body = data
+                if self.length_remaining is not None:
+                    self.length_remaining = max(self.length_remaining - len(data), 0)
+                if len(data) == 0 or (
+                    self.length_is_certain and self.length_remaining == 0
+                ):
+                    # definitely finished reading, close response stream
+                    self._response.body.close()
+                return typing.cast(bytes, data)
+
+    def read_chunked(
+        self,
+        amt: int | None = None,
+        decode_content: bool | None = None,
+    ) -> typing.Generator[bytes, None, None]:
+        # chunked is handled by browser
+        while True:
+            bytes = self.read(amt, decode_content)
+            if not bytes:
+                break
+            yield bytes
+
+    def release_conn(self) -> None:
+        if not self._pool or not self._connection:
+            return None
+
+        self._pool._put_conn(self._connection)
+        self._connection = None
+
+    def drain_conn(self) -> None:
+        self.close()
+
+    @property
+    def data(self) -> bytes:
+        if self._body:
+            return self._body
+        else:
+            return self.read(cache_content=True)
+
+    def json(self) -> typing.Any:
+        """
+        Deserializes the body of the HTTP response as a Python object.
+
+        The body of the HTTP response must be encoded using UTF-8, as per
+        `RFC 8529 Section 8.1 <https://www.rfc-editor.org/rfc/rfc8259#section-8.1>`_.
+
+        To use a custom JSON decoder pass the result of :attr:`HTTPResponse.data` to
+        your custom decoder instead.
+
+        If the body of the HTTP response is not decodable to UTF-8, a
+        `UnicodeDecodeError` will be raised. If the body of the HTTP response is not a
+        valid JSON document, a `json.JSONDecodeError` will be raised.
+
+        Read more :ref:`here <json_content>`.
+
+        :returns: The body of the HTTP response as a Python object.
+        """
+        data = self.data.decode("utf-8")
+        return _json.loads(data)
+
+    def close(self) -> None:
+        if not self._closed:
+            if isinstance(self._response.body, IOBase):
+                self._response.body.close()
+            if self._connection:
+                self._connection.close()
+                self._connection = None
+            self._closed = True
+
+    @contextmanager
+    def _error_catcher(self) -> typing.Generator[None, None, None]:
+        """
+        Catch Emscripten specific exceptions thrown by fetch.py,
+        instead re-raising urllib3 variants, so that low-level exceptions
+        are not leaked in the high-level api.
+
+        On exit, release the connection back to the pool.
+        """
+        from .fetch import _RequestError, _TimeoutError  # avoid circular import
+
+        clean_exit = False
+
+        try:
+            yield
+            # If no exception is thrown, we should avoid cleaning up
+            # unnecessarily.
+            clean_exit = True
+        except _TimeoutError as e:
+            raise TimeoutError(str(e))
+        except _RequestError as e:
+            raise HTTPException(str(e))
+        finally:
+            # If we didn't terminate cleanly, we need to throw away our
+            # connection.
+            if not clean_exit:
+                # The response may not be closed but we're not going to use it
+                # anymore so close it now
+                if (
+                    isinstance(self._response.body, IOBase)
+                    and not self._response.body.closed
+                ):
+                    self._response.body.close()
+                # release the connection back to the pool
+                self.release_conn()
+            else:
+                # If we have read everything from the response stream,
+                # return the connection back to the pool.
+                if (
+                    isinstance(self._response.body, IOBase)
+                    and self._response.body.closed
+                ):
+                    self.release_conn()

.venv/Lib/site-packages/urllib3/contrib/socks.py

@@ -0,0 +1,228 @@
+"""
+This module contains provisional support for SOCKS proxies from within
+urllib3. This module supports SOCKS4, SOCKS4A (an extension of SOCKS4), and
+SOCKS5. To enable its functionality, either install PySocks or install this
+module with the ``socks`` extra.
+
+The SOCKS implementation supports the full range of urllib3 features. It also
+supports the following SOCKS features:
+
+- SOCKS4A (``proxy_url='socks4a://...``)
+- SOCKS4 (``proxy_url='socks4://...``)
+- SOCKS5 with remote DNS (``proxy_url='socks5h://...``)
+- SOCKS5 with local DNS (``proxy_url='socks5://...``)
+- Usernames and passwords for the SOCKS proxy
+
+.. note::
+   It is recommended to use ``socks5h://`` or ``socks4a://`` schemes in
+   your ``proxy_url`` to ensure that DNS resolution is done from the remote
+   server instead of client-side when connecting to a domain name.
+
+SOCKS4 supports IPv4 and domain names with the SOCKS4A extension. SOCKS5
+supports IPv4, IPv6, and domain names.
+
+When connecting to a SOCKS4 proxy the ``username`` portion of the ``proxy_url``
+will be sent as the ``userid`` section of the SOCKS request:
+
+.. code-block:: python
+
+    proxy_url="socks4a://<userid>@proxy-host"
+
+When connecting to a SOCKS5 proxy the ``username`` and ``password`` portion
+of the ``proxy_url`` will be sent as the username/password to authenticate
+with the proxy:
+
+.. code-block:: python
+
+    proxy_url="socks5h://<username>:<password>@proxy-host"
+
+"""
+
+from __future__ import annotations
+
+try:
+    import socks  # type: ignore[import-not-found]
+except ImportError:
+    import warnings
+
+    from ..exceptions import DependencyWarning
+
+    warnings.warn(
+        (
+            "SOCKS support in urllib3 requires the installation of optional "
+            "dependencies: specifically, PySocks.  For more information, see "
+            "https://urllib3.readthedocs.io/en/latest/advanced-usage.html#socks-proxies"
+        ),
+        DependencyWarning,
+    )
+    raise
+
+import typing
+from socket import timeout as SocketTimeout
+
+from ..connection import HTTPConnection, HTTPSConnection
+from ..connectionpool import HTTPConnectionPool, HTTPSConnectionPool
+from ..exceptions import ConnectTimeoutError, NewConnectionError
+from ..poolmanager import PoolManager
+from ..util.url import parse_url
+
+try:
+    import ssl
+except ImportError:
+    ssl = None  # type: ignore[assignment]
+
+
+class _TYPE_SOCKS_OPTIONS(typing.TypedDict):
+    socks_version: int
+    proxy_host: str | None
+    proxy_port: str | None
+    username: str | None
+    password: str | None
+    rdns: bool
+
+
+class SOCKSConnection(HTTPConnection):
+    """
+    A plain-text HTTP connection that connects via a SOCKS proxy.
+    """
+
+    def __init__(
+        self,
+        _socks_options: _TYPE_SOCKS_OPTIONS,
+        *args: typing.Any,
+        **kwargs: typing.Any,
+    ) -> None:
+        self._socks_options = _socks_options
+        super().__init__(*args, **kwargs)
+
+    def _new_conn(self) -> socks.socksocket:
+        """
+        Establish a new connection via the SOCKS proxy.
+        """
+        extra_kw: dict[str, typing.Any] = {}
+        if self.source_address:
+            extra_kw["source_address"] = self.source_address
+
+        if self.socket_options:
+            extra_kw["socket_options"] = self.socket_options
+
+        try:
+            conn = socks.create_connection(
+                (self.host, self.port),
+                proxy_type=self._socks_options["socks_version"],
+                proxy_addr=self._socks_options["proxy_host"],
+                proxy_port=self._socks_options["proxy_port"],
+                proxy_username=self._socks_options["username"],
+                proxy_password=self._socks_options["password"],
+                proxy_rdns=self._socks_options["rdns"],
+                timeout=self.timeout,
+                **extra_kw,
+            )
+
+        except SocketTimeout as e:
+            raise ConnectTimeoutError(
+                self,
+                f"Connection to {self.host} timed out. (connect timeout={self.timeout})",
+            ) from e
+
+        except socks.ProxyError as e:
+            # This is fragile as hell, but it seems to be the only way to raise
+            # useful errors here.
+            if e.socket_err:
+                error = e.socket_err
+                if isinstance(error, SocketTimeout):
+                    raise ConnectTimeoutError(
+                        self,
+                        f"Connection to {self.host} timed out. (connect timeout={self.timeout})",
+                    ) from e
+                else:
+                    # Adding `from e` messes with coverage somehow, so it's omitted.
+                    # See #2386.
+                    raise NewConnectionError(
+                        self, f"Failed to establish a new connection: {error}"
+                    )
+            else:
+                raise NewConnectionError(
+                    self, f"Failed to establish a new connection: {e}"
+                ) from e
+
+        except OSError as e:  # Defensive: PySocks should catch all these.
+            raise NewConnectionError(
+                self, f"Failed to establish a new connection: {e}"
+            ) from e
+
+        return conn
+
+
+# We don't need to duplicate the Verified/Unverified distinction from
+# urllib3/connection.py here because the HTTPSConnection will already have been
+# correctly set to either the Verified or Unverified form by that module. This
+# means the SOCKSHTTPSConnection will automatically be the correct type.
+class SOCKSHTTPSConnection(SOCKSConnection, HTTPSConnection):
+    pass
+
+
+class SOCKSHTTPConnectionPool(HTTPConnectionPool):
+    ConnectionCls = SOCKSConnection
+
+
+class SOCKSHTTPSConnectionPool(HTTPSConnectionPool):
+    ConnectionCls = SOCKSHTTPSConnection
+
+
+class SOCKSProxyManager(PoolManager):
+    """
+    A version of the urllib3 ProxyManager that routes connections via the
+    defined SOCKS proxy.
+    """
+
+    pool_classes_by_scheme = {
+        "http": SOCKSHTTPConnectionPool,
+        "https": SOCKSHTTPSConnectionPool,
+    }
+
+    def __init__(
+        self,
+        proxy_url: str,
+        username: str | None = None,
+        password: str | None = None,
+        num_pools: int = 10,
+        headers: typing.Mapping[str, str] | None = None,
+        **connection_pool_kw: typing.Any,
+    ):
+        parsed = parse_url(proxy_url)
+
+        if username is None and password is None and parsed.auth is not None:
+            split = parsed.auth.split(":")
+            if len(split) == 2:
+                username, password = split
+        if parsed.scheme == "socks5":
+            socks_version = socks.PROXY_TYPE_SOCKS5
+            rdns = False
+        elif parsed.scheme == "socks5h":
+            socks_version = socks.PROXY_TYPE_SOCKS5
+            rdns = True
+        elif parsed.scheme == "socks4":
+            socks_version = socks.PROXY_TYPE_SOCKS4
+            rdns = False
+        elif parsed.scheme == "socks4a":
+            socks_version = socks.PROXY_TYPE_SOCKS4
+            rdns = True
+        else:
+            raise ValueError(f"Unable to determine SOCKS version from {proxy_url}")
+
+        self.proxy_url = proxy_url
+
+        socks_options = {
+            "socks_version": socks_version,
+            "proxy_host": parsed.host,
+            "proxy_port": parsed.port,
+            "username": username,
+            "password": password,
+            "rdns": rdns,
+        }
+        connection_pool_kw["_socks_options"] = socks_options
+
+        super().__init__(num_pools, headers, **connection_pool_kw)
+
+        self.pool_classes_by_scheme = SOCKSProxyManager.pool_classes_by_scheme

.venv/Lib/site-packages/wasabi-0.10.1.dist-info/INSTALLER

@@ -0,0 +1 @@
+uv

.venv/Lib/site-packages/wasabi-0.10.1.dist-info/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (C) 2018 Ines Montani
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

.venv/Lib/site-packages/wasabi-0.10.1.dist-info/METADATA

@@ -0,0 +1,575 @@
+Metadata-Version: 2.1
+Name: wasabi
+Version: 0.10.1
+Summary: A lightweight console printing and formatting toolkit
+Home-page: https://ines.io
+Author: Ines Montani
+Author-email: [email protected]
+License: MIT
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+# wasabi: A lightweight console printing and formatting toolkit
+
+Over the years, I've written countless implementations of coloring and
+formatting utilities to output messages in our libraries like
+[spaCy](https://spacy.io), [Thinc](https://github.com/explosion/thinc) and
+[Prodigy](https://prodi.gy). While there are many other great open-source
+options, I've always ended up wanting something slightly different or slightly
+custom.
+
+This package is still a work in progress and aims to bundle those utilities in a
+standardised way so they can be shared across our other projects. It's super
+lightweight, has zero dependencies and works across Python 2 and 3.
+
+[![Azure Pipelines](https://img.shields.io/azure-devops/build/explosion-ai/public/1/master.svg?logo=azure-pipelines&style=flat-square)](https://dev.azure.com/explosion-ai/public/_build?definitionId=1)
+[![PyPi](https://img.shields.io/pypi/v/wasabi.svg?style=flat-square&logo=pypi&logoColor=white)](https://pypi.python.org/pypi/wasabi)
+[![conda](https://img.shields.io/conda/vn/conda-forge/wasabi.svg?style=flat-square&logo=conda-forge/logoColor=white)](https://anaconda.org/conda-forge/wasabi)
+[![GitHub](https://img.shields.io/github/release/ines/wasabi/all.svg?style=flat-square&logo=github)](https://github.com/ines/wasabi)
+[![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg?style=flat-square)](https://github.com/ambv/black)
+
+<img width="609" src="https://user-images.githubusercontent.com/13643239/48663861-8c9ea000-ea96-11e8-8b04-d120c52276a8.png">
+
+## 💬 FAQ
+
+### Are you going to add more features?
+
+Yes, there's still a few of helpers and features to port over. However, the new
+features will be heavily biased by what we (think we) need. I always appreciate
+pull requests to improve the existing functionality – but I want to keep this
+library as simple, lightweight and specific as possible.
+
+### Can I use this for my projects?
+
+Sure, if you like it, feel free to adopt it! Just keep in mind that the package
+is very specific and not intended to be a full-featured and fully customisable
+formatting library. If that's what you're looking for, you might want to try
+other packages – for example, [`colored`](https://pypi.org/project/colored/),
+[`crayons`](https://github.com/kennethreitz/crayons),
+[`colorful`](https://github.com/timofurrer/colorful),
+[`tabulate`](https://bitbucket.org/astanin/python-tabulate),
+[`console`](https://github.com/mixmastamyk/console) or
+[`py-term`](https://github.com/gravmatt/py-term), to name a few.
+
+### Why `wasabi`?
+
+I was looking for a short and descriptive name, but everything was already
+taken. So I ended up naming this package after one of my rats, Wasabi. 🐀
+
+## ⌛️ Installation
+
+```bash
+pip install wasabi
+```
+
+## 🎛 API
+
+### <kbd>function</kbd> `msg`
+
+An instance of `Printer`, initialized with the default config. Useful as a quick
+shortcut if you don't need to customize initialization.
+
+```python
+from wasabi import msg
+
+msg.good("Success!")
+```
+
+### <kbd>class</kbd> `Printer`
+
+#### <kbd>method</kbd> `Printer.__init__`
+
+```python
+from wasabi import Printer
+
+msg = Printer()
+```
+
+| Argument          | Type      | Description                                                   | Default       |
+| ----------------- | --------- | ------------------------------------------------------------- | ------------- |
+| `pretty`          | bool      | Pretty-print output with colors and icons.                    | `True`        |
+| `no_print`        | bool      | Don't actually print, just return.                            | `False`       |
+| `colors`          | dict      | Add or overwrite color values, names mapped to `0`-`256`.     | `None`        |
+| `icons`           | dict      | Add or overwrite icon. Name mapped to unicode.                | `None`        |
+| `line_max`        | int       | Maximum line length (for divider).                            | `80`          |
+| `animation`       | str       | Steps of loading animation for `Printer.loading`.             | `"⠙⠹⠸⠼⠴⠦⠧⠇⠏"` |
+| `animation_ascii` | str       | Alternative animation for ASCII terminals.                    | `"\|/-\\"`    |
+| `hide_animation`  | bool      | Don't display animation, e.g. for logs.                       | `False`       |
+| `ignore_warnings` | bool      | Don't output messages of type `MESSAGE.WARN`.                 | `False`       |
+| `env_prefix`      | str       | Prefix for environment variables, e.g. `WASABI_LOG_FRIENDLY`. | `"WASABI"`    |
+| `timestamp`       | bool      | Add timestamp before output.                                  | `False`       |
+| **RETURNS**       | `Printer` | The initialized printer.                                      | -             |
+
+#### <kbd>method</kbd> `Printer.text`
+
+```python
+msg = Printer()
+msg.text("Hello world!")
+```
+
+| Argument   | Type           | Description                                                                                                            | Default |
+| ---------- | -------------- | ---------------------------------------------------------------------------------------------------------------------- | ------- |
+| `title`    | str            | The main text to print.                                                                                                | `""`    |
+| `text`     | str            | Optional additional text to print.                                                                                     | `""`    |
+| `color`    |  unicode / int | Color name or value.                                                                                                   | `None`  |
+| `icon`     | str            | Name of icon to add.                                                                                                   | `None`  |
+| `show`     | bool           | Whether to print or not. Can be used to only output messages under certain condition, e.g. if `--verbose` flag is set. | `True`  |
+| `spaced`   | bool           | Whether to add newlines around the output.                                                                             | `False` |
+| `no_print` | bool           | Don't actually print, just return. Overwrites global setting.                                                          | `False` |
+| `exits`    | int            | If set, perform a system exit with the given code after printing.                                                      | `None`  |
+
+#### <kbd>method</kbd> `Printer.good`, `Printer.fail`, `Printer.warn`, `Printer.info`
+
+Print special formatted messages.
+
+```python
+msg = Printer()
+msg.good("Success")
+msg.fail("Error")
+msg.warn("Warning")
+msg.info("Info")
+```
+
+| Argument | Type | Description                                                                                                            | Default |
+| -------- | ---- | ---------------------------------------------------------------------------------------------------------------------- | ------- |
+| `title`  | str  | The main text to print.                                                                                                | `""`    |
+| `text`   | str  | Optional additional text to print.                                                                                     | `""`    |
+| `show`   | bool | Whether to print or not. Can be used to only output messages under certain condition, e.g. if `--verbose` flag is set. | `True`  |
+| `exits`  | int  | If set, perform a system exit with the given code after printing.                                                      | `None`  |
+
+#### <kbd>method</kbd> `Printer.divider`
+
+Print a formatted divider.
+
+```python
+msg = Printer()
+msg.divider("Heading")
+```
+
+| Argument | Type | Description                                                                                                            | Default |
+| -------- | ---- | ---------------------------------------------------------------------------------------------------------------------- | ------- |
+| `text`   | str  | Headline text. If empty, only the line is printed.                                                                     | `""`    |
+| `char`   | str  | Single line character to repeat.                                                                                       | `"="`   |
+| `show`   | bool | Whether to print or not. Can be used to only output messages under certain condition, e.g. if `--verbose` flag is set. | `True`  |
+| `icon`   | str  | Optional icon to use with title.                                                                                       | `None`  |
+
+#### <kbd>contextmanager</kbd> `Printer.loading`
+
+```python
+msg = Printer()
+with msg.loading("Loading..."):
+    # Do something here that takes longer
+    time.sleep(10)
+msg.good("Successfully loaded something!")
+```
+
+| Argument | Type | Description                        | Default           |
+| -------- | ---- | ---------------------------------- | ----------------- |
+| `text`   | str  | The text to display while loading. | `"Loading..."`    |
+
+#### <kbd>method</kbd> `Printer.table`, `Printer.row`
+
+See [Tables](#tables).
+
+#### <kbd>property</kbd> `Printer.counts`
+
+Get the counts of how often the special printers were fired, e.g.
+`MESSAGES.GOOD`. Can be used to print an overview like "X warnings"
+
+```python
+msg = Printer()
+msg.good("Success")
+msg.fail("Error")
+msg.warn("Error")
+
+print(msg.counts)
+# Counter({'good': 1, 'fail': 2, 'warn': 0, 'info': 0})
+```
+
+| Argument    | Type      | Description                                          |
+| ----------- | --------- | ---------------------------------------------------- |
+| **RETURNS** | `Counter` | The counts for the individual special message types. |
+
+### Tables
+
+#### <kbd>function</kbd> `table`
+
+Lightweight helper to format tabular data.
+
+```python
+from wasabi import table
+
+data = [("a1", "a2", "a3"), ("b1", "b2", "b3")]
+header = ("Column 1", "Column 2", "Column 3")
+widths = (8, 9, 10)
+aligns = ("r", "c", "l")
+formatted = table(data, header=header, divider=True, widths=widths, aligns=aligns)
+```
+
+```
+Column 1   Column 2    Column 3
+--------   ---------   ----------
+      a1      a2       a3
+      b1      b2       b3
+```
+
+| Argument    | Type                | Description                                                                                                                         | Default  |
+| ----------- | ------------------- | ----------------------------------------------------------------------------------------------------------------------------------- | -------- |
+| `data`      | iterable / dict     | The data to render. Either a list of lists (one per row) or a dict for two-column tables.                                           |          |
+| `header`    | iterable            | Optional header columns.                                                                                                            | `None`   |
+| `footer`    | iterable            | Optional footer columns.                                                                                                            | `None`   |
+| `divider`   | bool                | Show a divider line between header/footer and body.                                                                                 | `False`  |
+| `widths`    | iterable / `"auto"` | Column widths in order. If `"auto"`, widths will be calculated automatically based on the largest value.                            | `"auto"` |
+| `max_col`   | int                 | Maximum column width.                                                                                                               | `30`     |
+| `spacing`   | int                 | Number of spaces between columns.                                                                                                   | `3`      |
+| `aligns`    | iterable / unicode  | Columns alignments in order. `"l"` (left, default), `"r"` (right) or `"c"` (center). If If a string, value is used for all columns. | `None`   |
+| `multiline` | bool                | If a cell value is a list of a tuple, render it on multiple lines, with one value per line.                                         | `False`  |
+| `env_prefix` | unicode                | Prefix for environment variables, e.g. WASABI_LOG_FRIENDLY.                                         | `"WASABI"` |
+| `color_values` | dict                | Add or overwrite color values, name mapped to value.                                         | `None`   |
+| `fg_colors` | iterable                | Foreground colors, one per column. None can be specified for individual columns to retain the default background color. | `None`   |
+| `bg_colors` | iterable                | Background colors, one per column. None can be specified for individual columns to retain the default background color. | `None`   |
+| **RETURNS** | str                 | The formatted table.                                                                                                                |          |
+
+#### <kbd>function</kbd> `row`
+
+```python
+from wasabi import row
+
+data = ("a1", "a2", "a3")
+formatted = row(data)
+```
+
+```
+a1   a2   a3
+```
+
+| Argument    | Type                      | Description                                                                                                                                                | Default  |
+| ----------- | ------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------- | -------- |
+| `data`      | iterable                  | The individual columns to format.                                                                                                                          |          |
+| `widths`    | list / int / `"auto"` | Column widths, either one integer for all columns or an iterable of values. If "auto", widths will be calculated automatically based on the largest value. | `"auto"` |
+| `spacing`   | int                       | Number of spaces between columns.                                                                                                                          | `3`      |
+| `aligns`    | list                  | Columns alignments in order. `"l"` (left), `"r"` (right) or `"c"` (center).                                                                                | `None`   |
+| `env_prefix` | unicode                | Prefix for environment variables, e.g. WASABI_LOG_FRIENDLY.                                         | `"WASABI"` |
+| `fg_colors`    | list                  | Foreground colors for the columns, in order. None can be specified for individual columns to retain the default foreground color. | `None`   |
+| `bg_colors`    | list                  | Background colors for the columns, in order. None can be specified for individual columns to retain the default background color. | `None`   |
+| **RETURNS** | str                       | The formatted row.                                                                                                                                         |          |
+
+### <kbd>class</kbd> `TracebackPrinter`
+
+Helper to output custom formatted tracebacks and error messages. Currently used
+in [Thinc](https://github.com/explosion/thinc).
+
+#### <kbd>method</kbd> `TracebackPrinter.__init__`
+
+Initialize a traceback printer.
+
+```python
+from wasabi import TracebackPrinter
+
+tb = TracebackPrinter(tb_base="thinc", tb_exclude=("check.py",))
+```
+
+| Argument          | Type               | Description                                                                                                                                                              | Default    |
+| ----------------- | ------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ---------- |
+| `color_error`     | str / int          | Color name or code for errors (passed to `color` helper).                                                                                                                | `"red"`    |
+| `color_tb`        | str / int          | Color name or code for traceback headline (passed to `color` helper).                                                                                                    | `"blue"`   |
+| `color_highlight` | str / int          | Color name or code for highlighted text (passed to `color` helper).                                                                                                      | `"yellow"` |
+| `indent`          | int                | Number of spaces to use for indentation.                                                                                                                                 | `2`        |
+| `tb_base`         | str                | Name of directory to use to show relative paths. For example, `"thinc"` will look for the last occurence of `"/thinc/"` in a path and only show path to the right of it. | `None`     |
+| `tb_exclude`      | tuple              | List of filenames to exclude from traceback.                                                                                                                             | `tuple()`  |
+| **RETURNS**       | `TracebackPrinter` | The traceback printer.                                                                                                                                                   |            |
+
+#### <kbd>method</kbd> `TracebackPrinter.__call__`
+
+Output custom formatted tracebacks and errors.
+
+```python
+from wasabi import TracebackPrinter
+import traceback
+
+tb = TracebackPrinter(tb_base="thinc", tb_exclude=("check.py",))
+
+error = tb("Some error", "Error description", highlight="kwargs", tb=traceback.extract_stack())
+raise ValueError(error)
+```
+
+```
+  Some error
+  Some error description
+
+  Traceback:
+  ├─ <lambda> [61] in .env/lib/python3.6/site-packages/pluggy/manager.py
+  ├─── _multicall [187] in .env/lib/python3.6/site-packages/pluggy/callers.py
+  └───── pytest_fixture_setup [969] in .env/lib/python3.6/site-packages/_pytest/fixtures.py
+         >>> result = call_fixture_func(fixturefunc, request, kwargs)
+```
+
+| Argument    | Type     | Description                                                                                | Default |
+| ----------- | -------- | ------------------------------------------------------------------------------------------ | ------- |
+| `title`     | str      | The message title.                                                                         |         |
+| `*texts`    | str      | Optional texts to print (one per line).                                                    |         |
+| `highlight` | str      | Optional sequence to highlight in the traceback, e.g. the bad value that caused the error. | `False` |
+| `tb`        | iterable | The traceback, e.g. generated by `traceback.extract_stack()`.                              | `None`  |
+| **RETURNS** | str      | The formatted traceback. Can be printed or raised by custom exception.                     |         |
+
+### <kbd>class</kbd> `MarkdownRenderer`
+
+Helper to create Markdown-formatted content. Will store the blocks added to the Markdown document in order.
+
+```python
+from wasabi import MarkdownRenderer
+
+md = MarkdownRenderer()
+md.add(md.title(1, "Hello world"))
+md.add("This is a paragraph")
+print(md.text)
+```
+
+### <kbd>method</kbd> `MarkdownRenderer.__init__`
+
+Initialize a Markdown renderer.
+
+```python
+from wasabi import MarkdownRenderer
+
+md = MarkdownRenderer()
+```
+
+| Argument    | Type               | Description                    | Default |
+| ----------- | ------------------ | ------------------------------ | ------- |
+| `no_emoji`  | bool               | Don't include emoji in titles. | `False` |
+| **RETURNS** | `MarkdownRenderer` | The renderer.                  |
+
+### <kbd>method</kbd> `MarkdownRenderer.add`
+
+Add a block to the Markdown document.
+
+```python
+from wasabi import MarkdownRenderer
+
+md = MarkdownRenderer()
+md.add("This is a paragraph")
+```
+
+| Argument | Type | Description         | Default |
+| -------- | ---- | ------------------- | ------- |
+| `text`   | str  | The content to add. |         |
+
+### <kbd>property</kbd> `MarkdownRenderer.text`
+
+The rendered Markdown document.
+
+```python
+md = MarkdownRenderer()
+md.add("This is a paragraph")
+print(md.text)
+```
+
+| Argument    | Type | Description                      | Default |
+| ----------- | ---- | -------------------------------- | ------- |
+| **RETURNS** | str  | The document as a single string. |         |
+
+### <kbd>method</kbd> `MarkdownRenderer.table`
+
+Create a Markdown-formatted table.
+
+```python
+md = MarkdownRenderer()
+table = md.table([("a", "b"), ("c", "d")], ["Column 1", "Column 2"])
+md.add(table)
+```
+
+<!-- prettier-ignore -->
+```markdown
+| Column 1 | Column 2 |
+| --- | --- |
+| a | b |
+| c | d |
+```
+
+| Argument    | Type                    | Description                                                                          | Default |
+| ----------- | ----------------------- | ------------------------------------------------------------------------------------ | ------- |
+| `data`      | Iterable[Iterable[str]] | The body, one iterable per row, containig an interable of column contents.           |         |
+| `header`    | Iterable[str]           | The column names.                                                                    |         |
+| `aligns`    | Iterable[str]           | Columns alignments in order. `"l"` (left, default), `"r"` (right) or `"c"` (center). | `None`  |
+| **RETURNS** | str                     | The table.                                                                           |         |
+
+### <kbd>method</kbd> `MarkdownRenderer.title`
+
+Create a Markdown-formatted heading.
+
+```python
+md = MarkdownRenderer()
+md.add(md.title(1, "Hello world"))
+md.add(md.title(2, "Subheading", "💖"))
+```
+
+```markdown
+# Hello world
+
+## 💖 Subheading
+```
+
+| Argument    | Type | Description                            | Default |
+| ----------- | ---- | -------------------------------------- | ------- |
+| `level`     | int  | The heading level, e.g. `3` for `###`. |         |
+| `text`      | str  | The heading text.                      |         |
+| `emoji`     | str  | Optional emoji to show before heading. | `None`  |
+| **RETURNS** | str  | The rendered title.                    |         |
+
+### <kbd>method</kbd> `MarkdownRenderer.list`
+
+Create a Markdown-formatted non-nested list.
+
+```python
+md = MarkdownRenderer()
+md.add(md.list(["item", "other item"]))
+md.add(md.list(["first item", "second item"], numbered=True))
+```
+
+```markdown
+- item
+- other item
+
+1. first item
+2. second item
+```
+
+| Argument    | Type          | Description                     | Default |
+| ----------- | ------------- | ------------------------------- | ------- |
+| `items`     | Iterable[str] | The list items.                 |         |
+| `numbered`  | bool          | Whether to use a numbered list. | `False` |
+| **RETURNS** | str           | The rendered list.              |         |
+
+### <kbd>method</kbd> `MarkdownRenderer.link`
+
+Create a Markdown-formatted link.
+
+```python
+md = MarkdownRenderer()
+md.add(md.link("Google", "https://google.com"))
+```
+
+```markdown
+[Google](https://google.com)
+```
+
+| Argument    | Type | Description        | Default |
+| ----------- | ---- | ------------------ | ------- |
+| `text`      | str  | The link text.     |         |
+| `url`       | str  | The link URL.      |         |
+| **RETURNS** | str  | The rendered link. |         |
+
+### <kbd>method</kbd> `MarkdownRenderer.code_block`
+
+Create a Markdown-formatted code block.
+
+```python
+md = MarkdownRenderer()
+md.add(md.code_block("import spacy", "python"))
+```
+
+````markdown
+```python
+import spacy
+```
+````
+
+| Argument    | Type | Description              | Default |
+| ----------- | ---- | ------------------------ | ------- |
+| `text`      | str  | The code text.           |         |
+| `lang`      | str  | Optional code language.  | `""`    |
+| **RETURNS** | str  | The rendered code block. |         |
+
+### <kbd>method</kbd> `MarkdownRenderer.code`, `MarkdownRenderer.bold`, `MarkdownRenderer.italic`
+
+Create a Markdown-formatted text.
+
+```python
+md = MarkdownRenderer()
+md.add(md.code("import spacy"))
+md.add(md.bold("Hello!"))
+md.add(md.italic("Emphasis"))
+```
+
+```markdown
+`import spacy`
+
+**Hello!**
+
+_Emphasis_
+```
+
+### Utilities
+
+#### <kbd>function</kbd> `color`
+
+```python
+from wasabi import color
+
+formatted = color("This is a text", fg="white", bg="green", bold=True)
+```
+
+| Argument    | Type      | Description                                   | Default |
+| ----------- | --------- | --------------------------------------------- | ------- |
+| `text`      | str       | The text to be formatted.                     | -       |
+| `fg`        | str / int | Foreground color. String name or `0` - `256`. | `None`  |
+| `bg`        | str / int | Background color. String name or `0` - `256`. | `None`  |
+| `bold`      | bool      | Format the text in bold.                      | `False` |
+| `underline` | bool      | Format the text by underlining.               | `False` |
+| **RETURNS** | str       | The formatted string.                         |         |
+
+#### <kbd>function</kbd> `wrap`
+
+```python
+from wasabi import wrap
+
+wrapped = wrap("Hello world, this is a text.", indent=2)
+```
+
+| Argument    | Type | Description                                | Default |
+| ----------- | ---- | ------------------------------------------ | ------- |
+| `text`      | str  | The text to wrap.                          | -       |
+| `wrap_max`  | int  | Maximum line width, including indentation. | `80`    |
+| `indent`    | int  | Number of spaces used for indentation.     | `4`     |
+| **RETURNS** | str  | The wrapped text with line breaks.         |         |
+
+#### <kbd>function</kbd> `diff_strings`
+
+```python
+from wasabi import diff_strings
+
+diff = diff_strings("hello world!", "helloo world")
+```
+
+| Argument    | Type      | Description                                                                  | Default            |
+| ----------- | --------- | ---------------------------------------------------------------------------- | ------------------ |
+| `a`         | str       | The first string to diff.                                                    |
+| `b`         | str       | The second string to diff.                                                   |
+| `fg`        | str / int | Foreground color. String name or `0` - `256`.                                | `"black"`          |
+| `bg`        | tuple     | Background colors as `(insert, delete)` tuple of string name or `0` - `256`. | `("green", "red")` |
+| **RETURNS** | str       | The formatted diff.                                                          |                    |
+
+### Environment variables
+
+Wasabi also respects the following environment variables. The prefix can be
+customised on the `Printer` via the `env_prefix` argument. For example, setting
+`env_prefix="SPACY"` will expect the environment variable `SPACY_LOG_FRIENDLY`.
+
+| Name                   | Description                                            |
+| ---------------------- | ------------------------------------------------------ |
+| `ANSI_COLORS_DISABLED` | Disable colors.                                        |
+| `WASABI_LOG_FRIENDLY`  | Make output nicer for logs (no colors, no animations). |
+| `WASABI_NO_PRETTY`     | Disable pretty printing, e.g. colors and icons.        |
+
+## 🔔 Run tests
+
+Fork or clone the repo, make sure you have `pytest` installed and then run it on
+the package directory. The tests are located in
+[`/wasabi/tests`](/wasabi/tests).
+
+```bash
+pip install pytest
+cd wasabi
+python -m pytest wasabi
+```

.venv/Lib/site-packages/wasabi-0.10.1.dist-info/RECORD

@@ -0,0 +1,21 @@
+wasabi-0.10.1.dist-info/LICENSE,sha256=VFEGPy-fp93JVB9xDa69VMP0RZLK8W9vmGJsMhO-yT0,1079
+wasabi-0.10.1.dist-info/METADATA,sha256=PqgL35FWFflAukT8zb2G9h3L0LDdZA-hfhATnYhPT4I,28325
+wasabi-0.10.1.dist-info/RECORD,,
+wasabi-0.10.1.dist-info/WHEEL,sha256=G16H4A3IeoQmnOrYV4ueZGKSjhipXx8zc8nu9FGlvMA,92
+wasabi-0.10.1.dist-info/top_level.txt,sha256=W9sjXfJi_nAtQ-jjHMYsfeSlxTmnidUT6Eg0PqIYxkM,7
+wasabi-0.10.1.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+wasabi-0.10.1.dist-info\INSTALLER,sha256=5hhM4Q4mYTT9z6QB6PGpUAW81PGNFrYrdXMj4oM_6ak,2
+wasabi-0.10.1.dist-info\REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+wasabi/__init__.py,sha256=Y7ESsG4XE5A2C5ZiXh0_tnrUweiZW3yHJzt05ZPSIbo,406
+wasabi/about.py,sha256=h52qkdZ4io5L_AJohzkCwF39SKEN3VZAAQBYHUj_V8E,222
+wasabi/markdown.py,sha256=vjlUPQJ0DwCfJYBuuzP4UdzvLsdBKrPbEtZTtF_qRRE,3430
+wasabi/printer.py,sha256=qxXdc7oxVT_CF03FYOAbBgwWso_HqniggwUUXqudcBU,9114
+wasabi/tables.py,sha256=jATbMi_CUs0UGom5fRlLOh-GMbyhVudZQf20CWkMIHY,5853
+wasabi/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+wasabi/tests/test_markdown.py,sha256=RkuBjcWCzK5vZzfIE_TqsnDk23LfyIAA55sr8rlvvjY,1244
+wasabi/tests/test_printer.py,sha256=GlgYIXAmrUMNe3C2zP3ClbDxpq5yzqxhzvGpgNWIuCI,7426
+wasabi/tests/test_tables.py,sha256=qTgQC-FKSYhUFn4OlWeVYO2gmLBdhNV_gHb5EsGAob8,17567
+wasabi/tests/test_traceback.py,sha256=neHeGSCQvuSWOvSnLfqvWuNGe4AKafJ5YNcbn-LBGhU,1692
+wasabi/tests/test_util.py,sha256=YZM3ydI92f3DO-rfeiBe9Q1XlaCC7-y6M40l3iUBHZk,2524
+wasabi/traceback_printer.py,sha256=1lII5g68jVhyEYPdkF_y6IIR0AhKgukKHxouGgaiAIE,4953
+wasabi/util.py,sha256=zmcRGQhoKSUflnnk7aY3ugV8V3bReIunmzPm6tegQr8,7206

.venv/Lib/site-packages/wasabi-0.10.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.37.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

.venv/Lib/site-packages/wasabi-0.10.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+wasabi

.venv/Lib/site-packages/wasabi-0.10.1.dist-info/zip-safe

@@ -0,0 +1 @@
+

.venv/Lib/site-packages/wasabi/tests/test_util.py

@@ -0,0 +1,75 @@
+# coding: utf8
+from __future__ import unicode_literals, print_function
+
+import pytest
+from wasabi.util import color, wrap, locale_escape, format_repr, diff_strings
+
+
+def test_color():
+    assert color("test", fg="green") == "\x1b[38;5;2mtest\x1b[0m"
+    assert color("test", fg=4) == "\x1b[38;5;4mtest\x1b[0m"
+    assert color("test", bold=True) == "\x1b[1mtest\x1b[0m"
+    assert color("test", fg="red", underline=True) == "\x1b[4;38;5;1mtest\x1b[0m"
+    assert (
+        color("test", fg=7, bg="red", bold=True) == "\x1b[1;38;5;7;48;5;1mtest\x1b[0m"
+    )
+
+
+def test_wrap():
+    text = "Hello world, this is a test."
+    assert wrap(text, indent=0) == text
+    assert wrap(text, indent=4) == "    Hello world, this is a test."
+    assert wrap(text, wrap_max=10, indent=0) == "Hello\nworld,\nthis is a\ntest."
+    assert (
+        wrap(text, wrap_max=5, indent=2)
+        == "  Hello\n  world,\n  this\n  is\n  a\n  test."
+    )
+
+
+def test_format_repr():
+    obj = {"hello": "world", "test": 123}
+    formatted = format_repr(obj)
+    assert formatted.replace("u'", "'") in [
+        "{'hello': 'world', 'test': 123}",
+        "{'test': 123, 'hello': 'world'}",
+    ]
+    formatted = format_repr(obj, max_len=10)
+    assert formatted.replace("u'", "'") in [
+        "{'hel ...  123}",
+        "{'tes ... rld'}",
+        "{'te ... rld'}",
+    ]
+    formatted = format_repr(obj, max_len=10, ellipsis="[...]")
+    assert formatted.replace("u'", "'") in [
+        "{'hel [...]  123}",
+        "{'tes [...] rld'}",
+        "{'te [...] rld'}",
+    ]
+
+
+@pytest.mark.parametrize(
+    "text,non_ascii",
+    [
+        ("abc", ["abc"]),
+        ("\u2714 abc", ["? abc"]),
+        ("👻", ["??", "?"]),  # On Python 3 windows, this becomes "?" instead of "??"
+    ],
+)
+def test_locale_escape(text, non_ascii):
+    result = locale_escape(text)
+    assert result == text or result in non_ascii
+    print(result)
+
+
+def test_diff_strings():
+    a = "hello\nworld\nwide\nweb"
+    b = "yo\nwide\nworld\nweb"
+    expected = "\x1b[38;5;16;48;5;2myo\x1b[0m\n\x1b[38;5;16;48;5;2mwide\x1b[0m\n\x1b[38;5;16;48;5;1mhello\x1b[0m\nworld\n\x1b[38;5;16;48;5;1mwide\x1b[0m\nweb"
+    assert diff_strings(a, b) == expected
+
+
+def test_diff_strings_with_symbols():
+    a = "hello\nworld\nwide\nweb"
+    b = "yo\nwide\nworld\nweb"
+    expected = "\x1b[38;5;16;48;5;2m+ yo\x1b[0m\n\x1b[38;5;16;48;5;2m+ wide\x1b[0m\n\x1b[38;5;16;48;5;1m- hello\x1b[0m\nworld\n\x1b[38;5;16;48;5;1m- wide\x1b[0m\nweb"
+    assert diff_strings(a, b, add_symbols=True) == expected

.venv/Lib/site-packages/xlstm/__init__.py

@@ -0,0 +1,9 @@
+__version__ = "1.0.8"
+
+from .blocks.mlstm.block import mLSTMBlock, mLSTMBlockConfig
+from .blocks.mlstm.layer import mLSTMLayer, mLSTMLayerConfig
+from .blocks.slstm.block import sLSTMBlock, sLSTMBlockConfig
+from .blocks.slstm.layer import sLSTMLayer, sLSTMLayerConfig
+from .components.feedforward import FeedForwardConfig, GatedFeedForward
+from .xlstm_block_stack import xLSTMBlockStack, xLSTMBlockStackConfig
+from .xlstm_lm_model import xLSTMLMModel, xLSTMLMModelConfig

.venv/Lib/site-packages/xlstm/blocks/mlstm/__init__.py

@@ -0,0 +1 @@
+

.venv/Lib/site-packages/xlstm/blocks/mlstm/backends.py

@@ -0,0 +1,145 @@
+# Copyright (c) NXAI GmbH and its affiliates 2024
+# Maximilian Beck
+import math
+
+import torch
+
+
+def parallel_stabilized_simple(
+    queries: torch.Tensor,
+    keys: torch.Tensor,
+    values: torch.Tensor,
+    igate_preact: torch.Tensor,
+    fgate_preact: torch.Tensor,
+    lower_triangular_matrix: torch.Tensor = None,
+    stabilize_rowwise: bool = True,
+    eps: float = 1e-6,
+    **kwargs,
+) -> torch.Tensor:
+    """This is the mLSTM cell in parallel form.
+    This version is stabilized. We control the range of exp() arguments by
+    ensuring that they are always smaller than 0.0 by subtracting the maximum.
+
+    Args:
+        queries (torch.Tensor): (B, NH, S, DH)
+        keys (torch.Tensor): (B, NH, S, DH)
+        values (torch.Tensor): (B, NH, S, DH)
+        igate_preact (torch.Tensor): (B, NH, S, 1)
+        fgate_preact (torch.Tensor): (B, NH, S, 1)
+        lower_triangular_matrix (torch.Tensor, optional): (S,S). Defaults to None.
+        stabilize_rowwise (bool, optional): Wether to stabilize the combination matrix C rowwise (take maximum per row).
+            Alternative: Subtract the maximum over all rows. Defaults to True.
+
+    Returns:
+        torch.Tensor: (B, NH, S, DH), h_tilde_state
+    """
+
+    B, NH, S, DH = queries.shape
+    _dtype, _device = queries.dtype, queries.device
+
+    # forget gate matrix
+    log_fgates = torch.nn.functional.logsigmoid(fgate_preact)  # (B, NH, S, 1)
+    if lower_triangular_matrix is None or S < lower_triangular_matrix.size(-1):
+        ltr = torch.tril(torch.ones((S, S), dtype=torch.bool, device=_device))
+    else:
+        ltr = lower_triangular_matrix
+    assert ltr.dtype == torch.bool, f"lower_triangular_matrix must be of dtype bool, got {ltr.dtype}"
+
+    log_fgates_cumsum = torch.cat(
+        [
+            torch.zeros((B, NH, 1, 1), dtype=_dtype, device=_device),
+            torch.cumsum(log_fgates, dim=-2),
+        ],
+        dim=-2,
+    )  # (B, NH, S+1, 1)
+    # for each batch/head this is a matrix of shape (S+1, S+1) containing the cumsum of the log forget gate values
+    # in the second dimension (colum dimension). Each row has the same is a copy of the first row.
+    # First entry of each row is zero.
+    rep_log_fgates_cumsum = log_fgates_cumsum.repeat(1, 1, 1, S + 1)  # (B, NH, S+1, S+1)
+    # Now in each row cut off / subtract the forgetgate values of the later timesteps
+    # where col j > row i
+    _log_fg_matrix = rep_log_fgates_cumsum - rep_log_fgates_cumsum.transpose(-2, -1)  # (B, NH, S+1, S+1)
+    # Causal masking & selection of the correct submatrix, such that forgetgate at timestep t is not applied
+    # to the input at timestep t
+    log_fg_matrix = torch.where(ltr, _log_fg_matrix[:, :, 1:, 1:], -float("inf"))  # (B, NH, S, S)
+
+    # gate decay matrix D (combination of forget gate and input gate)
+    log_D_matrix = log_fg_matrix + igate_preact.transpose(-2, -1)  # (B, NH, S, S)
+    # D matrix stabilization
+    if stabilize_rowwise:
+        max_log_D, _ = torch.max(log_D_matrix, dim=-1, keepdim=True)  # (B, NH, S, 1)
+    else:
+        max_log_D = torch.max(log_D_matrix.view(B, NH, -1), dim=-1, keepdim=True)[0].unsqueeze(-1)
+        # (B, NH, 1, 1)
+    log_D_matrix_stabilized = log_D_matrix - max_log_D  # (B, NH, S, S)
+    D_matrix = torch.exp(log_D_matrix_stabilized)  # (B, NH, S, S)
+
+    keys_scaled = keys / math.sqrt(DH)
+
+    # combination matrix C
+    qk_matrix = queries @ keys_scaled.transpose(-2, -1)  # (B, NH, S, S)
+    C_matrix = qk_matrix * D_matrix  # (B, NH, S, S)
+    normalizer = torch.maximum(C_matrix.sum(dim=-1, keepdim=True).abs(), torch.exp(-max_log_D))  # (B, NH, S, 1)
+    # (B, NH, S, S)
+    C_matrix_normalized = C_matrix / (normalizer + eps)
+
+    # retrieved values
+    h_tilde_state = C_matrix_normalized @ values  # (B, NH, S, DH)
+
+    return h_tilde_state
+
+
+def recurrent_step_stabilized_simple(
+    c_state: torch.Tensor,
+    n_state: torch.Tensor,
+    m_state: torch.Tensor,
+    q: torch.Tensor,
+    k: torch.Tensor,
+    v: torch.Tensor,
+    igate_preact: torch.Tensor,
+    fgate_preact: torch.Tensor,
+    eps: float = 1e-6,
+    **kwargs,
+) -> tuple[torch.Tensor, tuple[torch.Tensor, torch.Tensor]]:
+    """This is a single step of the mLSTM operation in recurrent form.
+
+    Args:
+        c_state (torch.Tensor): (B, NH, DH, DH)
+        n_state (torch.Tensor): (B, NH, DH, 1)
+        m_state (torch.Tensor): (B, NH, 1, 1)
+        q (torch.Tensor): (B, NH, 1, DH)
+        k (torch.Tensor): (B, NH, 1, DH)
+        v (torch.Tensor): (B, NH, 1, DH)
+        igate_preact (torch.Tensor): (B, NH, 1, 1)
+        fgate_preact (torch.Tensor): (B, NH, 1, 1)
+
+    Returns:
+        tuple[torch.Tensor, tuple[torch.Tensor, torch.Tensor]]:
+            (hidden_state [B, NH, DH], (c_state_new [B, NH, DH, DH], n_state_new [B, NH, DH, 1]], m_state_new [B, NH, 1, 1]))
+    """
+    B, NH, S, DH = q.shape
+    # projections
+    q, k, v = q.squeeze_(2).unsqueeze(-1), k.squeeze_(2).unsqueeze(-1), v.squeeze_(2).unsqueeze(-1)  # (B, NH, DH, 1)
+
+    # gates
+    log_fg_act = torch.nn.functional.logsigmoid(fgate_preact)  # (B, NH, 1, 1)
+
+    # update rule
+    m_state_new = torch.max(log_fg_act + m_state, igate_preact)  # (B, NH, 1, 1)
+
+    fg_act = torch.exp(log_fg_act + m_state - m_state_new)  # (B, NH, 1, 1)
+    ig_act = torch.exp(igate_preact - m_state_new)  # (B, NH, 1, 1)
+
+    k_scaled = k / math.sqrt(DH)
+
+    c_state_new = fg_act * c_state + ig_act * (k_scaled @ v.transpose(-1, -2))  # (B, NH, DH, DH)
+    n_state_new = fg_act * n_state + ig_act * k_scaled  # (B, NH, DH, 1)
+
+    h_num = q.transpose(-1, -2) @ c_state_new  # (B, NH, 1, DH)
+
+    qn_dotproduct = q.transpose(-1, -2) @ n_state_new  # (B, NH, 1, 1)
+    max_val = torch.exp(-m_state_new)  # (B, NH, 1, 1)
+    h_denom = torch.maximum(qn_dotproduct.abs(), max_val) + eps
+    h = h_num / h_denom  # (B, NH, 1, DH) / (B, NH, 1, 1) = (B, NH, 1, DH)
+
+    return h, (c_state_new, n_state_new, m_state_new)

.venv/Lib/site-packages/xlstm/blocks/mlstm/block.py

@@ -0,0 +1,34 @@
+# Copyright (c) NXAI GmbH and its affiliates 2024
+# Maximilian Beck
+from dataclasses import dataclass, field
+
+from ..xlstm_block import xLSTMBlock, xLSTMBlockConfig
+from .layer import mLSTMLayerConfig
+
+
+@dataclass
+class mLSTMBlockConfig:
+    mlstm: mLSTMLayerConfig = field(default_factory=mLSTMLayerConfig)
+
+    # we initialize these with None to catch the case where they are not set
+    _num_blocks: int = None
+    _block_idx: int = None
+
+    def __post_init__(self):
+        self.mlstm._num_blocks = self._num_blocks
+        self.mlstm.__post_init__()
+
+
+class mLSTMBlock(xLSTMBlock):
+    config_class = mLSTMBlockConfig
+
+    def __init__(self, config: mLSTMBlockConfig) -> None:
+        super().__init__(
+            config=xLSTMBlockConfig(
+                mlstm=config.mlstm,
+                slstm=None,
+                feedforward=None,
+                _num_blocks=config._num_blocks,
+                _block_idx=config._block_idx,
+            )
+        )

.venv/Lib/site-packages/xlstm/blocks/mlstm/cell.py

@@ -0,0 +1,140 @@
+# Copyright (c) NXAI GmbH and its affiliates 2024
+# Maximilian Beck
+from dataclasses import dataclass
+
+import torch
+from torch import nn
+
+from ...components.init import bias_linspace_init_
+from ...components.ln import MultiHeadLayerNorm
+from .backends import parallel_stabilized_simple, recurrent_step_stabilized_simple
+
+
+@dataclass
+class mLSTMCellConfig:
+    context_length: int = -1
+    embedding_dim: int = -1
+    num_heads: int = -1
+
+
+class mLSTMCell(nn.Module):
+    config_class = mLSTMCellConfig
+
+    def __init__(self, config: mLSTMCellConfig):
+        super().__init__()
+        self.config = config
+
+        self.backend_fn = parallel_stabilized_simple
+        self.backend_fn_step = recurrent_step_stabilized_simple
+
+        self.igate = nn.Linear(3 * config.embedding_dim, config.num_heads)
+        self.fgate = nn.Linear(3 * config.embedding_dim, config.num_heads)
+
+        self.outnorm = MultiHeadLayerNorm(ndim=config.embedding_dim, weight=True, bias=False)
+
+        self.register_buffer(
+            "causal_mask",
+            torch.tril(torch.ones(config.context_length, config.context_length, dtype=torch.bool)),
+            persistent=False,
+        )
+
+        self.reset_parameters()
+
+    def forward(self, q: torch.Tensor, k: torch.Tensor, v: torch.Tensor, **kwargs) -> torch.Tensor:
+        B, S, _ = q.shape  # (B, S, H)
+
+        if_gate_input = torch.cat([q, k, v], dim=-1)
+        q = q.view(B, S, self.config.num_heads, -1)  # (B, S, NH, DH)
+        k = k.view(B, S, self.config.num_heads, -1)  # (B, S, NH, DH)
+        v = v.view(B, S, self.config.num_heads, -1)  # (B, S, NH, DH)
+
+        q = q.transpose(1, 2)  # (B, NH, S, DH)
+        k = k.transpose(1, 2)  # (B, NH, S, DH)
+        v = v.transpose(1, 2)  # (B, NH, S, DH)
+
+        # compute input and forget gate pre-activations
+        igate_preact = self.igate(if_gate_input)  # (B, S, NH)
+        igate_preact = igate_preact.transpose(-1, -2).unsqueeze(-1)  # (B, NH, S, 1)
+        fgate_preact = self.fgate(if_gate_input)  # (B, S, NH)
+        fgate_preact = fgate_preact.transpose(-1, -2).unsqueeze(-1)  # (B, NH, S, 1)#
+
+        h_state = self.backend_fn(
+            queries=q,
+            keys=k,
+            values=v,
+            igate_preact=igate_preact,
+            fgate_preact=fgate_preact,
+            lower_triangular_matrix=self.causal_mask,
+        )  # (B, NH, S, DH)
+
+        h_state_norm = self.outnorm(h_state)  # (B, NH, S, DH)
+        h_state_norm = h_state_norm.transpose(1, 2).reshape(B, S, -1)  # (B, NH, S, DH) -> (B, S, NH, DH) -> (B, S, H)
+
+        return h_state_norm
+
+    def step(
+        self,
+        q: torch.Tensor,
+        k: torch.Tensor,
+        v: torch.Tensor,
+        mlstm_state: tuple[torch.Tensor, torch.Tensor, torch.Tensor] = None,
+        **kwargs,
+    ) -> tuple[torch.Tensor, tuple[torch.Tensor, torch.Tensor, torch.Tensor]]:
+        B, S, _ = q.shape  # (B, S, H)
+        assert S == 1, f"mLSTMCell.step only supports sequence length S=1, but got S={S}."
+
+        if_gate_input = torch.cat([q, k, v], dim=-1)
+        q = q.view(B, S, self.config.num_heads, -1)  # (B, S, NH, DH)
+        k = k.view(B, S, self.config.num_heads, -1)  # (B, S, NH, DH)
+        v = v.view(B, S, self.config.num_heads, -1)  # (B, S, NH, DH)
+
+        _, _, NH, DH = q.shape
+
+        q = q.transpose(1, 2)  # (B, NH, S, DH)
+        k = k.transpose(1, 2)  # (B, NH, S, DH)
+        v = v.transpose(1, 2)  # (B, NH, S, DH)
+
+        # compute input and forget gate pre-activations
+        igate_preact = self.igate(if_gate_input)  # (B, S, NH)
+        igate_preact = igate_preact.transpose(-1, -2).unsqueeze(-1)  # (B, NH, S, 1)
+        fgate_preact = self.fgate(if_gate_input)  # (B, S, NH)
+        fgate_preact = fgate_preact.transpose(-1, -2).unsqueeze(-1)  # (B, NH, S, 1)
+
+        if mlstm_state is None:
+            c_state = torch.zeros(size=(B, NH, DH, DH), device=q.device, dtype=q.dtype)
+            n_state = torch.zeros(size=(B, NH, DH, 1), device=q.device, dtype=q.dtype)
+            m_state = torch.zeros(size=(B, NH, 1, 1), device=q.device, dtype=q.dtype)
+        else:
+            c_state, n_state, m_state = mlstm_state
+            c_state = c_state.to(device=q.device, dtype=q.dtype)
+            n_state = n_state.to(device=q.device, dtype=q.dtype)
+            m_state = m_state.to(device=q.device, dtype=q.dtype)
+
+        assert c_state.shape == (B, NH, DH, DH), f"Expected c_state shape {(B, NH, DH, DH)}, but got {c_state.shape}."
+        assert n_state.shape == (B, NH, DH, 1), f"Expected n_state shape {(B, NH, DH, 1)}, but got {n_state.shape}."
+        assert m_state.shape == (B, NH, 1, 1), f"Expected m_state shape {(B, NH, 1, 1)}, but got {m_state.shape}."
+
+        h_state, mlstm_state = self.backend_fn_step(
+            c_state=c_state,
+            n_state=n_state,
+            m_state=m_state,
+            q=q,
+            k=k,
+            v=v,
+            igate_preact=igate_preact,
+            fgate_preact=fgate_preact,
+        )  # (B, NH, 1 DH), ((B, NH, DH, DH), (B, NH, DH, 1), (B, NH, 1, 1))
+
+        h_state_norm = self.outnorm(h_state)  # (B, NH, S, DH)
+        h_state_norm = h_state_norm.transpose(1, 2).reshape(B, S, -1)  # (B, NH, S, DH) -> (B, S, NH, DH) -> (B, S, H)
+
+        return h_state_norm, mlstm_state
+
+    def reset_parameters(self):
+        self.outnorm.reset_parameters()
+        # forget gate initialization
+        torch.nn.init.zeros_(self.fgate.weight)
+        bias_linspace_init_(self.fgate.bias, start=3.0, end=6.0)
+        # input gate initialization
+        torch.nn.init.zeros_(self.igate.weight)
+        torch.nn.init.normal_(self.igate.bias, mean=0.0, std=0.1)

.venv/Lib/site-packages/xlstm/blocks/mlstm/layer.py

@@ -0,0 +1,180 @@
+# Copyright (c) NXAI GmbH and its affiliates 2024
+# Maximilian Beck
+from dataclasses import dataclass
+
+import torch
+from torch import nn
+
+from ...components.conv import CausalConv1d, CausalConv1dConfig
+from ...components.init import small_init_init_, wang_init_
+from ...components.linear_headwise import (
+    LinearHeadwiseExpand,
+    LinearHeadwiseExpandConfig,
+)
+from ...utils import UpProjConfigMixin
+from .cell import mLSTMCell, mLSTMCellConfig
+
+
+@dataclass
+class mLSTMLayerConfig(UpProjConfigMixin):
+    conv1d_kernel_size: int = 4
+    qkv_proj_blocksize: int = 4
+    num_heads: int = 4
+    proj_factor: float = 2.0
+
+    # will be set toplevel config
+    embedding_dim: int = -1
+    bias: bool = False
+    dropout: float = 0.0
+    context_length: int = -1
+
+    _num_blocks: int = 1
+    _inner_embedding_dim: int = None
+
+    def __post_init__(self):
+        self._set_proj_up_dim(embedding_dim=self.embedding_dim)
+        self._inner_embedding_dim = self._proj_up_dim
+
+
+class mLSTMLayer(nn.Module):
+    config_class = mLSTMLayerConfig
+
+    def __init__(self, config: mLSTMLayerConfig):
+        super().__init__()
+        self.config = config
+
+        self.proj_up = nn.Linear(
+            in_features=self.config.embedding_dim,
+            out_features=2 * self.config._inner_embedding_dim,
+            bias=self.config.bias,
+        )
+
+        num_proj_heads = round(self.config._inner_embedding_dim // self.config.qkv_proj_blocksize)
+        self.q_proj = LinearHeadwiseExpand(
+            config=LinearHeadwiseExpandConfig(
+                in_features=self.config._inner_embedding_dim,
+                num_heads=num_proj_heads,
+                bias=self.config.bias,
+            )
+        )
+        self.k_proj = LinearHeadwiseExpand(
+            config=LinearHeadwiseExpandConfig(
+                in_features=self.config._inner_embedding_dim,
+                num_heads=num_proj_heads,
+                bias=self.config.bias,
+            )
+        )
+        self.v_proj = LinearHeadwiseExpand(
+            config=LinearHeadwiseExpandConfig(
+                in_features=self.config._inner_embedding_dim,
+                num_heads=num_proj_heads,
+                bias=self.config.bias,
+            )
+        )
+
+        self.conv1d = CausalConv1d(
+            config=CausalConv1dConfig(
+                feature_dim=self.config._inner_embedding_dim,
+                kernel_size=self.config.conv1d_kernel_size,
+            )
+        )
+        self.conv_act_fn = nn.SiLU()
+        self.mlstm_cell = mLSTMCell(
+            config=mLSTMCellConfig(
+                context_length=self.config.context_length,
+                embedding_dim=self.config._inner_embedding_dim,
+                num_heads=self.config.num_heads,
+            )
+        )
+        self.ogate_act_fn = nn.SiLU()
+
+        self.learnable_skip = nn.Parameter(torch.ones(self.config._inner_embedding_dim, requires_grad=True))
+
+        self.proj_down = nn.Linear(
+            in_features=self.config._inner_embedding_dim,
+            out_features=self.config.embedding_dim,
+            bias=self.config.bias,
+        )
+        self.dropout = nn.Dropout(self.config.dropout)
+        self.reset_parameters()
+
+    def forward(self, x: torch.Tensor, **kwargs) -> torch.Tensor:
+        B, S, _ = x.shape
+
+        # up-projection
+        x_inner = self.proj_up(x)
+        x_mlstm, z = torch.split(x_inner, split_size_or_sections=self.config._inner_embedding_dim, dim=-1)
+
+        # mlstm branch
+        x_mlstm_conv = self.conv1d(x_mlstm)
+        x_mlstm_conv_act = self.conv_act_fn(x_mlstm_conv)
+
+        q = self.q_proj(x_mlstm_conv_act)
+        k = self.k_proj(x_mlstm_conv_act)
+        v = self.v_proj(x_mlstm)
+
+        h_tilde_state = self.mlstm_cell(q=q, k=k, v=v)
+
+        h_tilde_state_skip = h_tilde_state + (self.learnable_skip * x_mlstm_conv_act)
+
+        # output / z branch
+        h_state = h_tilde_state_skip * self.ogate_act_fn(z)
+
+        # down-projection
+        y = self.dropout(self.proj_down(h_state))
+        return y
+
+    def step(
+        self,
+        x: torch.Tensor,
+        mlstm_state: tuple[torch.Tensor, torch.Tensor, torch.Tensor] = None,
+        conv_state: tuple[torch.Tensor] = None,
+    ) -> tuple[torch.Tensor, dict[str, tuple[torch.Tensor, ...]]]:
+        B, S, _ = x.shape
+
+        # up-projection
+        x_inner = self.proj_up(x)
+        x_mlstm, z = torch.split(x_inner, split_size_or_sections=self.config._inner_embedding_dim, dim=-1)
+
+        # mlstm branch
+        x_mlstm_conv, conv_state = self.conv1d.step(x_mlstm, conv_state=conv_state)
+        x_mlstm_conv_act = self.conv_act_fn(x_mlstm_conv)
+
+        q = self.q_proj(x_mlstm_conv_act)
+        k = self.k_proj(x_mlstm_conv_act)
+        v = self.v_proj(x_mlstm)
+
+        h_tilde_state, mlstm_state = self.mlstm_cell.step(q=q, k=k, v=v, mlstm_state=mlstm_state)
+
+        h_tilde_state_skip = h_tilde_state + (self.learnable_skip * x_mlstm_conv_act)
+
+        # output / z branch
+        h_state = h_tilde_state_skip * self.ogate_act_fn(z)
+
+        # down-projection
+        y = self.dropout(self.proj_down(h_state))
+        return y, {"mlstm_state": mlstm_state, "conv_state": conv_state}
+
+    def reset_parameters(self):
+        # init inproj
+        small_init_init_(self.proj_up.weight, dim=self.config.embedding_dim)
+        if self.proj_up.bias is not None:
+            nn.init.zeros_(self.proj_up.bias)
+        # init outproj
+        wang_init_(self.proj_down.weight, dim=self.config.embedding_dim, num_blocks=self.config._num_blocks)
+        if self.proj_down.bias is not None:
+            nn.init.zeros_(self.proj_down.bias)
+
+        nn.init.ones_(self.learnable_skip)
+
+        def _init_qkv_proj(qkv_proj: LinearHeadwiseExpand):
+            # use the embedding dim instead of the inner embedding dim
+            small_init_init_(qkv_proj.weight, dim=self.config.embedding_dim)
+            if qkv_proj.bias is not None:
+                nn.init.zeros_(qkv_proj.bias)
+
+        _init_qkv_proj(self.q_proj)
+        _init_qkv_proj(self.k_proj)
+        _init_qkv_proj(self.v_proj)
+
+        self.mlstm_cell.reset_parameters()