Delete myvenv

myvenv/bin/Activate.ps1

@@ -1,247 +0,0 @@
-<#
-.Synopsis
-Activate a Python virtual environment for the current PowerShell session.
-
-.Description
-Pushes the python executable for a virtual environment to the front of the
-$Env:PATH environment variable and sets the prompt to signify that you are
-in a Python virtual environment. Makes use of the command line switches as
-well as the `pyvenv.cfg` file values present in the virtual environment.
-
-.Parameter VenvDir
-Path to the directory that contains the virtual environment to activate. The
-default value for this is the parent of the directory that the Activate.ps1
-script is located within.
-
-.Parameter Prompt
-The prompt prefix to display when this virtual environment is activated. By
-default, this prompt is the name of the virtual environment folder (VenvDir)
-surrounded by parentheses and followed by a single space (ie. '(.venv) ').
-
-.Example
-Activate.ps1
-Activates the Python virtual environment that contains the Activate.ps1 script.
-
-.Example
-Activate.ps1 -Verbose
-Activates the Python virtual environment that contains the Activate.ps1 script,
-and shows extra information about the activation as it executes.
-
-.Example
-Activate.ps1 -VenvDir C:\Users\MyUser\Common\.venv
-Activates the Python virtual environment located in the specified location.
-
-.Example
-Activate.ps1 -Prompt "MyPython"
-Activates the Python virtual environment that contains the Activate.ps1 script,
-and prefixes the current prompt with the specified string (surrounded in
-parentheses) while the virtual environment is active.
-
-.Notes
-On Windows, it may be required to enable this Activate.ps1 script by setting the
-execution policy for the user. You can do this by issuing the following PowerShell
-command:
-
-PS C:\> Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser
-
-For more information on Execution Policies: 
-https://go.microsoft.com/fwlink/?LinkID=135170
-
-#>
-Param(
-    [Parameter(Mandatory = $false)]
-    [String]
-    $VenvDir,
-    [Parameter(Mandatory = $false)]
-    [String]
-    $Prompt
-)
-
-<# Function declarations --------------------------------------------------- #>
-
-<#
-.Synopsis
-Remove all shell session elements added by the Activate script, including the
-addition of the virtual environment's Python executable from the beginning of
-the PATH variable.
-
-.Parameter NonDestructive
-If present, do not remove this function from the global namespace for the
-session.
-
-#>
-function global:deactivate ([switch]$NonDestructive) {
-    # Revert to original values
-
-    # The prior prompt:
-    if (Test-Path -Path Function:_OLD_VIRTUAL_PROMPT) {
-        Copy-Item -Path Function:_OLD_VIRTUAL_PROMPT -Destination Function:prompt
-        Remove-Item -Path Function:_OLD_VIRTUAL_PROMPT
-    }
-
-    # The prior PYTHONHOME:
-    if (Test-Path -Path Env:_OLD_VIRTUAL_PYTHONHOME) {
-        Copy-Item -Path Env:_OLD_VIRTUAL_PYTHONHOME -Destination Env:PYTHONHOME
-        Remove-Item -Path Env:_OLD_VIRTUAL_PYTHONHOME
-    }
-
-    # The prior PATH:
-    if (Test-Path -Path Env:_OLD_VIRTUAL_PATH) {
-        Copy-Item -Path Env:_OLD_VIRTUAL_PATH -Destination Env:PATH
-        Remove-Item -Path Env:_OLD_VIRTUAL_PATH
-    }
-
-    # Just remove the VIRTUAL_ENV altogether:
-    if (Test-Path -Path Env:VIRTUAL_ENV) {
-        Remove-Item -Path env:VIRTUAL_ENV
-    }
-
-    # Just remove VIRTUAL_ENV_PROMPT altogether.
-    if (Test-Path -Path Env:VIRTUAL_ENV_PROMPT) {
-        Remove-Item -Path env:VIRTUAL_ENV_PROMPT
-    }
-
-    # Just remove the _PYTHON_VENV_PROMPT_PREFIX altogether:
-    if (Get-Variable -Name "_PYTHON_VENV_PROMPT_PREFIX" -ErrorAction SilentlyContinue) {
-        Remove-Variable -Name _PYTHON_VENV_PROMPT_PREFIX -Scope Global -Force
-    }
-
-    # Leave deactivate function in the global namespace if requested:
-    if (-not $NonDestructive) {
-        Remove-Item -Path function:deactivate
-    }
-}
-
-<#
-.Description
-Get-PyVenvConfig parses the values from the pyvenv.cfg file located in the
-given folder, and returns them in a map.
-
-For each line in the pyvenv.cfg file, if that line can be parsed into exactly
-two strings separated by `=` (with any amount of whitespace surrounding the =)
-then it is considered a `key = value` line. The left hand string is the key,
-the right hand is the value.
-
-If the value starts with a `'` or a `"` then the first and last character is
-stripped from the value before being captured.
-
-.Parameter ConfigDir
-Path to the directory that contains the `pyvenv.cfg` file.
-#>
-function Get-PyVenvConfig(
-    [String]
-    $ConfigDir
-) {
-    Write-Verbose "Given ConfigDir=$ConfigDir, obtain values in pyvenv.cfg"
-
-    # Ensure the file exists, and issue a warning if it doesn't (but still allow the function to continue).
-    $pyvenvConfigPath = Join-Path -Resolve -Path $ConfigDir -ChildPath 'pyvenv.cfg' -ErrorAction Continue
-
-    # An empty map will be returned if no config file is found.
-    $pyvenvConfig = @{ }
-
-    if ($pyvenvConfigPath) {
-
-        Write-Verbose "File exists, parse `key = value` lines"
-        $pyvenvConfigContent = Get-Content -Path $pyvenvConfigPath
-
-        $pyvenvConfigContent | ForEach-Object {
-            $keyval = $PSItem -split "\s*=\s*", 2
-            if ($keyval[0] -and $keyval[1]) {
-                $val = $keyval[1]
-
-                # Remove extraneous quotations around a string value.
-                if ("'""".Contains($val.Substring(0, 1))) {
-                    $val = $val.Substring(1, $val.Length - 2)
-                }
-
-                $pyvenvConfig[$keyval[0]] = $val
-                Write-Verbose "Adding Key: '$($keyval[0])'='$val'"
-            }
-        }
-    }
-    return $pyvenvConfig
-}
-
-
-<# Begin Activate script --------------------------------------------------- #>
-
-# Determine the containing directory of this script
-$VenvExecPath = Split-Path -Parent $MyInvocation.MyCommand.Definition
-$VenvExecDir = Get-Item -Path $VenvExecPath
-
-Write-Verbose "Activation script is located in path: '$VenvExecPath'"
-Write-Verbose "VenvExecDir Fullname: '$($VenvExecDir.FullName)"
-Write-Verbose "VenvExecDir Name: '$($VenvExecDir.Name)"
-
-# Set values required in priority: CmdLine, ConfigFile, Default
-# First, get the location of the virtual environment, it might not be
-# VenvExecDir if specified on the command line.
-if ($VenvDir) {
-    Write-Verbose "VenvDir given as parameter, using '$VenvDir' to determine values"
-}
-else {
-    Write-Verbose "VenvDir not given as a parameter, using parent directory name as VenvDir."
-    $VenvDir = $VenvExecDir.Parent.FullName.TrimEnd("\\/")
-    Write-Verbose "VenvDir=$VenvDir"
-}
-
-# Next, read the `pyvenv.cfg` file to determine any required value such
-# as `prompt`.
-$pyvenvCfg = Get-PyVenvConfig -ConfigDir $VenvDir
-
-# Next, set the prompt from the command line, or the config file, or
-# just use the name of the virtual environment folder.
-if ($Prompt) {
-    Write-Verbose "Prompt specified as argument, using '$Prompt'"
-}
-else {
-    Write-Verbose "Prompt not specified as argument to script, checking pyvenv.cfg value"
-    if ($pyvenvCfg -and $pyvenvCfg['prompt']) {
-        Write-Verbose "  Setting based on value in pyvenv.cfg='$($pyvenvCfg['prompt'])'"
-        $Prompt = $pyvenvCfg['prompt'];
-    }
-    else {
-        Write-Verbose "  Setting prompt based on parent's directory's name. (Is the directory name passed to venv module when creating the virtual environment)"
-        Write-Verbose "  Got leaf-name of $VenvDir='$(Split-Path -Path $venvDir -Leaf)'"
-        $Prompt = Split-Path -Path $venvDir -Leaf
-    }
-}
-
-Write-Verbose "Prompt = '$Prompt'"
-Write-Verbose "VenvDir='$VenvDir'"
-
-# Deactivate any currently active virtual environment, but leave the
-# deactivate function in place.
-deactivate -nondestructive
-
-# Now set the environment variable VIRTUAL_ENV, used by many tools to determine
-# that there is an activated venv.
-$env:VIRTUAL_ENV = $VenvDir
-
-if (-not $Env:VIRTUAL_ENV_DISABLE_PROMPT) {
-
-    Write-Verbose "Setting prompt to '$Prompt'"
-
-    # Set the prompt to include the env name
-    # Make sure _OLD_VIRTUAL_PROMPT is global
-    function global:_OLD_VIRTUAL_PROMPT { "" }
-    Copy-Item -Path function:prompt -Destination function:_OLD_VIRTUAL_PROMPT
-    New-Variable -Name _PYTHON_VENV_PROMPT_PREFIX -Description "Python virtual environment prompt prefix" -Scope Global -Option ReadOnly -Visibility Public -Value $Prompt
-
-    function global:prompt {
-        Write-Host -NoNewline -ForegroundColor Green "($_PYTHON_VENV_PROMPT_PREFIX) "
-        _OLD_VIRTUAL_PROMPT
-    }
-    $env:VIRTUAL_ENV_PROMPT = $Prompt
-}
-
-# Clear PYTHONHOME
-if (Test-Path -Path Env:PYTHONHOME) {
-    Copy-Item -Path Env:PYTHONHOME -Destination Env:_OLD_VIRTUAL_PYTHONHOME
-    Remove-Item -Path Env:PYTHONHOME
-}
-
-# Add the venv to the PATH
-Copy-Item -Path Env:PATH -Destination Env:_OLD_VIRTUAL_PATH
-$Env:PATH = "$VenvExecDir$([System.IO.Path]::PathSeparator)$Env:PATH"

