semvec/pypi-packages huggingface dataset:
itemlist 0.1.5
CLI tool for selecting and executing functions.
Requires Python: >=3.7

# ItemList
**ItemList** provides a tool for selecting and executing functions in a CLI environment. It offers an intuitive interface for managing and executing multiple workflows or tasks efficiently.

#### **1. Simple Decorator-Based Integration**
- Functions can be added to the menu simply by using the **@item decorator**. It requires minimal changes to existing functions to integrate them into the CLI menu.

  **Example Code**:
  ```python
  @item # only this!
  def flow_runner():
      print("Flow 1 is running...")

  @item
  def flow2_runner():
      print("Flow 2 is running...")
  ```

![itemlist](https://github.com/user-attachments/assets/2a3ec397-ef90-4d44-a9df-c4a6b571cb6c)

#### **2. Intuitive CLI Interface**
- Utilizing the **curses** library, users can navigate through options smoothly with arrow keys or `j`/`k`. The currently selected item is displayed in bold for better visibility.

#### **3. Efficient Search Functionality**
- The menu includes a **search bar**, allowing users to filter options by function name or description. This makes it easy to quickly find the desired function, even among numerous options.

#### **4. Function Registration with Descriptions**
- Each function can be registered with an optional **description**. This allows users to easily understand the purpose or details of each task, reducing the chance of incorrect selections.

## Installation

```bash
pip install itemlist
```

## Usage

More details can be found in the [examples](https://github.com/Luftalian/itemlist/tree/main/examples) directory.

```python
from itemlist import item

@item
def flow_runner(description="Run the first flow"):
    run_locally(flow)

@item
def flow2_runner(description="Run the second flow"):
    run_locally(flow2)

@item
def flow3_runner(description="Run the third flow"):
    run_locally(flow3)

if __name__ == '__main__':
    selected = item.select()
    item.endwin()

    selected_name, selected_func, selected_func_description = selected

    if selected_func == item._cancel:
        print("Cancel selected. Exiting the program.")
    else:
        print(f"Running: {selected_name}\n")
        print(f"Description: {selected_func_description}\n")
        selected_func()
```

## License

[MIT License](https://github.com/Luftalian/itemlist/blob/main/LICENSE)
lucasdp 0.6.12
Modulos comunes para proyectos de datos

# Lucas's Ultimate Clear And Simplified Data Package
Conjunto de scripts para el desarrollo de soluciones de datos.

Este paquete proporciona scripts comunes que se pueden reutilizar en varios proyectos. Incluye funcionalidades para configuraciÃ³n de registros (logging) y conexiÃ³n a base de datos. 
<!-- y gestiÃ³n de correos electrÃ³nicos. -->

## Estructura del Proyecto

lucasdp/  
â”œâ”€â”€ init.py  

## Uso

### ConfiguraciÃ³n de Registros (logging)

```python
from prefect import flow, task

from lucasdp.log_tools import PrefectLogger

logger_global = PrefectLogger(__file__)

@task
def mi_tarea(mensaje_tarea: str = ""):
    logger = logger_global.obtener_logger_prefect()
    logger.info("Iniciando tarea...")
    logger.info("Hola %s desde la tarea", mensaje_tarea)
    
    # Cambio el archivo de salida
    logger = logger_global.cambiar_rotfile_handler_params(r"C:\src\logeo\logs\hola.log")
    logger.info("Tarea finalizada...")

@flow
def mi_flujo(mensaje_flujo: str = ""):
    logger = logger_global.obtener_logger_prefect()
    logger.info("Hola %s desde el flujo", mensaje_flujo)
    mi_tarea(mensaje_flujo)

if __name__ == '__main__':
    mi_flujo()
```

## Â¿Como colaborar en el proyecto?
### 1. Clonar el repositorio

```bash
git clone https://github.com/lucasdepetris/lucasdp.git
cd lucasdp
```

### 2. Crear una rama nueva
```bash
git checkout -b nombre_de_tu_rama
```

### 3. Realizar mejoras y hacer un commit
```bash
git add .
git commit -m "DescripciÃ³n clara de las mejoras realizadas"
```

### 4. Subir los cambios
```bash
git push origin nombre_de_tu_rama
```

### 5. Instalar
Ejecutar:
```bash
pip install git+https://github.com/lucasdepetris/lucasdp.git
```

## TODO

- [ ] Actualizar documentacion de nuevos modulos en este README

- [ ] Probar y mejorar manejador de scripts SQL.
    - [ ] Agregar ejemplo funcional
- [ ] Agregar modulo de configuraciÃ³n de emails.

<!-- ### ConfiguraciÃ³n de Correos

```python
# Uso del mÃ³dulo de gestiÃ³n de correos electrÃ³nicos
from commonscripts import emails_manager

emails_manager.send_email(recipient='destinatario@example.com', subject='Asunto', body='Cuerpo del correo')
``` -->
lanoel 0.1.2
A Secret Santa generator for groups of people.
Requires Python: <4.0,>=3.12

# La Noel (Secret Santa)

A Secret Santa generator for groups of people.

## Table of Contents

- [Installation](#installation)
- [Usage](#usage)
- [Features](#features)

## Installation

To install lanoel, run the following command:

```bash
pip install lanoel
```

## Usage

To use lanoel, simply run the following command:

```bash
$lanoel --help
usage: lanoel [-h] [-p PARTICIPANT] [-f FILE]

options:
  -h, --help            show this help message and exit
  -p PARTICIPANT, --participant PARTICIPANT
                        The name of participants and optionally category separated by a semicolon. If category is not
                        provided, the participant will be in the default category. ex: Oliver,Tuner
  -f FILE, --file FILE  The path of the csv file. The file should be in the format 'name;category'.
```

## Features

- Generate Secret Santa pairs for groups of people
- Support for categories to ensure participants are not paired with someone from the same category
- Easy to use command-line interface
prompt-sensitivity-index 0.0.1
A Prompt Sensitivity Index for Language Models
Requires Python: >=3.8

<p align="center">
    <br>
        &nbsp&nbsp&nbsp&nbsp&nbsp&nbsp&nbsp&nbsp&nbsp&nbsp&nbsp&nbsp
        <img src="https://github.com/kowndinya-renduchintala/POSIX/blob/main/posix_logo.png" width="500" />
    </br>
</p>

<p align="center">
    <a href="https://github.com/kowndinya-renduchintala/POSIX/blob/main/LICENSE.txt">
        <img alt="GitHub" src="https://img.shields.io/github/license/kowndinya-renduchintala/POSIX?color=blue">
    </a>
    <a href="#">
        <img alt="GitHub Stars" src="https://img.shields.io/github/stars/kowndinya-renduchintala/POSIX">
    </a>
    <a href="#">
        <img alt="GitHub Forks" src="https://img.shields.io/github/forks/kowndinya-renduchintala/POSIX">
    </a>
</p>

# About POSIX

*POSIX* is a simple and easy-to-use Python Library to evaluate prompt sensitivity of Language Models. 

# Installation

The simplest way to install *POSIX* is via `pip`:
```bash
pip install prompt-sensitivity-index
```

You can also install *POSIX* from source:
```bash
git clone https://github.com/kowndinya-renduchintala/POSIX.git
cd POSIX
pip install .
```

# Example Usage

```python
from prompt_sensitivity_index.models import HFModel
from prompt_sensitivity_index.posix import (
    PosixConfig, 
    PosixTrace, 
    get_prompt_sensitivity, 
    write_trace_to_json
)

intent_aligned_prompts=[
    [
        "Q: What is the capital of France?\nA: ",
        "Q: WHat is te capital city of France?\nA: ",
        "Q: what is teh cpital of france??\nA: "
    ],
    [
        "Q: What is the national animal of India?\nA: ",
        "Q: What's the national animl of India?\nA: ",
        "Q: WHat is teh national animal of India?\nA: "
    ],
    [
        "Q: Tell me the meaning of rendezvous?\nA: ",
        "Q: WHat is the meaning of rendezvous?\nA: ",
        "Q: What does rendezvous mean?\nA: "
    ]
]
model=HFModel("openai-community/gpt2")
config=PosixConfig(max_new_tokens=5, batched=False)
posix, trace=get_prompt_sensitivity(model, intent_aligned_prompts, config, verbose=True)
print(f"Prompt Sensitivity Index: {posix}")
write_trace_to_json(trace, "posix_trace.json")
```

# Citation

If you use *POSIX* in your research, please cite of our EMNLP 2024 paper (aclanthology version coming soon...)

[_POSIX: A Prompt Sensitivity Index For Large Language Models_](https://arxiv.org/abs/2410.02185):

```
@article{chatterjee2024posix,
  title={POSIX: A Prompt Sensitivity Index For Large Language Models},
  author={Chatterjee, Anwoy and Renduchintala, HSVNS Kowndinya and Bhatia, Sumit and Chakraborty, Tanmoy},
  journal={arXiv preprint arXiv:2410.02185},
  year={2024}
}
```

# License

*POSIX* is licensed under the MIT License. See [LICENSE](LICENSE) for more information.
fluxel 0.3.1
A simple interpreter for Fluxel scripts
Requires Python: >=3.6

# Fluxel Interpreter

Fluxel is a simple, user-friendly scripting language and interpreter designed for creating interactive applications with ease. It provides a range of features for building GUI applications, handling user input, and even integrating with AI models.


## Updates

0.3.1 Acidentally forgot to put new interpreter
I replaced the old one with the new one so the new commands should work now.

0.3.0 Added "blast"
blast is a fun little minigame. Press enter to shoot. just make a new line in your code and put "blast" (without the "").

0.2.4 Fixed accidentally deleted interpreter

0.2.3 Added "typewriteask"
Litteraly just typewriter + ask.
example: 
[typewriteask "Hows your day today?" 3
remember userDay
typewrite "You're having a " + userDay + " today? Nice."]

0.2.2	 Added "typewriter"
example: [typewriter "Hello!" 3] Types each letter out and takes 3 seconds to finish.

0.2.0 Added "wait"
example: [wait 3] waits 3 seconds.

## Installation

Install Fluxel using pip:


pip install fluxel
text

## Usage

Run a Fluxel script using the command:


fluxel Script.flux
text

## Features

### Variables and Input

- **Variable Declaration**: `var name = value`
- **User Input**: `ask "Question?"`
- **Remember User Input**: `remember variable_name`

### Output and Interaction

- **Print to Console**: `say "Message" + variable`
- **Pause Execution**: `pause`

### GUI Elements

- **Create Window**: `window "Window Title"`
- **Set Window Size**: `windowsize "width,height"`
- **Add Button**: `button "Button Text" "Command"`
- **Add Label**: `label "Label Text"`
- **Show Window**: `show window`
- **Display Message Box**: `message "Message Text"`

### GUI Input Elements

- **Create Entry Field**: `var entry_name = entry`
- **Create Text Area**: `var text_name = text`
- **Get Entry Value**: `get entry variable_name entry_name`

### AI Integration (Google Gemini) (unfinished)

- **Configure Gemini**: `configure_gemini "API_KEY"`
- **Generate Content**: `generate_content "Prompt"`

### Text Manipulation

- **Append Text**: `append_text variable_name "Text to append"`

### Advanced GUI Features

- **Button with Custom Location**: 

button "Button Text" "Command" objectLocation = x,y
text

## Example Script


window "My First Fluxel App"
windowsize "300,200"
label "Welcome to Fluxel!"
var name_entry = entry
button "Say Hello" "get entry name name_entry
message "Hello, " + name + "!"
"
show window
text

## Notes

- The interpreter automatically adds a pause at the end of each script execution.
- GUI elements are packed vertically by default unless a specific location is provided.
- The Gemini AI integration requires a valid API key from Google.

## Contributing

Contributions to Fluxel are welcome! Please feel free to submit a Pull Request. 

## License

This project is licensed under the GNU GENERAL PUBLIC License - see the LICENSE file for details.
phase-curve 0.1.0
Lightweight, bare bones asteroid phase curve fitter
Requires Python: >=3.6

This is a lightweight and bare bones implementation of the commonly used asteroid phase curve models, with an associated simple chi2 fitter using scipy least squares. This was developed as part of the production of the [LSST DP0.3](https://dp0-3.lsst.io/index.html) and has been used as an independent verification of the package [Sorcha](https://github.com/dirac-institute/sorcha) (which uses the excellent [sbpy](https://sbpy.org/) under the hood).

The only dependencies are `numpy` and `scipy`, see code and/or docstrings for usage details.
smart-commit-msg 0.1.1
Builds a smart commit message using LLMs
Requires Python: >=3.9

## Smart Commit Msg

<img src="./assets/git-diff.jpeg" height=200 width=300></img>

A tool that creates smart commit messages using the `git diff`.

## Usage

Install the CLI

```sh
$ pip install smart-commit-msg
```

Go to a git repository

```sh
$ git add .
$ smart-commit-msg
```

Smart commit msg gives you a commit message based on the staged changes.

## Tool Help

```sh
NAME
    smart-commit-msg - Main function that orchestrates the commit message generation and user interaction.

SYNOPSIS
    smart-commit-msg <flags>

DESCRIPTION
    Main function that orchestrates the commit message generation and user interaction.

FLAGS
    --model=MODEL
        Default: 'meta-llama/Llama...
    --max_tokens=MAX_TOKENS
        Default: 100
```


## Models

This tool uses the `huggingface_hub.InferenceClient` API. So you can use all the models that support
the inference endpoints!

To know more about inference endpoints please read the official [documentation](https://huggingface.co/docs/inference-endpoints/en/index).

## References

* [Andrej Karpathy's Tweet](https://x.com/karpathy/status/1827810695658029262)
* [Andrej Karpathy's Gist](https://gist.github.com/karpathy/1dd0294ef9567971c1e4348a90d69285)
njx 0.1.0
NJX is a library for morphologically and bio-physically detailed neuron simulations in JAX.
Requires Python: >=3.11

# njx

NJX is a library for morphologically and bio-physically detailed neuron simulations in JAX.

## Acknowledgements

This library incorporates code from the excellent [jax-cfd](https://github.com/google/jax-cfd) library. In particular we make use of their solver code and some utilities. The respective files carry the original copyright notices.
groqshell-cli 0.0.22
Command-line interface for Groq AI models
Keywords: python, groq, ai, cli, shell, interface


# GroqShell

Welcome to **GroqShell**, a powerful command-line interface designed for seamless interaction with Groq AI models. With GroqShell, you can effortlessly send prompts to Groq models and receive instant responses right in your terminal.

## 🌟 Features

- **Command-Line Interaction**: Engage with Groq AI models directly from your terminal.
- **Model Selection**: Choose from a variety of available Groq models.
- **JSON Output**: Easily force JSON output for structured responses.
- **Persistent Model Selection**: Your selected model is remembered for future sessions.
- **Interactive Mode**: Enjoy a continuous conversation with the AI.
- **Markdown Formatting**: Responses are beautifully formatted in Markdown.
- **Syntax Highlighting**: Code blocks are highlighted for better readability.
- **Command History Support**: Navigate through your command history effortlessly.

## 🚀 Installation

To get started with GroqShell, follow these simple steps:

1. Install the package using pip:

   ```bash
   pip install groqshell-cli
   ```

## Usage

Before using **GroqShell**, make sure to set your **Groq API key** as an environment variable:

```
export GROQ_API_KEY='your-api-key-here'
```

**Basic usage:**

```
groqshell -p "Your prompt here"
```

**Force JSON output:**

```
groqshell -p "Your prompt here" -j
```

**Select a different Groq model:**

```
groqshell -m
```

**List available Groq models:**

```
groqshell -l
```

**Enter interactive mode:**

```
groqshell -I
```

## 🔍 Options

- `-p`, `--prompt`: The prompt to send to the Groq AI model (required)
- `-j`, `--json`: Force JSON output
- `-c`, `--change`: Change the Groq model
- `-i`, `--info`: Get information about the currently selected model
- `-l`, `--list`: List available Groq models
- `-I`, `--interactive`: Enter interactive mode for continuous conversation

## 🤝 Contributing

Contributions are welcome! Please feel free to submit a Pull Request.

## 📜 License

This project is licensed under the MIT License.
groqshell 0.0.21
Command-line interface for Groq AI models
Keywords: python, groq, ai, cli, shell, interface


# GroqShell

Welcome to **GroqShell**, a powerful command-line interface designed for seamless interaction with Groq AI models. With GroqShell, you can effortlessly send prompts to Groq models and receive instant responses right in your terminal.

## 🌟 Features

- **Command-Line Interaction**: Engage with Groq AI models directly from your terminal.
- **Model Selection**: Choose from a variety of available Groq models.
- **JSON Output**: Easily force JSON output for structured responses.
- **Persistent Model Selection**: Your selected model is remembered for future sessions.
- **Interactive Mode**: Enjoy a continuous conversation with the AI.
- **Markdown Formatting**: Responses are beautifully formatted in Markdown.
- **Syntax Highlighting**: Code blocks are highlighted for better readability.
- **Command History Support**: Navigate through your command history effortlessly.

## 🚀 Installation

To get started with GroqShell, follow these simple steps:

1. Install the package using pip:

   ```bash
   pip install groqshell-cli
   ```

## Usage

Before using **GroqShell**, make sure to set your **Groq API key** as an environment variable:

```
export GROQ_API_KEY='your-api-key-here'
```

**Basic usage:**

```
groqshell -p "Your prompt here"
```

**Force JSON output:**

```
groqshell -p "Your prompt here" -j
```

**Select a different Groq model:**

```
groqshell -m
```

**List available Groq models:**

```
groqshell -l
```

**Enter interactive mode:**

```
groqshell -I
```

## 🔍 Options

- `-p`, `--prompt`: The prompt to send to the Groq AI model (required)
- `-j`, `--json`: Force JSON output
- `-c`, `--change`: Change the Groq model
- `-i`, `--info`: Get information about the currently selected model
- `-l`, `--list`: List available Groq models
- `-I`, `--interactive`: Enter interactive mode for continuous conversation

## 🤝 Contributing

Contributions are welcome! Please feel free to submit a Pull Request.

## 📜 License

This project is licensed under the MIT License.
postman-drf 0.1.1
A package to convert Postman collections to Django rest framework code and vice versa.
Requires Python: >=3.7

# postman-drf
A package to convert Postman collections to Django rest framework code and vice versa.
## installation
```shell
pip install postman-drf
```
## usage
```shell
python -m postman_drf [OPTIONS] COMMAND [ARGS]
```
To convert a Postman collection to Django rest framework test, you can use the following command:
```shell
python -m postman_drf postman_to_drf Example_collection.json tests.py
```