semvec/pypi-packages huggingface dataset:
ezcmt 0.1.12
A simple and free CLI tool for Git
Requires Python: >=3.10

# ezcmt
An AI CLI tool to make finding commit messages easier!\
\
It requires no internet connection and is completely free with its use of specialized local AI model.
#

# How to use
```
pip install ezcmt
ezcmt setup
ezcmt generate --count 5
```
#

# System requirements
A GPU with a minimum of 8.5gbs of vram
bitfrog 0.0.8
A Python API for Bitfrog notifications.
Requires Python: >=3.8

# Bitfrog Python API
*A Python API for easy push notifications through Bitfrog.*

**IMPORTANT**: Bitfrog has not been released yet, this package will not be useful until it has.

## Installation
```
pip install bitfrog
```

## Usage

```python
import bitfrog

bitfrog.notify("WOW so concise!", "XXXX-XXXX-XXXX-XXXX")
```

Or if you have many notifications and don't want to repeat the token;

```python
project = bitfrog.Project("XXXX-XXXX-XXXX-XXXX")
project.notify("Hello project!")

# Specify custom channel
channel = project.channel("Test Channel")
channel.notify("Finger lickin' good")
```
uuid7-standard 1.1.0
UUIDv7 with the final standard. Not to be confused with the uuid7 package on pypi, based on a draft version that was very different.
Requires Python: >=3.8
Keywords: database, ordering, primary-key, timestamp, uuid, uuid7

# UUIDv7 for Python

A simple module for generating UUIDv7 that contain creation
timestamps. Another function for extracting the time of an UUID.

Note: As of writing, Python has no UUIDv7 support. There's an abandoned package `uuid7` that uses a draft RFC with incorrect timestamps (some two centuries off). These modules conflict, uninstall the other one.