myvenv/bin/activate

@@ -1,70 +0,0 @@
-# This file must be used with "source bin/activate" *from bash*
-# You cannot run it directly
-
-deactivate () {
-    # reset old environment variables
-    if [ -n "${_OLD_VIRTUAL_PATH:-}" ] ; then
-        PATH="${_OLD_VIRTUAL_PATH:-}"
-        export PATH
-        unset _OLD_VIRTUAL_PATH
-    fi
-    if [ -n "${_OLD_VIRTUAL_PYTHONHOME:-}" ] ; then
-        PYTHONHOME="${_OLD_VIRTUAL_PYTHONHOME:-}"
-        export PYTHONHOME
-        unset _OLD_VIRTUAL_PYTHONHOME
-    fi
-
-    # Call hash to forget past commands. Without forgetting
-    # past commands the $PATH changes we made may not be respected
-    hash -r 2> /dev/null
-
-    if [ -n "${_OLD_VIRTUAL_PS1:-}" ] ; then
-        PS1="${_OLD_VIRTUAL_PS1:-}"
-        export PS1
-        unset _OLD_VIRTUAL_PS1
-    fi
-
-    unset VIRTUAL_ENV
-    unset VIRTUAL_ENV_PROMPT
-    if [ ! "${1:-}" = "nondestructive" ] ; then
-    # Self destruct!
-        unset -f deactivate
-    fi
-}
-
-# unset irrelevant variables
-deactivate nondestructive
-
-# on Windows, a path can contain colons and backslashes and has to be converted:
-if [ "${OSTYPE:-}" = "cygwin" ] || [ "${OSTYPE:-}" = "msys" ] ; then
-    # transform D:\path\to\venv to /d/path/to/venv on MSYS
-    # and to /cygdrive/d/path/to/venv on Cygwin
-    export VIRTUAL_ENV=$(cygpath /home/coldstrel/Documents/model-rmt-draft/myvenv)
-else
-    # use the path as-is
-    export VIRTUAL_ENV=/home/coldstrel/Documents/model-rmt-draft/myvenv
-fi
-
-_OLD_VIRTUAL_PATH="$PATH"
-PATH="$VIRTUAL_ENV/"bin":$PATH"
-export PATH
-
-# unset PYTHONHOME if set
-# this will fail if PYTHONHOME is set to the empty string (which is bad anyway)
-# could use `if (set -u; : $PYTHONHOME) ;` in bash
-if [ -n "${PYTHONHOME:-}" ] ; then
-    _OLD_VIRTUAL_PYTHONHOME="${PYTHONHOME:-}"
-    unset PYTHONHOME
-fi
-
-if [ -z "${VIRTUAL_ENV_DISABLE_PROMPT:-}" ] ; then
-    _OLD_VIRTUAL_PS1="${PS1:-}"
-    PS1='(myvenv) '"${PS1:-}"
-    export PS1
-    VIRTUAL_ENV_PROMPT='(myvenv) '
-    export VIRTUAL_ENV_PROMPT
-fi
-
-# Call hash to forget past commands. Without forgetting
-# past commands the $PATH changes we made may not be respected
-hash -r 2> /dev/null

myvenv/bin/activate.csh

@@ -1,27 +0,0 @@
-# This file must be used with "source bin/activate.csh" *from csh*.
-# You cannot run it directly.
-
-# Created by Davide Di Blasi <[email protected]>.
-# Ported to Python 3.3 venv by Andrew Svetlov <[email protected]>
-
-alias deactivate 'test $?_OLD_VIRTUAL_PATH != 0 && setenv PATH "$_OLD_VIRTUAL_PATH" && unset _OLD_VIRTUAL_PATH; rehash; test $?_OLD_VIRTUAL_PROMPT != 0 && set prompt="$_OLD_VIRTUAL_PROMPT" && unset _OLD_VIRTUAL_PROMPT; unsetenv VIRTUAL_ENV; unsetenv VIRTUAL_ENV_PROMPT; test "\!:*" != "nondestructive" && unalias deactivate'
-
-# Unset irrelevant variables.
-deactivate nondestructive
-
-setenv VIRTUAL_ENV /home/coldstrel/Documents/model-rmt-draft/myvenv
-
-set _OLD_VIRTUAL_PATH="$PATH"
-setenv PATH "$VIRTUAL_ENV/"bin":$PATH"
-
-
-set _OLD_VIRTUAL_PROMPT="$prompt"
-
-if (! "$?VIRTUAL_ENV_DISABLE_PROMPT") then
-    set prompt = '(myvenv) '"$prompt"
-    setenv VIRTUAL_ENV_PROMPT '(myvenv) '
-endif
-
-alias pydoc python -m pydoc
-
-rehash

myvenv/bin/activate.fish

@@ -1,69 +0,0 @@
-# This file must be used with "source <venv>/bin/activate.fish" *from fish*
-# (https://fishshell.com/). You cannot run it directly.
-
-function deactivate  -d "Exit virtual environment and return to normal shell environment"
-    # reset old environment variables
-    if test -n "$_OLD_VIRTUAL_PATH"
-        set -gx PATH $_OLD_VIRTUAL_PATH
-        set -e _OLD_VIRTUAL_PATH
-    end
-    if test -n "$_OLD_VIRTUAL_PYTHONHOME"
-        set -gx PYTHONHOME $_OLD_VIRTUAL_PYTHONHOME
-        set -e _OLD_VIRTUAL_PYTHONHOME
-    end
-
-    if test -n "$_OLD_FISH_PROMPT_OVERRIDE"
-        set -e _OLD_FISH_PROMPT_OVERRIDE
-        # prevents error when using nested fish instances (Issue #93858)
-        if functions -q _old_fish_prompt
-            functions -e fish_prompt
-            functions -c _old_fish_prompt fish_prompt
-            functions -e _old_fish_prompt
-        end
-    end
-
-    set -e VIRTUAL_ENV
-    set -e VIRTUAL_ENV_PROMPT
-    if test "$argv[1]" != "nondestructive"
-        # Self-destruct!
-        functions -e deactivate
-    end
-end
-
-# Unset irrelevant variables.
-deactivate nondestructive
-
-set -gx VIRTUAL_ENV /home/coldstrel/Documents/model-rmt-draft/myvenv
-
-set -gx _OLD_VIRTUAL_PATH $PATH
-set -gx PATH "$VIRTUAL_ENV/"bin $PATH
-
-# Unset PYTHONHOME if set.
-if set -q PYTHONHOME
-    set -gx _OLD_VIRTUAL_PYTHONHOME $PYTHONHOME
-    set -e PYTHONHOME
-end
-
-if test -z "$VIRTUAL_ENV_DISABLE_PROMPT"
-    # fish uses a function instead of an env var to generate the prompt.
-
-    # Save the current fish_prompt function as the function _old_fish_prompt.
-    functions -c fish_prompt _old_fish_prompt
-
-    # With the original prompt function renamed, we can override with our own.
-    function fish_prompt
-        # Save the return status of the last command.
-        set -l old_status $status
-
-        # Output the venv prompt; color taken from the blue of the Python logo.
-        printf "%s%s%s" (set_color 4B8BBE) '(myvenv) ' (set_color normal)
-
-        # Restore the return status of the previous command.
-        echo "exit $old_status" | .
-        # Output the original/"old" prompt.
-        _old_fish_prompt
-    end
-
-    set -gx _OLD_FISH_PROMPT_OVERRIDE "$VIRTUAL_ENV"
-    set -gx VIRTUAL_ENV_PROMPT '(myvenv) '
-end

myvenv/bin/huggingface-cli

