semvec/pypi-packages huggingface dataset:
goose-talk-to-me 0.3.2
A voice interaction plugin for your goose
Requires Python: >=3.10

# Goose-Talk-To-Me

A voice interaction plugin for your [goose](https://github.com/square/goose/tree/main). This project
leverages a local copy of Whisper for voice interaction and transcription.

## Project Description

Goose-Talk-To-Me is a project dedicated to enabling voice interactions using state-of-the-art AI
technologies. It uses tools and libraries like `goose-ai`, `openai-whisper`, `sounddevice`, and
others to provide seamless voice processing capabilities.

## Features

- Voice Interaction using `goose-ai`
- Voice to text transcription
- Real-time voice processing
- Text to speech using `pyttsx4`

## Requirements

- Python >= 3.12
- `goose-ai`
- `openai-whisper`
- `sounddevice`
- `soundfile`
- `numpy`
- `scipy`
- `torch`
- `numba`
- `more-itertools`
- `ffmpeg`
- `pyttsx4`

## Installation

Install the dependencies and prepare your environment:

### Linux

```bash
sudo apt update && sudo apt install espeak ffmpeg libespeak1 portaudio19-dev
pipx install goose & install goose-talk-to-me

### MacOS
```bash
brew install ffmpeg
brew install portaudio
pipx install goose & install goose-talk-to-me  --include-deps
```

## Usage

To use `goose-talk-to-me`, follow these steps:

1. add talk-to-me toolkit to a profile `~/.config/goose/profiles.yaml`
2. start a new goose session with the profile
3. ask goose to talk to you

```
time-tracker 0.5.3
CLI to track time spent on tasks using pomodoro technique
Requires Python: >=3.11

# `time-tracker`

Time tracker cli

**Usage**:

```console
$ time-tracker [OPTIONS] COMMAND [ARGS]...
```

**Options**:

* `--install-completion`: Install completion for the current shell.
* `--show-completion`: Show completion for the current shell, to copy it or customize the installation.
* `--help`: Show this message and exit.

**Commands**:

* `log`
* `track`: Run depending on mode

## `tt log`

**Usage**:

```console
$ time-tracker log [OPTIONS]
```

**Options**:

* `-l, --last`: Open last log file  [default: False]
* `-o, --output`: Return log file content to terminal  [default: False]
* `--help`: Show this message and exit.

## `tt track`

Run depending on mode

**Usage**:

```console
$ tt track [OPTIONS]
```

**Options**:

* `-w, --workDuration INTEGER`: Set work time (minutes)  [default: 25]
* `-b, --breakDuration INTEGER`: Set break time (minutes)  [default: 5]
* `-B, --bigBreakDuration INTEGER`: Set break time (minutes)  [default: 30]
* `-m, --mode [manual|pomodoro]`: Set pomodoro mode. This will change the flow of work to 4 work sessions with small breaks and finish with a big Break  [default: pomodoro]
* `-p, --prompt`: Set if it should prompt to go for next session  [default: True]
* `--help`: Show this message and exit.
interactive-terminal 0.2
An interactive terminal question and answer module.

# Interactive Terminal

`interactive_terminal` is a Python module that provides an easy-to-use interface for creating interactive command-line applications. With this module, developers can ask various types of questions, including text input, lists, confirmations, numeric inputs, ranges, and choices, all while validating user responses for a smooth user experience.

## Features

- Supports multiple question types:
  - **Text Input**: For open-ended questions.
  - **List Selection**: Allows users to choose from a list of options.
  - **Confirmation**: Simple yes/no questions.
  - **Numeric Input**: For getting numeric responses.
  - **Range Selection**: For selecting a range of values.
  - **Choice Selection**: For picking one option from multiple choices.
- Input validation to ensure accurate and meaningful user responses.
- Easy integration into Python applications.

## Installation

You can install the `interactive_terminal` module using `pip`. Open your terminal or command prompt and run:

```bash
pip install interactive_terminal
```

## Usage

To use the `interactive_terminal` module, follow these steps:

1. **Import the necessary classes** from the module.
2. **Define the questions** you want to ask using the `Question` class.
3. **Call the `ask_questions` function** to prompt the user and collect their responses.

### Example

Here's a simple example demonstrating how to use the `interactive_terminal` module:

```python
from interactive_terminal import Question, QuestionType, ask_questions

def main():
    questions = [
        Question(QuestionType.TEXT, "name", "What is your name?"),
        Question(QuestionType.LIST, "favorite_color", "What is your favorite color?", 
                 options=["Red", "Blue", "Green", "Yellow"]),
        Question(QuestionType.CONFIRM, "like_programming", "Do you like programming?"),
        Question(QuestionType.NUMBER, "experience_years", "How many years have you been programming?"),
        Question(QuestionType.RANGE, "age_range", "What is your age range?", 
                 options=["0-18", "19-30", "31-45", "46+"]),
        Question(QuestionType.CHOICE, "os_choice", "Which operating system do you prefer?",
                 options=["Windows", "macOS", "Linux"])
    ]
    
    answers = ask_questions(questions)
    print("\nThank you for your answers! Here's what you provided:")
    for key, value in answers.items():
        print(f"{key.capitalize()}: {value}")

if __name__ == "__main__":
    main()
```

### Output

When you run the example code, it will prompt the user with a series of questions, like so:

```plaintext
[?] What is your name?:
```

The user can respond with their name, and the program will continue asking the rest of the questions in sequence, validating their input as specified.

## Contributing

Contributions are welcome! If you have suggestions for improvements or new features, please email me and I will think about your request.

## License

This project is licensed under the MIT License. See the LICENSE file for details.