semvec/pypi-packages huggingface dataset:
mbrug-email-mcp-server 0.1.0
Email MCP Server for Amazon Q CLI
Requires Python: >=3.6

# Email MCP Server for Amazon Q

A custom MCP (Model Context Protocol) server that provides email functionality for Amazon Q CLI.

## Features

- Send emails using Gmail OAuth 2.0
- Secure authentication with Google's OAuth 2.0 flow
- Easy integration with Amazon Q CLI

## Installation

```bash
pip install mbrug-email-mcp-server
```

## Usage

### Setup OAuth 2.0 credentials

1. Create a project in the [Google Cloud Console](https://console.cloud.google.com/)
2. Enable the Gmail API
3. Create OAuth 2.0 credentials (Desktop application)
4. Download the credentials JSON file
5. Run the setup command:

```bash
q tool mbrug.email-mcp-server___setup_oauth --credentials_path /path/to/credentials.json
```

### Send an email

```bash
q tool mbrug.email-mcp-server___send_email --to recipient@example.com --subject "Hello" --body "This is a test email"
```

## Running the server manually

If you need to run the server manually:

```bash
mbrug-email-mcp-server
```

Then configure Amazon Q to use it:

```bash
q config add-mcp-server email http://localhost:8080
```

## License

MIT
bitvector-for-humans 0.14.4
A simple pure python Bit Vector class for Humans™.
Requires Python: >=3.9

<!-- python3 bitvector bit vector bits bit-twiddling binary -->
![version][pypi-version]
![pytest][pytest-action]
![license][license]
![monthly-downloads][monthly-downloads]
![Code style: black][code-style-black]



# Bit Vectors For Humans™

This simple bit vector implementation aims to make addressing single
bits a little less fiddly. It can be used by itself to work with bit
fields in an integer word, but it really starts to shine when you use
the supplied `BitField` descriptor with a subclass of `BitVector`:

```python
> from bitvector import BitVector, BitField
>
> class IOTDeviceCommand(BitVector):
>     def __init__(self):
>         super().__init__(size=32)
>
>     power = BitField(0, 1) # offset and size
>     spin  = BitField(1, 1)
>     speed = BitField(2, 4)
>     sense = BitField(6, 2)
>     red   = BitField(8, 8)
>     blue  = BitField(16, 8)
>     green = BitField(24, 8)
>
> widget_cmd = IOTDeviceCommand()
> widget_cmd.power = 1
> widget_cmd.sense = 2
> widget_cmd.speed = 5
> widget_cmd.red = 0xaa
> widget_cmd.blue = 0xbb
> widget_cmd.green = 0xcc
> widget_cmd
IOTDeviceCommand(value=0xccbbaa95, size=32)
> widget_cmd.bytes
b'\xcc\xbb\xaa\x95'
```


## Installation

```console
$ python3 -m pip install bitvector-for-humans
$ pydoc bitvector
...
```

Or directly from github:

```console
$ pip install git+https://github.com/JnyJny/bitvector.git
```

## Motivations

1. Address sub-byte bits in a less error prone way.
2. Minimize subdependencies (zero is minimized right?).
3. Learn something about descriptors: ✅. 

## Caveats

The tests need expanding and I got lazy when writing the multi-bit
setting / getting code and it could undoubtedly be improved. Pull
requests gladly accepted.

## Other Ways to Implement a Bit Vector
<!-- EJO add links to these other things -->
1. Python builtin `ctypes.Structure` allows sub-byte bit fields
2. Python builtin `struct` provides extensive support for byte manipulations
3. Python3 IntEnums can be used to build bit field masks
4. The plain `int` will serve admirably with bitwise operators
5. Provide cffi bindings to existing bit-twiddling libraries
6. Use Numpy bool arrays as the "backing store"
7. Other good ideas I overlooked, forgot about or just plain don't know.


<!-- badges -->
[pytest-action]: https://github.com/JnyJny/bitvector/workflows/pytest/badge.svg
[code-style-black]: https://img.shields.io/badge/code%20style-black-000000.svg
[pypi-version]: https://img.shields.io/pypi/v/bitvector-for-humans
[license]: https://img.shields.io/pypi/l/bitvector-for-humans
[monthly-downloads]: https://img.shields.io/pypi/dm/bitvector-for-humans
proxyrotator 0.0.2
A simple proxy rotation utility
Requires Python: >=3.6

# proxyrotator

A simple Python utility to rotate proxies by validating them against ipinfo.io.

## Installation

```bash
pip install proxyrotator

from proxyrotator import getproxy

proxies = [
    "http://1.2.3.4:8080",
    "http://5.6.7.8:3128",
]

proxy = getproxy(proxies)
print(proxy)
neorick 1.2.2
A system monitoring and reporting tool
Requires Python: >=3.13

<h1 align=center>NEORICK</h1>

<div align=center>
  
  ![Project Status](https://img.shields.io/badge/status-Em%20andamento-yellow)
  ![versão](https://img.shields.io/badge/versão-1.0.0-important)
  
</div>

> [!WARNING]
> O uso dos arquivos deste projeto é delimitado para <strong>fins de estudo</strong>. Caso queira colaborar com o desenvolvimento, entre no [site](https://neorick-net.vercel.app) e contate-nos.

> Caso ainda não tenha o Python instalado, baixe [aqui.](https://www.python.org/downloads)

# Requisitos

1. Python 3.10 ou superior

# Uso do código fonte

Você pode clonar o repositório ou baixar o arquivo `.tar.gz` no site do [NeoRick](https://neorick-net.vercel.app)

Caso queira prosseguir com a opção 1:

1. Clone o repositório de entre nele

```sh
git clone https://github.com/Rickzinho3/neorick.git
cd neorick
```

2. Instale as dependências

```sh
poetry install
```

# Extra

Caso queira que o `Neorich` seja executado no seu powershell, siga os seguintes passos:

1. Instale a biblioteca

```sh
pip install neorick
```

2. Abra o `Powershell` e digite o comando `notepad $PROFILE`

> [!NOTE]
> Caso você não tenha um perfil, irá aparecer uma mensagem para você criar, basta confirmar.

Depois de abrir o seu perfil, cole `neorick` e salve.
<br>

<p align=center>J. Henrique &copy; 2025. Todos os direitos reservados.</p>
igloohome-api 0.1.1
A python package for using igloohome's API
Requires Python: >=3.8

# igloohome-api
A python HTTP library based on `aiohttp` to make use of [igloohome's REST API](https://igloocompany.stoplight.io/docs/igloohome-api/1w1cuv56ge5xq-overview).
This library is designed to be used via the [iglooaccess](https://www.igloocompany.co/iglooaccess) service.

## Requirements
An account on the iglooaccess portal needs to be created to get a `client_id` & `client_secret` for authentication.

## Usage

### Authentication
```python
from igloohome_api import Auth
from aiohttp import ClientSession

session = ClientSession()
auth = Auth(
    client_id="<client_id>",
    client_secret="<client_secret>",
    session=session,
)
```

### API usage
```python
from igloohome_api import Api

api = Api(auth)

devices = await api.get_devices()
```
little-bank 0.1.0
Double book-keeping transaction framework
Requires Python: >=3.13

<h1 align=center>little-bank</h1>

<p align=center>
    <a href=https://github.com/antonagestam/little-bank/actions?query=workflow%3ACI+branch%3Amain><img src=https://github.com/antonagestam/little-bank/workflows/CI/badge.svg alt="CI Build Status"></a>
</p>

Little Bank is a framework for analyzing financial transactions.

#### Design goals

- All analysis should be a matter of summarizing credit, debit or balance of an account
  in a system. The intention is to reduce bugs by making all analysis use the same
  numerical implementation.
- This means that we're of the opinion that implementing filters and doing arithmetic on
  transactions outside of little-bank code is _wrong_. If we find ourselves grasping to
  do this, what we should instead do is introduce new accounts our possibly restructure
  the flow between the existing ones.
- Allow defining rules for a system in a declarative way.
- Disallow mutation. The design encourages immutable, append-only transactions.
- All operations that update the system are very similar: appending transactions which
  automatically verifies all defined rules, and persisting the new transactions. This
  allows centralizing code that saves transactions to a single place.

#### Non-goals

- Performance. This library is intended to be used to analyze systems of a small number
  of transactions. Therefor exposing APIs that are easy to reason about is a much higher
  priority than performance.