@@ -1,8 +0,0 @@
-#!/home/coldstrel/Documents/model-rmt-draft/myvenv/bin/python3
-# -*- coding: utf-8 -*-
-import re
-import sys
-from huggingface_hub.commands.huggingface_cli import main
-if __name__ == '__main__':
-    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
-    sys.exit(main())

myvenv/bin/normalizer

@@ -1,8 +0,0 @@
-#!/home/coldstrel/Documents/model-rmt-draft/myvenv/bin/python3
-# -*- coding: utf-8 -*-
-import re
-import sys
-from charset_normalizer import cli
-if __name__ == '__main__':
-    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
-    sys.exit(cli.cli_detect())

myvenv/bin/pip

@@ -1,8 +0,0 @@
-#!/home/coldstrel/Documents/model-rmt-draft/myvenv/bin/python3
-# -*- coding: utf-8 -*-
-import re
-import sys
-from pip._internal.cli.main import main
-if __name__ == '__main__':
-    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
-    sys.exit(main())

myvenv/bin/pip3

@@ -1,8 +0,0 @@
-#!/home/coldstrel/Documents/model-rmt-draft/myvenv/bin/python3
-# -*- coding: utf-8 -*-
-import re
-import sys
-from pip._internal.cli.main import main
-if __name__ == '__main__':
-    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
-    sys.exit(main())

myvenv/bin/pip3.12

@@ -1,8 +0,0 @@
-#!/home/coldstrel/Documents/model-rmt-draft/myvenv/bin/python3
-# -*- coding: utf-8 -*-
-import re
-import sys
-from pip._internal.cli.main import main
-if __name__ == '__main__':
-    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
-    sys.exit(main())

myvenv/bin/python

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

myvenv/bin/python3

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

myvenv/bin/python3.12

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

myvenv/bin/tiny-agents

@@ -1,8 +0,0 @@
-#!/home/coldstrel/Documents/model-rmt-draft/myvenv/bin/python3
-# -*- coding: utf-8 -*-
-import re
-import sys
-from huggingface_hub.inference._mcp.cli import app
-if __name__ == '__main__':
-    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
-    sys.exit(app())

myvenv/bin/tqdm

@@ -1,8 +0,0 @@
-#!/home/coldstrel/Documents/model-rmt-draft/myvenv/bin/python3
-# -*- coding: utf-8 -*-
-import re
-import sys
-from tqdm.cli import main
-if __name__ == '__main__':
-    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
-    sys.exit(main())

myvenv/lib/python3.12/site-packages/InquirerPy/__init__.py

@@ -1,2 +0,0 @@
-from InquirerPy.resolver import prompt, prompt_async
-from InquirerPy.utils import get_style

myvenv/lib/python3.12/site-packages/InquirerPy/base/__init__.py

@@ -1,15 +0,0 @@
-"""Module contains base class for prompts.
-
-BaseSimplePrompt ← InputPrompt ← SecretPrompt ...
-        ↑
-BaseComplexPrompt
-        ↑
-BaseListPrompt ← FuzzyPrompt
-        ↑
-ListPrompt ← ExpandPrompt ...
-"""
-
-from .complex import BaseComplexPrompt, FakeDocument
-from .control import Choice, InquirerPyUIListControl
-from .list import BaseListPrompt
-from .simple import BaseSimplePrompt

myvenv/lib/python3.12/site-packages/InquirerPy/base/complex.py

@@ -1,294 +0,0 @@
-"""Contains the interface class :class:`.BaseComplexPrompt` for more complex prompts and the mocked document class :class:`.FakeDocument`."""
-import shutil
-from dataclasses import dataclass
-from typing import Any, Callable, List, Optional, Tuple, Union
-
-from prompt_toolkit.application import Application
-from prompt_toolkit.enums import EditingMode
-from prompt_toolkit.filters.base import Condition, FilterOrBool
-from prompt_toolkit.key_binding.key_bindings import KeyHandlerCallable
-from prompt_toolkit.keys import Keys
-
-from InquirerPy.base.simple import BaseSimplePrompt
-from InquirerPy.enum import INQUIRERPY_KEYBOARD_INTERRUPT
-from InquirerPy.utils import (
-    InquirerPySessionResult,
-    InquirerPyStyle,
-    InquirerPyValidate,
-)
-
-
-@dataclass
-class FakeDocument:
-    """A fake `prompt_toolkit` document class.
-
-    Work around to allow non-buffer type :class:`~prompt_toolkit.layout.UIControl` to use
-    :class:`~prompt_toolkit.validation.Validator`.
-
-    Args:
-        text: Content to be validated.
-        cursor_position: Fake cursor position.
-    """
-
-    text: str
-    cursor_position: int = 0
-
-
-class BaseComplexPrompt(BaseSimplePrompt):
-    """A base class to create a more complex prompt that will involve :class:`~prompt_toolkit.application.Application`.
-
-    Note:
-        This class does not create :class:`~prompt_toolkit.layout.Layout` nor :class:`~prompt_toolkit.application.Application`,
-        it only contains the necessary attributes and helper functions to be consumed.
-
-    Note:
-        Use :class:`~InquirerPy.base.BaseListPrompt` to create a complex list prompt which involves multiple choices. It has
-        more methods and helper function implemented.
-
-    See Also:
-        :class:`~InquirerPy.base.BaseListPrompt`
-        :class:`~InquirerPy.prompts.fuzzy.FuzzyPrompt`
-    """
-
-    def __init__(
-        self,
-        message: Union[str, Callable[[InquirerPySessionResult], str]],
-        style: Optional[InquirerPyStyle] = None,
-        border: bool = False,
-        vi_mode: bool = False,
-        qmark: str = "?",
-        amark: str = "?",
-        instruction: str = "",
-        long_instruction: str = "",
-        transformer: Optional[Callable[[Any], Any]] = None,
-        filter: Optional[Callable[[Any], Any]] = None,
-        validate: Optional[InquirerPyValidate] = None,
-        invalid_message: str = "Invalid input",
-        wrap_lines: bool = True,
-        raise_keyboard_interrupt: bool = True,
-        mandatory: bool = True,
-        mandatory_message: str = "Mandatory prompt",
-        session_result: Optional[InquirerPySessionResult] = None,
-    ) -> None:
-        super().__init__(
-            message=message,
-            style=style,
-            vi_mode=vi_mode,
-            qmark=qmark,
-            amark=amark,
-            instruction=instruction,
-            transformer=transformer,
-            filter=filter,
-            invalid_message=invalid_message,
-            validate=validate,
-            wrap_lines=wrap_lines,
-            raise_keyboard_interrupt=raise_keyboard_interrupt,
-            mandatory=mandatory,
-            mandatory_message=mandatory_message,
-            session_result=session_result,
-        )
-        self._invalid_message = invalid_message
-        self._rendered = False
-        self._invalid = False
-        self._loading = False
-        self._application: Application
-        self._long_instruction = long_instruction
-        self._border = border
-        self._height_offset = 2  # prev prompt result + current prompt question
-        if self._border:
-            self._height_offset += 2
-        if self._long_instruction:
-            self._height_offset += 1
-        self._validation_window_bottom_offset = 0 if not self._long_instruction else 1
-        if self._wrap_lines:
-            self._validation_window_bottom_offset += (
-                self.extra_long_instruction_line_count
-            )
-
-        self._is_vim_edit = Condition(lambda: self._editing_mode == EditingMode.VI)
-        self._is_invalid = Condition(lambda: self._invalid)
-        self._is_displaying_long_instruction = Condition(
-            lambda: self._long_instruction != ""
-        )
-
-    def _redraw(self) -> None:
-        """Redraw the application UI."""
-        self._application.invalidate()
-
-    def register_kb(
-        self, *keys: Union[Keys, str], filter: FilterOrBool = True
-    ) -> Callable[[KeyHandlerCallable], KeyHandlerCallable]:
-        """Decorate keybinding registration function.
-
-        Ensure that the `invalid` state is cleared on next keybinding entered.
-        """
-        kb_dec = super().register_kb(*keys, filter=filter)
-
-        def decorator(func: KeyHandlerCallable) -> KeyHandlerCallable:
-            @kb_dec
-            def executable(event):
-                if self._invalid:
-                    self._invalid = False
-                func(event)
-
-            return executable
-
-        return decorator
-
-    def _exception_handler(self, _, context) -> None:
-        """Set exception handler for the event loop.
-
-        Skip the question and raise exception.
-
-        Args:
-            loop: Current event loop.
-            context: Exception context.
-        """
-        self._status["answered"] = True
-        self._status["result"] = INQUIRERPY_KEYBOARD_INTERRUPT
-        self._status["skipped"] = True
-        self._application.exit(exception=context["exception"])
-
-    def _after_render(self, app: Optional[Application]) -> None:
-        """Run after the :class:`~prompt_toolkit.application.Application` is rendered/updated.
-
-        Since this function is fired up on each render, adding a check on `self._rendered` to
-        process logics that should only run once.
-
-        Set event loop exception handler here, since its guaranteed that the event loop is running
-        in `_after_render`.
-        """
-        if not self._rendered:
-            self._rendered = True
-
-            self._keybinding_factory()
-            self._on_rendered(app)
-
-    def _set_error(self, message: str) -> None:
-        """Set error message and set invalid state.
-
-        Args:
-            message: Error message to display.
-        """
-        self._invalid_message = message
-        self._invalid = True
-
-    def _get_error_message(self) -> List[Tuple[str, str]]:
-        """Obtain the error message dynamically.
-
-        Returns:
-            FormattedText in list of tuple format.
-        """
-        return [
-            (
-                "class:validation-toolbar",
-                self._invalid_message,
-            )
-        ]
-
-    def _on_rendered(self, _: Optional[Application]) -> None:
-        """Run once after the UI is rendered. Acts like `ComponentDidMount`."""
-        pass
-
-    def _get_prompt_message(self) -> List[Tuple[str, str]]:
-        """Get the prompt message to display.
-
-        Returns:
-            Formatted text in list of tuple format.
-        """
-        pre_answer = (
-            "class:instruction",
-            " %s " % self.instruction if self.instruction else " ",
-        )
-        post_answer = ("class:answer", " %s" % self.status["result"])
-        return super()._get_prompt_message(pre_answer, post_answer)
-
-    def _run(self) -> Any:
-        """Run the application."""
-        return self.application.run()
-
-    async def _run_async(self) -> None:
-        """Run the application asynchronously."""
-        return await self.application.run_async()
-
-    @property
-    def application(self) -> Application:
-        """Get the application.
-
-        :class:`.BaseComplexPrompt` requires :attr:`.BaseComplexPrompt._application` to be defined since this class
-        doesn't implement :class:`~prompt_toolkit.layout.Layout` and :class:`~prompt_toolkit.application.Application`.
-
-        Raises:
-            NotImplementedError: When `self._application` is not defined.
-        """
-        if not self._application:
-            raise NotImplementedError
-        return self._application
-
-    @application.setter
-    def application(self, value: Application) -> None:
-        self._application = value
-
-    @property
-    def height_offset(self) -> int:
-        """int: Height offset to apply."""
-        if not self._wrap_lines:
-            return self._height_offset
-        return self.extra_line_count + self._height_offset
-
-    @property
-    def total_message_length(self) -> int:
-        """int: Total length of the message."""
-        total_message_length = 0
-        if self._qmark:
-            total_message_length += len(self._qmark)
-            total_message_length += 1  # Extra space if qmark is present
-        total_message_length += len(str(self._message))
-        total_message_length += 1  # Extra space between message and instruction
-        total_message_length += len(str(self._instruction))
-        if self._instruction:
-            total_message_length += 1  # Extra space behind the instruction
-        return total_message_length
-
-    @property
-    def extra_message_line_count(self) -> int:
-        """int: Get the extra lines created caused by line wrapping.
-
-        Minus 1 on the totoal message length as we only want the extra line.
-        24 // 24 will equal to 1 however we only want the value to be 1 when we have 25 char
-        which will create an extra line.
-        """
-        term_width, _ = shutil.get_terminal_size()
-        return (self.total_message_length - 1) // term_width
-
-    @property
-    def extra_long_instruction_line_count(self) -> int:
-        """int: Get the extra lines created caused by line wrapping.
-
-        See Also:
-            :attr:`.BaseComplexPrompt.extra_message_line_count`
-        """
-        if self._long_instruction:
-            term_width, _ = shutil.get_terminal_size()
-            return (len(self._long_instruction) - 1) // term_width
-        else:
-            return 0
-
-    @property
-    def extra_line_count(self) -> int:
-        """Get the extra lines created caused by line wrapping.
-
-        Used mainly to calculate how much additional offset should be applied when getting
-        the height.
-
-        Returns:
-            Total extra lines created due to line wrapping.
-        """
-        result = 0
-
-        # message wrap
-        result += self.extra_message_line_count
-        # long instruction wrap
-        result += self.extra_long_instruction_line_count
-
-        return result

