semvec/pypi-packages huggingface dataset:
macgputils 0.1.2
A package to fetch GPU stats on macOS using powermetrics
Requires Python: >=3.6

# macgputils

`macgputils` is a lightweight Python utility to fetch GPU statistics on macOS using the native `powermetrics` tool. It provides programmatic access to GPU power usage, frequency, active/idle time, and more.

## Features

- Read real-time GPU power consumption (in mW)
- Get GPU hardware active frequency
- Check GPU idle residency
- Sample multiple times to monitor changes over time
- Easy-to-use API: `macgputils.get_gpu_stats()`

## Installation

```bash
pip install macgputils
```

> If `powermetrics` is not already available, `macgputils` will prompt and help install it via Apple's developer tools.

## Usage

```python
import macgputils

# Get single sample
stats = macgputils.get_gpu_stats()
print(stats)

# Get multiple samples
for sample in macgputils.get_gpu_stats(samples=3):
    print(sample)
```

### Output Example

```python
{'Active Frequency': '389 MHz', 'HW Active Residency': '14.00%', 'Idle Residency': '86.00%', 'GPU Power': '33 mW'}
```

## API Reference

### `macgputils.get_gpu_stats(samples=1, interval=5)`

| Parameter | Description |
|----------|-------------|
| `samples` | Number of GPU usage samples to collect |
| `interval` | Time in seconds between each sample |

Returns:
- A dictionary if `samples=1`
- A list of dictionaries if `samples > 1`

---

## Requirements

- macOS
- Python 3.6+
- `powermetrics` (part of macOS; auto-installable via Xcode command line tools)

## License

MIT License

---

## Author

Developed by @aabhinavg1. Contributions are welcome — feel free to fork and submit pull requests!
mcp-server-qq-music 0.1.4
QQ Music MCP Server
Requires Python: >=3.13

# QQ Music MCP Server

## Tools

- check login status
- login
- search songs
- get song detail

## Usage

```json
{
    "mcpServers": {
        "qq-music": {
            "command": "uvx",
            "args": [
                "mcp-server-qq-music"
            ]
        }
    }
}
```

## Debugging

```shell
git clone https://github.com/saltfishpr/mcp-servers.git
```

```json
{
    "mcpServers": {
        "qq-music": {
            "command": "uv",
            "args": [
                "--directory",
                "/<path to mcp-servers folder>",
                "run",
                "mcp-server-qq-music"
            ]
        }
    }
}
```

or

```shell
npx @modelcontextprotocol/inspector uv run mcp-server-qq-music
```
mcp-server-rednote 0.1.4
RedNote MCP Server
Requires Python: >=3.13

# RedNote MCP Server

## Tools

- check login status
- login
- search notes

## Usage

```json
{
    "mcpServers": {
        "rednote": {
            "command": "uvx",
            "args": [
                "mcp-server-rednote"
            ]
        }
    }
}
```

## Debugging

```shell
git clone https://github.com/saltfishpr/mcp-servers.git
```

```json
{
    "mcpServers": {
        "rednote": {
            "command": "uv",
            "args": [
                "--directory",
                "/<path to mcp-servers folder>",
                "run",
                "mcp-server-rednote"
            ]
        }
    }
}
```

or

```shell
npx @modelcontextprotocol/inspector uv run mcp-server-rednote
```
mflt-build-id 1.1.1
Memfault CLI tool
Requires Python: <4.0,>=3.8

# Memfault Build ID Tool

This package contains the `mflt_build_id` CLI tool.

