Add files using upload-large-folder tool

parrot/lib/python3.10/site-packages/httpx-0.24.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.14.0
+Root-Is-Purelib: true
+Tag: py3-none-any

parrot/lib/python3.10/site-packages/matplotlib-3.9.2.dist-info/LICENSE

@@ -0,0 +1,99 @@
+License agreement for matplotlib versions 1.3.0 and later
+=========================================================
+
+1. This LICENSE AGREEMENT is between the Matplotlib Development Team
+("MDT"), and the Individual or Organization ("Licensee") accessing and
+otherwise using matplotlib software in source or binary form and its
+associated documentation.
+
+2. Subject to the terms and conditions of this License Agreement, MDT
+hereby grants Licensee a nonexclusive, royalty-free, world-wide license
+to reproduce, analyze, test, perform and/or display publicly, prepare
+derivative works, distribute, and otherwise use matplotlib
+alone or in any derivative version, provided, however, that MDT's
+License Agreement and MDT's notice of copyright, i.e., "Copyright (c)
+2012- Matplotlib Development Team; All Rights Reserved" are retained in
+matplotlib  alone or in any derivative version prepared by
+Licensee.
+
+3. In the event Licensee prepares a derivative work that is based on or
+incorporates matplotlib or any part thereof, and wants to
+make the derivative work available to others as provided herein, then
+Licensee hereby agrees to include in any such work a brief summary of
+the changes made to matplotlib .
+
+4. MDT is making matplotlib available to Licensee on an "AS
+IS" basis.  MDT MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR
+IMPLIED.  BY WAY OF EXAMPLE, BUT NOT LIMITATION, MDT MAKES NO AND
+DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR FITNESS
+FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF MATPLOTLIB
+WILL NOT INFRINGE ANY THIRD PARTY RIGHTS.
+
+5. MDT SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF MATPLOTLIB
+ FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR
+LOSS AS A RESULT OF MODIFYING, DISTRIBUTING, OR OTHERWISE USING
+MATPLOTLIB , OR ANY DERIVATIVE THEREOF, EVEN IF ADVISED OF
+THE POSSIBILITY THEREOF.
+
+6. This License Agreement will automatically terminate upon a material
+breach of its terms and conditions.
+
+7. Nothing in this License Agreement shall be deemed to create any
+relationship of agency, partnership, or joint venture between MDT and
+Licensee.  This License Agreement does not grant permission to use MDT
+trademarks or trade name in a trademark sense to endorse or promote
+products or services of Licensee, or any third party.
+
+8. By copying, installing or otherwise using matplotlib ,
+Licensee agrees to be bound by the terms and conditions of this License
+Agreement.
+
+License agreement for matplotlib versions prior to 1.3.0
+========================================================
+
+1. This LICENSE AGREEMENT is between John D. Hunter ("JDH"), and the
+Individual or Organization ("Licensee") accessing and otherwise using
+matplotlib software in source or binary form and its associated
+documentation.
+
+2. Subject to the terms and conditions of this License Agreement, JDH
+hereby grants Licensee a nonexclusive, royalty-free, world-wide license
+to reproduce, analyze, test, perform and/or display publicly, prepare
+derivative works, distribute, and otherwise use matplotlib
+alone or in any derivative version, provided, however, that JDH's
+License Agreement and JDH's notice of copyright, i.e., "Copyright (c)
+2002-2011 John D. Hunter; All Rights Reserved" are retained in
+matplotlib  alone or in any derivative version prepared by
+Licensee.
+
+3. In the event Licensee prepares a derivative work that is based on or
+incorporates matplotlib  or any part thereof, and wants to
+make the derivative work available to others as provided herein, then
+Licensee hereby agrees to include in any such work a brief summary of
+the changes made to matplotlib.
+
+4. JDH is making matplotlib  available to Licensee on an "AS
+IS" basis.  JDH MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR
+IMPLIED.  BY WAY OF EXAMPLE, BUT NOT LIMITATION, JDH MAKES NO AND
+DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR FITNESS
+FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF MATPLOTLIB
+WILL NOT INFRINGE ANY THIRD PARTY RIGHTS.
+
+5. JDH SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF MATPLOTLIB
+ FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR
+LOSS AS A RESULT OF MODIFYING, DISTRIBUTING, OR OTHERWISE USING
+MATPLOTLIB , OR ANY DERIVATIVE THEREOF, EVEN IF ADVISED OF
+THE POSSIBILITY THEREOF.
+
+6. This License Agreement will automatically terminate upon a material
+breach of its terms and conditions.
+
+7. Nothing in this License Agreement shall be deemed to create any
+relationship of agency, partnership, or joint venture between JDH and
+Licensee.  This License Agreement does not grant permission to use JDH
+trademarks or trade name in a trademark sense to endorse or promote
+products or services of Licensee, or any third party.
+
+8. By copying, installing or otherwise using matplotlib,
+Licensee agrees to be bound by the terms and conditions of this License
+Agreement.

parrot/lib/python3.10/site-packages/mistral_inference/__init__.py

@@ -0,0 +1 @@
+__version__ = "1.4.0"

parrot/lib/python3.10/site-packages/mistral_inference/args.py

@@ -0,0 +1,64 @@
+from dataclasses import dataclass
+from typing import Optional
+
+from simple_parsing.helpers import Serializable
+
+from mistral_inference.lora import LoraArgs
+from mistral_inference.moe import MoeArgs
+
+
+@dataclass
+class VisionEncoderArgs:
+    hidden_size: int
+    num_channels: int
+    image_size: int
+    patch_size: int
+    intermediate_size: int
+    num_hidden_layers: int
+    num_attention_heads: int
+    rope_theta: float = 1e4  # for rope-2D
+    image_token_id: int = 10
+
+
+@dataclass
+class TransformerArgs(Serializable):
+    dim: int
+    n_layers: int
+    head_dim: int
+    hidden_dim: int
+    n_heads: int
+    n_kv_heads: int
+    norm_eps: float
+    vocab_size: int
+
+    max_batch_size: int = 0
+
+    # For rotary embeddings. If not set, will be inferred
+    rope_theta: Optional[float] = None
+    # If this is set, we will use MoE layers instead of dense layers.
+    moe: Optional[MoeArgs] = None
+    # If this is set, we will load LoRA linear layers instead of linear layers.
+    lora: Optional[LoraArgs] = None
+    model_type: str = "transformer"
+
+    vision_encoder: Optional[VisionEncoderArgs] = None
+
+    def __post_init__(self) -> None:
+        assert self.model_type == "transformer", self.model_type
+
+
+@dataclass
+class MambaArgs(Serializable):
+    dim: int
+    n_layers: int
+    vocab_size: int
+    n_groups: int
+    rms_norm: bool
+    residual_in_fp32: bool
+    fused_add_norm: bool
+    pad_vocab_size_multiple: int
+    tie_embeddings: bool
+    model_type: str = "mamba"
+
+    def __post_init__(self) -> None:
+        assert self.model_type == "mamba", self.model_type

parrot/lib/python3.10/site-packages/mistral_inference/cache.py

@@ -0,0 +1,201 @@
+from dataclasses import dataclass
+from typing import List, Optional, Tuple
+
+import torch
+from xformers.ops.fmha.attn_bias import (  # type: ignore
+    AttentionBias,
+    BlockDiagonalCausalMask,
+    BlockDiagonalCausalWithOffsetPaddedKeysMask,
+    BlockDiagonalMask,
+)
+
+
+@dataclass
+class CacheInputMetadata:
+    # rope absolute positions
+    positions: torch.Tensor
+    # where tokens should go in the cache
+    cache_positions: torch.Tensor
+
+    # if prefill, use block diagonal causal mask
+    # else use causal with padded key mask
+    prefill: bool
+    mask: AttentionBias
+    seqlens: List[int]
+
+
+def interleave_list(l1: List[torch.Tensor], l2: List[torch.Tensor]) -> List[torch.Tensor]:
+    assert len(l1) == len(l2)
+    return [v for pair in zip(l1, l2) for v in pair]
+
+
+class CacheView:
+    def __init__(
+        self,
+        cache_k: torch.Tensor,
+        cache_v: torch.Tensor,
+        metadata: CacheInputMetadata,
+        kv_seqlens: torch.Tensor,
+    ):
+        self.cache_k = cache_k
+        self.cache_v = cache_v
+        self.kv_seqlens = kv_seqlens
+        self.metadata = metadata
+
+    def update(self, xk: torch.Tensor, xv: torch.Tensor) -> None:
+        """
+        to_cache_mask masks the last [max_seq_len] tokens in each sequence
+        """
+        n_kv_heads, head_dim = self.cache_k.shape[-2:]
+        flat_cache_k = self.cache_k.view(-1, n_kv_heads, head_dim)
+        flat_cache_v = self.cache_v.view(-1, n_kv_heads, head_dim)
+
+        flat_cache_k.index_copy_(0, self.metadata.cache_positions, xk)
+        flat_cache_v.index_copy_(0, self.metadata.cache_positions, xv)
+
+    def interleave_kv(self, xk: torch.Tensor, xv: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor]:
+        """
+        This is a naive implementation and not optimized for speed.
+        """
+        assert xk.ndim == xv.ndim == 3  # (B * T, H, D)
+        assert xk.shape == xv.shape
+
+        if all([s == 0 for s in self.metadata.seqlens]):
+            # No cache to interleave
+            return xk, xv
+
+        # Make it a list of [(T, H, D)]
+        xk: Tuple[torch.Tensor] = torch.split(xk, self.metadata.seqlens)  # type: ignore
+        xv: Tuple[torch.Tensor] = torch.split(xv, self.metadata.seqlens)  # type: ignore
+        assert len(xk) == len(self.kv_seqlens), f"Batch size is {len(self.kv_seqlens)}, got {len(xk)}"
+
+        # Retrieve cache
+        cache_k = [cache_k[:seq_len] for cache_k, seq_len in zip(self.cache_k, self.kv_seqlens)]
+        cache_v = [cache_v[:seq_len] for cache_v, seq_len in zip(self.cache_v, self.kv_seqlens)]
+
+        interleaved_k = interleave_list(cache_k, list(xk))
+        interleaved_v = interleave_list(cache_v, list(xv))
+
+        return torch.cat(interleaved_k, dim=0), torch.cat(interleaved_v, dim=0)
+
+    @property
+    def max_seq_len(self) -> int:
+        return self.cache_k.shape[1]
+
+    @property
+    def key(self) -> torch.Tensor:
+        return self.cache_k[: len(self.kv_seqlens)]
+
+    @property
+    def value(self) -> torch.Tensor:
+        return self.cache_v[: len(self.kv_seqlens)]
+
+    @property
+    def prefill(self) -> bool:
+        return self.metadata.prefill
+
+    @property
+    def mask(self) -> AttentionBias:
+        return self.metadata.mask
+
+
+class BufferCache:
+    """
+    This is an example that implements a buffer cache, allowing for variable length sequences.
+    Allocated cache is rectangular which is wasteful (see PagedAttention for better mechanisms)
+    """
+
+    def __init__(
+        self,
+        n_layers: int,
+        max_batch_size: int,
+        max_seq_len: int,
+        n_kv_heads: int,
+        head_dim: int,
+    ):
+        self.max_seq_len = max_seq_len
+        self.n_kv_heads = n_kv_heads
+        self.head_dim = head_dim
+
+        self.cache_k = torch.empty((n_layers, max_batch_size, max_seq_len, n_kv_heads, head_dim))
+        self.cache_v = torch.empty((n_layers, max_batch_size, max_seq_len, n_kv_heads, head_dim))
+        # holds the valid length for each batch element in the cache
+        self.kv_seqlens: Optional[torch.Tensor] = None
+
+    def get_view(self, layer_id: int, metadata: CacheInputMetadata) -> CacheView:
+        assert self.kv_seqlens is not None
+        return CacheView(self.cache_k[layer_id], self.cache_v[layer_id], metadata, self.kv_seqlens)
+
+    def reset(self) -> None:
+        self.kv_seqlens = None
+
+    def init_kvseqlens(self, batch_size: int) -> None:
+        self.kv_seqlens = torch.zeros((batch_size,), device=self.device, dtype=torch.long)
+
+    @property
+    def device(self) -> torch.device:
+        return self.cache_k.device
+
+    def to(self, device: torch.device, dtype: torch.dtype) -> "BufferCache":
+        self.cache_k = self.cache_k.to(device=device, dtype=dtype)
+        self.cache_v = self.cache_v.to(device=device, dtype=dtype)
+
+        return self
+
+    def update_seqlens(self, seqlens: List[int]) -> None:
+        assert self.kv_seqlens is not None
+        self.kv_seqlens += torch.tensor(seqlens, device=self.device, dtype=torch.long)
+
+    def get_input_metadata(self, seqlens: List[int]) -> CacheInputMetadata:
+        """
+        Get metadata about cache positions
+        """
+        if self.kv_seqlens is None:
+            self.init_kvseqlens(len(seqlens))
+
+        assert isinstance(self.kv_seqlens, torch.Tensor)
+        assert len(seqlens) == len(
+            self.kv_seqlens
+        ), f"Batch size is {len(self.kv_seqlens)}, got {len(seqlens)}, did you forget to reset cache?"
+        seqpos = self.kv_seqlens.tolist()
+
+        assert len(seqlens) > 0, seqlens
+        cached_elements = torch.tensor(seqlens, device=self.device, dtype=torch.long)
+
+        positions = torch.cat([torch.arange(pos, pos + seqlen) for pos, seqlen in zip(seqpos, seqlens)]).to(
+            device=self.device, dtype=torch.long
+        )
+
+        batch_idx = torch.tensor(
+            sum([[i] * seqlen for i, seqlen in enumerate(seqlens)], []),
+            device=self.device,
+            dtype=torch.long,
+        )
+        cache_positions = positions + batch_idx * self.max_seq_len
+
+        first_prefill = seqpos[0] == 0
+        subsequent_prefill = any(seqlen > 1 for seqlen in seqlens)
+        if first_prefill:
+            assert all([pos == 0 for pos in seqpos]), seqpos
+            mask = BlockDiagonalCausalMask.from_seqlens(seqlens).make_local_attention(self.max_seq_len)
+        elif subsequent_prefill:
+            mask = BlockDiagonalMask.from_seqlens(
+                q_seqlen=seqlens,
+                kv_seqlen=[
+                    s + cached_s.clamp(max=self.max_seq_len).item() for (s, cached_s) in zip(seqlens, self.kv_seqlens)
+                ],
+            ).make_local_attention_from_bottomright(self.max_seq_len)
+        else:
+            mask = BlockDiagonalCausalWithOffsetPaddedKeysMask.from_seqlens(
+                q_seqlen=seqlens,
+                kv_padding=self.max_seq_len,
+                kv_seqlen=(self.kv_seqlens + cached_elements).clamp(max=self.max_seq_len).tolist(),
+            )
+
+        return CacheInputMetadata(
+            positions=positions,
+            cache_positions=cache_positions,
+            prefill=first_prefill or subsequent_prefill,
+            mask=mask,
+            seqlens=seqlens,
+        )

parrot/lib/python3.10/site-packages/mistral_inference/generate.py