myvenv/lib/python3.12/site-packages/InquirerPy/base/control.py

@@ -1,227 +0,0 @@
-"""Contains the content control class :class:`.InquirerPyUIListControl`."""
-from abc import abstractmethod
-from dataclasses import asdict, dataclass
-from typing import Any, Callable, Dict, List, Optional, Tuple, cast
-
-from prompt_toolkit.layout.controls import FormattedTextControl
-
-from InquirerPy.exceptions import InvalidArgument, RequiredKeyNotFound
-from InquirerPy.separator import Separator
-from InquirerPy.utils import InquirerPyListChoices, InquirerPySessionResult
-
-__all__ = ["Choice", "InquirerPyUIListControl"]
-
-
-@dataclass
-class Choice:
-    """Class to create choices for list type prompts.
-
-    A simple dataclass that can be used as an alternate to using :class:`dict`
-    when working with choices.
-
-    Args:
-        value: The value of the choice when user selects this choice.
-        name: The value that should be presented to the user prior/after selection of the choice.
-            This value is optional, if not provided, it will fallback to the string representation of `value`.
-        enabled: Indicates if the choice should be pre-selected.
-            This only has effects when the prompt has `multiselect` enabled.
-    """
-
-    value: Any
-    name: Optional[str] = None
-    enabled: bool = False
-
-    def __post_init__(self):
-        """Assign strinify value to name if not present."""
-        if self.name is None:
-            self.name = str(self.value)
-
-
-class InquirerPyUIListControl(FormattedTextControl):
-    """A base class to create :class:`~prompt_toolkit.layout.UIControl` to display list type contents.
-
-    Args:
-        choices(InquirerPyListChoices): List of choices to display as the content.
-            Can also be a callable or async callable that returns a list of choices.
-        default: Default value, this will affect the cursor position.
-        multiselect: Indicate if the current prompt has `multiselect` enabled.
-        session_result: Current session result.
-    """
-
-    def __init__(
-        self,
-        choices: InquirerPyListChoices,
-        default: Any = None,
-        multiselect: bool = False,
-        session_result: Optional[InquirerPySessionResult] = None,
-    ) -> None:
-        self._session_result = session_result or {}
-        self._selected_choice_index: int = 0
-        self._choice_func = None
-        self._multiselect = multiselect
-        self._default = (
-            default
-            if not isinstance(default, Callable)
-            else cast(Callable, default)(self._session_result)
-        )
-        self._raw_choices = (
-            choices
-            if not isinstance(choices, Callable)
-            else cast(Callable, choices)(self._session_result)
-        )
-        self._choices = self._get_choices(self._raw_choices, self._default)
-        self._safety_check()
-        self._format_choices()
-        super().__init__(self._get_formatted_choices)
-
-    def _get_choices(self, choices: List[Any], default: Any) -> List[Dict[str, Any]]:
-        """Process the raw user input choices and format it into dictionary.
-
-        Args:
-            choices: List of chices to display.
-            default: Default value, this will affect the :attr:`.InquirerPyUIListControl.selected_choice_index`
-
-        Returns:
-            List of choices.
-
-        Raises:
-            RequiredKeyNotFound: When the provided choice is missing the `name` or `value` key.
-        """
-        processed_choices: List[Dict[str, Any]] = []
-        try:
-            for index, choice in enumerate(choices, start=0):
-                if isinstance(choice, dict):
-                    if choice["value"] == default:
-                        self.selected_choice_index = index
-                    processed_choices.append(
-                        {
-                            "name": str(choice["name"]),
-                            "value": choice["value"],
-                            "enabled": choice.get("enabled", False)
-                            if self._multiselect
-                            else False,
-                        }
-                    )
-                elif isinstance(choice, Separator):
-                    if self.selected_choice_index == index:
-                        self.selected_choice_index = (
-                            self.selected_choice_index + 1
-                        ) % len(choices)
-                    processed_choices.append(
-                        {"name": str(choice), "value": choice, "enabled": False}
-                    )
-                elif isinstance(choice, Choice):
-                    dict_choice = asdict(choice)
-                    if dict_choice["value"] == default:
-                        self.selected_choice_index = index
-                    if not self._multiselect:
-                        dict_choice["enabled"] = False
-                    processed_choices.append(dict_choice)
-                else:
-                    if choice == default:
-                        self.selected_choice_index = index
-                    processed_choices.append(
-                        {"name": str(choice), "value": choice, "enabled": False}
-                    )
-        except KeyError:
-            raise RequiredKeyNotFound(
-                "dictionary type of choice require a 'name' key and a 'value' key"
-            )
-        return processed_choices
-
-    @property
-    def selected_choice_index(self) -> int:
-        """int: Current highlighted index."""
-        return self._selected_choice_index
-
-    @selected_choice_index.setter
-    def selected_choice_index(self, value: int) -> None:
-        self._selected_choice_index = value
-
-    @property
-    def choices(self) -> List[Dict[str, Any]]:
-        """List[Dict[str, Any]]: Get all processed choices."""
-        return self._choices
-
-    @choices.setter
-    def choices(self, value: List[Dict[str, Any]]) -> None:
-        self._choices = value
-
-    def _safety_check(self) -> None:
-        """Validate processed choices.
-
-        Check if the choices are empty or if it only contains :class:`~InquirerPy.separator.Separator`.
-        """
-        if not self.choices:
-            raise InvalidArgument("argument choices cannot be empty")
-        should_proceed: bool = False
-        for choice in self.choices:
-            if not isinstance(choice["value"], Separator):
-                should_proceed = True
-                break
-        if not should_proceed:
-            raise InvalidArgument(
-                "argument choices should contain choices other than separator"
-            )
-
-    def _get_formatted_choices(self) -> List[Tuple[str, str]]:
-        """Get all choices in formatted text format.
-
-        Returns:
-            List of choices in formatted text form.
-        """
-        display_choices = []
-
-        for index, choice in enumerate(self.choices):
-            if index == self.selected_choice_index:
-                display_choices += self._get_hover_text(choice)
-            else:
-                display_choices += self._get_normal_text(choice)
-            display_choices.append(("", "\n"))
-        if display_choices:
-            display_choices.pop()
-        return display_choices
-
-    def _format_choices(self) -> None:
-        """Perform post processing on the choices.
-
-        Additional customisation to the choices after :meth:`.InquirerPyUIListControl._get_choices` call.
-        """
-        pass
-
-    @abstractmethod
-    def _get_hover_text(self, choice) -> List[Tuple[str, str]]:
-        """Generate the formatted text for hovered choice.
-
-        Returns:
-            Formatted text in list of tuple format.
-        """
-        pass
-
-    @abstractmethod
-    def _get_normal_text(self, choice) -> List[Tuple[str, str]]:
-        """Generate the formatted text for non-hovered choices.
-
-        Returns:
-            Formatted text in list of tuple format.
-        """
-        pass
-
-    @property
-    def choice_count(self) -> int:
-        """int: Total count of choices."""
-        return len(self.choices)
-
-    @property
-    def selection(self) -> Dict[str, Any]:
-        """Dict[str, Any]: Current selected choice."""
-        return self.choices[self.selected_choice_index]
-
-    @property
-    def loading(self) -> bool:
-        """bool: Indicate if the content control is loading."""
-        return self._loading
-
-    @loading.setter
-    def loading(self, value: bool) -> None:
-        self._loading = value

