semvec/pypi-packages huggingface dataset:
typer-cli-tool 0.5.2
Typing practice in your terminal. Like monkeytype, but in the CLI.
Requires Python: >=3.8
Keywords: typing, typing-test, typing-speed, typing-practice, wpm, terminal, cli, monkeytype, speed-typing, keyboard, curses, typing-game, touch-typing

# typer

Typing practice in your terminal. Like [monkeytype](https://monkeytype.com), but in the CLI.

## Install

**Homebrew** (macOS/Linux):

```
brew tap William-Ger/typer
brew install typer
```

**pip**:

```
pip install typer-cli-tool
```

Then just run:

```
typer
```

## Usage

```
typer              # 30s medium (default)
typer -t 15        # 15 second test
typer -t 60        # 60 second test
typer -d hard      # hard difficulty
typer -t 15 -d easy # quick easy warmup
```

## Controls

| Key       | Action              |
|-----------|---------------------|
| `tab`     | restart / home      |
| `ctrl+q`  | quit                |
| `←` `→`  | change time         |
| `↑` `↓`  | change difficulty   |
| `click`   | click time/difficulty|
| `s`       | stats               |

## Features

- Timed tests: 15s, 30s, 60s, 120s
- Three difficulty levels (easy, medium, hard)
- Live WPM and accuracy while typing
- Personal stats: best WPM, streaks, per-difficulty averages, sparkline
- User profiles stored locally at `~/.config/typer/`
- Passive update check — shows update command if a new version is available

## Update

Homebrew:

```
brew update && brew upgrade typer
```

pip:

```
pip install --upgrade typer-cli-tool
```

## Zero dependencies

Pure Python. Only uses `curses` (built-in). Works on macOS and Linux out of the box.
librehardwaremonitor-api 1.10.1
A Python API client for LibreHardwareMonitor
Requires Python: >=3.11

# LibreHardwareMonitor API Client
A Python library for interacting with the [LibreHardwareMonitor](https://github.com/LibreHardwareMonitor/LibreHardwareMonitor) API.

## Overview
This library provides a simple interface for fetching data from the API provided by the inbuilt LibreHardwareMonitor web server.

## Installation
To install the library, run the following command:
```bash
pip install librehardwaremonitor-api
```

## Usage
The `LibreHardwareMonitorClient` takes the following parameters:
* Required:
  * `host` (str): hostname or IP address of your system
  * `port` (int): port used by Libre Hardware Monitor (default: 8085)
* Optional:
  * `username` (str): if you have set up authentication for the webserver in Libre Hardware Monitor
  * `password` (str): if you have set up authentication for the webserver in Libre Hardware Monitor
  * `session` (aiohttp.ClientSession): provide a aiohttp.ClientSession

The library provides one callable method:

* `get_data`: Returns a `LibreHardwareMonitorData` object containing the computer name, main hardware device names and all sensor data from your Libre Hardware Monitor instance.

`LibreHardwareMonitorData` has 4 properties with the following structure:
```
LibreHardwareMonitorData(
    computer_name: str
    # for example: "MY_COMPUTER"

    main_device_ids_and_names: dict[DeviceId, DeviceName]
    # for example:
    # {
    #     "amdcpu-0": "AMD Ryzen 7 7800X3D",
    #     "gpu-nvidia-0": "NVIDIA GeForce RTX 4080 SUPER"
    # }
    # the dictionary keys represent a unique device id.

    sensor_data: dict[str, LibreHardwareMonitorSensorData]
    # for example
    # {
    #     "amdcpu-0-power-0": {
    #         "name": Package Power",
    #         "value": "25.6",
    #         "type": "Power",
    #         "min": "25.2",
    #         "max": "76.4",
    #         "unit": "W",
    #         "device_id": "amdcpu-0",
    #         "device_name": "AMD Ryzen 7 7800X3D",
    #         "device_type": "CPU",
    #         "sensor_id": "amdcpu-0-power-0"
    #     },
    #     "amdcpu-0-power-1" : { ... },
    #     ...
    # }
    # the dictionary keys represent a unique sensor id.
    
    is_deprecated_version: bool
    # indicates whether the requested API version is deprecated
    # at the moment, versions <= 0.9.4 are deprecated
)
```

## Example
```
import asyncio
from librehardwaremonitor_api import LibreHardwareMonitorClient

async def main():
    client = LibreHardwareMonitorClient("192.168.1.100", 8085)

    lhm_data = await client.get_data()
    print(lhm_data.computer_name)
    print(lhm_data.main_device_ids_and_names)
    print(lhm_data.sensor_data)
    
    if lhm_data.is_deprecated_version:
        print("Deprecated version detected.")

asyncio.run(main())
```

## Development

This package uses uv as project manager.  
To set up a dev environment, clone the project and run 
````
uv sync
````
inside the project's root directory.  
Set up pre-commit hooks with:
```
uv run pre-commit install
```
Optionally, execute manually via:
```
uv run pre-commit run --all-files
```
dworshak-env 0.1.4
dworshak-env exists to make environment variables and .env files easy to access in Python programs and through the Dworshak ecosystem. With dworshak-env, Dworshak enables Python devs who already know how they like their configuration by inviting them to leverage the dworshak-prompt library and the dworshak CLI.
Requires Python: >=3.9
Keywords: environ, env, getenv, dotenv, .env


# dworshak-env

[GitHub: dworshak-env](https://github.com/your-org/dworshak-env)

`dworshak-env` provides a small, convenient interface for working with environment variables and `.env` files. It is designed to fit into existing workflows without introducing surprises.

This library does **not** replace `os.getenv`. Instead, it helps you manage environment variables in a predictable, Pythonic way and integrates naturally with the broader Dworshak ecosystem:

* [dworshak-prompt](https://github.com/your-org/dworshak-prompt) — prompting and configuration
* [dworshak-config](https://github.com/your-org/dworshak-config) — JSON-based configuration
* [dworshak-secret](https://github.com/your-org/dworshak-secret) — secure secret storage

Think of it as joining the herd: use modern `.env` patterns without creating a Dworshak-specific cult in `~/.dworshak/`.

---

## Installation

```bash
pip install dworshak-env
```

---

## Usage

### Simple access to environment variables

```python
from dworshak_env import DworshakEnv

env = DworshakEnv()
api_url = env.get("API_URL", default="https://api.github.com")
print(api_url)
```

### Loading from a `.env` file

```python
env = DworshakEnv(dotenv_path=".env")
db_password = env.get("DB_PASSWORD")
```

### Setting defaults

You can instantiate `DworshakEnv` with defaults that act as fallbacks:

```python
defaults = {"API_URL": "https://api.github.com", "DEBUG": "0"}
env = DworshakEnv(defaults=defaults)

print(env.get("API_URL"))  # returns the default if not set in environment
```

### Integration with `dworshak-prompt` and `dworshak-obtain`

`dworshak-env` can be used alongside `DworshakPrompt` and `DworshakObtain` to fetch values from the environment when prompting for config or secrets:

```python
from dworshak_prompt import DworshakPrompt

prompt = DworshakPrompt()
api_url = prompt.env("API_URL", default="https://api.github.com")
```

Or within `dworshak_obtain`:

```python
from dworshak_prompt import dworshak_obtain

token = dworshak_obtain(service="github", key="api_token", store="env")
```

---

## Philosophy

`dworshak-env` exists to make environment variables and `.env` files easy to access in Python programs.

It joins the mainstream patterns that Python developers already know, 
while providing smooth prompting to users via DworshakPrompt - because developers are users too.

Use it wherever you want predictable, Pythonic environment variable access, with optional integration into the Dworshak ecosystem.

---

## Links

* [dworshak-env](https://github.com/your-org/dworshak-env)
* [dworshak-prompt](https://github.com/your-org/dworshak-prompt)
* [dworshak-config](https://github.com/your-org/dworshak-config)
* [dworshak-secret](https://github.com/your-org/dworshak-secret)

---
arco 0.1.6
Python bindings for Arco optimization library
Requires Python: >=3.9
Keywords: optimization, linear-programming, mixed-integer-programming

# Arco Python bindings

Build and install locally with uv:

```bash
cd bindings/python
uv sync --group dev
uv run maturin develop
```

Run linting:

```bash
uv run ruff check .
uv run ty check .
```

Run examples:

```bash
uv run python examples/simple_lp.py
```
sapient-machine 0.0.1
Machine description
Requires Python: >=3.10
Keywords: sapient-machine

Sapient Machine
<pre>
  pip install sapient-machine
</pre>
Then:
```Python
  # Python
  import sapient_machine
```
Or:
```bash
  echo '[{"role": "user", "content": "I have a question..."}]' | \
  uvx sapient-machine \
    --PROVIDER_API_KEY=sk-ant-api... \
    --GITHUB_TOKEN=ghp_... \
    --mode=single
```
bertdotbillwebterminal 2.8.2
Webterminal Component for Bert's Interactive Lesson Loader
Requires Python: >=3.7
Keywords: browser-based, webterminal, xtermjs

# Overview

This is the Webterminal agent to be used with various projects I've developed, e.g.

- [bert.dashboard](https://github.com/berttejeda/bert.dashboard)
- [bert.bill](https://github.com/berttejeda/bert.bill) (superceded by above)
- [bert.slidev - webterminal addon](https://github.com/berttejeda/bert.slidev)

This agent allows the app's [xtermjs]((https://github.com/xtermjs/xterm.js/)) Webterminal React component to connect \
to a local bash process on your computer.

You can get this Webterminal agent running either by:

- Running the pre-built docker image:
  ```shell
  docker run -it --name webterminal --rm -p 10001:10001 berttejeda/bill-webterminal
  ```
- Running `docker-compose up -d` from this project
- Install btdashboard with `pip install btdashboard` and running `btdashboard`, OR \
  Cloning the [berttejeda/bert.dashboard](https://github.com/berttejeda/bert.dashboard) project, installing all requirements, and \
  running `python btdashboard/app.py -aio` \
  Doing so will launch a local websocket that forwards keystrokes to a bash process on your system
- Install bertdotbill with `pip install bertdotbill` and running `bill -aio`, OR \
  Cloning the [bert.bill](https://github.com/berttejeda/bert.bill) project, installing all requirements, and \
  running `python bertdotbill/app.py -aio` \
  Doing so will launch a local websocket that forwards keystrokes to a bash process on your system

Either of the commands above will start the websocket and bash process on localhost:10001, \
but you can change the port if you like.

You can then connect to the agent through the Web UI.

# Architecture

- Utilizes [spyder-terminal](https://github.com/spyder-ide/spyder-terminal) component

# Features

- You can practice the lesson material with your own OS/system
- Simply **click** on a command, and it will be sent and executed on the underlying shell via web terminal!
- Default shell is bash (for now)