@@ -0,0 +1,169 @@
+from typing import List, Optional, Tuple
+
+import numpy as np
+import torch
+
+from mistral_inference.cache import BufferCache
+from mistral_inference.mamba import Mamba
+from mistral_inference.transformer import Transformer
+
+
+@torch.inference_mode()
+def generate_mamba(
+    encoded_prompts: List[List[int]],
+    model: Mamba,
+    *,
+    max_tokens: int,
+    temperature: float,
+    chunk_size: Optional[int] = None,
+    eos_id: Optional[int] = None,
+) -> Tuple[List[List[int]], List[List[float]]]:
+    input_ids = torch.tensor(encoded_prompts, device=model.device)
+    output = model.model.generate(
+        input_ids=input_ids,
+        max_length=input_ids.shape[-1] + max_tokens,
+        cg=True,
+        return_dict_in_generate=True,
+        output_scores=True,
+        enable_timing=False,
+        eos_token_id=eos_id,
+        temperature=temperature,
+        top_p=0.8,
+    )
+    generated_tokens = output.sequences[:, input_ids.shape[-1] :].tolist()
+
+    _logprobs: List[List[float]] = [[] for _ in range(len(generated_tokens))]
+    for seq_idx, batch_score in enumerate(output.scores):
+        for batch_idx, score in enumerate(batch_score.tolist()):
+            _logprobs[batch_idx].append(score[generated_tokens[batch_idx][seq_idx]])
+
+    return generated_tokens, _logprobs
+
+
+@torch.inference_mode()
+def generate(
+    encoded_prompts: List[List[int]],
+    model: Transformer,
+    images: List[List[np.ndarray]] = [],
+    *,
+    max_tokens: int,
+    temperature: float,
+    chunk_size: Optional[int] = None,
+    eos_id: Optional[int] = None,
+) -> Tuple[List[List[int]], List[List[float]]]:
+    images_torch: List[List[torch.Tensor]] = []
+    if images:
+        assert chunk_size is None
+        images_torch = [
+            [torch.tensor(im, device=model.device, dtype=model.dtype) for im in images_for_sample]
+            for images_for_sample in images
+        ]
+
+    model = model.eval()
+    B, V = len(encoded_prompts), model.args.vocab_size
+
+    seqlens = [len(x) for x in encoded_prompts]
+
+    # Cache
+    cache_window = max(seqlens) + max_tokens
+    cache = BufferCache(
+        model.n_local_layers,
+        model.args.max_batch_size,
+        cache_window,
+        model.args.n_kv_heads,
+        model.args.head_dim,
+    )
+    cache.to(device=model.device, dtype=model.dtype)
+    cache.reset()
+
+    # Bookkeeping
+    logprobs: List[List[float]] = [[] for _ in range(B)]
+    last_token_prelogits = None
+
+    # One chunk if size not specified
+    max_prompt_len = max(seqlens)
+    if chunk_size is None:
+        chunk_size = max_prompt_len
+
+    flattened_images: List[torch.Tensor] = sum(images_torch, [])
+
+    # Encode prompt by chunks
+    for s in range(0, max_prompt_len, chunk_size):
+        prompt_chunks = [p[s : s + chunk_size] for p in encoded_prompts]
+        assert all(len(p) > 0 for p in prompt_chunks)
+        prelogits = model.forward(
+            torch.tensor(sum(prompt_chunks, []), device=model.device, dtype=torch.long),
+            images=flattened_images,
+            seqlens=[len(p) for p in prompt_chunks],
+            cache=cache,
+        )
+        logits = torch.log_softmax(prelogits, dim=-1)
+
+        if last_token_prelogits is not None:
+            # Pass > 1
+            last_token_logits = torch.log_softmax(last_token_prelogits, dim=-1)
+            for i_seq in range(B):
+                logprobs[i_seq].append(last_token_logits[i_seq, prompt_chunks[i_seq][0]].item())
+
+        offset = 0
+        for i_seq, sequence in enumerate(prompt_chunks):
+            logprobs[i_seq].extend([logits[offset + i, sequence[i + 1]].item() for i in range(len(sequence) - 1)])
+            offset += len(sequence)
+
+        last_token_prelogits = prelogits.index_select(
+            0,
+            torch.tensor([len(p) for p in prompt_chunks], device=prelogits.device).cumsum(dim=0) - 1,
+        )
+        assert last_token_prelogits.shape == (B, V)
+
+    # decode
+    generated_tensors = []
+    is_finished = torch.tensor([False for _ in range(B)])
+
+    assert last_token_prelogits is not None
+    for _ in range(max_tokens):
+        next_token = sample(last_token_prelogits, temperature=temperature, top_p=0.8)
+
+        if eos_id is not None:
+            is_finished = is_finished | (next_token == eos_id).cpu()
+
+        if is_finished.all():
+            break
+
+        last_token_logits = torch.log_softmax(last_token_prelogits, dim=-1)
+        for i in range(B):
+            logprobs[i].append(last_token_logits[i, next_token[i]].item())
+
+        generated_tensors.append(next_token[:, None])
+        last_token_prelogits = model.forward(next_token, seqlens=[1] * B, cache=cache)
+        assert last_token_prelogits.shape == (B, V)
+
+    generated_tokens: List[List[int]]
+    if generated_tensors:
+        generated_tokens = torch.cat(generated_tensors, 1).tolist()
+    else:
+        generated_tokens = []
+
+    return generated_tokens, logprobs
+
+
+def sample(logits: torch.Tensor, temperature: float, top_p: float) -> torch.Tensor:
+    if temperature > 0:
+        probs = torch.softmax(logits / temperature, dim=-1)
+        next_token = sample_top_p(probs, top_p)
+    else:
+        next_token = torch.argmax(logits, dim=-1).unsqueeze(0)
+
+    return next_token.reshape(-1)
+
+
+def sample_top_p(probs: torch.Tensor, p: float) -> torch.Tensor:
+    assert 0 <= p <= 1
+
+    probs_sort, probs_idx = torch.sort(probs, dim=-1, descending=True)
+    probs_sum = torch.cumsum(probs_sort, dim=-1)
+    mask = probs_sum - probs_sort > p
+    probs_sort[mask] = 0.0
+    probs_sort.div_(probs_sort.sum(dim=-1, keepdim=True))
+    next_token = torch.multinomial(probs_sort, num_samples=1)
+    return torch.gather(probs_idx, -1, next_token)

parrot/lib/python3.10/site-packages/mistral_inference/lora.py

@@ -0,0 +1,155 @@
+import logging
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Dict, NamedTuple, Union
+
+import safetensors.torch
+import torch
+import torch.nn as nn
+from simple_parsing.helpers import Serializable
+
+
+@dataclass
+class LoraArgs(Serializable):
+    rank: int
+    scaling: float
+
+    def __post_init__(self) -> None:
+        assert self.rank > 0
+        assert self.scaling > 0.0
+
+
+class LoRALinear(nn.Module):
+    """
+    Implementation of:
+        - LoRA: https://arxiv.org/abs/2106.09685
+
+    Notes:
+        - Freezing is handled at network level, not layer level.
+        - Scaling factor controls relative importance of LoRA skip
+          connection versus original frozen weight. General guidance is
+          to keep it to 2.0 and sweep over learning rate when changing
+          the rank.
+    """
+
+    def __init__(
+        self,
+        in_features: int,
+        out_features: int,
+        rank: int,
+        scaling: float,
+        bias: bool = False,
+    ):
+        super().__init__()
+
+        self.in_features = in_features
+        self.out_features = out_features
+        assert not bias
+        self.bias = bias
+        self.rank = rank
+        self.scaling = scaling
+
+        self.lora_A = nn.Linear(
+            self.in_features,
+            self.rank,
+            bias=self.bias,
+        )
+        self.lora_B = nn.Linear(
+            self.rank,
+            self.out_features,
+            bias=self.bias,
+        )
+
+        self.linear = nn.Linear(self.in_features, self.out_features, bias=self.bias)
+
+        # make sure no LoRA weights are marked as "missing" in load_state_dict
+        def ignore_missing_keys(m: nn.Module, incompatible_keys: NamedTuple) -> None:
+            incompatible_keys.missing_keys[:] = []  # type: ignore
+
+        self.register_load_state_dict_post_hook(ignore_missing_keys)
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        lora = self.lora_B(self.lora_A(x))
+        result: torch.Tensor = self.linear(x) + lora * self.scaling
+        return result
+
+    def _load_from_state_dict(self, state_dict: Dict[str, Any], prefix: str, *args, **kwargs) -> None:  # type: ignore[no-untyped-def]
+        key_name = prefix + "weight"
+
+        # full checkpoint
+        if key_name in state_dict:
+            w_ref = state_dict[key_name]
+
+            # load frozen weights
+            state_dict = {
+                "linear.weight": w_ref,
+                "lora_A.weight": torch.zeros_like(self.lora_A.weight, device=w_ref.device, dtype=w_ref.dtype),
+                "lora_B.weight": torch.zeros_like(self.lora_B.weight, device=w_ref.device, dtype=w_ref.dtype),
+            }
+            self.load_state_dict(state_dict, assign=True, strict=True)
+
+
+class LoRALoaderMixin:
+    def load_lora(self, lora_path: Union[Path, str], scaling: float = 2.0) -> None:
+        """Loads LoRA checkpoint"""
+
+        lora_path = Path(lora_path)
+        assert lora_path.is_file(), f"{lora_path} does not exist or is not a file"
+
+        state_dict = safetensors.torch.load_file(lora_path)
+
+        self._load_lora_state_dict(state_dict, scaling=scaling)
+
+    def _load_lora_state_dict(self, lora_state_dict: Dict[str, torch.Tensor], scaling: float = 2.0) -> None:
+        """Loads LoRA state_dict"""
+        lora_dtypes = set([p.dtype for p in lora_state_dict.values()])
+        assert (
+            len(lora_dtypes) == 1
+        ), f"LoRA weights have multiple different dtypes {lora_dtypes}. All weights need to have the same dtype"
+        lora_dtype = lora_dtypes.pop()
+        assert lora_dtype == self.dtype, f"LoRA weights dtype differs from model's dtype {lora_dtype} != {self.dtype}"  # type: ignore[attr-defined]
+        assert all("lora" in key for key in lora_state_dict.keys())
+
+        # move tensors to device
+        lora_state_dict = {k: v.to(self.device) for k, v in lora_state_dict.items()}  # type: ignore[attr-defined]
+
+        state_dict = self.state_dict()  # type: ignore[attr-defined]
+
+        if self.args.lora is None:  # type: ignore[attr-defined]
+            logging.info("Loading and merging LoRA weights...")
+
+            # replace every nn.Linear with a LoRALinear with 'meta' device except the output layer
+            named_modules = dict(self.named_modules())  # type: ignore[attr-defined]
+            for name, module in named_modules.items():
+                if isinstance(module, nn.Linear) and name != "output":
+                    layer_id = name.split(".")[1]
+                    if layer_id not in self.layers:  # type: ignore[attr-defined]
+                        logging.debug(
+                            "Skipping parameter %s at pipeline rank %d",
+                            name,
+                            self.pipeline_rank,  # type: ignore[attr-defined]
+                        )
+                    elif (name + ".lora_B.weight") in lora_state_dict:
+                        weight = (
+                            module.weight
+                            + (lora_state_dict[name + ".lora_B.weight"] @ lora_state_dict[name + ".lora_A.weight"])
+                            * scaling
+                        )
+
+                        state_dict[name + ".weight"] = weight
+        else:
+            logging.info("Loading LoRA weights...")
+            for k, v in lora_state_dict.items():
+                state_dict.update(lora_state_dict)
+
+                layer_id = k.split(".")[1]
+                if layer_id in self.layers:  # type: ignore[attr-defined]
+                    state_dict[k] = v
+                else:
+                    logging.debug(
+                        "Skipping parameter %s at pipeline rank %d",
+                        k,
+                        self.pipeline_rank,  # type: ignore[attr-defined]
+                    )
+
+        self.load_state_dict(state_dict, strict=True)  # type: ignore[attr-defined]

parrot/lib/python3.10/site-packages/mistral_inference/main.py