myvenv/lib/python3.12/site-packages/InquirerPy/base/list.py

@@ -1,238 +0,0 @@
-"""Contains the base class :class:`.BaseListPrompt` which can be used to create a prompt involving choices."""
-from abc import abstractmethod
-from typing import Any, Callable, List, Optional
-
-from prompt_toolkit.filters.base import Condition
-from prompt_toolkit.keys import Keys
-
-from InquirerPy.base.complex import BaseComplexPrompt
-from InquirerPy.base.control import InquirerPyUIListControl
-from InquirerPy.separator import Separator
-from InquirerPy.utils import (
-    InquirerPyKeybindings,
-    InquirerPyMessage,
-    InquirerPySessionResult,
-    InquirerPyStyle,
-    InquirerPyValidate,
-)
-
-
-class BaseListPrompt(BaseComplexPrompt):
-    """A base class to create a complex prompt involving choice selections (i.e. list) using `prompt_toolkit` Application.
-
-    Note:
-        This class does not create :class:`~prompt_toolkit.layout.Layout` nor :class:`~prompt_toolkit.application.Application`,
-        it only contains the necessary attributes and helper functions to be consumed.
-
-    See Also:
-        :class:`~InquirerPy.prompts.list.ListPrompt`
-        :class:`~InquirerPy.prompts.fuzzy.FuzzyPrompt`
-    """
-
-    def __init__(
-        self,
-        message: InquirerPyMessage,
-        style: Optional[InquirerPyStyle] = None,
-        vi_mode: bool = False,
-        qmark: str = "?",
-        amark: str = "?",
-        instruction: str = "",
-        long_instruction: str = "",
-        border: bool = False,
-        transformer: Optional[Callable[[Any], Any]] = None,
-        filter: Optional[Callable[[Any], Any]] = None,
-        validate: Optional[InquirerPyValidate] = None,
-        invalid_message: str = "Invalid input",
-        multiselect: bool = False,
-        keybindings: Optional[InquirerPyKeybindings] = None,
-        cycle: bool = True,
-        wrap_lines: bool = True,
-        raise_keyboard_interrupt: bool = True,
-        mandatory: bool = True,
-        mandatory_message: str = "Mandatory prompt",
-        session_result: Optional[InquirerPySessionResult] = None,
-    ) -> None:
-        super().__init__(
-            message=message,
-            style=style,
-            border=border,
-            vi_mode=vi_mode,
-            qmark=qmark,
-            amark=amark,
-            transformer=transformer,
-            filter=filter,
-            invalid_message=invalid_message,
-            validate=validate,
-            instruction=instruction,
-            long_instruction=long_instruction,
-            wrap_lines=wrap_lines,
-            raise_keyboard_interrupt=raise_keyboard_interrupt,
-            mandatory=mandatory,
-            mandatory_message=mandatory_message,
-            session_result=session_result,
-        )
-
-        self._content_control: InquirerPyUIListControl
-        self._multiselect = multiselect
-        self._is_multiselect = Condition(lambda: self._multiselect)
-        self._cycle = cycle
-
-        if not keybindings:
-            keybindings = {}
-
-        self.kb_maps = {
-            "down": [
-                {"key": "down"},
-                {"key": "c-n", "filter": ~self._is_vim_edit},
-                {"key": "j", "filter": self._is_vim_edit},
-            ],
-            "up": [
-                {"key": "up"},
-                {"key": "c-p", "filter": ~self._is_vim_edit},
-                {"key": "k", "filter": self._is_vim_edit},
-            ],
-            "toggle": [
-                {"key": "space"},
-            ],
-            "toggle-down": [
-                {"key": Keys.Tab},
-            ],
-            "toggle-up": [
-                {"key": Keys.BackTab},
-            ],
-            "toggle-all": [
-                {"key": "alt-r"},
-                {"key": "c-r"},
-            ],
-            "toggle-all-true": [
-                {"key": "alt-a"},
-                {"key": "c-a"},
-            ],
-            "toggle-all-false": [],
-            **keybindings,
-        }
-
-        self.kb_func_lookup = {
-            "down": [{"func": self._handle_down}],
-            "up": [{"func": self._handle_up}],
-            "toggle": [{"func": self._handle_toggle_choice}],
-            "toggle-down": [
-                {"func": self._handle_toggle_choice},
-                {"func": self._handle_down},
-            ],
-            "toggle-up": [
-                {"func": self._handle_toggle_choice},
-                {"func": self._handle_up},
-            ],
-            "toggle-all": [{"func": self._handle_toggle_all}],
-            "toggle-all-true": [{"func": self._handle_toggle_all, "args": [True]}],
-            "toggle-all-false": [{"func": self._handle_toggle_all, "args": [False]}],
-        }
-
-    @property
-    def content_control(self) -> InquirerPyUIListControl:
-        """Get the content controller object.
-
-        Needs to be an instance of :class:`~InquirerPy.base.control.InquirerPyUIListControl`.
-
-        Each :class:`.BaseComplexPrompt` requires a `content_control` to display custom
-        contents for the prompt.
-
-        Raises:
-            NotImplementedError: When `self._content_control` is not found.
-        """
-        if not self._content_control:
-            raise NotImplementedError
-        return self._content_control
-
-    @content_control.setter
-    def content_control(self, value: InquirerPyUIListControl) -> None:
-        self._content_control = value
-
-    @property
-    def result_name(self) -> Any:
-        """Get the result value that should be printed to the terminal.
-
-        In multiselect scenario, return result as a list.
-        """
-        if self._multiselect:
-            return [choice["name"] for choice in self.selected_choices]
-        else:
-            try:
-                return self.content_control.selection["name"]
-            except IndexError:
-                return ""
-
-    @property
-    def result_value(self) -> Any:
-        """Get the result value that should return to the user.
-
-        In multiselect scenario, return result as a list.
-        """
-        if self._multiselect:
-            return [choice["value"] for choice in self.selected_choices]
-        else:
-            try:
-                return self.content_control.selection["value"]
-            except IndexError:
-                return ""
-
-    @property
-    def selected_choices(self) -> List[Any]:
-        """List[Any]: Get all user selected choices."""
-
-        def filter_choice(choice):
-            return not isinstance(choice, Separator) and choice["enabled"]
-
-        return list(filter(filter_choice, self.content_control.choices))
-
-    def _handle_down(self, _) -> bool:
-        """Handle event when user attempts to move down.
-
-        Returns:
-            Boolean indicating if the action hits the cap.
-        """
-        if self._cycle:
-            self.content_control.selected_choice_index = (
-                self.content_control.selected_choice_index + 1
-            ) % self.content_control.choice_count
-            return False
-        else:
-            self.content_control.selected_choice_index += 1
-            if (
-                self.content_control.selected_choice_index
-                >= self.content_control.choice_count
-            ):
-                self.content_control.selected_choice_index = (
-                    self.content_control.choice_count - 1
-                )
-                return True
-            return False
-
-    def _handle_up(self, _) -> bool:
-        """Handle event when user attempts to move up.
-
-        Returns:
-            Boolean indicating if the action hits the cap.
-        """
-        if self._cycle:
-            self.content_control.selected_choice_index = (
-                self.content_control.selected_choice_index - 1
-            ) % self.content_control.choice_count
-            return False
-        else:
-            self.content_control.selected_choice_index -= 1
-            if self.content_control.selected_choice_index < 0:
-                self.content_control.selected_choice_index = 0
-                return True
-            return False
-
-    @abstractmethod
-    def _handle_toggle_choice(self, event) -> None:
-        """Handle event when user attempting to toggle the state of the chocie."""
-        pass
-
-    @abstractmethod
-    def _handle_toggle_all(self, event, value: bool) -> None:
-        """Handle event when user attempting to alter the state of all choices."""
-        pass

