semvec/pypi-packages huggingface dataset:
pandas-query-mcp 0.1.0
Add your description here
Requires Python: >=3.12

# pandas-query-mcp

This is a MCP (Model Context Protocol) server for pandas-query.


## Setup

```json
{
  "mcpServers": {
    "pandas-query-mcp": {
      "command": "uvx",
      "args": [
        "pandas-query-mcp",
        "--file",
        "<file path>",
        "--sheet",
        "<sheet name or index>"
      ],
      "alwaysAllow": [
        "describe",
        "head",
        "tail",
        "query"
      ],
      "disabled": false
    }
  }
}
```
coverage-threshold 0.6.2
Tools for coverage threshold limits
Requires Python: >=3.7

# coverage threshold

A command line tool for checking coverage reports against configurable coverage minimums.
Currently built for use around python's [coverage](https://pypi.org/project/coverage/)

### Installation

`pip install coverage-threshold`

also recommended:

`pip install coverage`

### Usage

Typical execution:

```bash
coverage run -m pytest tests/  # or any test runner here
coverage json
coverage-threshold
```

cli command options:

```
> coverage-threshold --help
usage: coverage-threshold [-h] [--line-coverage-min LINE_COVERAGE_MIN]
                          [--branch-coverage-min BRANCH_COVERAGE_MIN]
                          [--combined-coverage-min COMBINED_COVERAGE_MIN]
                          [--file-line-coverage-min FILE_LINE_COVERAGE_MIN]
                          [--file-branch-coverage-min FILE_BRANCH_COVERAGE_MIN]
                          [--file-combined-coverage-min FILE_COMBINED_COVERAGE_MIN]
                          [--coverage-json COVERAGE_JSON] [--config CONFIG]

A command line tool for checking coverage reports against configurable coverage minimums

optional arguments:
  -h, --help            show this help message and exit
  --line-coverage-min LINE_COVERAGE_MIN
                        minimum global average line coverage threshold
  --branch-coverage-min BRANCH_COVERAGE_MIN
                        minimum global average branch coverage threshold
  --combined-coverage-min COMBINED_COVERAGE_MIN
                        minimum global average combined line and branch coverage threshold
  --file-line-coverage-min FILE_LINE_COVERAGE_MIN
                        the line coverage threshold for each file
  --file-branch-coverage-min FILE_BRANCH_COVERAGE_MIN
                        the branch coverage threshold for each file
  --file-combined-coverage-min FILE_COMBINED_COVERAGE_MIN
                        the combined line and branch coverage threshold for each file
  --coverage-json COVERAGE_JSON
                        path to coverage json (default: ./coverage.json)
  --config CONFIG       path to config file (default: ./pyproject.toml)
```

### Config