@@ -0,0 +1,273 @@
+import json
+import logging
+import os
+import warnings
+from pathlib import Path
+from typing import List, Optional, Tuple, Type, Union
+
+import fire  # type: ignore
+import torch
+import torch.distributed as dist
+from mistral_common.protocol.instruct.messages import (
+    AssistantMessage,
+    ContentChunk,
+    ImageChunk,
+    ImageURLChunk,
+    TextChunk,
+    UserMessage,
+)
+from mistral_common.protocol.instruct.request import ChatCompletionRequest
+from mistral_common.tokens.tokenizers.base import Tokenizer
+from mistral_common.tokens.tokenizers.mistral import MistralTokenizer
+from mistral_common.tokens.tokenizers.sentencepiece import is_sentencepiece
+from mistral_common.tokens.tokenizers.tekken import (
+    SpecialTokenPolicy,
+    Tekkenizer,
+    is_tekken,
+)
+from PIL import Image
+
+from mistral_inference.args import TransformerArgs
+from mistral_inference.generate import generate, generate_mamba
+from mistral_inference.mamba import Mamba
+from mistral_inference.transformer import Transformer
+
+
+def is_torchrun() -> bool:
+    required_vars = ["MASTER_ADDR", "MASTER_PORT", "RANK", "WORLD_SIZE"]
+    return all(var in os.environ for var in required_vars)
+
+
+def load_tokenizer(model_path: Path) -> MistralTokenizer:
+    tokenizer = [f for f in os.listdir(model_path) if is_tekken(model_path / f) or is_sentencepiece(model_path / f)]
+    assert (
+        len(tokenizer) > 0
+    ), f"No tokenizer in {model_path}, place a `tokenizer.model.[v1,v2,v3]` or `tekken.json` file in {model_path}."
+    assert (
+        len(tokenizer) == 1
+    ), f"Multiple tokenizers {', '.join(tokenizer)} found in `model_path`, make sure to only have one tokenizer"
+
+    mistral_tokenizer = MistralTokenizer.from_file(str(model_path / tokenizer[0]))
+
+    if isinstance(mistral_tokenizer.instruct_tokenizer.tokenizer, Tekkenizer):
+        mistral_tokenizer.instruct_tokenizer.tokenizer.special_token_policy = SpecialTokenPolicy.KEEP
+
+    logging.info(f"Loaded tokenizer of type {mistral_tokenizer.instruct_tokenizer.__class__}")
+
+    return mistral_tokenizer
+
+
+def get_model_cls(model_path: str) -> Union[Type[Mamba], Type[Transformer]]:
+    with open(Path(model_path) / "params.json", "r") as f:
+        args_dict = json.load(f)
+
+    return {"mamba": Mamba, "transformer": Transformer}[args_dict.get("model_type", "transformer")]  # type: ignore[return-value]
+
+
+def pad_and_convert_to_tensor(list_of_lists: List[List[int]], pad_id: int) -> List[List[int]]:
+    # Determine the length of the longest list
+    max_len = max(len(lst) for lst in list_of_lists)
+
+    # Left pad each list to the maximum length
+    padded_lists = [[pad_id] * (max_len - len(lst)) + lst for lst in list_of_lists]
+
+    return padded_lists
+
+
+def _get_multimodal_input() -> Tuple[UserMessage, bool]:
+    chunks: List[ContentChunk] = []
+
+    response = input("Text prompt: ")
+    if response:
+        chunks.append(TextChunk(text=response))
+
+    print("[You can input zero, one or more images now.]")
+    while True:
+        did_something = False
+        response = input("Image path or url [Leave empty and press enter to finish image input]: ")
+        if response:
+            if Path(response).is_file():
+                chunks.append(ImageChunk(image=Image.open(response)))
+            else:
+                assert response.startswith("http"), f"{response} does not seem to be a valid url."
+                chunks.append(ImageURLChunk(image_url=response))
+            did_something = True
+
+        if not did_something:
+            break
+
+    return UserMessage(content=chunks), not chunks
+
+
+def interactive(
+    model_path: str,
+    max_tokens: int = 35,
+    temperature: float = 0.7,
+    num_pipeline_ranks: int = 1,
+    instruct: bool = False,
+    lora_path: Optional[str] = None,
+) -> None:
+    if is_torchrun():
+        torch.distributed.init_process_group()
+        torch.cuda.set_device(torch.distributed.get_rank())
+        should_print = torch.distributed.get_rank() == 0
+
+        num_pipeline_ranks = torch.distributed.get_world_size()
+    else:
+        should_print = True
+        num_pipeline_ranks = 1
+
+    mistral_tokenizer: MistralTokenizer = load_tokenizer(Path(model_path))
+    tokenizer: Tokenizer = mistral_tokenizer.instruct_tokenizer.tokenizer
+
+    model_cls = get_model_cls(model_path)
+    model = model_cls.from_folder(Path(model_path), max_batch_size=3, num_pipeline_ranks=num_pipeline_ranks)
+    is_multimodal = isinstance(model.args, TransformerArgs) and model.args.vision_encoder is not None
+
+    if is_multimodal:
+        assert instruct, "Multimodal models should only be used in instruct mode"
+
+    # load LoRA
+    if lora_path is not None:
+        model.load_lora(Path(lora_path))
+
+    prompt: str = ""
+    messages: List[UserMessage | AssistantMessage] = []
+
+    while True:
+        if should_print:
+            if not is_multimodal:
+                user_input = input("Prompt: ")
+
+            if instruct:
+                if is_multimodal:
+                    mm_input, finished = _get_multimodal_input()
+                    if finished:
+                        break
+                    messages += [mm_input]
+                else:
+                    messages += [UserMessage(content=user_input)]
+                chat_completion_request = ChatCompletionRequest(messages=messages)
+
+                tokenized = mistral_tokenizer.encode_chat_completion(chat_completion_request)
+                tokens = tokenized.tokens
+                images = tokenized.images
+            else:
+                prompt += user_input
+
+                tokens = tokenizer.encode(prompt, bos=True, eos=False)
+                images = []
+
+            length_tensor = torch.tensor([len(tokens)], dtype=torch.int)
+        else:
+            length_tensor = torch.tensor([0], dtype=torch.int)
+
+        if is_torchrun():
+            dist.broadcast(length_tensor, src=0)
+
+        if not should_print:
+            tokens = int(length_tensor.item()) * [0]
+
+        generate_fn = generate if isinstance(model, Transformer) else generate_mamba
+        generated_tokens, _ = generate_fn(  # type: ignore[operator]
+            [tokens],
+            model,
+            [images],
+            max_tokens=max_tokens,
+            temperature=temperature,
+            eos_id=tokenizer.eos_id,
+        )
+
+        answer = tokenizer.decode(generated_tokens[0])
+
+        if should_print:
+            print(answer)
+            print("=====================")
+
+        if instruct:
+            messages += [AssistantMessage(content=answer)]
+        else:
+            prompt += answer
+
+
+def demo(
+    model_path: str,
+    max_tokens: int = 35,
+    temperature: float = 0,
+    lora_path: Optional[str] = None,
+) -> None:
+    if is_torchrun():
+        torch.distributed.init_process_group()
+        torch.cuda.set_device(torch.distributed.get_rank())
+        should_print = torch.distributed.get_rank() == 0
+
+        num_pipeline_ranks = torch.distributed.get_world_size()
+    else:
+        should_print = True
+        num_pipeline_ranks = 1
+
+    model_cls = get_model_cls(model_path)
+    model = model_cls.from_folder(Path(model_path), max_batch_size=3, num_pipeline_ranks=num_pipeline_ranks)
+    # load LoRA
+    if lora_path is not None:
+        model.load_lora(Path(lora_path))
+
+    mistral_tokenizer: MistralTokenizer = load_tokenizer(Path(model_path))
+    tokenizer: Tokenizer = mistral_tokenizer.instruct_tokenizer.tokenizer
+
+    prompts = [
+        "This is a test",
+        "This is another great test",
+        "This is a third test, mistral AI is very good at testing. ",
+    ]
+
+    encoded_prompts = [tokenizer.encode(prompt, bos=True, eos=False) for prompt in prompts]
+
+    if isinstance(model, Transformer):
+        generate_fn = generate
+    else:
+        generate_fn = generate_mamba  # type: ignore[assignment]
+        warnings.warn(
+            "Batched generation is not correctly supported at the moment and therefore might lead to worse results "
+            "as compared to non-batched generation. "
+            "See https://github.com/state-spaces/mamba/issues/66#issuecomment-1862349718 for more information."
+        )
+        encoded_prompts = pad_and_convert_to_tensor(encoded_prompts, mistral_tokenizer.instruct_tokenizer.BOS)  # type: ignore[attr-defined]
+
+    generated_tokens, _logprobs = generate_fn(
+        encoded_prompts,
+        model,  # type: ignore[arg-type]
+        max_tokens=max_tokens,
+        temperature=temperature,
+        eos_id=tokenizer.eos_id,
+    )
+
+    generated_words = []
+    for i, x in enumerate(generated_tokens):
+        generated_words.append(tokenizer.decode(encoded_prompts[i] + x))
+
+    res = generated_words
+
+    if should_print:
+        for w, logprob in zip(res, _logprobs):
+            print(w)
+            logging.debug("Logprobs: %s", logprob)
+            print("=====================")
+
+
+def mistral_chat() -> None:
+    fire.Fire(interactive)
+
+
+def mistral_demo() -> None:
+    fire.Fire(demo)
+
+
+if __name__ == "__main__":
+    logging.basicConfig(level=logging.INFO)
+    fire.Fire(
+        {
+            "interactive": interactive,
+            "demo": demo,
+        }
+    )

parrot/lib/python3.10/site-packages/mistral_inference/mamba.py

@@ -0,0 +1,83 @@
+import json
+from pathlib import Path
+from typing import List, Optional, Union
+
+import safetensors
+import torch
+import torch.nn as nn
+
+from mistral_inference.args import MambaArgs
+from mistral_inference.cache import BufferCache
+from mistral_inference.model import ModelBase
+
+_is_mamba_installed = False
+try:
+    from mamba_ssm.models.config_mamba import MambaConfig
+    from mamba_ssm.models.mixer_seq_simple import MambaLMHeadModel
+
+    _is_mamba_installed = True
+except ImportError:
+    _is_mamba_installed = False
+
+
+class Mamba(ModelBase, nn.Module):
+    def __init__(self, args: MambaArgs):
+        super().__init__()
+        self.args = args
+        assert _is_mamba_installed, "Mamba is not installed. Please install it using `pip install mamba-ssm`."
+
+        # make sure naming is consistent with `mamba_ssm`
+        config = MambaConfig(
+            d_model=args.dim,
+            n_layer=args.n_layers,
+            vocab_size=args.vocab_size,
+            ssm_cfg={"ngroups": args.n_groups, "layer": "Mamba2"},
+            attn_layer_idx=[],
+            attn_cfg={},
+            rms_norm=args.rms_norm,
+            residual_in_fp32=args.residual_in_fp32,
+            fused_add_norm=args.fused_add_norm,
+            pad_vocab_size_multiple=args.pad_vocab_size_multiple,
+            tie_embeddings=args.tie_embeddings,
+        )
+        self.model = MambaLMHeadModel(config)
+
+    @property
+    def dtype(self) -> torch.dtype:
+        return next(self.parameters()).dtype
+
+    @property
+    def device(self) -> torch.device:
+        return next(self.parameters()).device
+
+    def forward(
+        self,
+        input_ids: torch.Tensor,
+        seqlens: List[int],  # not supported for now
+        cache: Optional[BufferCache] = None,  # not supported for now
+    ) -> torch.Tensor:
+        lm_output = self.model(input_ids)
+        result: torch.Tensor = lm_output.logits
+        return result
+
+    @staticmethod
+    def from_folder(
+        folder: Union[Path, str],
+        max_batch_size: int = 1,
+        num_pipeline_ranks: int = 1,
+        device: Union[torch.device, str] = "cuda",
+        dtype: Optional[torch.dtype] = None,
+    ) -> "Mamba":
+        with open(Path(folder) / "params.json", "r") as f:
+            model_args = MambaArgs.from_dict(json.load(f))
+
+        with torch.device("meta"):
+            model = Mamba(model_args)
+
+        model_file = Path(folder) / "consolidated.safetensors"
+
+        assert model_file.exists(), f"Make sure {model_file} exists."
+        loaded = safetensors.torch.load_file(str(model_file))
+
+        model.load_state_dict(loaded, assign=True, strict=True)
+        return model.to(device=device, dtype=dtype)

parrot/lib/python3.10/site-packages/mistral_inference/model.py

@@ -0,0 +1,43 @@
+from abc import ABC, abstractmethod
+from pathlib import Path
+from typing import List, Optional, Union
+
+import torch
+import torch.nn as nn
+
+from mistral_inference.cache import BufferCache
+
+
+class ModelBase(nn.Module, ABC):
+    def __init__(self) -> None:
+        super().__init__()
+
+    @property
+    @abstractmethod
+    def dtype(self) -> torch.dtype:
+        pass
+
+    @property
+    @abstractmethod
+    def device(self) -> torch.device:
+        pass
+
+    @abstractmethod
+    def forward(
+        self,
+        input_ids: torch.Tensor,
+        seqlens: List[int],  # not supported for now
+        cache: Optional[BufferCache] = None,  # not supported for now
+    ) -> torch.Tensor:
+        pass
+
+    @staticmethod
+    @abstractmethod
+    def from_folder(
+        folder: Union[Path, str],
+        max_batch_size: int = 1,
+        num_pipeline_ranks: int = 1,
+        device: Union[torch.device, str] = "cuda",
+        dtype: Optional[torch.dtype] = None,
+    ) -> "ModelBase":
+        pass

parrot/lib/python3.10/site-packages/mistral_inference/moe.py

@@ -0,0 +1,32 @@
+import dataclasses
+from typing import List
+
+import torch
+import torch.nn.functional as F
+from simple_parsing.helpers import Serializable
+from torch import nn
+
+
+@dataclasses.dataclass
+class MoeArgs(Serializable):
+    num_experts: int
+    num_experts_per_tok: int
+
+
+class MoeLayer(nn.Module):
+    def __init__(self, experts: List[nn.Module], gate: nn.Module, moe_args: MoeArgs):
+        super().__init__()
+        assert len(experts) > 0
+        self.experts = nn.ModuleList(experts)
+        self.gate = gate
+        self.args = moe_args
+
+    def forward(self, inputs: torch.Tensor) -> torch.Tensor:
+        gate_logits = self.gate(inputs)
+        weights, selected_experts = torch.topk(gate_logits, self.args.num_experts_per_tok)
+        weights = F.softmax(weights, dim=1, dtype=torch.float).to(inputs.dtype)
+        results = torch.zeros_like(inputs)
+        for i, expert in enumerate(self.experts):
+            batch_idx, nth_expert = torch.where(selected_experts == i)
+            results[batch_idx] += weights[batch_idx, nth_expert, None] * expert(inputs[batch_idx])
+        return results

parrot/lib/python3.10/site-packages/mistral_inference/rope.py