myvenv/lib/python3.12/site-packages/InquirerPy/base/simple.py

@@ -1,378 +0,0 @@
-"""Contains the base class :class:`.BaseSimplePrompt`."""
-import os
-import re
-from abc import ABC, abstractmethod
-from typing import (
-    TYPE_CHECKING,
-    Any,
-    Callable,
-    Dict,
-    List,
-    Optional,
-    Tuple,
-    Union,
-    cast,
-)
-
-from prompt_toolkit.enums import EditingMode
-from prompt_toolkit.filters.base import Condition, FilterOrBool
-from prompt_toolkit.key_binding.key_bindings import KeyBindings, KeyHandlerCallable
-from prompt_toolkit.keys import Keys
-from prompt_toolkit.styles.style import Style
-from prompt_toolkit.validation import Validator
-
-from InquirerPy.enum import INQUIRERPY_KEYBOARD_INTERRUPT
-from InquirerPy.exceptions import RequiredKeyNotFound
-from InquirerPy.utils import (
-    InquirerPyMessage,
-    InquirerPySessionResult,
-    InquirerPyStyle,
-    InquirerPyValidate,
-    get_style,
-)
-
-if TYPE_CHECKING:
-    from prompt_toolkit.key_binding.key_processor import KeyPressEvent
-
-
-class BaseSimplePrompt(ABC):
-    """The base class to create a simple terminal input prompt.
-
-    Note:
-        No actual :class:`~prompt_toolkit.application.Application` is created by this class.
-        This class only creates some common interface and attributes that can be easily used
-        by `prompt_toolkit`.
-
-        To have a functional prompt, you'll at least have to implement the :meth:`.BaseSimplePrompt._run`
-        and :meth:`.BaseSimplePrompt._get_prompt_message`.
-
-    See Also:
-        :class:`~InquirerPy.prompts.input.InputPrompt`
-    """
-
-    def __init__(
-        self,
-        message: InquirerPyMessage,
-        style: Optional[InquirerPyStyle] = None,
-        vi_mode: bool = False,
-        qmark: str = "?",
-        amark: str = "?",
-        instruction: str = "",
-        validate: Optional[InquirerPyValidate] = None,
-        invalid_message: str = "Invalid input",
-        transformer: Optional[Callable[[Any], Any]] = None,
-        filter: Optional[Callable[[Any], Any]] = None,
-        default: Any = "",
-        wrap_lines: bool = True,
-        raise_keyboard_interrupt: bool = True,
-        mandatory: bool = True,
-        mandatory_message: str = "Mandatory prompt",
-        session_result: Optional[InquirerPySessionResult] = None,
-    ) -> None:
-        self._mandatory = mandatory
-        self._mandatory_message = mandatory_message
-        self._result = session_result or {}
-        self._message = (
-            message
-            if not isinstance(message, Callable)
-            else cast(Callable, message)(self._result)
-        )
-        self._instruction = instruction
-        self._default = (
-            default if not isinstance(default, Callable) else default(self._result)
-        )
-        self._style = Style.from_dict(style.dict if style else get_style().dict)
-        self._qmark = qmark
-        self._amark = amark
-        self._status = {"answered": False, "result": None, "skipped": False}
-        self._kb = KeyBindings()
-        self._lexer = "class:input"
-        self._transformer = transformer
-        self._filter = filter
-        self._wrap_lines = wrap_lines
-        self._editing_mode = (
-            EditingMode.VI
-            if vi_mode or bool(os.getenv("INQUIRERPY_VI_MODE", False))
-            else EditingMode.EMACS
-        )
-        if isinstance(validate, Validator):
-            self._validator = validate
-        else:
-            self._validator = Validator.from_callable(
-                validate if validate else lambda _: True,
-                invalid_message,
-                move_cursor_to_end=True,
-            )
-        self._raise_kbi = not os.getenv(
-            "INQUIRERPY_NO_RAISE_KBI", not raise_keyboard_interrupt
-        )
-        self._is_rasing_kbi = Condition(lambda: self._raise_kbi)
-
-        self._kb_maps = {
-            "answer": [{"key": Keys.Enter}],
-            "interrupt": [
-                {"key": "c-c", "filter": self._is_rasing_kbi},
-                {"key": "c-d", "filter": ~self._is_rasing_kbi},
-            ],
-            "skip": [{"key": "c-z"}, {"key": "c-c", "filter": ~self._is_rasing_kbi}],
-        }
-        self._kb_func_lookup = {
-            "answer": [{"func": self._handle_enter}],
-            "interrupt": [{"func": self._handle_interrupt}],
-            "skip": [{"func": self._handle_skip}],
-        }
-
-    def _keybinding_factory(self):
-        """Register all keybindings in `self._kb_maps`.
-
-        It's required to call this function at the end of prompt constructor if
-        it inherits from :class:`~InquirerPy.base.simple.BaseSimplePrompt` or
-        :class:`~InquirerPy.base.complex.BaseComplexPrompt`.
-        """
-
-        def _factory(keys, filter, action):
-            if action not in self.kb_func_lookup:
-                raise RequiredKeyNotFound(f"keybinding action {action} not found")
-            if not isinstance(keys, list):
-                keys = [keys]
-
-            @self.register_kb(*keys, filter=filter)
-            def _(event):
-                for method in self.kb_func_lookup[action]:
-                    method["func"](event, *method.get("args", []))
-
-        for key, item in self.kb_maps.items():
-            if not isinstance(item, list):
-                item = [item]
-            for kb in item:
-                _factory(kb["key"], kb.get("filter", Condition(lambda: True)), key)
-
-    @abstractmethod
-    def _set_error(self, message: str) -> None:
-        """Set the error message for the prompt.
-
-        Args:
-            message: Error message to set.
-        """
-        pass
-
-    def _handle_skip(self, event: Optional["KeyPressEvent"]) -> None:
-        """Handle the event when attempting to skip a prompt.
-
-        Skip the prompt if the `_mandatory` field is False, otherwise
-        show an error message that the prompt cannot be skipped.
-        """
-        if not self._mandatory:
-            self.status["answered"] = True
-            self.status["skipped"] = True
-            self.status["result"] = None
-            if event:
-                event.app.exit(result=None)
-        else:
-            self._set_error(message=self._mandatory_message)
-
-    def _handle_interrupt(self, event: Optional["KeyPressEvent"]) -> None:
-        """Handle the event when a KeyboardInterrupt signal is sent."""
-        self.status["answered"] = True
-        self.status["result"] = INQUIRERPY_KEYBOARD_INTERRUPT
-        self.status["skipped"] = True
-        if event:
-            event.app.exit(result=INQUIRERPY_KEYBOARD_INTERRUPT)
-
-    @abstractmethod
-    def _handle_enter(self, event: Optional["KeyPressEvent"]) -> None:
-        """Handle the event when user attempt to answer the question."""
-        pass
-
-    @property
-    def status(self) -> Dict[str, Any]:
-        """Dict[str, Any]: Get current prompt status.
-
-        The status contains 3 keys: "answered" and "result".
-            answered: If the current prompt is answered.
-            result: The result of the user answer.
-            skipped: If the prompt is skipped.
-        """
-        return self._status
-
-    @status.setter
-    def status(self, value) -> None:
-        self._status = value
-
-    def register_kb(
-        self, *keys: Union[Keys, str], filter: FilterOrBool = True, **kwargs
-    ) -> Callable[[KeyHandlerCallable], KeyHandlerCallable]:
-        """Keybinding registration decorator.
-
-        This decorator wraps around the :meth:`prompt_toolkit.key_binding.KeyBindings.add` with
-        added feature to process `alt` realted keybindings.
-
-        By default, `prompt_toolkit` doesn't process `alt` related keybindings,
-        it requires `alt-ANY` to `escape` + `ANY`.
-
-        Args:
-            keys: The keys to bind that can trigger the function.
-            filter: :class:`~prompt_toolkit.filter.Condition` to indicate if this keybinding should be active.
-
-        Returns:
-            A decorator that should be applied to the function thats intended to be active when the keys
-            are pressed.
-
-        Examples:
-            >>> @self.register_kb("alt-j")
-            ... def test(event):
-            ...     pass
-        """
-        alt_pattern = re.compile(r"^alt-(.*)")
-
-        def decorator(func: KeyHandlerCallable) -> KeyHandlerCallable:
-            formatted_keys = []
-            for key in keys:
-                match = alt_pattern.match(key)
-                if match:
-                    formatted_keys.append("escape")
-                    formatted_keys.append(match.group(1))
-                else:
-                    formatted_keys.append(key)
-
-            @self._kb.add(*formatted_keys, filter=filter, **kwargs)
-            def executable(event) -> None:
-                func(event)
-
-            return executable
-
-        return decorator
-
-    @abstractmethod
-    def _get_prompt_message(
-        self, pre_answer: Tuple[str, str], post_answer: Tuple[str, str]
-    ) -> List[Tuple[str, str]]:
-        """Get the question message in formatted text form to display in the prompt.
-
-        This function is mainly used to render the question message dynamically based
-        on the current status (answered or not answered) of the prompt.
-
-        Note:
-            The function requires implementation when inheriting :class:`.BaseSimplePrompt`.
-            You should call `super()._get_prompt_message(pre_answer, post_answer)` in
-            the implemented `_get_prompt_message`.
-
-        Args:
-            pre_answer: The message to display before the question is answered.
-            post_answer: The information to display after the question is answered.
-
-        Returns:
-            Formatted text in list of tuple format.
-        """
-        display_message = []
-        if self.status["skipped"]:
-            display_message.append(("class:skipped", self._qmark))
-            display_message.append(
-                ("class:skipped", "%s%s " % (" " if self._qmark else "", self._message))
-            )
-        elif self.status["answered"]:
-            display_message.append(("class:answermark", self._amark))
-            display_message.append(
-                (
-                    "class:answered_question",
-                    "%s%s" % (" " if self._amark else "", self._message),
-                )
-            )
-            display_message.append(
-                post_answer
-                if not self._transformer
-                else (
-                    "class:answer",
-                    " %s" % self._transformer(self.status["result"]),
-                )
-            )
-        else:
-            display_message.append(("class:questionmark", self._qmark))
-            display_message.append(
-                (
-                    "class:question",
-                    "%s%s" % (" " if self._qmark else "", self._message),
-                )
-            )
-            display_message.append(pre_answer)
-        return display_message
-
-    @abstractmethod
-    def _run(self) -> Any:
-        """Abstractmethod to enforce a run function is implemented.
-
-        All prompt instance requires a `_run` call to initialise and run an instance of
-        `PromptSession` or `Application`.
-        """
-        pass
-
-    @abstractmethod
-    async def _run_async(self) -> Any:
-        """Abstractmethod to enforce a run function is implemented.
-
-        All prompt instance requires a `_run_async` call to initialise and run an instance of
-        `PromptSession` or `Application`.
-        """
-        pass
-
-    def execute(self, raise_keyboard_interrupt: Optional[bool] = None) -> Any:
-        """Run the prompt and get the result.
-
-        Args:
-            raise_keyboard_interrupt: **Deprecated**. Set this parameter on the prompt initialisation instead.
-
-        Returns:
-            Value of the user answer. Types varies depending on the prompt.
-
-        Raises:
-            KeyboardInterrupt: When `ctrl-c` is pressed and `raise_keyboard_interrupt` is True.
-        """
-        result = self._run()
-        if raise_keyboard_interrupt is not None:
-            self._raise_kbi = not os.getenv(
-                "INQUIRERPY_NO_RAISE_KBI", not raise_keyboard_interrupt
-            )
-        if result == INQUIRERPY_KEYBOARD_INTERRUPT:
-            raise KeyboardInterrupt
-        if not self._filter:
-            return result
-        return self._filter(result)
-
-    async def execute_async(self) -> None:
-        """Run the prompt asynchronously and get the result.
-
-        Returns:
-            Value of the user answer. Types varies depending on the prompt.
-
-        Raises:
-            KeyboardInterrupt: When `ctrl-c` is pressed and `raise_keyboard_interrupt` is True.
-        """
-        result = await self._run_async()
-        if result == INQUIRERPY_KEYBOARD_INTERRUPT:
-            raise KeyboardInterrupt
-        if not self._filter:
-            return result
-        return self._filter(result)
-
-    @property
-    def instruction(self) -> str:
-        """str: Instruction to display next to question."""
-        return self._instruction
-
-    @property
-    def kb_maps(self) -> Dict[str, Any]:
-        """Dict[str, Any]: Keybinding mappings."""
-        return self._kb_maps
-
-    @kb_maps.setter
-    def kb_maps(self, value: Dict[str, Any]) -> None:
-        self._kb_maps = {**self._kb_maps, **value}
-
-    @property
-    def kb_func_lookup(self) -> Dict[str, Any]:
-        """Dict[str, Any]: Keybinding function lookup mappings.."""
-        return self._kb_func_lookup
-
-    @kb_func_lookup.setter
-    def kb_func_lookup(self, value: Dict[str, Any]) -> None:
-        self._kb_func_lookup = {**self._kb_func_lookup, **value}