the current expected config file format is [toml](https://toml.io/en/)
the default config file used is `pyproject.toml` but and alternative path can be specified with `--config`

example config:

```toml
[tool.coverage-threshold]
line_coverage_min = 95
file_line_coverage_min = 95
branch_coverage_min = 50

[tool.coverage-threshold.modules."src/cli/"]
file_line_coverage_min = 40

[tool.coverage-threshold.modules."src/cli/my_command.py"]
file_line_coverage_min = 100

[tool.coverage-threshold.modules."src/lib/"]
file_line_coverage_min = 100
file_branch_coverage_min = 100

[tool.coverage-threshold.modules."src/model/"]
file_line_coverage_min = 100

[tool.coverage-threshold.modules."src/__main__.py"]
file_line_coverage_min = 0
```

Each string key in `config.modules` is treated as a path prefix, where the longest matching prefix is used to configure the coverage thresholds for each file
discord-trad-bot 2.0.1
A Discord bot that automatically translates messages in specified channels
Requires Python: >=3.8

# Discord Translation Bot

A Discord bot that automatically translates messages in a designated channel to each user's preferred language while maintaining Discord's rich formatting.

---

## 📦 Deployment & Installation Guide
- [Install on Render (English)](RENDER_INSTALL_GUIDE.md)

---

## Features

- Automatic translation of messages in a designated channel
- User language preferences
- Preserves Discord formatting (emojis, mentions, etc.)
- Free to use (uses Google Translate API free tier)

## Setup (Local Development)

1. **Clone this repository**
2. **Create a virtual environment:**
   ```
   python -m venv venv
   source venv/bin/activate  # On Windows: venv\Scripts\activate
   ```
3. **Upgrade pip (required for editable installs with modern packaging):**
   ```
   python -m pip install --upgrade pip
   ```
4. **Install the package in editable/development mode from the project root:**
   ```
   pip install -e .
   ```
   This makes the `discord_trad_bot` package available for import and development, and any code changes are picked up instantly.

5. **Create a `.env` file in the project root with your Discord bot token and Google Translate API key:**
   ```
   DISCORD_TOKEN=your_discord_bot_token
   GOOGLE_TRANSLATE_API_KEY=your_google_translate_api_key
   ```

## Running the Bot Locally

You have several options:

- **Recommended:**  
  If you have a `__main__.py` in `src/discord_trad_bot/` (recommended for package-style projects), run:
  ```
  python -m discord_trad_bot
  ```

- **Directly:**  
  Or, run the main file directly:
  ```
  python src/discord_trad_bot/main.py
  ```

- **Via entry point (if set up in pyproject.toml):**  
  If you have a script entry point defined, you can also run:
  ```
  discord-trad-bot
  ```

- **Using the Makefile (shortcut for dev):**
  If you prefer, you can use the provided Makefile command to run the bot in development mode:
  ```
  make dev
  ```
  This is equivalent to running `python src/discord_trad_bot/main.py` and is handy for quick local testing.

## Configuration

Create a `.env` file with the following variables:
```
DISCORD_TOKEN=your_discord_bot_token
GOOGLE_TRANSLATE_API_KEY=your_google_translate_api_key
```

## Commands

### User Commands
- `!setlang <language_code>` — Set your preferred language
- `!mylang` — Show your current language setting
- `!languages` — List available languages
- `!ping` — Test if the bot is working

### Admin Commands
- `!settranschannel <#channel>` — Set the translation channel
- `!addtranschannel <#channel>` — Add a new translation channel
- `!removetranschannel <#channel>` — Remove a translation channel
- `!listtranschannels` — List all translation channels
- `!setchannellang <#channel> <language_code>` — Set the default language for a translation channel
- `!debugdb` — Debug command to check database schema and content
- `!transstatus` — Show bot status and usage

---

## Contributing

Pull requests are welcome! For major changes, please open an issue first to discuss what you would like to change.

---

## License

MIT
mute 3.0.0
Muon Intensity Code

# MUTE

[![DOI](https://zenodo.org/badge/DOI/10.5282/zenodo.5791812.svg)](https://doi.org/10.5281/zenodo.5791812)

MUTE (**MU**on in**T**ensity cod**E**) is a computational tool for calculating atmospheric muon fluxes and intensities underground. It makes use of the state-of-the-art codes [daemonflux](https://github.com/mceq-project/daemonflux) and [MCEq](https://github.com/afedynitch/MCEq), to calculate surface fluxes, and [PROPOSAL](https://github.com/tudo-astroparticlephysics/PROPOSAL), to simulate the propagation of muons through rock and water.

## Installation

MUTE can be installed via pip:

```
pip install mute
```

This will install most of the requirements, including MCEq.

### Additional Requirements

In order to generate custom survival probability tensors, PROPOSAL should be installed. Because it requires compilation, it needs to be installed separately (see detailed installation instructions [here](https://github.com/tudo-astroparticlephysics/PROPOSAL/blob/master/INSTALL.md)):

```
pip install proposal==7.6.2
```

MUTE has been tested with PROPOSAL v7.6.2; earlier or later versions are not guaranteed to work. Environment set-up help for PROPOSAL installation on a Mac can be found [here](docs/Installing_PROPOSAL_on_a_Mac.md).

## Getting Started

![Total Underground Flux vs Vertical Depth](docs/total_underground_flux.png)

The code for the above plot is found in [``/examples/example_total_flux_plot.ipynb``](examples/example_total_flux_plot.ipynb).

For a basic example and a detailed description of how to use MUTE, see the [Tutorial](docs/Tutorial.md). For further examples, see the [examples](examples).

## Citation

Please cite https://inspirehep.net/literature/1927720 for MUTE v1-2 and https://inspirehep.net/literature/2799258 for MUTE v3.

The current version of MUTE can be cited with the [Zenodo DOI](https://zenodo.org/record/5791812).

The citations for the models and propagation tools used by MUTE can be found in the [MCEq](https://github.com/afedynitch/MCEq#please-cite-our-work) and [PROPOSAL](https://github.com/tudo-astroparticlephysics/PROPOSAL#how-to-cite-proposal) documentation.

### Authors

[William Woodley](mailto:wwoodley@ualberta.ca)

### Contributors

Anatoli Fedynitch ([@afedynitch](https://github.com/afedynitch)) and Marie-Cécile Piro ([@MarieCecile](https://github.com/MarieCecile))

## License

MUTE is licensed under the BSD 3-Clause License (see [LICENSE](LICENSE)).
llm-connectors 0.1.0
A library of connectors for popular AI platforms
Requires Python: >=3.8

# LLM Connectors

A Python library providing connectors for popular AI platforms including ChatGPT, Copilot, Gemini, and DeepSeek.

## Installation

```bash
pip install llm-connectors
```

## Usage

### ChatGPT

```python
from llm_connectors import ChatGPTConnector

# Initialize the connector
chatgpt = ChatGPTConnector(api_key="your-openai-api-key")

# Chat example
messages = [
    {"role": "user", "content": "Hello, how are you?"}
]
response = await chatgpt.chat(messages)
print(response["content"])

# Text generation example
text = await chatgpt.generate_text("Write a poem about AI")
print(text)

# Get embeddings
embeddings = await chatgpt.get_embeddings("Hello, world!")
print(embeddings)
```

### Gemini

```python
from llm_connectors import GeminiConnector

# Initialize the connector
gemini = GeminiConnector(api_key="your-google-api-key")

# Chat example
messages = [
    {"role": "user", "content": "Hello, how are you?"}
]
response = await gemini.chat(messages)
print(response["content"])

# Text generation example
text = await gemini.generate_text("Write a poem about AI")
print(text)

# Get embeddings
embeddings = await gemini.get_embeddings("Hello, world!")
print(embeddings)
```

### Copilot and DeepSeek

Note: These connectors are currently placeholders and will be implemented when their respective APIs become available.

## Features

- Unified interface for multiple AI platforms
- Async support for better performance
- Consistent API across different providers
- Support for chat, text generation, and embeddings
- Type hints for better IDE support

## Requirements

- Python 3.8+
- OpenAI API key (for ChatGPT)
- Google API key (for Gemini)
- Microsoft API key (for Copilot, when available)
- DeepSeek API key (when available)

## License

MIT License
aplicacion-ventas-irv 0.1.0
Paquete para gestionar ventas, precios, impuestos y descuentos
Requires Python: >=3.7

# APLICACION DE VENTAS
Este paquete proporciona funcionalidades para gestionar
ventas, incluyendo el calculo de precios, impuestos
y descuentos.

## InstalaciÃ³n
Puedes Instalar el paquete usando:
```bash 
pip install .
"


"""
COMENTARIO DEL PROFESOR: USO UN LENGUAJE DE MARCADO
LLAMADO MARKDOWN
# TÃ­tulo principal
## SubtÃ­tulo
Texto en **negrita** y *cursiva*.

- Elemento de lista
- Otro elemento

[Enlace a un sitio](https://example.com)


"""
cvprocessor 1.0.8
CVProcessor is a Python library for processing CV (Curriculum Vitae) or resume documents.
Requires Python: >=3.8
Keywords: CV, Curriculum Vitae, Resume, xslx

**Warning**: This is under development, some features may not work as expected.

# CVProcessor

CVProcessor is a Python library for processing CV (Curriculum Vitae) or resume documents. It provides a set of functions and utilities to extract information from CVs, such as personal details, education, work experience, skills, and more.

## Features

- Extract personal details from CVs, including name, contact information, and address.
- Parse education details, including degrees, institutions, and dates.
- Extract work experience information, including job titles, companies, and dates.
- Identify and extract skills mentioned in CVs.
- Support for xlsx files.

## Installation

You can install CVProcessor using pip:

```bash
pip install cvprocessor
```

## Usage

Here's a simple example of how to use CVProcessor to extract personal details from a CV:

```python
from cvprocessor.cv import CV

# Load a CV file
cv_file = "cv.xlsx"
cv = CV(cv_file)

# print education details
print(cv.education)
# Print teaching experience
print(cv.teaching)
```