@@ -0,0 +1,51 @@
+from typing import Tuple
+
+import torch
+
+
+def precompute_freqs_cis(dim: int, end: int, theta: float) -> torch.Tensor:
+    freqs = 1.0 / (theta ** (torch.arange(0, dim, 2)[: (dim // 2)].float() / dim))
+    t = torch.arange(end, device=freqs.device)
+    freqs = torch.outer(t, freqs).float()
+    return torch.polar(torch.ones_like(freqs), freqs)  # complex64
+
+
+def apply_rotary_emb(
+    xq: torch.Tensor,
+    xk: torch.Tensor,
+    freqs_cis: torch.Tensor,
+) -> Tuple[torch.Tensor, torch.Tensor]:
+    xq_ = torch.view_as_complex(xq.float().reshape(*xq.shape[:-1], -1, 2))
+    xk_ = torch.view_as_complex(xk.float().reshape(*xk.shape[:-1], -1, 2))
+    freqs_cis = freqs_cis[:, None, :]
+    xq_out = torch.view_as_real(xq_ * freqs_cis).flatten(-2)
+    xk_out = torch.view_as_real(xk_ * freqs_cis).flatten(-2)
+    return xq_out.type_as(xq), xk_out.type_as(xk)
+
+
+def precompute_freqs_cis_2d(
+    dim: int,
+    height: int,
+    width: int,
+    theta: float,
+) -> torch.Tensor:
+    """
+    freqs_cis: 2D complex tensor of shape (height, width, dim // 2) to be indexed by
+        (height, width) position tuples
+    """
+    # (dim / 2) frequency bases
+    freqs = 1.0 / (theta ** (torch.arange(0, dim, 2).float() / dim))
+
+    h = torch.arange(height, device=freqs.device)
+    w = torch.arange(width, device=freqs.device)
+
+    freqs_h = torch.outer(h, freqs[::2]).float()
+    freqs_w = torch.outer(w, freqs[1::2]).float()
+    freqs_2d = torch.cat(
+        [
+            freqs_h[:, None, :].repeat(1, width, 1),
+            freqs_w[None, :, :].repeat(height, 1, 1),
+        ],
+        dim=-1,
+    )
+    return torch.polar(torch.ones_like(freqs_2d), freqs_2d)

parrot/lib/python3.10/site-packages/mistral_inference/transformer.py

@@ -0,0 +1,292 @@
+import json
+import logging
+import math
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, List, Mapping, Optional, Union
+
+import safetensors.torch
+import torch
+from torch import nn
+
+from mistral_inference.args import TransformerArgs
+from mistral_inference.cache import BufferCache, CacheInputMetadata
+from mistral_inference.lora import LoRALoaderMixin
+from mistral_inference.model import ModelBase
+from mistral_inference.rope import precompute_freqs_cis
+from mistral_inference.transformer_layers import RMSNorm, TransformerBlock
+from mistral_inference.vision_encoder import VisionLanguageAdapter, VisionTransformer
+
+
+@dataclass
+class SimpleInputMetadata:
+    # rope absolute positions
+    positions: torch.Tensor
+
+    @staticmethod
+    def from_seqlens(seqlens: List[int], device: torch.device) -> "SimpleInputMetadata":
+        return SimpleInputMetadata(
+            positions=torch.cat([torch.arange(0, seqlen) for seqlen in seqlens]).to(device=device, dtype=torch.long)
+        )
+
+
+class Transformer(ModelBase, LoRALoaderMixin):
+    def __init__(
+        self,
+        args: TransformerArgs,
+        pipeline_rank: int = 0,
+        num_pipeline_ranks: int = 1,
+    ):
+        super().__init__()
+        self.args = args
+        self.vocab_size = args.vocab_size
+        self.n_layers = args.n_layers
+        self._precomputed_freqs_cis: Optional[torch.Tensor] = None
+        assert self.vocab_size > 0
+        assert pipeline_rank < num_pipeline_ranks, (pipeline_rank, num_pipeline_ranks)
+        self.pipeline_rank = pipeline_rank
+        self.num_pipeline_ranks = num_pipeline_ranks
+        # Modules specific to some ranks:
+        self.tok_embeddings: Optional[nn.Embedding] = None
+        self.norm: Optional[RMSNorm] = None
+        self.output: Optional[nn.Linear] = None
+        if pipeline_rank == 0:
+            self.tok_embeddings = nn.Embedding(args.vocab_size, args.dim)
+
+            self.vision_encoder: Optional[VisionTransformer] = None
+            self.vision_language_adapter: Optional[VisionLanguageAdapter] = None
+            if args.vision_encoder is not None:
+                self.vision_encoder = VisionTransformer(args.vision_encoder)
+                self.vision_language_adapter = VisionLanguageAdapter(args.vision_encoder.hidden_size, args.dim)
+        if pipeline_rank == num_pipeline_ranks - 1:
+            self.norm = RMSNorm(args.dim, eps=args.norm_eps)
+            self.output = nn.Linear(args.dim, args.vocab_size, bias=False)
+        # Initialize all layers but slice off those not of this rank.
+        layers = [
+            TransformerBlock(
+                dim=args.dim,
+                hidden_dim=args.hidden_dim,
+                n_heads=args.n_heads,
+                n_kv_heads=args.n_kv_heads,
+                head_dim=args.head_dim,
+                norm_eps=args.norm_eps,
+                lora=args.lora,
+                moe=args.moe,
+            )
+            for _ in range(args.n_layers)
+        ]
+        num_layers_per_rank = math.ceil(self.n_layers / self.num_pipeline_ranks)
+        offset = self.pipeline_rank * num_layers_per_rank
+        end = min(self.n_layers, offset + num_layers_per_rank)
+        self.layers = nn.ModuleDict({str(i): layers[i] for i in range(offset, end)})
+        self.n_local_layers = len(self.layers)
+
+    @property
+    def dtype(self) -> torch.dtype:
+        return next(self.parameters()).dtype
+
+    @property
+    def device(self) -> torch.device:
+        return next(self.parameters()).device
+
+    @property
+    def freqs_cis(self) -> torch.Tensor:
+        # We cache freqs_cis but need to take care that it is on the right device
+        # and has the right dtype (complex64). The fact that the dtype is different
+        # from the module's  dtype means we cannot register it as a buffer
+        if self._precomputed_freqs_cis is None:
+            # default to 10**6
+            theta = self.args.rope_theta or 1000000.0
+            self._precomputed_freqs_cis = precompute_freqs_cis(self.args.head_dim, 128_000, theta)
+
+        if self._precomputed_freqs_cis.device != self.device:
+            self._precomputed_freqs_cis = self._precomputed_freqs_cis.to(device=self.device)
+        return self._precomputed_freqs_cis
+
+    def embed_vision_language_features(self, input_ids: torch.Tensor, images: List[torch.tensor]) -> torch.Tensor:  # type: ignore[valid-type]
+        assert self.tok_embeddings is not None
+        assert self.vision_encoder is not None
+        assert self.vision_language_adapter is not None
+        assert self.args.vision_encoder is not None
+
+        text_locations = input_ids != self.args.vision_encoder.image_token_id
+        image_locations = input_ids == self.args.vision_encoder.image_token_id
+        text_features = self.tok_embeddings(input_ids[text_locations])
+        image_features = self.vision_language_adapter(self.vision_encoder(images))
+
+        seq_len = input_ids.shape[0]
+        N_txt, D_txt = text_features.shape
+        N_img, D_img = image_features.shape
+
+        assert D_txt == D_img, f"Text features dim {D_txt} should be equal to image features dim {D_img}"
+        assert (
+            seq_len == N_txt + N_img
+        ), f"seq_len {seq_len} should be equal to N_txt + N_img {(N_txt, N_img, image_locations.sum().item())}"
+
+        combined_features = torch.empty(
+            (seq_len, D_txt),
+            dtype=text_features.dtype,
+            device=text_features.device,
+        )
+        combined_features[text_locations, :] = text_features
+        combined_features[image_locations, :] = image_features
+        return combined_features
+
+    def forward_partial(
+        self,
+        input_ids: torch.Tensor,
+        seqlens: List[int],
+        cache: Optional[BufferCache] = None,
+        images: Optional[List[torch.Tensor]] = None,
+    ) -> torch.Tensor:
+        """Local forward pass.
+
+        If doing pipeline parallelism, this will return the activations of the last layer of this stage.
+        For the last stage, this will return the normalized final embeddings.
+        """
+        assert (
+            len(seqlens) <= self.args.max_batch_size
+        ), f"Max batch size is {self.args.max_batch_size}, got batch size of {len(seqlens)}"
+        (num_toks,) = input_ids.shape
+        assert sum(seqlens) == num_toks, (sum(seqlens), num_toks)
+
+        input_metadata: Union[CacheInputMetadata, SimpleInputMetadata]
+
+        if cache is not None:
+            input_metadata = cache.get_input_metadata(seqlens)
+        else:
+            input_metadata = SimpleInputMetadata.from_seqlens(seqlens, self.device)
+
+        if self.pipeline_rank == 0:
+            assert self.tok_embeddings is not None
+            if self.vision_encoder is not None and images:
+                h = self.embed_vision_language_features(input_ids, images)
+            else:
+                h = self.tok_embeddings(input_ids)
+        else:
+            h = torch.empty(num_toks, self.args.dim, device=self.device, dtype=self.dtype)
+            torch.distributed.recv(h, src=self.pipeline_rank - 1)
+
+        freqs_cis = self.freqs_cis[input_metadata.positions]
+
+        for local_layer_id, layer in enumerate(self.layers.values()):
+            if cache is not None:
+                assert input_metadata is not None
+                assert isinstance(input_metadata, CacheInputMetadata)
+                cache_view = cache.get_view(local_layer_id, input_metadata)
+            else:
+                cache_view = None
+            h = layer(h, freqs_cis, cache_view)
+
+        if cache is not None:
+            cache.update_seqlens(seqlens)
+        if self.pipeline_rank < self.num_pipeline_ranks - 1:
+            torch.distributed.send(h, dst=self.pipeline_rank + 1)
+            return h
+        else:
+            # Last rank has a final normalization step.
+            assert self.norm is not None
+            return self.norm(h)  # type: ignore
+
+    def forward(
+        self,
+        input_ids: torch.Tensor,
+        seqlens: List[int],
+        cache: Optional[BufferCache] = None,
+        images: Optional[List[torch.Tensor]] = None,
+    ) -> torch.Tensor:
+        h = self.forward_partial(input_ids, seqlens, cache=cache, images=images)
+        if self.pipeline_rank < self.num_pipeline_ranks - 1:
+            # ignore the intermediate activations as we'll get the final output from
+            # the last stage
+            outs = torch.empty(h.shape[0], self.vocab_size, device=h.device, dtype=h.dtype)
+        else:
+            assert self.output is not None
+            outs = self.output(h)
+        if self.num_pipeline_ranks > 1:
+            torch.distributed.broadcast(outs, src=self.num_pipeline_ranks - 1)
+        return outs.float()
+
+    def load_state_dict(self, state_dict: Mapping[str, Any], strict: bool = True, assign: bool = False) -> None:
+        state_to_load = {}
+        skipped = set([])
+        for k, v in state_dict.items():
+            if k.startswith("tok_embeddings"):
+                if self.pipeline_rank == 0:
+                    state_to_load[k] = v
+                else:
+                    logging.debug(
+                        "Skipping parameter %s at pipeline rank %d",
+                        k,
+                        self.pipeline_rank,
+                    )
+                    skipped.add(k)
+            elif k.startswith("norm") or k.startswith("output"):
+                if self.pipeline_rank == self.num_pipeline_ranks - 1:
+                    state_to_load[k] = v
+                else:
+                    logging.debug(
+                        "Skipping parameter %s at pipeline rank %d",
+                        k,
+                        self.pipeline_rank,
+                    )
+                    skipped.add(k)
+            elif k.startswith("layers"):
+                layer_id = k.split(".")[1]
+                if layer_id in self.layers:
+                    state_to_load[k] = v
+                else:
+                    logging.debug(
+                        "Skipping parameter %s at pipeline rank %d",
+                        k,
+                        self.pipeline_rank,
+                    )
+                    skipped.add(k)
+            elif k.startswith("vision_encoder") or k.startswith("vision_language_adapter"):
+                assert not self.pipeline_rank
+                state_to_load[k] = v
+            else:
+                raise ValueError(f"Unexpected key {k}")
+        assert set(state_dict.keys()) == skipped.union(set(state_to_load.keys()))
+        super().load_state_dict(state_to_load, strict=strict, assign=assign)
+
+    @staticmethod
+    def from_folder(
+        folder: Union[Path, str],
+        max_batch_size: int = 1,
+        num_pipeline_ranks: int = 1,
+        device: Union[torch.device, str] = "cuda",
+        dtype: Optional[torch.dtype] = None,
+    ) -> "Transformer":
+        with open(Path(folder) / "params.json", "r") as f:
+            model_args = TransformerArgs.from_dict(json.load(f))
+        model_args.max_batch_size = max_batch_size
+        if num_pipeline_ranks > 1:
+            pipeline_rank = torch.distributed.get_rank()
+        else:
+            pipeline_rank = 0
+        with torch.device("meta"):
+            model = Transformer(
+                model_args,
+                pipeline_rank=pipeline_rank,
+                num_pipeline_ranks=num_pipeline_ranks,
+            )
+
+        pt_model_file = Path(folder) / "consolidated.00.pth"
+        safetensors_model_file = Path(folder) / "consolidated.safetensors"
+
+        assert (
+            pt_model_file.exists() or safetensors_model_file.exists()
+        ), f"Make sure either {pt_model_file} or {safetensors_model_file} exists"
+        assert not (
+            pt_model_file.exists() and safetensors_model_file.exists()
+        ), f"Both {pt_model_file} and {safetensors_model_file} cannot exist"
+
+        if pt_model_file.exists():
+            loaded = torch.load(str(pt_model_file), mmap=True)
+        else:
+            loaded = safetensors.torch.load_file(str(safetensors_model_file))
+
+        model.load_state_dict(loaded, assign=True, strict=True)
+
+        return model.to(device=device, dtype=dtype)

parrot/lib/python3.10/site-packages/mistral_inference/transformer_layers.py

@@ -0,0 +1,169 @@
+from functools import partial
+from typing import Optional, Tuple, Type, Union
+
+import torch
+from torch import nn
+from xformers.ops.fmha import memory_efficient_attention  # type: ignore
+from xformers.ops.fmha.attn_bias import BlockDiagonalMask
+
+from mistral_inference.args import LoraArgs
+from mistral_inference.cache import CacheView
+from mistral_inference.lora import LoRALinear
+from mistral_inference.moe import MoeArgs, MoeLayer
+from mistral_inference.rope import apply_rotary_emb
+
+
+def repeat_kv(keys: torch.Tensor, values: torch.Tensor, repeats: int, dim: int) -> Tuple[torch.Tensor, torch.Tensor]:
+    keys = torch.repeat_interleave(keys, repeats=repeats, dim=dim)
+    values = torch.repeat_interleave(values, repeats=repeats, dim=dim)
+    return keys, values
+
+
+def maybe_lora(
+    lora_args: Optional[LoraArgs],
+) -> Union[Type[nn.Linear], partial[LoRALinear]]:
+    if lora_args is None:
+        return nn.Linear
+    else:
+        return partial(LoRALinear, rank=lora_args.rank, scaling=lora_args.scaling)
+
+
+class Attention(nn.Module):
+    def __init__(
+        self,
+        dim: int,
+        n_heads: int,
+        head_dim: int,
+        n_kv_heads: int,
+        lora: Optional[LoraArgs] = None,
+    ):
+        super().__init__()
+
+        self.n_heads: int = n_heads
+        self.head_dim: int = head_dim
+        self.n_kv_heads: int = n_kv_heads
+
+        self.repeats = self.n_heads // self.n_kv_heads
+
+        self.scale = self.head_dim**-0.5
+
+        MaybeLora = maybe_lora(lora)
+        self.wq = MaybeLora(dim, n_heads * head_dim, bias=False)
+        self.wk = MaybeLora(dim, n_kv_heads * head_dim, bias=False)
+        self.wv = MaybeLora(dim, n_kv_heads * head_dim, bias=False)
+        self.wo = MaybeLora(n_heads * head_dim, dim, bias=False)
+
+    def forward(
+        self,
+        x: torch.Tensor,
+        freqs_cis: torch.Tensor,
+        cache: Optional[CacheView] = None,
+        mask: Optional[BlockDiagonalMask] = None,
+    ) -> torch.Tensor:
+        assert mask is None or cache is None
+        seqlen_sum, _ = x.shape
+
+        xq, xk, xv = self.wq(x), self.wk(x), self.wv(x)
+        xq = xq.view(seqlen_sum, self.n_heads, self.head_dim)
+        xk = xk.view(seqlen_sum, self.n_kv_heads, self.head_dim)
+        xv = xv.view(seqlen_sum, self.n_kv_heads, self.head_dim)
+        xq, xk = apply_rotary_emb(xq, xk, freqs_cis=freqs_cis)
+
+        if cache is None:
+            key, val = xk, xv
+        elif cache.prefill:
+            key, val = cache.interleave_kv(xk, xv)
+            cache.update(xk, xv)
+        else:
+            cache.update(xk, xv)
+            key, val = cache.key, cache.value
+            key = key.view(seqlen_sum * cache.max_seq_len, self.n_kv_heads, self.head_dim)
+            val = val.view(seqlen_sum * cache.max_seq_len, self.n_kv_heads, self.head_dim)
+
+        # Repeat keys and values to match number of query heads
+        key, val = repeat_kv(key, val, self.repeats, dim=1)
+
+        # xformers requires (B=1, S, H, D)
+        xq, key, val = xq[None, ...], key[None, ...], val[None, ...]
+        output = memory_efficient_attention(xq, key, val, mask if cache is None else cache.mask)
+        output = output.view(seqlen_sum, self.n_heads * self.head_dim)
+
+        assert isinstance(output, torch.Tensor)
+
+        return self.wo(output)  # type: ignore
+
+
+class FeedForward(nn.Module):
+    def __init__(self, dim: int, hidden_dim: int, lora: Optional[LoraArgs] = None):
+        super().__init__()
+
+        MaybeLora = maybe_lora(lora)
+        self.w1 = MaybeLora(dim, hidden_dim, bias=False)
+        self.w2 = MaybeLora(hidden_dim, dim, bias=False)
+        self.w3 = MaybeLora(dim, hidden_dim, bias=False)
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        return self.w2(nn.functional.silu(self.w1(x)) * self.w3(x))  # type: ignore
+
+
+class RMSNorm(torch.nn.Module):
+    def __init__(self, dim: int, eps: float = 1e-6):
+        super().__init__()
+        self.eps = eps
+        self.weight = nn.Parameter(torch.ones(dim))
+
+    def _norm(self, x: torch.Tensor) -> torch.Tensor:
+        return x * torch.rsqrt(x.pow(2).mean(-1, keepdim=True) + self.eps)
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        output = self._norm(x.float()).type_as(x)
+        return output * self.weight
+
+
+class TransformerBlock(nn.Module):
+    def __init__(
+        self,
+        dim: int,
+        hidden_dim: int,
+        n_heads: int,
+        n_kv_heads: int,
+        head_dim: int,
+        norm_eps: float,
+        lora: Optional[LoraArgs] = None,
+        moe: Optional[MoeArgs] = None,
+    ):
+        super().__init__()
+        self.n_heads = n_heads
+        self.dim = dim
+        self.attention = Attention(
+            dim=dim,
+            n_heads=n_heads,
+            head_dim=head_dim,
+            n_kv_heads=n_kv_heads,
+            lora=lora,
+        )
+        self.attention_norm = RMSNorm(dim, eps=norm_eps)
+        self.ffn_norm = RMSNorm(dim, eps=norm_eps)
+
+        self.feed_forward: nn.Module
+        if moe is not None:
+            self.feed_forward = MoeLayer(
+                experts=[FeedForward(dim=dim, hidden_dim=hidden_dim, lora=lora) for _ in range(moe.num_experts)],
+                gate=nn.Linear(dim, moe.num_experts, bias=False),
+                moe_args=moe,
+            )
+        else:
+            self.feed_forward = FeedForward(dim=dim, hidden_dim=hidden_dim, lora=lora)
+
+    def forward(
+        self,
+        x: torch.Tensor,
+        freqs_cis: torch.Tensor,
+        cache: Optional[CacheView] = None,
+        mask: Optional[BlockDiagonalMask] = None,
+    ) -> torch.Tensor:
+        r = self.attention.forward(self.attention_norm(x), freqs_cis, cache)
+        h = x + r
+        r = self.feed_forward.forward(self.ffn_norm(h))
+        out = h + r
+        return out

parrot/lib/python3.10/site-packages/mistral_inference/vision_encoder.py

@@ -0,0 +1,146 @@
+from typing import List, Optional
+
+import torch
+import torch.nn as nn
+from xformers.ops.fmha.attn_bias import BlockDiagonalMask
+
+from mistral_inference.args import VisionEncoderArgs
+from mistral_inference.rope import precompute_freqs_cis_2d
+from mistral_inference.transformer_layers import RMSNorm, TransformerBlock
+
+
+def position_meshgrid(
+    patch_embeds_list: list[torch.Tensor],
+) -> torch.Tensor:
+    positions = torch.cat(
+        [
+            torch.stack(
+                torch.meshgrid(
+                    torch.arange(p.shape[-2]),
+                    torch.arange(p.shape[-1]),
+                    indexing="ij",
+                ),
+                dim=-1,
+            ).reshape(-1, 2)
+            for p in patch_embeds_list
+        ]
+    )
+    return positions
+
+
+class VisionTransformer(nn.Module):
+    def __init__(self, args: VisionEncoderArgs):
+        super().__init__()
+        self.args = args
+        self.patch_conv = nn.Conv2d(
+            in_channels=args.num_channels,
+            out_channels=args.hidden_size,
+            kernel_size=args.patch_size,
+            stride=args.patch_size,
+            bias=False,
+        )
+        self.ln_pre = RMSNorm(args.hidden_size, eps=1e-5)
+        self.transformer = VisionTransformerBlocks(args)
+
+        head_dim = self.args.hidden_size // self.args.num_attention_heads
+        assert head_dim % 2 == 0, "ROPE requires even head_dim"
+        self._freqs_cis: Optional[torch.Tensor] = None
+
+    @property
+    def max_patches_per_side(self) -> int:
+        return self.args.image_size // self.args.patch_size
+
+    @property
+    def device(self) -> torch.device:
+        return next(self.parameters()).device
+
+    @property
+    def freqs_cis(self) -> torch.Tensor:
+        if self._freqs_cis is None:
+            self._freqs_cis = precompute_freqs_cis_2d(
+                dim=self.args.hidden_size // self.args.num_attention_heads,
+                height=self.max_patches_per_side,
+                width=self.max_patches_per_side,
+                theta=self.args.rope_theta,
+            )
+
+        if self._freqs_cis.device != self.device:
+            self._freqs_cis = self._freqs_cis.to(device=self.device)
+
+        return self._freqs_cis
+
+    def forward(
+        self,
+        images: List[torch.Tensor],
+    ) -> torch.Tensor:
+        """
+        Args:
+            images: list of N_img images of variable sizes, each of shape (C, H, W)
+
+        Returns:
+            image_features: tensor of token features for all tokens of all images of
+                shape (N_toks, D)
+        """
+        # pass images through initial convolution independently
+        patch_embeds_list = [self.patch_conv(img.unsqueeze(0)).squeeze(0) for img in images]
+
+        # flatten to a single sequence
+        patch_embeds = torch.cat([p.flatten(1).permute(1, 0) for p in patch_embeds_list], dim=0)
+        patch_embeds = self.ln_pre(patch_embeds)
+
+        # positional embeddings
+        positions = position_meshgrid(patch_embeds_list).to(self.device)
+        freqs_cis = self.freqs_cis[positions[:, 0], positions[:, 1]]
+
+        # pass through Transformer with a block diagonal mask delimiting images
+        mask = BlockDiagonalMask.from_seqlens(
+            [p.shape[-2] * p.shape[-1] for p in patch_embeds_list],
+        )
+        out = self.transformer(patch_embeds, mask=mask, freqs_cis=freqs_cis)
+
+        # remove batch dimension of the single sequence
+        return out  # type: ignore[no-any-return]
+
+
+class VisionLanguageAdapter(nn.Module):
+    def __init__(self, in_dim: int, out_dim: int):
+        super().__init__()
+        self.w_in = nn.Linear(
+            in_dim,
+            out_dim,
+            bias=True,
+        )
+        self.gelu = nn.GELU()
+        self.w_out = nn.Linear(out_dim, out_dim, bias=True)
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        return self.w_out(self.gelu(self.w_in(x)))  # type: ignore[no-any-return]
+
+
+class VisionTransformerBlocks(nn.Module):
+    def __init__(self, args: VisionEncoderArgs):
+        super().__init__()
+        self.layers = torch.nn.ModuleList()
+        for _ in range(args.num_hidden_layers):
+            self.layers.append(
+                TransformerBlock(
+                    dim=args.hidden_size,
+                    hidden_dim=args.intermediate_size,
+                    n_heads=args.num_attention_heads,
+                    n_kv_heads=args.num_attention_heads,
+                    head_dim=args.hidden_size // args.num_attention_heads,
+                    norm_eps=1e-5,
+                )
+            )
+
+    def forward(
+        self,
+        x: torch.Tensor,
+        mask: BlockDiagonalMask,
+        freqs_cis: Optional[torch.Tensor],
+    ) -> torch.Tensor:
+        for layer in self.layers:
+            x = layer(x, mask=mask, freqs_cis=freqs_cis)
+        return x
+
+

parrot/lib/python3.10/site-packages/scripts/run_emscripten_tests.py

@@ -0,0 +1,343 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+
+import argparse
+import contextlib
+import http.server
+import os
+import queue
+import shutil
+import subprocess
+import sys
+import time
+import threading
+
+from pathlib import Path
+from io import BytesIO
+
+from selenium import webdriver
+
+
+class TemplateOverrider(http.server.SimpleHTTPRequestHandler):
+    def log_request(self, code="-", size="-"):
+        # don't log successful requests
+        return
+
+    def do_GET(self) -> bytes | None:
+        if self.path.endswith(PYARROW_WHEEL_PATH.name):
+            self.send_response(200)
+            self.send_header("Content-type", "application/x-zip")
+            self.end_headers()
+            with PYARROW_WHEEL_PATH.open(mode="rb") as wheel:
+                self.copyfile(wheel, self.wfile)
+        if self.path.endswith("/test.html"):
+            body = b"""
+                <!doctype html>
+                <html>
+                <head>
+                    <script>
+                        window.python_done_callback = undefined;
+                        window.python_logs = [];
+                        function capturelogs(evt) {
+                            if ('results' in evt.data) {
+                                if (window.python_done_callback) {
+                                    let callback = window.python_done_callback;
+                                    window.python_done_callback = undefined;
+                                    callback({result:evt.data.results});
+                                }
+                            }
+                            if ('print' in evt.data) {
+                                evt.data.print.forEach((x)=>{window.python_logs.push(x)});
+                            }
+                        }
+                        window.pyworker = new Worker("worker.js");
+                        window.pyworker.onmessage = capturelogs;
+                    </script>
+                </head>
+                <body></body>
+                </html>
+                """
+            self.send_response(200)
+            self.send_header("Content-type", "text/html")
+            self.send_header("Content-length", len(body))
+            self.end_headers()
+            self.copyfile(BytesIO(body), self.wfile)
+        elif self.path.endswith("/worker.js"):
+            body = b"""
+                importScripts("./pyodide.js");
+                onmessage = async function (e) {
+                    const data = e.data;
+                    if (!self.pyodide) {
+                        self.pyodide = await loadPyodide();
+                    }
+                    function do_print(arg) {
+                        let databytes = Array.from(arg);
+                        self.postMessage({print:databytes});
+                        return databytes.length;
+                    }
+                    self.pyodide.setStdout({write:do_print,isatty:data.isatty});
+                    self.pyodide.setStderr({write:do_print,isatty:data.isatty});
+
+                    await self.pyodide.loadPackagesFromImports(data.python);
+                    let results = await self.pyodide.runPythonAsync(data.python);
+                    self.postMessage({results});
+                }
+                """
+            self.send_response(200)
+            self.send_header("Content-type", "application/javascript")
+            self.send_header("Content-length", len(body))
+            self.end_headers()
+            self.copyfile(BytesIO(body), self.wfile)
+
+        else:
+            return super().do_GET()
+
+    def end_headers(self):
+        # Enable Cross-Origin Resource Sharing (CORS)
+        self.send_header("Access-Control-Allow-Origin", "*")
+        super().end_headers()
+
+
+def run_server_thread(dist_dir, q):
+    global _SERVER_ADDRESS
+    os.chdir(dist_dir)
+    server = http.server.HTTPServer(("", 0), TemplateOverrider)
+    q.put(server.server_address)
+    print(f"Starting server for {dist_dir} at: {server.server_address}")
+    server.serve_forever()
+
+
+@contextlib.contextmanager
+def launch_server(dist_dir):
+    q = queue.Queue()
+    p = threading.Thread(target=run_server_thread, args=[dist_dir, q], daemon=True)
+    p.start()
+    address = q.get(timeout=50)
+    time.sleep(0.1)  # wait to make sure server is started
+    yield address
+    p.terminate()
+
+
+class NodeDriver:
+    import subprocess
+
+    def __init__(self, hostname, port):
+        self.process = subprocess.Popen(
+            [shutil.which("script"), "-c", shutil.which("node")],
+            stdin=subprocess.PIPE,
+            shell=False,
+            bufsize=0,
+        )
+        print(self.process)
+        time.sleep(0.1)  # wait for node to start
+        self.hostname = hostname
+        self.port = port
+        self.last_ret_code = None
+
+    def load_pyodide(self, dist_dir):
+        self.execute_js(
+            f"""
+        const {{ loadPyodide }} = require('{dist_dir}/pyodide.js');
+        let pyodide = await loadPyodide();
+        """
+        )
+
+    def clear_logs(self):
+        pass  # we don't handle logs for node
+
+    def write_stdin(self, buffer):
+        # because we use unbuffered IO for
+        # stdout, stdin.write is also unbuffered
+        # so might under-run on writes
+        while len(buffer) > 0 and self.process.poll() is None:
+            written = self.process.stdin.write(buffer)
+            if written == len(buffer):
+                break
+            elif written == 0:
+                # full buffer - wait
+                time.sleep(0.01)
+            else:
+                buffer = buffer[written:]
+
+    def execute_js(self, code, wait_for_terminate=True):
+        self.write_stdin((code + "\n").encode("utf-8"))
+
+    def load_arrow(self):
+        self.execute_js(f"await pyodide.loadPackage('{PYARROW_WHEEL_PATH}');")
+
+    def execute_python(self, code, wait_for_terminate=True):
+        js_code = f"""
+            python = `{code}`;
+            await pyodide.loadPackagesFromImports(python);
+            python_output = await pyodide.runPythonAsync(python);
+        """
+        self.last_ret_code = self.execute_js(js_code, wait_for_terminate)
+        return self.last_ret_code
+
+    def wait_for_done(self):
+        # in node we just let it run above
+        # then send EOF and join process
+        self.write_stdin(b"process.exit(python_output)\n")
+        return self.process.wait()
+
+
+class BrowserDriver:
+    def __init__(self, hostname, port, driver):
+        self.driver = driver
+        self.driver.get(f"http://{hostname}:{port}/test.html")
+        self.driver.set_script_timeout(100)
+
+    def load_pyodide(self, dist_dir):
+        pass
+
+    def load_arrow(self):
+        self.execute_python(
+            f"import pyodide_js as pjs\n"
+            f"await pjs.loadPackage('{PYARROW_WHEEL_PATH.name}')\n"
+        )
+
+    def execute_python(self, code, wait_for_terminate=True):
+        if wait_for_terminate:
+            self.driver.execute_async_script(
+                f"""
+                let callback = arguments[arguments.length-1];
+                python = `{code}`;
+                window.python_done_callback = callback;
+                window.pyworker.postMessage(
+                    {{python, isatty: {'true' if sys.stdout.isatty() else 'false'}}});
+                """
+            )
+        else:
+            self.driver.execute_script(
+                f"""
+                let python = `{code}`;
+                window.python_done_callback= (x) => {{window.python_script_done=x;}};
+                window.pyworker.postMessage(
+                    {{python,isatty:{'true' if sys.stdout.isatty() else 'false'}}});
+                """
+            )
+
+    def clear_logs(self):
+        self.driver.execute_script("window.python_logs = [];")
+
+    def wait_for_done(self):
+        while True:
+            # poll for console.log messages from our webworker
+            # which are the output of pytest
+            lines = self.driver.execute_script(
+                "let temp = window.python_logs;window.python_logs=[];return temp;"
+            )
+            if len(lines) > 0:
+                sys.stdout.buffer.write(bytes(lines))
+            done = self.driver.execute_script("return window.python_script_done;")
+            if done is not None:
+                value = done["result"]
+                self.driver.execute_script("delete window.python_script_done;")
+                return value
+            time.sleep(0.1)
+
+
+class ChromeDriver(BrowserDriver):
+    def __init__(self, hostname, port):
+        from selenium.webdriver.chrome.options import Options
+
+        options = Options()
+        options.add_argument("--headless")
+        options.add_argument("--no-sandbox")
+        super().__init__(hostname, port, webdriver.Chrome(options=options))
+
+
+class FirefoxDriver(BrowserDriver):
+    def __init__(self, hostname, port):
+        from selenium.webdriver.firefox.options import Options
+
+        options = Options()
+        options.add_argument("--headless")
+
+        super().__init__(hostname, port, webdriver.Firefox(options=options))
+
+
+def _load_pyarrow_in_runner(driver, wheel_name):
+    driver.load_arrow()
+    driver.execute_python(
+        """import sys
+import micropip
+if "pyarrow" not in sys.modules:
+    await micropip.install("hypothesis")
+    import pyodide_js as pjs
+    await pjs.loadPackage("numpy")
+    await pjs.loadPackage("pandas")
+    import pytest
+    import pandas # import pandas after pyarrow package load for pandas/pyarrow
+                  # functions to work
+import pyarrow
+    """,
+        wait_for_terminate=True,
+    )
+
+
+parser = argparse.ArgumentParser()
+parser.add_argument(
+    "-d",
+    "--dist-dir",
+    type=str,
+    help="Pyodide distribution directory",
+    default="./pyodide",
+)
+parser.add_argument("wheel", type=str, help="Wheel to run tests from")
+parser.add_argument(
+    "-t", "--test-submodule", help="Submodule that tests live in", default="test"
+)
+parser.add_argument(
+    "-r",
+    "--runtime",
+    type=str,
+    choices=["chrome", "node", "firefox"],
+    help="Runtime to run tests in",
+    default="chrome",
+)
+args = parser.parse_args()
+
+PYARROW_WHEEL_PATH = Path(args.wheel).resolve()
+
+dist_dir = Path(os.getcwd(), args.dist_dir).resolve()
+print(f"dist dir={dist_dir}")
+with launch_server(dist_dir) as (hostname, port):
+    if args.runtime == "chrome":
+        driver = ChromeDriver(hostname, port)
+    elif args.runtime == "node":
+        driver = NodeDriver(hostname, port)
+    elif args.runtime == "firefox":
+        driver = FirefoxDriver(hostname, port)
+
+    print("Load pyodide in browser")
+    driver.load_pyodide(dist_dir)
+    print("Load pyarrow in browser")
+    _load_pyarrow_in_runner(driver, Path(args.wheel).name)
+    driver.clear_logs()
+    print("Run pytest in browser")
+    driver.execute_python(
+        """
+import pyarrow,pathlib
+pyarrow_dir = pathlib.Path(pyarrow.__file__).parent
+pytest.main([pyarrow_dir, '-v'])
+""",
+        wait_for_terminate=False,
+    )
+    print("Wait for done")
+    os._exit(driver.wait_for_done())

parrot/lib/python3.10/site-packages/scripts/test_leak.py

@@ -0,0 +1,110 @@
+#!/usr/bin/env python
+
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+import pyarrow as pa
+import numpy as np
+import pandas as pd
+from pyarrow.tests.util import rands
+import memory_profiler
+import gc
+import io
+
+MEGABYTE = 1 << 20
+
+
+def assert_does_not_leak(f, iterations=10, check_interval=1, tolerance=5):
+    gc.collect()
+    baseline = memory_profiler.memory_usage()[0]
+    for i in range(iterations):
+        f()
+        if i % check_interval == 0:
+            gc.collect()
+            usage = memory_profiler.memory_usage()[0]
+            diff = usage - baseline
+            print("{0}: {1}\r".format(i, diff), end="")
+            if diff > tolerance:
+                raise Exception("Memory increased by {0} megabytes after {1} "
+                                "iterations".format(diff, i + 1))
+    gc.collect()
+    usage = memory_profiler.memory_usage()[0]
+    diff = usage - baseline
+    print("\nMemory increased by {0} megabytes after {1} "
+          "iterations".format(diff, iterations))
+
+
+def test_leak1():
+    data = [pa.array(np.concatenate([np.random.randn(100000)] * 1000))]
+    table = pa.Table.from_arrays(data, ['foo'])
+
+    def func():
+        table.to_pandas()
+    assert_does_not_leak(func)
+
+
+def test_leak2():
+    data = [pa.array(np.concatenate([np.random.randn(100000)] * 10))]
+    table = pa.Table.from_arrays(data, ['foo'])
+
+    def func():
+        df = table.to_pandas()
+
+        batch = pa.RecordBatch.from_pandas(df)
+
+        sink = io.BytesIO()
+        writer = pa.RecordBatchFileWriter(sink, batch.schema)
+        writer.write_batch(batch)
+        writer.close()
+
+        buf_reader = pa.BufferReader(sink.getvalue())
+        reader = pa.open_file(buf_reader)
+        reader.read_all()
+
+    assert_does_not_leak(func, iterations=50, tolerance=50)
+
+
+def test_leak3():
+    import pyarrow.parquet as pq
+
+    df = pd.DataFrame({'a{0}'.format(i): [1, 2, 3, 4]
+                       for i in range(50)})
+    table = pa.Table.from_pandas(df, preserve_index=False)
+
+    writer = pq.ParquetWriter('leak_test_' + rands(5) + '.parquet',
+                              table.schema)
+
+    def func():
+        writer.write_table(table, row_group_size=len(table))
+
+    # This does not "leak" per se but we do want to have this use as little
+    # memory as possible
+    assert_does_not_leak(func, iterations=500,
+                         check_interval=50, tolerance=20)
+
+
+def test_ARROW_8801():
+    x = pd.to_datetime(np.random.randint(0, 2**32, size=2**20, dtype=np.int64),
+                       unit='ms', utc=True)
+    table = pa.table(pd.DataFrame({'x': x}))
+
+    assert_does_not_leak(lambda: table.to_pandas(split_blocks=False),
+                         iterations=1000, check_interval=50, tolerance=1000)
+
+
+if __name__ == '__main__':
+    test_ARROW_8801()

parrot/lib/python3.10/site-packages/setuptools-75.8.0-py3.10.egg-info/PKG-INFO

@@ -0,0 +1,142 @@
+Metadata-Version: 2.2
+Name: setuptools
+Version: 75.8.0
+Summary: Easily download, build, install, upgrade, and uninstall Python packages
+Author-email: Python Packaging Authority <distutils-sig@python.org>
+Project-URL: Source, https://github.com/pypa/setuptools
+Project-URL: Documentation, https://setuptools.pypa.io/
+Project-URL: Changelog, https://setuptools.pypa.io/en/stable/history.html
+Keywords: CPAN PyPI distutils eggs package management
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: System :: Archiving :: Packaging
+Classifier: Topic :: System :: Systems Administration
+Classifier: Topic :: Utilities
+Requires-Python: >=3.9
+Description-Content-Type: text/x-rst
+License-File: LICENSE
+Provides-Extra: test
+Requires-Dist: pytest!=8.1.*,>=6; extra == "test"
+Requires-Dist: virtualenv>=13.0.0; extra == "test"
+Requires-Dist: wheel>=0.44.0; extra == "test"
+Requires-Dist: pip>=19.1; extra == "test"
+Requires-Dist: packaging>=24.2; extra == "test"
+Requires-Dist: jaraco.envs>=2.2; extra == "test"
+Requires-Dist: pytest-xdist>=3; extra == "test"
+Requires-Dist: jaraco.path>=3.7.2; extra == "test"
+Requires-Dist: build[virtualenv]>=1.0.3; extra == "test"
+Requires-Dist: filelock>=3.4.0; extra == "test"
+Requires-Dist: ini2toml[lite]>=0.14; extra == "test"
+Requires-Dist: tomli-w>=1.0.0; extra == "test"
+Requires-Dist: pytest-timeout; extra == "test"
+Requires-Dist: pytest-perf; sys_platform != "cygwin" and extra == "test"
+Requires-Dist: jaraco.develop>=7.21; (python_version >= "3.9" and sys_platform != "cygwin") and extra == "test"
+Requires-Dist: pytest-home>=0.5; extra == "test"
+Requires-Dist: pytest-subprocess; extra == "test"
+Requires-Dist: pyproject-hooks!=1.1; extra == "test"
+Requires-Dist: jaraco.test>=5.5; extra == "test"
+Provides-Extra: doc
+Requires-Dist: sphinx>=3.5; extra == "doc"
+Requires-Dist: jaraco.packaging>=9.3; extra == "doc"
+Requires-Dist: rst.linker>=1.9; extra == "doc"
+Requires-Dist: furo; extra == "doc"
+Requires-Dist: sphinx-lint; extra == "doc"
+Requires-Dist: jaraco.tidelift>=1.4; extra == "doc"
+Requires-Dist: pygments-github-lexers==0.0.5; extra == "doc"
+Requires-Dist: sphinx-favicon; extra == "doc"
+Requires-Dist: sphinx-inline-tabs; extra == "doc"
+Requires-Dist: sphinx-reredirects; extra == "doc"
+Requires-Dist: sphinxcontrib-towncrier; extra == "doc"
+Requires-Dist: sphinx-notfound-page<2,>=1; extra == "doc"
+Requires-Dist: pyproject-hooks!=1.1; extra == "doc"
+Requires-Dist: towncrier<24.7; extra == "doc"
+Provides-Extra: ssl
+Provides-Extra: certs
+Provides-Extra: core
+Requires-Dist: packaging>=24.2; extra == "core"
+Requires-Dist: more_itertools>=8.8; extra == "core"
+Requires-Dist: jaraco.text>=3.7; extra == "core"
+Requires-Dist: importlib_metadata>=6; python_version < "3.10" and extra == "core"
+Requires-Dist: tomli>=2.0.1; python_version < "3.11" and extra == "core"
+Requires-Dist: wheel>=0.43.0; extra == "core"
+Requires-Dist: platformdirs>=4.2.2; extra == "core"
+Requires-Dist: jaraco.collections; extra == "core"
+Requires-Dist: jaraco.functools>=4; extra == "core"
+Requires-Dist: packaging; extra == "core"
+Requires-Dist: more_itertools; extra == "core"
+Provides-Extra: check
+Requires-Dist: pytest-checkdocs>=2.4; extra == "check"
+Requires-Dist: pytest-ruff>=0.2.1; sys_platform != "cygwin" and extra == "check"
+Requires-Dist: ruff>=0.8.0; sys_platform != "cygwin" and extra == "check"
+Provides-Extra: cover
+Requires-Dist: pytest-cov; extra == "cover"
+Provides-Extra: enabler
+Requires-Dist: pytest-enabler>=2.2; extra == "enabler"
+Provides-Extra: type
+Requires-Dist: pytest-mypy; extra == "type"
+Requires-Dist: mypy==1.14.*; extra == "type"
+Requires-Dist: importlib_metadata>=7.0.2; python_version < "3.10" and extra == "type"
+Requires-Dist: jaraco.develop>=7.21; sys_platform != "cygwin" and extra == "type"
+
+.. |pypi-version| image:: https://img.shields.io/pypi/v/setuptools.svg
+   :target: https://pypi.org/project/setuptools
+
+.. |py-version| image:: https://img.shields.io/pypi/pyversions/setuptools.svg
+
+.. |test-badge| image:: https://github.com/pypa/setuptools/actions/workflows/main.yml/badge.svg
+   :target: https://github.com/pypa/setuptools/actions?query=workflow%3A%22tests%22
+   :alt: tests
+
+.. |ruff-badge| image:: https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/charliermarsh/ruff/main/assets/badge/v2.json
+   :target: https://github.com/astral-sh/ruff
+   :alt: Ruff
+
+.. |docs-badge| image:: https://img.shields.io/readthedocs/setuptools/latest.svg
+   :target: https://setuptools.pypa.io
+
+.. |skeleton-badge| image:: https://img.shields.io/badge/skeleton-2024-informational
+   :target: https://blog.jaraco.com/skeleton
+
+.. |codecov-badge| image:: https://img.shields.io/codecov/c/github/pypa/setuptools/master.svg?logo=codecov&logoColor=white
+   :target: https://codecov.io/gh/pypa/setuptools
+
+.. |tidelift-badge| image:: https://tidelift.com/badges/github/pypa/setuptools?style=flat
+   :target: https://tidelift.com/subscription/pkg/pypi-setuptools?utm_source=pypi-setuptools&utm_medium=readme
+
+.. |discord-badge| image:: https://img.shields.io/discord/803025117553754132
+   :target: https://discord.com/channels/803025117553754132/815945031150993468
+   :alt: Discord
+
+|pypi-version| |py-version| |test-badge| |ruff-badge| |docs-badge| |skeleton-badge| |codecov-badge| |discord-badge|
+
+See the `Quickstart <https://setuptools.pypa.io/en/latest/userguide/quickstart.html>`_
+and the `User's Guide <https://setuptools.pypa.io/en/latest/userguide/>`_ for
+instructions on how to use Setuptools.
+
+Questions and comments should be directed to `GitHub Discussions
+<https://github.com/pypa/setuptools/discussions>`_.
+Bug reports and especially tested patches may be
+submitted directly to the `bug tracker
+<https://github.com/pypa/setuptools/issues>`_.
+
+
+Code of Conduct
+===============
+
+Everyone interacting in the setuptools project's codebases, issue trackers,
+chat rooms, and fora is expected to follow the
+`PSF Code of Conduct <https://github.com/pypa/.github/blob/main/CODE_OF_CONDUCT.md>`_.
+
+
+For Enterprise
+==============
+
+Available as part of the Tidelift Subscription.
+
+Setuptools and the maintainers of thousands of other packages are working with Tidelift to deliver one enterprise subscription that covers all of the open source you use.
+
+`Learn more <https://tidelift.com/subscription/pkg/pypi-setuptools?utm_source=pypi-setuptools&utm_medium=referral&utm_campaign=github>`_.

parrot/lib/python3.10/site-packages/setuptools-75.8.0-py3.10.egg-info/SOURCES.txt

@@ -0,0 +1,571 @@
+LICENSE
+MANIFEST.in
+NEWS.rst
+README.rst
+conftest.py
+exercises.py
+launcher.c
+mypy.ini
+pyproject.toml
+pytest.ini
+setup.cfg
+setup.py
+tox.ini
+_distutils_hack/__init__.py
+_distutils_hack/override.py
+docs/artwork.rst
+docs/build_meta.rst
+docs/conf.py
+docs/history.rst
+docs/index.rst
+docs/pkg_resources.rst
+docs/python 2 sunset.rst
+docs/roadmap.rst
+docs/setuptools.rst
+docs/deprecated/changed_keywords.rst
+docs/deprecated/commands.rst
+docs/deprecated/dependency_links.rst
+docs/deprecated/distutils-legacy.rst
+docs/deprecated/easy_install.rst
+docs/deprecated/functionalities.rst
+docs/deprecated/index.rst
+docs/deprecated/python_eggs.rst
+docs/deprecated/resource_extraction.rst
+docs/deprecated/zip_safe.rst
+docs/deprecated/distutils/_setuptools_disclaimer.rst
+docs/deprecated/distutils/apiref.rst
+docs/deprecated/distutils/builtdist.rst
+docs/deprecated/distutils/commandref.rst
+docs/deprecated/distutils/configfile.rst
+docs/deprecated/distutils/examples.rst
+docs/deprecated/distutils/extending.rst
+docs/deprecated/distutils/index.rst
+docs/deprecated/distutils/introduction.rst
+docs/deprecated/distutils/packageindex.rst
+docs/deprecated/distutils/setupscript.rst
+docs/deprecated/distutils/sourcedist.rst
+docs/deprecated/distutils/uploading.rst
+docs/development/developer-guide.rst
+docs/development/index.rst
+docs/development/releases.rst
+docs/references/keywords.rst
+docs/userguide/datafiles.rst
+docs/userguide/declarative_config.rst
+docs/userguide/dependency_management.rst
+docs/userguide/development_mode.rst
+docs/userguide/distribution.rst
+docs/userguide/entry_point.rst
+docs/userguide/ext_modules.rst
+docs/userguide/extension.rst
+docs/userguide/index.rst
+docs/userguide/miscellaneous.rst
+docs/userguide/package_discovery.rst
+docs/userguide/pyproject_config.rst
+docs/userguide/quickstart.rst
+newsfragments/.gitignore
+newsfragments/README.rst
+pkg_resources/__init__.py
+pkg_resources/api_tests.txt
+pkg_resources/py.typed
+pkg_resources/tests/__init__.py
+pkg_resources/tests/test_find_distributions.py
+pkg_resources/tests/test_integration_zope_interface.py
+pkg_resources/tests/test_markers.py
+pkg_resources/tests/test_pkg_resources.py
+pkg_resources/tests/test_resources.py
+pkg_resources/tests/test_working_set.py
+pkg_resources/tests/data/my-test-package-source/setup.cfg
+pkg_resources/tests/data/my-test-package-source/setup.py
+pkg_resources/tests/data/my-test-package-zip/my-test-package.zip
+pkg_resources/tests/data/my-test-package_unpacked-egg/my_test_package-1.0-py3.7.egg/EGG-INFO/PKG-INFO
+pkg_resources/tests/data/my-test-package_unpacked-egg/my_test_package-1.0-py3.7.egg/EGG-INFO/SOURCES.txt
+pkg_resources/tests/data/my-test-package_unpacked-egg/my_test_package-1.0-py3.7.egg/EGG-INFO/dependency_links.txt
+pkg_resources/tests/data/my-test-package_unpacked-egg/my_test_package-1.0-py3.7.egg/EGG-INFO/top_level.txt
+pkg_resources/tests/data/my-test-package_unpacked-egg/my_test_package-1.0-py3.7.egg/EGG-INFO/zip-safe
+pkg_resources/tests/data/my-test-package_zipped-egg/my_test_package-1.0-py3.7.egg
+setuptools/__init__.py
+setuptools/_core_metadata.py
+setuptools/_entry_points.py
+setuptools/_imp.py
+setuptools/_importlib.py
+setuptools/_itertools.py
+setuptools/_normalization.py
+setuptools/_path.py
+setuptools/_reqs.py
+setuptools/_shutil.py
+setuptools/_static.py
+setuptools/archive_util.py
+setuptools/build_meta.py
+setuptools/cli-32.exe
+setuptools/cli-64.exe
+setuptools/cli-arm64.exe
+setuptools/cli.exe
+setuptools/depends.py
+setuptools/discovery.py
+setuptools/dist.py
+setuptools/errors.py
+setuptools/extension.py
+setuptools/glob.py
+setuptools/gui-32.exe
+setuptools/gui-64.exe
+setuptools/gui-arm64.exe
+setuptools/gui.exe
+setuptools/installer.py
+setuptools/launch.py
+setuptools/logging.py
+setuptools/modified.py
+setuptools/monkey.py
+setuptools/msvc.py
+setuptools/namespaces.py
+setuptools/package_index.py
+setuptools/sandbox.py
+setuptools/script (dev).tmpl
+setuptools/script.tmpl
+setuptools/unicode_utils.py
+setuptools/version.py
+setuptools/warnings.py
+setuptools/wheel.py
+setuptools/windows_support.py
+setuptools.egg-info/PKG-INFO
+setuptools.egg-info/SOURCES.txt
+setuptools.egg-info/dependency_links.txt
+setuptools.egg-info/entry_points.txt
+setuptools.egg-info/requires.txt
+setuptools.egg-info/top_level.txt
+setuptools/_distutils/__init__.py
+setuptools/_distutils/_log.py
+setuptools/_distutils/_macos_compat.py
+setuptools/_distutils/_modified.py
+setuptools/_distutils/_msvccompiler.py
+setuptools/_distutils/archive_util.py
+setuptools/_distutils/ccompiler.py
+setuptools/_distutils/cmd.py
+setuptools/_distutils/core.py
+setuptools/_distutils/cygwinccompiler.py
+setuptools/_distutils/debug.py
+setuptools/_distutils/dep_util.py
+setuptools/_distutils/dir_util.py
+setuptools/_distutils/dist.py
+setuptools/_distutils/errors.py
+setuptools/_distutils/extension.py
+setuptools/_distutils/fancy_getopt.py
+setuptools/_distutils/file_util.py
+setuptools/_distutils/filelist.py
+setuptools/_distutils/log.py
+setuptools/_distutils/spawn.py
+setuptools/_distutils/sysconfig.py
+setuptools/_distutils/text_file.py
+setuptools/_distutils/unixccompiler.py
+setuptools/_distutils/util.py
+setuptools/_distutils/version.py
+setuptools/_distutils/versionpredicate.py
+setuptools/_distutils/zosccompiler.py
+setuptools/_distutils/command/__init__.py
+setuptools/_distutils/command/_framework_compat.py
+setuptools/_distutils/command/bdist.py
+setuptools/_distutils/command/bdist_dumb.py
+setuptools/_distutils/command/bdist_rpm.py
+setuptools/_distutils/command/build.py
+setuptools/_distutils/command/build_clib.py
+setuptools/_distutils/command/build_ext.py
+setuptools/_distutils/command/build_py.py
+setuptools/_distutils/command/build_scripts.py
+setuptools/_distutils/command/check.py
+setuptools/_distutils/command/clean.py
+setuptools/_distutils/command/config.py
+setuptools/_distutils/command/install.py
+setuptools/_distutils/command/install_data.py
+setuptools/_distutils/command/install_egg_info.py
+setuptools/_distutils/command/install_headers.py
+setuptools/_distutils/command/install_lib.py
+setuptools/_distutils/command/install_scripts.py
+setuptools/_distutils/command/sdist.py
+setuptools/_distutils/compat/__init__.py
+setuptools/_distutils/compat/py39.py
+setuptools/_distutils/tests/__init__.py
+setuptools/_distutils/tests/support.py
+setuptools/_distutils/tests/test_archive_util.py
+setuptools/_distutils/tests/test_bdist.py
+setuptools/_distutils/tests/test_bdist_dumb.py
+setuptools/_distutils/tests/test_bdist_rpm.py
+setuptools/_distutils/tests/test_build.py
+setuptools/_distutils/tests/test_build_clib.py
+setuptools/_distutils/tests/test_build_ext.py
+setuptools/_distutils/tests/test_build_py.py
+setuptools/_distutils/tests/test_build_scripts.py
+setuptools/_distutils/tests/test_ccompiler.py
+setuptools/_distutils/tests/test_check.py
+setuptools/_distutils/tests/test_clean.py
+setuptools/_distutils/tests/test_cmd.py
+setuptools/_distutils/tests/test_config_cmd.py
+setuptools/_distutils/tests/test_core.py
+setuptools/_distutils/tests/test_cygwinccompiler.py
+setuptools/_distutils/tests/test_dir_util.py
+setuptools/_distutils/tests/test_dist.py
+setuptools/_distutils/tests/test_extension.py
+setuptools/_distutils/tests/test_file_util.py
+setuptools/_distutils/tests/test_filelist.py
+setuptools/_distutils/tests/test_install.py
+setuptools/_distutils/tests/test_install_data.py
+setuptools/_distutils/tests/test_install_headers.py
+setuptools/_distutils/tests/test_install_lib.py
+setuptools/_distutils/tests/test_install_scripts.py
+setuptools/_distutils/tests/test_log.py
+setuptools/_distutils/tests/test_mingwccompiler.py
+setuptools/_distutils/tests/test_modified.py
+setuptools/_distutils/tests/test_msvccompiler.py
+setuptools/_distutils/tests/test_sdist.py
+setuptools/_distutils/tests/test_spawn.py
+setuptools/_distutils/tests/test_sysconfig.py
+setuptools/_distutils/tests/test_text_file.py
+setuptools/_distutils/tests/test_unixccompiler.py
+setuptools/_distutils/tests/test_util.py
+setuptools/_distutils/tests/test_version.py
+setuptools/_distutils/tests/test_versionpredicate.py
+setuptools/_distutils/tests/unix_compat.py
+setuptools/_distutils/tests/compat/__init__.py
+setuptools/_distutils/tests/compat/py39.py
+setuptools/_vendor/ruff.toml
+setuptools/_vendor/typing_extensions.py
+setuptools/_vendor/autocommand/__init__.py
+setuptools/_vendor/autocommand/autoasync.py
+setuptools/_vendor/autocommand/autocommand.py
+setuptools/_vendor/autocommand/automain.py
+setuptools/_vendor/autocommand/autoparse.py
+setuptools/_vendor/autocommand/errors.py
+setuptools/_vendor/autocommand-2.2.2.dist-info/INSTALLER
+setuptools/_vendor/autocommand-2.2.2.dist-info/LICENSE
+setuptools/_vendor/autocommand-2.2.2.dist-info/METADATA
+setuptools/_vendor/autocommand-2.2.2.dist-info/RECORD
+setuptools/_vendor/autocommand-2.2.2.dist-info/WHEEL
+setuptools/_vendor/autocommand-2.2.2.dist-info/top_level.txt
+setuptools/_vendor/backports/__init__.py
+setuptools/_vendor/backports.tarfile-1.2.0.dist-info/INSTALLER
+setuptools/_vendor/backports.tarfile-1.2.0.dist-info/LICENSE
+setuptools/_vendor/backports.tarfile-1.2.0.dist-info/METADATA
+setuptools/_vendor/backports.tarfile-1.2.0.dist-info/RECORD
+setuptools/_vendor/backports.tarfile-1.2.0.dist-info/REQUESTED
+setuptools/_vendor/backports.tarfile-1.2.0.dist-info/WHEEL
+setuptools/_vendor/backports.tarfile-1.2.0.dist-info/top_level.txt
+setuptools/_vendor/backports/tarfile/__init__.py
+setuptools/_vendor/backports/tarfile/__main__.py
+setuptools/_vendor/backports/tarfile/compat/__init__.py
+setuptools/_vendor/backports/tarfile/compat/py38.py
+setuptools/_vendor/importlib_metadata/__init__.py
+setuptools/_vendor/importlib_metadata/_adapters.py
+setuptools/_vendor/importlib_metadata/_collections.py
+setuptools/_vendor/importlib_metadata/_compat.py
+setuptools/_vendor/importlib_metadata/_functools.py
+setuptools/_vendor/importlib_metadata/_itertools.py
+setuptools/_vendor/importlib_metadata/_meta.py
+setuptools/_vendor/importlib_metadata/_text.py
+setuptools/_vendor/importlib_metadata/diagnose.py
+setuptools/_vendor/importlib_metadata/py.typed
+setuptools/_vendor/importlib_metadata-8.0.0.dist-info/INSTALLER
+setuptools/_vendor/importlib_metadata-8.0.0.dist-info/LICENSE
+setuptools/_vendor/importlib_metadata-8.0.0.dist-info/METADATA
+setuptools/_vendor/importlib_metadata-8.0.0.dist-info/RECORD
+setuptools/_vendor/importlib_metadata-8.0.0.dist-info/REQUESTED
+setuptools/_vendor/importlib_metadata-8.0.0.dist-info/WHEEL
+setuptools/_vendor/importlib_metadata-8.0.0.dist-info/top_level.txt
+setuptools/_vendor/importlib_metadata/compat/__init__.py
+setuptools/_vendor/importlib_metadata/compat/py311.py
+setuptools/_vendor/importlib_metadata/compat/py39.py
+setuptools/_vendor/inflect/__init__.py
+setuptools/_vendor/inflect/py.typed
+setuptools/_vendor/inflect-7.3.1.dist-info/INSTALLER
+setuptools/_vendor/inflect-7.3.1.dist-info/LICENSE
+setuptools/_vendor/inflect-7.3.1.dist-info/METADATA
+setuptools/_vendor/inflect-7.3.1.dist-info/RECORD
+setuptools/_vendor/inflect-7.3.1.dist-info/WHEEL
+setuptools/_vendor/inflect-7.3.1.dist-info/top_level.txt
+setuptools/_vendor/inflect/compat/__init__.py
+setuptools/_vendor/inflect/compat/py38.py
+setuptools/_vendor/jaraco/context.py
+setuptools/_vendor/jaraco.collections-5.1.0.dist-info/INSTALLER
+setuptools/_vendor/jaraco.collections-5.1.0.dist-info/LICENSE
+setuptools/_vendor/jaraco.collections-5.1.0.dist-info/METADATA
+setuptools/_vendor/jaraco.collections-5.1.0.dist-info/RECORD
+setuptools/_vendor/jaraco.collections-5.1.0.dist-info/REQUESTED
+setuptools/_vendor/jaraco.collections-5.1.0.dist-info/WHEEL
+setuptools/_vendor/jaraco.collections-5.1.0.dist-info/top_level.txt
+setuptools/_vendor/jaraco.context-5.3.0.dist-info/INSTALLER
+setuptools/_vendor/jaraco.context-5.3.0.dist-info/LICENSE
+setuptools/_vendor/jaraco.context-5.3.0.dist-info/METADATA
+setuptools/_vendor/jaraco.context-5.3.0.dist-info/RECORD
+setuptools/_vendor/jaraco.context-5.3.0.dist-info/WHEEL
+setuptools/_vendor/jaraco.context-5.3.0.dist-info/top_level.txt
+setuptools/_vendor/jaraco.functools-4.0.1.dist-info/INSTALLER
+setuptools/_vendor/jaraco.functools-4.0.1.dist-info/LICENSE
+setuptools/_vendor/jaraco.functools-4.0.1.dist-info/METADATA
+setuptools/_vendor/jaraco.functools-4.0.1.dist-info/RECORD
+setuptools/_vendor/jaraco.functools-4.0.1.dist-info/WHEEL
+setuptools/_vendor/jaraco.functools-4.0.1.dist-info/top_level.txt
+setuptools/_vendor/jaraco.text-3.12.1.dist-info/INSTALLER
+setuptools/_vendor/jaraco.text-3.12.1.dist-info/LICENSE
+setuptools/_vendor/jaraco.text-3.12.1.dist-info/METADATA
+setuptools/_vendor/jaraco.text-3.12.1.dist-info/RECORD
+setuptools/_vendor/jaraco.text-3.12.1.dist-info/REQUESTED
+setuptools/_vendor/jaraco.text-3.12.1.dist-info/WHEEL
+setuptools/_vendor/jaraco.text-3.12.1.dist-info/top_level.txt
+setuptools/_vendor/jaraco/collections/__init__.py
+setuptools/_vendor/jaraco/collections/py.typed
+setuptools/_vendor/jaraco/functools/__init__.py
+setuptools/_vendor/jaraco/functools/__init__.pyi
+setuptools/_vendor/jaraco/functools/py.typed
+setuptools/_vendor/jaraco/text/Lorem ipsum.txt
+setuptools/_vendor/jaraco/text/__init__.py
+setuptools/_vendor/jaraco/text/layouts.py
+setuptools/_vendor/jaraco/text/show-newlines.py
+setuptools/_vendor/jaraco/text/strip-prefix.py
+setuptools/_vendor/jaraco/text/to-dvorak.py
+setuptools/_vendor/jaraco/text/to-qwerty.py
+setuptools/_vendor/more_itertools/__init__.py
+setuptools/_vendor/more_itertools/__init__.pyi
+setuptools/_vendor/more_itertools/more.py
+setuptools/_vendor/more_itertools/more.pyi
+setuptools/_vendor/more_itertools/py.typed
+setuptools/_vendor/more_itertools/recipes.py
+setuptools/_vendor/more_itertools/recipes.pyi
+setuptools/_vendor/more_itertools-10.3.0.dist-info/INSTALLER
+setuptools/_vendor/more_itertools-10.3.0.dist-info/LICENSE
+setuptools/_vendor/more_itertools-10.3.0.dist-info/METADATA
+setuptools/_vendor/more_itertools-10.3.0.dist-info/RECORD
+setuptools/_vendor/more_itertools-10.3.0.dist-info/REQUESTED
+setuptools/_vendor/more_itertools-10.3.0.dist-info/WHEEL
+setuptools/_vendor/packaging/__init__.py
+setuptools/_vendor/packaging/_elffile.py
+setuptools/_vendor/packaging/_manylinux.py
+setuptools/_vendor/packaging/_musllinux.py
+setuptools/_vendor/packaging/_parser.py
+setuptools/_vendor/packaging/_structures.py
+setuptools/_vendor/packaging/_tokenizer.py
+setuptools/_vendor/packaging/markers.py
+setuptools/_vendor/packaging/metadata.py
+setuptools/_vendor/packaging/py.typed
+setuptools/_vendor/packaging/requirements.py
+setuptools/_vendor/packaging/specifiers.py
+setuptools/_vendor/packaging/tags.py
+setuptools/_vendor/packaging/utils.py
+setuptools/_vendor/packaging/version.py
+setuptools/_vendor/packaging-24.2.dist-info/INSTALLER
+setuptools/_vendor/packaging-24.2.dist-info/LICENSE
+setuptools/_vendor/packaging-24.2.dist-info/LICENSE.APACHE
+setuptools/_vendor/packaging-24.2.dist-info/LICENSE.BSD
+setuptools/_vendor/packaging-24.2.dist-info/METADATA
+setuptools/_vendor/packaging-24.2.dist-info/RECORD
+setuptools/_vendor/packaging-24.2.dist-info/REQUESTED
+setuptools/_vendor/packaging-24.2.dist-info/WHEEL
+setuptools/_vendor/packaging/licenses/__init__.py
+setuptools/_vendor/packaging/licenses/_spdx.py
+setuptools/_vendor/platformdirs/__init__.py
+setuptools/_vendor/platformdirs/__main__.py
+setuptools/_vendor/platformdirs/android.py
+setuptools/_vendor/platformdirs/api.py
+setuptools/_vendor/platformdirs/macos.py
+setuptools/_vendor/platformdirs/py.typed
+setuptools/_vendor/platformdirs/unix.py
+setuptools/_vendor/platformdirs/version.py
+setuptools/_vendor/platformdirs/windows.py
+setuptools/_vendor/platformdirs-4.2.2.dist-info/INSTALLER
+setuptools/_vendor/platformdirs-4.2.2.dist-info/METADATA
+setuptools/_vendor/platformdirs-4.2.2.dist-info/RECORD
+setuptools/_vendor/platformdirs-4.2.2.dist-info/REQUESTED
+setuptools/_vendor/platformdirs-4.2.2.dist-info/WHEEL
+setuptools/_vendor/platformdirs-4.2.2.dist-info/licenses/LICENSE
+setuptools/_vendor/tomli/__init__.py
+setuptools/_vendor/tomli/_parser.py
+setuptools/_vendor/tomli/_re.py
+setuptools/_vendor/tomli/_types.py
+setuptools/_vendor/tomli/py.typed
+setuptools/_vendor/tomli-2.0.1.dist-info/INSTALLER
+setuptools/_vendor/tomli-2.0.1.dist-info/LICENSE
+setuptools/_vendor/tomli-2.0.1.dist-info/METADATA
+setuptools/_vendor/tomli-2.0.1.dist-info/RECORD
+setuptools/_vendor/tomli-2.0.1.dist-info/REQUESTED
+setuptools/_vendor/tomli-2.0.1.dist-info/WHEEL
+setuptools/_vendor/typeguard/__init__.py
+setuptools/_vendor/typeguard/_checkers.py
+setuptools/_vendor/typeguard/_config.py
+setuptools/_vendor/typeguard/_decorators.py
+setuptools/_vendor/typeguard/_exceptions.py
+setuptools/_vendor/typeguard/_functions.py
+setuptools/_vendor/typeguard/_importhook.py
+setuptools/_vendor/typeguard/_memo.py
+setuptools/_vendor/typeguard/_pytest_plugin.py
+setuptools/_vendor/typeguard/_suppression.py
+setuptools/_vendor/typeguard/_transformer.py
+setuptools/_vendor/typeguard/_union_transformer.py
+setuptools/_vendor/typeguard/_utils.py
+setuptools/_vendor/typeguard/py.typed
+setuptools/_vendor/typeguard-4.3.0.dist-info/INSTALLER
+setuptools/_vendor/typeguard-4.3.0.dist-info/LICENSE
+setuptools/_vendor/typeguard-4.3.0.dist-info/METADATA
+setuptools/_vendor/typeguard-4.3.0.dist-info/RECORD
+setuptools/_vendor/typeguard-4.3.0.dist-info/WHEEL
+setuptools/_vendor/typeguard-4.3.0.dist-info/entry_points.txt
+setuptools/_vendor/typeguard-4.3.0.dist-info/top_level.txt
+setuptools/_vendor/typing_extensions-4.12.2.dist-info/INSTALLER
+setuptools/_vendor/typing_extensions-4.12.2.dist-info/LICENSE
+setuptools/_vendor/typing_extensions-4.12.2.dist-info/METADATA
+setuptools/_vendor/typing_extensions-4.12.2.dist-info/RECORD
+setuptools/_vendor/typing_extensions-4.12.2.dist-info/WHEEL
+setuptools/_vendor/wheel/__init__.py
+setuptools/_vendor/wheel/__main__.py
+setuptools/_vendor/wheel/_setuptools_logging.py
+setuptools/_vendor/wheel/bdist_wheel.py
+setuptools/_vendor/wheel/macosx_libfile.py
+setuptools/_vendor/wheel/metadata.py
+setuptools/_vendor/wheel/util.py
+setuptools/_vendor/wheel/wheelfile.py
+setuptools/_vendor/wheel-0.43.0.dist-info/INSTALLER
+setuptools/_vendor/wheel-0.43.0.dist-info/LICENSE.txt
+setuptools/_vendor/wheel-0.43.0.dist-info/METADATA
+setuptools/_vendor/wheel-0.43.0.dist-info/RECORD
+setuptools/_vendor/wheel-0.43.0.dist-info/REQUESTED
+setuptools/_vendor/wheel-0.43.0.dist-info/WHEEL
+setuptools/_vendor/wheel-0.43.0.dist-info/entry_points.txt
+setuptools/_vendor/wheel/cli/__init__.py
+setuptools/_vendor/wheel/cli/convert.py
+setuptools/_vendor/wheel/cli/pack.py
+setuptools/_vendor/wheel/cli/tags.py
+setuptools/_vendor/wheel/cli/unpack.py
+setuptools/_vendor/wheel/vendored/__init__.py
+setuptools/_vendor/wheel/vendored/vendor.txt
+setuptools/_vendor/wheel/vendored/packaging/__init__.py
+setuptools/_vendor/wheel/vendored/packaging/_elffile.py
+setuptools/_vendor/wheel/vendored/packaging/_manylinux.py
+setuptools/_vendor/wheel/vendored/packaging/_musllinux.py
+setuptools/_vendor/wheel/vendored/packaging/_parser.py
+setuptools/_vendor/wheel/vendored/packaging/_structures.py
+setuptools/_vendor/wheel/vendored/packaging/_tokenizer.py
+setuptools/_vendor/wheel/vendored/packaging/markers.py
+setuptools/_vendor/wheel/vendored/packaging/requirements.py
+setuptools/_vendor/wheel/vendored/packaging/specifiers.py
+setuptools/_vendor/wheel/vendored/packaging/tags.py
+setuptools/_vendor/wheel/vendored/packaging/utils.py
+setuptools/_vendor/wheel/vendored/packaging/version.py
+setuptools/_vendor/zipp/__init__.py
+setuptools/_vendor/zipp/glob.py
+setuptools/_vendor/zipp-3.19.2.dist-info/INSTALLER
+setuptools/_vendor/zipp-3.19.2.dist-info/LICENSE
+setuptools/_vendor/zipp-3.19.2.dist-info/METADATA
+setuptools/_vendor/zipp-3.19.2.dist-info/RECORD
+setuptools/_vendor/zipp-3.19.2.dist-info/REQUESTED
+setuptools/_vendor/zipp-3.19.2.dist-info/WHEEL
+setuptools/_vendor/zipp-3.19.2.dist-info/top_level.txt
+setuptools/_vendor/zipp/compat/__init__.py
+setuptools/_vendor/zipp/compat/py310.py
+setuptools/command/__init__.py
+setuptools/command/_requirestxt.py
+setuptools/command/alias.py
+setuptools/command/bdist_egg.py
+setuptools/command/bdist_rpm.py
+setuptools/command/bdist_wheel.py
+setuptools/command/build.py
+setuptools/command/build_clib.py
+setuptools/command/build_ext.py
+setuptools/command/build_py.py
+setuptools/command/develop.py
+setuptools/command/dist_info.py
+setuptools/command/easy_install.py
+setuptools/command/editable_wheel.py
+setuptools/command/egg_info.py
+setuptools/command/install.py
+setuptools/command/install_egg_info.py
+setuptools/command/install_lib.py
+setuptools/command/install_scripts.py
+setuptools/command/launcher manifest.xml
+setuptools/command/rotate.py
+setuptools/command/saveopts.py
+setuptools/command/sdist.py
+setuptools/command/setopt.py
+setuptools/command/test.py
+setuptools/compat/__init__.py
+setuptools/compat/py310.py
+setuptools/compat/py311.py
+setuptools/compat/py312.py
+setuptools/compat/py39.py
+setuptools/config/NOTICE
+setuptools/config/__init__.py
+setuptools/config/_apply_pyprojecttoml.py
+setuptools/config/distutils.schema.json
+setuptools/config/expand.py
+setuptools/config/pyprojecttoml.py
+setuptools/config/setupcfg.py
+setuptools/config/setuptools.schema.json
+setuptools/config/_validate_pyproject/NOTICE
+setuptools/config/_validate_pyproject/__init__.py
+setuptools/config/_validate_pyproject/error_reporting.py
+setuptools/config/_validate_pyproject/extra_validations.py
+setuptools/config/_validate_pyproject/fastjsonschema_exceptions.py
+setuptools/config/_validate_pyproject/fastjsonschema_validations.py
+setuptools/config/_validate_pyproject/formats.py
+setuptools/tests/__init__.py
+setuptools/tests/contexts.py
+setuptools/tests/environment.py
+setuptools/tests/fixtures.py
+setuptools/tests/mod_with_constant.py
+setuptools/tests/namespaces.py
+setuptools/tests/script-with-bom.py
+setuptools/tests/server.py
+setuptools/tests/test_archive_util.py
+setuptools/tests/test_bdist_deprecations.py
+setuptools/tests/test_bdist_egg.py
+setuptools/tests/test_bdist_wheel.py
+setuptools/tests/test_build.py
+setuptools/tests/test_build_clib.py
+setuptools/tests/test_build_ext.py
+setuptools/tests/test_build_meta.py
+setuptools/tests/test_build_py.py
+setuptools/tests/test_config_discovery.py
+setuptools/tests/test_core_metadata.py
+setuptools/tests/test_depends.py
+setuptools/tests/test_develop.py
+setuptools/tests/test_dist.py
+setuptools/tests/test_dist_info.py
+setuptools/tests/test_distutils_adoption.py
+setuptools/tests/test_easy_install.py
+setuptools/tests/test_editable_install.py
+setuptools/tests/test_egg_info.py
+setuptools/tests/test_extern.py
+setuptools/tests/test_find_packages.py
+setuptools/tests/test_find_py_modules.py
+setuptools/tests/test_glob.py
+setuptools/tests/test_install_scripts.py
+setuptools/tests/test_logging.py
+setuptools/tests/test_manifest.py
+setuptools/tests/test_namespaces.py
+setuptools/tests/test_packageindex.py
+setuptools/tests/test_sandbox.py
+setuptools/tests/test_sdist.py
+setuptools/tests/test_setopt.py
+setuptools/tests/test_setuptools.py
+setuptools/tests/test_shutil_wrapper.py
+setuptools/tests/test_unicode_utils.py
+setuptools/tests/test_virtualenv.py
+setuptools/tests/test_warnings.py
+setuptools/tests/test_wheel.py
+setuptools/tests/test_windows_wrappers.py
+setuptools/tests/text.py
+setuptools/tests/textwrap.py
+setuptools/tests/compat/__init__.py
+setuptools/tests/compat/py39.py
+setuptools/tests/config/__init__.py
+setuptools/tests/config/setupcfg_examples.txt
+setuptools/tests/config/test_apply_pyprojecttoml.py
+setuptools/tests/config/test_expand.py
+setuptools/tests/config/test_pyprojecttoml.py
+setuptools/tests/config/test_pyprojecttoml_dynamic_deps.py
+setuptools/tests/config/test_setupcfg.py
+setuptools/tests/config/downloads/__init__.py
+setuptools/tests/config/downloads/preload.py
+setuptools/tests/indexes/test_links_priority/external.html
+setuptools/tests/indexes/test_links_priority/simple/foobar/index.html
+setuptools/tests/integration/__init__.py
+setuptools/tests/integration/helpers.py
+setuptools/tests/integration/test_pip_install_sdist.py
+tools/build_launchers.py
+tools/finalize.py
+tools/generate_validation_code.py
+tools/vendored.py

parrot/lib/python3.10/site-packages/setuptools-75.8.0-py3.10.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

parrot/lib/python3.10/site-packages/setuptools-75.8.0-py3.10.egg-info/entry_points.txt

@@ -0,0 +1,51 @@
+[distutils.commands]
+alias = setuptools.command.alias:alias
+bdist_egg = setuptools.command.bdist_egg:bdist_egg
+bdist_rpm = setuptools.command.bdist_rpm:bdist_rpm
+bdist_wheel = setuptools.command.bdist_wheel:bdist_wheel
+build = setuptools.command.build:build
+build_clib = setuptools.command.build_clib:build_clib
+build_ext = setuptools.command.build_ext:build_ext
+build_py = setuptools.command.build_py:build_py
+develop = setuptools.command.develop:develop
+dist_info = setuptools.command.dist_info:dist_info
+easy_install = setuptools.command.easy_install:easy_install
+editable_wheel = setuptools.command.editable_wheel:editable_wheel
+egg_info = setuptools.command.egg_info:egg_info
+install = setuptools.command.install:install
+install_egg_info = setuptools.command.install_egg_info:install_egg_info
+install_lib = setuptools.command.install_lib:install_lib
+install_scripts = setuptools.command.install_scripts:install_scripts
+rotate = setuptools.command.rotate:rotate
+saveopts = setuptools.command.saveopts:saveopts
+sdist = setuptools.command.sdist:sdist
+setopt = setuptools.command.setopt:setopt
+
+[distutils.setup_keywords]
+dependency_links = setuptools.dist:assert_string_list
+eager_resources = setuptools.dist:assert_string_list
+entry_points = setuptools.dist:check_entry_points
+exclude_package_data = setuptools.dist:check_package_data
+extras_require = setuptools.dist:check_extras
+include_package_data = setuptools.dist:assert_bool
+install_requires = setuptools.dist:check_requirements
+namespace_packages = setuptools.dist:check_nsp
+package_data = setuptools.dist:check_package_data
+packages = setuptools.dist:check_packages
+python_requires = setuptools.dist:check_specifier
+setup_requires = setuptools.dist:check_requirements
+use_2to3 = setuptools.dist:invalid_unless_false
+zip_safe = setuptools.dist:assert_bool
+
+[egg_info.writers]
+PKG-INFO = setuptools.command.egg_info:write_pkg_info
+dependency_links.txt = setuptools.command.egg_info:overwrite_arg
+eager_resources.txt = setuptools.command.egg_info:overwrite_arg
+entry_points.txt = setuptools.command.egg_info:write_entries
+namespace_packages.txt = setuptools.command.egg_info:overwrite_arg
+requires.txt = setuptools.command.egg_info:write_requirements
+top_level.txt = setuptools.command.egg_info:write_toplevel_names
+
+[setuptools.finalize_distribution_options]
+keywords = setuptools.dist:Distribution._finalize_setup_keywords
+parent_finalize = setuptools.dist:_Distribution.finalize_options

parrot/lib/python3.10/site-packages/setuptools-75.8.0-py3.10.egg-info/requires.txt

@@ -0,0 +1,85 @@
+
+[certs]
+
+[check]
+pytest-checkdocs>=2.4
+
+[check:sys_platform != "cygwin"]
+pytest-ruff>=0.2.1
+ruff>=0.8.0
+
+[core]
+packaging>=24.2
+more_itertools>=8.8
+jaraco.text>=3.7
+wheel>=0.43.0
+platformdirs>=4.2.2
+jaraco.collections
+jaraco.functools>=4
+packaging
+more_itertools
+
+[core:python_version < "3.10"]
+importlib_metadata>=6
+
+[core:python_version < "3.11"]
+tomli>=2.0.1
+
+[cover]
+pytest-cov
+
+[doc]
+sphinx>=3.5
+jaraco.packaging>=9.3
+rst.linker>=1.9
+furo
+sphinx-lint
+jaraco.tidelift>=1.4
+pygments-github-lexers==0.0.5
+sphinx-favicon
+sphinx-inline-tabs
+sphinx-reredirects
+sphinxcontrib-towncrier
+sphinx-notfound-page<2,>=1
+pyproject-hooks!=1.1
+towncrier<24.7
+
+[enabler]
+pytest-enabler>=2.2
+
+[ssl]
+
+[test]
+pytest!=8.1.*,>=6
+virtualenv>=13.0.0
+wheel>=0.44.0
+pip>=19.1
+packaging>=24.2
+jaraco.envs>=2.2
+pytest-xdist>=3
+jaraco.path>=3.7.2
+build[virtualenv]>=1.0.3
+filelock>=3.4.0
+ini2toml[lite]>=0.14
+tomli-w>=1.0.0
+pytest-timeout
+pytest-home>=0.5
+pytest-subprocess
+pyproject-hooks!=1.1
+jaraco.test>=5.5
+
+[test:python_version >= "3.9" and sys_platform != "cygwin"]
+jaraco.develop>=7.21
+
+[test:sys_platform != "cygwin"]
+pytest-perf
+
+[type]
+pytest-mypy
+mypy==1.14.*
+
+[type:python_version < "3.10"]
+importlib_metadata>=7.0.2
+
+[type:sys_platform != "cygwin"]
+jaraco.develop>=7.21

parrot/lib/python3.10/site-packages/setuptools-75.8.0-py3.10.egg-info/top_level.txt

@@ -0,0 +1,3 @@
+_distutils_hack
+pkg_resources
+setuptools

parrot/lib/python3.10/site-packages/shellingham/__init__.py

@@ -0,0 +1,23 @@
+import importlib
+import os
+
+from ._core import ShellDetectionFailure
+
+__version__ = "1.5.4"
+
+
+def detect_shell(pid=None, max_depth=10):
+    name = os.name
+    try:
+        impl = importlib.import_module(".{}".format(name), __name__)
+    except ImportError:
+        message = "Shell detection not implemented for {0!r}".format(name)
+        raise RuntimeError(message)
+    try:
+        get_shell = impl.get_shell
+    except AttributeError:
+        raise RuntimeError("get_shell not implemented for {0!r}".format(name))
+    shell = get_shell(pid, max_depth=max_depth)
+    if shell:
+        return shell
+    raise ShellDetectionFailure()