myvenv/lib/python3.12/site-packages/InquirerPy/containers/__init__.py

@@ -1 +0,0 @@
-from .spinner import SpinnerWindow

myvenv/lib/python3.12/site-packages/InquirerPy/containers/instruction.py

@@ -1,38 +0,0 @@
-"""Module contains :class:`.InstructionWindow` which can be used to display long instructions."""
-
-from typing import TYPE_CHECKING
-
-from prompt_toolkit.layout.containers import ConditionalContainer, Window
-from prompt_toolkit.layout.controls import FormattedTextControl
-
-if TYPE_CHECKING:
-    from prompt_toolkit.filters.base import FilterOrBool
-    from prompt_toolkit.formatted_text.base import AnyFormattedText
-
-
-class InstructionWindow(ConditionalContainer):
-    """Conditional `prompt_toolkit` :class:`~prompt_toolkit.layout.Window` that displays long instructions.
-
-    Args:
-        message: Long instructions to display.
-        filter: Condition to display the instruction window.
-    """
-
-    def __init__(self, message: str, filter: "FilterOrBool", **kwargs) -> None:
-        self._message = message
-        super().__init__(
-            Window(
-                FormattedTextControl(text=self._get_message),
-                dont_extend_height=True,
-                **kwargs
-            ),
-            filter=filter,
-        )
-
-    def _get_message(self) -> "AnyFormattedText":
-        """Get long instruction to display.
-
-        Returns:
-            FormattedText in list of tuple format.
-        """
-        return [("class:long_instruction", self._message)]

myvenv/lib/python3.12/site-packages/InquirerPy/containers/message.py

@@ -1,42 +0,0 @@
-"""Module contains the main message window :class:`~prompt_toolkit.container.Container`."""
-
-from typing import TYPE_CHECKING
-
-from prompt_toolkit.layout.containers import ConditionalContainer, Window
-from prompt_toolkit.layout.controls import FormattedTextControl
-from prompt_toolkit.layout.dimension import LayoutDimension
-
-if TYPE_CHECKING:
-    from prompt_toolkit.filters.base import FilterOrBool
-    from prompt_toolkit.formatted_text.base import AnyFormattedText
-
-
-class MessageWindow(ConditionalContainer):
-    """Main window to display question to the user.
-
-    Args:
-        message: The message to display in the terminal.
-        filter: Condition that this message window should be displayed.
-            Use a loading condition to only display this window while its not loading.
-        wrap_lines: Enable line wrapping if the message is too long.
-        show_cursor: Display cursor.
-    """
-
-    def __init__(
-        self,
-        message: "AnyFormattedText",
-        filter: "FilterOrBool",
-        wrap_lines: bool = True,
-        show_cursor: bool = True,
-        **kwargs
-    ) -> None:
-        super().__init__(
-            content=Window(
-                height=LayoutDimension.exact(1) if not wrap_lines else None,
-                content=FormattedTextControl(message, show_cursor=show_cursor),
-                wrap_lines=wrap_lines,
-                dont_extend_height=True,
-                **kwargs
-            ),
-            filter=filter,
-        )

myvenv/lib/python3.12/site-packages/InquirerPy/containers/spinner.py