The purpose of the tool is simplify reading or writing
[Build IDs](https://interrupt.memfault.com/blog/gnu-build-id-for-firmware) in a
firmware image irrespective of the compiler or build system being used in a
project.

## Example Usage

```
$ mflt_build_id --help
usage: mflt_build_id [-h] [--dump [DUMP]] [--crc CRC] [--sha1 SHA1] elf

Inspects provided ELF for a Build ID and when missing adds one if possible.

If a pre-existing Build ID is found (either a GNU Build ID or a Memfault Build ID),
no action is taken.

If no Build ID is found, this script will generate a unique ID by computing a SHA1 over the
contents that will be in the final binary. Once computed, the build ID will be "patched" into a
read-only struct defined in memfault-firmware-sdk/components/core/src/memfault_build_id.c to hold
the info.

If the --crc <symbol_holding_crc32> argument is used, instead of populating the Memfault Build ID
structure, the symbol specified will be updated with a CRC32 computed over the contents that will
be in the final binary.

If the --sha1 <symbol_holding_sha> argument is used, instead of populating the Memfault Build ID
structure, the symbol specified will be updated directly with Memfault SHA1 using the same strategy
discussed above. The only expectation in this mode is that a global symbol has been defined as follow:

const uint8_t g_your_symbol_build_id[20] = { 0x1, };

For further reading about Build Ids in general see:
  https://mflt.io//symbol-file-build-ids

positional arguments:
  elf

options:
  -h, --help     show this help message and exit
  --dump [DUMP]
  --crc CRC
  --sha1 SHA1
```

## Changes

### [1.1.1] - 2025-04-18

- Fix `mflt_build_id` script to be installed correctly again (regression in
  1.1.0)
- Add an alternate name `mflt-build-id` for the `mflt_build_id` script

### [1.1.0] - 2024-11-07

- Remove support for Python 3.6 + 3.7
gadfasthealth 0.0.1
FastAPI health check extension for Kubernetes liveness, readiness, and startup probes.
Requires Python: >=3.8

<p align="center">
  <a href="https://github.com/AlexDemure/gadfasthealth">
    <a href="https://ibb.co/xK8Cydh3"><img src="https://i.ibb.co/Y4TR6w2b/logo.png" alt="logo" border="0"></a>
  </a>
</p>

<p align="center">
  FastAPI health check extension for Kubernetes liveness, readiness, and startup probes
</p>

---

### Installation

```
pip install gadfasthealth
```

### Usage

```python
def check_redis() -> bool:
    return False

async def check_db() -> bool:
    return True

app = fastapi.FastAPI()

health = Health(
    ("/-/liveness", check_db),
    ("/-/readiness", check_db, check_redis),
    ("/-/startup", check_db),
    ("/-/custom"),
)

app.include_router(health.router)
```
pby-cli 0.1.1
CLI pour gérer les images et conteneurs Docker Probayes
Requires Python: >=3.8

# CLI Tool for Creating and Managing Ready-to-Go Docker Images for ML Projects

## Description

This CLI tool allows the user to easily create and personalize Docker environments for machine learning projects. Features include:

- Docker image base customization
- GPU/CPU allocation
- Probayes, LDAP, and SSH configuration
- Container volume management

## Installation

1. Clone the repository.
2. Navigate to the `docker_cli/` directory.
3. Install the required dependencies by running:

    ```bash
    pip install -r requirements.txt
    ```

## Usage

### 1. Building a Docker Image

To build a Docker image with your desired configuration, run the following command:

```bash
python cli.py build --image-name <image-name> [OPTIONAL] --extra-packages '["package1","package2"]' --with-probayes
```
Example : 
```bash
python cli.py build cli-test-img --base-image python:3.10-slim --with-probayes --extra-packages '["wget","curl"]' 
```

After executing the command, a Dockerfile will be created. To build the image, use:

```bash
sudo docker build -t <image_name> .
```

pby-cli build testing --base-image python:3.10-slim --with-probayes

### 2. Managing Users

Once the image is created, you can run the container and add specific configurations like CPU allocation, GPU settings, and directory mounts. Use the following command:

```bash
python cli.py run --image-name <image_name> --cpus <number_of_cpus> --ssh-port <ssh_port> --<gpu_option> --workspace <workspace_directory> --data-project <data_project_directory> --data-device <data_device_directory> --model-dir <model_directory>

```
sbcli-pool 1.0.17
CLI for managing SimplyBlock cluster


# Simply Block
[![Docker Image Build](https://github.com/simplyblock-io/sbcli/actions/workflows/docker-image.yml/badge.svg)](https://github.com/simplyblock-io/sbcli/actions/workflows/docker-image.yml)

[![Python Unit Testing](https://github.com/simplyblock-io/sbcli/actions/workflows/python-testing.yml/badge.svg)](https://github.com/simplyblock-io/sbcli/actions/workflows/python-testing.yml)


## Install
Add the package repo from AWS CodeArtifact using [awscli](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)

```bash
aws codeartifact login --tool pip --repository sbcli --domain simplyblock --domain-owner 565979732541 --region eu-west-1
```
Install package
```bash
pip install --extra-index-url https://pypi.org/simple sbcli-dev
```

# Components

## Simply Block Core
Contains core logic and controllers for the simplyblock cluster

## Simply Block CLI
Please see this document
[README.md](../main/simplyblock_cli/README.md)


## Simply Block Web API
Please see this document
[README.md](../main/simplyblock_web/README.md)



### local development

FoundationDB requires a client library (libfdb_c.dylib) for the Python bindings to interact with the database.
Depending on the OS architecture, please install the appropriate version from the official github repo

```
wget https://github.com/apple/foundationdb/releases/download/7.3.3/FoundationDB-7.3.3_arm64.pkg
```

setup the code on a management node and the webApp code can be developed by building the `docker-compose-dev.yml` file.


```
sudo docker compose -f docker-compose-dev.yml up --build -d
```