- **Standard compliant**: Follows the final UUIDv7 [specification](https://www.rfc-editor.org/rfc/rfc9562.html#name-uuid-version-7).
- **Pythonic**: Uses stdlib `datetime` and `UUID` facilities rather than milliseconds or bare strings.

## Installation

```sh
pip install uuid7-standard
```

Or for your project using [uv](https://docs.astral.sh/uv/):
```sh
uv add uuid7-standard
```

## Usage

```python
import uuid7

# Create a random UUIDv7 with current timestamp
u = uuid7.create()
print(str(u), u.bytes)

# Create with specific timestamp
from datetime import datetime, UTC

when = datetime(1970, 1, 1, tzinfo=UTC)
u = uuid7.create(when)

# Extract timestamp
from uuid import UUID

u = UUID('00000000-0000-7dac-b3e3-ecb571bb3e2f')
timestamp = uuid7.time(u)  # 1970-01-01 UTC
```

### `create(when: datetime?) -> UUID`

Create a UUIDv7 with timestamp-based ordering.

The current time is used, unless `when` is passed as datetime (local time or timezone-aware) This is useful e.g. for creating a bunch of UUIDv7 with precisely the same timestamp.

### `time(u: UUID|str) -> datetime`

Extract the timestamp from a UUIDv7. Raises ValueError if the UUID is not a UUIDv7.
GmMonitorix 0.1.2
Monitorix Frontend for Gemini Protocol
Requires Python: >=3.8

# Monitorix Gemini-Frontend

Gemini-page with Monitorix ascii-graphs in braille.
* System load average and usage
  (System load, Memory allocation, Active processes, Entropy, Uptime)
* Filesystem usage and I/O activity
  (Filesystem usage, Disk I/O activity, Inode usage, Time spent in I/O activity)
* Network traffic and usage (Traffic, Packets Errors)
* Icecast (Listeners, Bitrate)

|   |   |
|---|---|
|![w-urls.png](https://codeberg.org/cthulhu/gm-monitorix-cgi/raw/tag/v0.1.2/assets/w-urls.png)|![wo-urls.png](https://codeberg.org/cthulhu/gm-monitorix-cgi/raw/tag/v0.1.2/assets/wo-urls.png)|

## Install

Requirements:
* `Monitorix` - installed and started system service
* `rrdtool` - python package to provide access to *.rrd database files
* `brasciichart` - python package to ascii-graph

Installing `rrdtool` python-package can require developer
packages: `python3.x-dev`, `librrd-dev`. 
```shell
$ sudo apt install python3.9-dev librrd-dev
```
```shell
$ pip install GmMonitorix
```
After `GmMonitorix` successfully installed, remove dev-packages if not required:
```shell
$ sudo apt remove python3.9-dev librrd-dev
```

The Gemini-server account should have write-access in the work directory.
To protect monitorix page with user certificate, place `.admins` file with
user's certificate fingerprints into this work directory.

### GmCapsule
For [GmCapsule][3] server add to your [config-file][4]
a section with CGI-settings.
```gm-capsule-config.ini
[cgi.monitorix]
# monitoring gemini-page url-path
path = /monitorix/*

cwd = /writable/work/dir/

# path to a Python-interpreter with rrdtool, brasciichart, GmMonitorix
command = /path/to/python3 -m GmMonitorix
```
The monitoring gemini-page will be accessible 
by `gemini://<hostname>/monitorix/cgi` URL.

## Links
* [Gemini Protocol][0]
* [Project Gemini FAQ][1]
* [Monitorix][2]
* [GmCapsule (codeberg.org)][3]
* [GmCapsule User manual :: Configuration][4]

[0]: https://geminiprotocol.net/
[1]: https://geminiprotocol.net/docs/faq.gmi
[2]: https://www.monitorix.org/
[3]: https://codeberg.org/skyjake/gmcapsule
[4]: https://geminispace.org/gmcapsule/gmcapsule.html#id2

## TODO
* all metrics
* support net traffic bit/s
* support FreeBSD, OpenBSD, NetBSD total memory bytes
* support uptime units: minutes, hours
* support OpenBSD, NetBSD with m_mused, m_macti only

## Change log

### v0.1.2
* Add Icecast (Listeners, Bitrate)

### v0.1.1
* Add Filesystem Usage (Usage, Disk I/O, Inode, Time spent in I/O)
* Use rigid and limits from config
  
### v0.1.0
Initial release
solar-plus-intelbras 0.1.4
A wrapper for api solar plus intelbras
Requires Python: <4.0,>=3.11

# Python Solar Plus Intelbras

[![Python package](https://github.com/hudsonbrendon/python-solar-plus-intelbras/actions/workflows/pythonpackage.yml/badge.svg?branch=main)](https://github.com/hudsonbrendon/python-solar-plus-intelbras/actions/workflows/pythonpackage.yml)
[![Upload Python Package](https://github.com/hudsonbrendon/python-solar-plus-intelbras/actions/workflows/python-publish.yml/badge.svg)](https://github.com/hudsonbrendon/python-solar-plus-intelbras/actions/workflows/python-publish.yml)
[![Dependabot Updates](https://github.com/hudsonbrendon/python-solar-plus-intelbras/actions/workflows/dependabot/dependabot-updates/badge.svg?branch=main)](https://github.com/hudsonbrendon/python-solar-plus-intelbras/actions/workflows/dependabot/dependabot-updates)
[![pages-build-deployment](https://github.com/hudsonbrendon/python-solar-plus-intelbras/actions/workflows/pages/pages-build-deployment/badge.svg)](https://github.com/hudsonbrendon/python-solar-plus-intelbras/actions/workflows/pages/pages-build-deployment)

A wrapper for api solar plus intelbras


Install using pip:


```shell
pip install solar-plus-intelbras
```

Now, let's get started:


```pycon
>>> from solar_plus_intelbras import SolarPlusIntelbras
>>> solar_plus_intelbras = SolarPlusIntelbras(email="test@email.com", plus="i2gH3zuE68ClMDop50h8OxKlOYjvWd0vCDACBtN9sEo")
>>> solar_plus_intelbras.records(plant_id=12345, period="day", key="energy_today", start_date="2025-01-01", end_date="2025-01-01")
```

## Features

Python Solar Plus Intelbras supports the main endpoints of the Intelbras API:

- Plants: return the list of plants of account;
- Records: return the records of especific range;
- Inverters: return the inverters of account;
- Alerts: return the alerts of account;
- Notifications: return the notifications of account.

## Documentation

Project documentation is available at [https://hudsonbrendon.github.io/python-solar-plus-intelbras/](https://hudsonbrendon.github.io/python-solar-plus-intelbras/).

## Contribute

If you want to contribute with Python Solar Plus Intelbras check out the Contributing Guide to learn how to start.

```shell
$ git clone git@github.com:hudsonbrendon/python-solar-plus-intelbras.git
```

```shell
$ cd python-solar-plus-intelbras
```

```shell
$ poetry install
```

### Run tests

```shell
$ pytest
```
Or running via vscode interface.

## Dependencies

The Python Solar Plus project relies on these excellent libraries:

- poetry - A manager for virtualenvs and dependencies;
- requests - A client for http requests;
- pytest - The best lib python for tests;
- python 3 - support for python >= 3.8.

<div align="center">

`python solar plus intelbras` is made with 💙 by the [@hudsonbrendon](https://github.com/hudsonbrendon) and distributed under [MIT License](LICENSE.md).




</div>
kgrok 0.1.5
forward local processes into k8s cluster
Requires Python: >=3.12
Keywords: kubernetes, proxy

# Kgrok

## Quick Start

```
kgrok my-svc localhost:8080
```

We assume you have a service already listening locally on port 8080
and you have your `kubectl` context configured for the cluster you want to
listen receive traffic from.


## Installation

Using [pipx] might be the most reliable.

```
pipx install kgrok
```

[pipx]: https://pipx.pypa.io/stable/

If you are however already in a Python 3.12 virtual environment, or inside
a container with pip, you can probably get away with it.

```
python3 -m pip install kgrok
```
darksoulsapi 0.0.1
A Dark Souls: Remastered API for AI research
Requires Python: >=3.12

# Dark Souls: Remastered API

<img src="https://github.com/joconno2/dsapi/raw/main/grey_dsapi_logo.png" width=50%>

**A Dark Souls: Remastered Python API, enabling the development of real-time AI agents.**

## About
This repository provides an API for Dark Souls: Remastered, enabling the development of AI agents to interact with and play the game. The API handles game state detection, action execution, and provides a simple interface for training agents. Currently, the API exists to simulate boss fight scenarios.

### Features

- **Ability to simulate various boss scenarios**
- **Real-time game screen capture for visual input**
- **Easy framework for training artificial intelligence agents**

## Requirements

- **Operating System**: Windows only (due to `win32api` dependency)
- **Python**: 3.12 or higher
- **Game**: Dark Souls: Remastered must be installed already

## Installation

Install from PyPI:

```bash
pip install darksoulsapi
```

## Usage
### 1. Configure Game Settings

Before using the API, configure Dark Souls: Remastered with these settings:

- **Resolution**: Set to 800x600, windowed mode
- **Key Bindings**: Update the following in Key Settings:
  - "Right weapon action (attack)" → `t`
  - "Right weapon action (Strong Attack)" → `Shift + t`
  - "Left weapon action (block)" → `y`
  - "Left weapon action (parry)" → `Shift + y`

> **Note**: Custom key bindings help prevent mouse input issues.

### 2. Obtain Game Paths

The API requires two main paths:

1. **Game Directory**: Path to your Dark Souls: Remastered installation
   ```
   Example: "C:/Program Files (x86)/Steam/steamapps/common/DARK SOULS REMASTERED/"
   ```

2. **Save Directory**: Path to your Dark Souls save files
   ```
   Example: "C:/Users/username/Documents/NBGI/Dark Souls Remastered/1638/"
   ```


### 3. Basic usage (more examples in /examples folder)
```python
import darksoulsapi
import random
import time

# Create game environment with your paths
env = darksoulsapi.create_game_state(
    game_directory="C:/Program Files (x86)/Steam/steamapps/common/DARK SOULS REMASTERED/",
    save_directory="C:/Users/username/Documents/NBGI/DARK SOULS REMASTERED/1638/"
)

# Reset the game state and obtain pixel input
pixel_input = env.reset()

# Main game loop
terminated = False
while not terminated:
  # Choose a random action from the action space
  action_key, action_value = random.choice(list(env.action_space.items()))
  print("Performing", action_key)
  # Execute action and get new state
  pixel_input, terminated = env.step(action_value)
  # Pause to allow action to be followed through
  time.sleep(1.0)
print("Game Session Terminated")
```




## Testing
- Run the tests to make sure that the environment is set up correctly and working.
  - Tests for game screen being obtained properly (run `show_visual_feed.py`)
should-color 0.2.2
Determine if terminal output should be colored, respecting environment variables
Requires Python: >=3.8
Keywords: ansi, clicolor, color, no-color, terminal

should-color
===================

[![github](https://img.shields.io/badge/github-Techcable/should-color.py-master)](https://github.com/Techcable/should-color.py)
[![pypi](https://img.shields.io/pypi/v/should-color)](https://pypi.org/project/should-color)
![types](https://img.shields.io/pypi/types/should-color)

Determine if terminal output should be colored, respecting [`NO_COLOR`] and [`CLICOLOR`] environment variables.

On Unix, ANSI colors are enabled if the output is [`isatty`]. On Windows, ANSI colors are assumed to be unsupported unless or [`colorama`] is installed and enabled.

[`isatty`]: https://docs.python.org/3/library/io.html#io.IOBase.isatty
[`NO_COLOR`]: https://no-color.org/
[`CLICOLOR`]: https://bixense.com/clicolors/
[`colorama`]: https://pypi.org/project/colorama/

## Example Usage
```python
import sys
from should_color import should_color, apply_ansi_style

should_color(sys.stdout)
should_color(sys.stderr)
should_color('stdout')  # same as should_color(sys.stdout)
should_color('stderr')  # same as should_color(sys.stdout)
print(
    apply_ansi_style(
        "ERROR:",
        color="red",
        bold=True,
        # implicitly checks should_color('stdout'),
        # both these options are the implicit defaults if unspecified
        enabled='auto',
        file='stdout',
    ),
    "Fatal problem",
)
```

## License
Licensed under either the [Apache 2.0 License](./LICENSE-APACHE.txt) or [MIT License](./LICENSE-MIT.txt) at your option.

Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in this project by you, as defined in the Apache-2.0 license, shall be dual licensed as above, without any additional terms or conditions.