@@ -1,108 +0,0 @@
-"""Module contains spinner related resources.
-
-Note:
-    The spinner is not a standalone spinner to run in the terminal
-    but rather a `prompt_toolkit` :class:`~prompt_toolkit.layout.Window` that displays a spinner.
-
-    Use library such as `yaspin <https://github.com/pavdmyt/yaspin>`_ if you need a plain spinner.
-"""
-import asyncio
-from typing import TYPE_CHECKING, Callable, List, NamedTuple, Optional, Tuple, Union
-
-from prompt_toolkit.filters.utils import to_filter
-from prompt_toolkit.layout.containers import ConditionalContainer, Window
-from prompt_toolkit.layout.controls import FormattedTextControl
-
-if TYPE_CHECKING:
-    from prompt_toolkit.filters.base import Filter
-
-__all__ = ["SPINNERS", "SpinnerWindow"]
-
-
-class SPINNERS(NamedTuple):
-    """Presets of spinner patterns.
-
-    See Also:
-        https://github.com/pavdmyt/yaspin/blob/master/yaspin/data/spinners.json
-
-    This only contains some basic ones thats ready to use. For more patterns, checkout the
-    URL above.
-
-    Examples:
-        >>> from InquirerPy import inquirer
-        >>> from InquirerPy.spinner import SPINNERS
-        >>> inquirer.select(message="", choices=lambda _: [1, 2, 3], spinner_pattern=SPINNERS.dots)
-    """
-
-    dots = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"]
-    dots2 = ["⣾", "⣽", "⣻", "⢿", "⡿", "⣟", "⣯", "⣷"]
-    line = ["-", "\\", "|", "/"]
-    line2 = ["⠂", "-", "–", "—", "–", "-"]
-    pipe = ["┤", "┘", "┴", "└", "├", "┌", "┬", "┐"]
-    star = ["✶", "✸", "✹", "✺", "✹", "✷"]
-    star2 = ["+", "x", "*"]
-    flip = ["_", "_", "_", "-", "`", "`", "'", "´", "-", "_", "_", "_"]
-    hamburger = ["☱", "☲", "☴"]
-    grow_vertical = ["▁", "▃", "▄", "▅", "▆", "▇", "▆", "▅", "▄", "▃"]
-    grow_horizontal = ["▏", "▎", "▍", "▌", "▋", "▊", "▉", "▊", "▋", "▌", "▍", "▎"]
-    box_bounce = ["▖", "▘", "▝", "▗"]
-    triangle = ["◢", "◣", "◤", "◥"]
-    arc = ["◜", "◠", "◝", "◞", "◡", "◟"]
-    circle = ["◡", "⊙", "◠"]
-
-
-class SpinnerWindow(ConditionalContainer):
-    """Conditional `prompt_toolkit` :class:`~prompt_toolkit.layout.Window` that displays a spinner.
-
-    Args:
-        loading: A :class:`~prompt_toolkit.filters.Condition` to indicate if the spinner should be visible.
-        redraw: A redraw function (i.e. :meth:`~prompt_toolkit.application.Application.invalidate`) to refresh the UI.
-        pattern: List of pattern to display as the spinner.
-        delay: Spinner refresh frequency.
-        text: Loading text to display.
-    """
-
-    def __init__(
-        self,
-        loading: "Filter",
-        redraw: Callable[[], None],
-        pattern: Optional[Union[List[str], SPINNERS]] = None,
-        delay: float = 0.1,
-        text: str = "",
-    ) -> None:
-        self._loading = to_filter(loading)
-        self._spinning = False
-        self._redraw = redraw
-        self._pattern = pattern or SPINNERS.line
-        self._char = self._pattern[0]
-        self._delay = delay
-        self._text = text or "Loading ..."
-
-        super().__init__(
-            content=Window(content=FormattedTextControl(text=self._get_text)),
-            filter=self._loading,
-        )
-
-    def _get_text(self) -> List[Tuple[str, str]]:
-        """Dynamically get the text for the :class:`~prompt_toolkit.layout.Window`.
-
-        Returns:
-            Formatted text.
-        """
-        return [
-            ("class:spinner_pattern", self._char),
-            ("", " "),
-            ("class:spinner_text", self._text),
-        ]
-
-    async def start(self) -> None:
-        """Start the spinner."""
-        if self._spinning:
-            return
-        self._spinning = True
-        while self._loading():
-            for char in self._pattern:
-                await asyncio.sleep(self._delay)
-                self._char = char
-                self._redraw()
-        self._spinning = False

myvenv/lib/python3.12/site-packages/InquirerPy/containers/validation.py

@@ -1,60 +0,0 @@
-"""Module contains :class:`.ValidationWindow` which can be used to display error."""
-
-from typing import Optional
-
-from prompt_toolkit.filters.base import FilterOrBool
-from prompt_toolkit.formatted_text.base import AnyFormattedText
-from prompt_toolkit.layout.containers import ConditionalContainer, Float, Window
-from prompt_toolkit.layout.controls import FormattedTextControl
-
-
-class ValidationWindow(ConditionalContainer):
-    """Conditional `prompt_toolkit` :class:`~prompt_toolkit.layout.Window` that displays error.
-
-    Args:
-        invalid_message: Error message to display when error occured.
-        filter: Condition to display the error window.
-    """
-
-    def __init__(
-        self, invalid_message: AnyFormattedText, filter: FilterOrBool, **kwargs
-    ) -> None:
-        super().__init__(
-            Window(
-                FormattedTextControl(invalid_message), dont_extend_height=True, **kwargs
-            ),
-            filter=filter,
-        )
-
-
-class ValidationFloat(Float):
-    """:class:`~prompt_toolkit.layout.Float` wrapper around :class:`.ValidationWindow`.
-
-    Args:
-        invalid_message: Error message to display when error occured.
-        filter: Condition to display the error window.
-        left: Distance to left.
-        right: Distance to right.
-        bottom: Distance to bottom.
-        top: Distance to top.
-    """
-
-    def __init__(
-        self,
-        invalid_message: AnyFormattedText,
-        filter: FilterOrBool,
-        left: Optional[int] = None,
-        right: Optional[int] = None,
-        bottom: Optional[int] = None,
-        top: Optional[int] = None,
-        **kwargs
-    ) -> None:
-        super().__init__(
-            content=ValidationWindow(
-                invalid_message=invalid_message, filter=filter, **kwargs
-            ),
-            left=left,
-            right=right,
-            bottom=bottom,
-            top=top,
-        )

myvenv/lib/python3.12/site-packages/InquirerPy/enum.py

@@ -1,7 +0,0 @@
-"""Module contains common constants."""
-INQUIRERPY_KEYBOARD_INTERRUPT: str = "INQUIRERPY_KEYBOARD_INTERRUPT"
-
-INQUIRERPY_POINTER_SEQUENCE: str = "\u276f"
-INQUIRERPY_FILL_CIRCLE_SEQUENCE: str = "\u25c9"
-INQUIRERPY_EMPTY_CIRCLE_SEQUENCE: str = "\u25cb"
-INQUIRERPY_QMARK_SEQUENCE: str = "\u003f"

myvenv/lib/python3.12/site-packages/InquirerPy/exceptions.py

@@ -1,25 +0,0 @@
-"""Module contains exceptions that will be raised by `InquirerPy`."""
-
-
-class InvalidArgument(Exception):
-    """Provided argument is invalid.
-
-    Args:
-        message: Exception message.
-    """
-
-    def __init__(self, message: str = "invalid argument"):
-        self._message = message
-        super().__init__(self._message)
-
-
-class RequiredKeyNotFound(Exception):
-    """Missing required keys in dictionary.
-
-    Args:
-        message: Exception message.
-    """
-
-    def __init__(self, message="required key not found"):
-        self.message = message
-        super().__init__(self.message)

myvenv/lib/python3.12/site-packages/InquirerPy/inquirer.py

@@ -1,17 +0,0 @@
-"""Servers as another entry point for `InquirerPy`.
-
-See Also:
-    :ref:`index:Alternate Syntax`.
-
-`inquirer` directly interact with individual prompt classes. It’s more flexible, easier to customise and also provides IDE type hintings/completions.
-"""
-from InquirerPy.prompts import CheckboxPrompt as checkbox
-from InquirerPy.prompts import ConfirmPrompt as confirm
-from InquirerPy.prompts import ExpandPrompt as expand
-from InquirerPy.prompts import FilePathPrompt as filepath
-from InquirerPy.prompts import FuzzyPrompt as fuzzy
-from InquirerPy.prompts import InputPrompt as text
-from InquirerPy.prompts import ListPrompt as select
-from InquirerPy.prompts import NumberPrompt as number
-from InquirerPy.prompts import RawlistPrompt as rawlist
-from InquirerPy.prompts import SecretPrompt as secret

myvenv/lib/python3.12/site-packages/InquirerPy/prompts/__init__.py

@@ -1,11 +0,0 @@
-"""Module contains import of all prompts classes."""
-from InquirerPy.prompts.checkbox import CheckboxPrompt
-from InquirerPy.prompts.confirm import ConfirmPrompt
-from InquirerPy.prompts.expand import ExpandPrompt
-from InquirerPy.prompts.filepath import FilePathPrompt
-from InquirerPy.prompts.fuzzy import FuzzyPrompt
-from InquirerPy.prompts.input import InputPrompt
-from InquirerPy.prompts.list import ListPrompt
-from InquirerPy.prompts.number import NumberPrompt
-from InquirerPy.prompts.rawlist import RawlistPrompt
-from InquirerPy.prompts.secret import SecretPrompt