semvec/pypi-packages huggingface dataset:
lowhum 1.0.1
Deep Brown Noise for Focus as a MenuBar App & CLI Tool
Requires Python: >=3.12
Keywords: audio, brown-noise, focus, macos, menu-bar

<p align="center">
  <img src="src/lowhum/icon.png" alt="LowHum icon" width="128">
</p>

# LowHum

**Deep brown noise for focus, right from the macOS menu bar.**

No browser tabs. No subscriptions. No account. Fully offline.

<!-- TODO: Add GIF demo here -->

Brown noise is one of the most effective focus aids for people with ADHD and anyone who needs to block out distractions. Most options require keeping a YouTube tab open, paying for a subscription app, or relying on your phone. LowHum is a single-purpose menu bar app that generates deep brown noise locally and plays it on loop — install it, click play, forget about it.

## Install

```bash
uv tool install lowhum          # recommended
# or
pip install lowhum
```

## Usage

```bash
lowhum                          # launch the menu-bar app
lowhum start                    # play immediately in terminal (Ctrl+C to stop)
lowhum start -d 3               # play on a specific output device
lowhum devices                  # list output devices
lowhum generate                 # pre-generate the audio file
```

`lhm` is a shorthand alias — all commands work with either name.

### Menu-bar app

- Play / Stop from the menu bar
- **Output Device** submenu — pick any connected audio device
- Auto-stops when headphones connect or disconnect

## How it works

1. **Generation** — On first run, a 10-minute WAV is synthesised locally: cumulative-sum brown noise, Butterworth bandpass (1–500 Hz + 20 Hz sub-bass HP), RMS-normalised per chunk, crossfaded at boundaries. Stored at `~/.lowhum/`.
2. **Playback** — Memory-mapped streaming through PortAudio. No full-file RAM load. Loops seamlessly.
3. **Device detection** — Polls audio devices every 2 seconds. Headphone unplug, Bluetooth disconnect — playback stops instantly.
4. **Menu-bar icon** — Template icon; macOS handles dark/light mode automatically.

## Requirements

- macOS
- Python >= 3.12

## License

MIT
hybrid-platform 0.0.2
Platform domain Gymnasium environment
Requires Python: >=3.7

# Hybrid Platform

A Gymnasium environment for the Platform domain, featuring a parameterized (hybrid) action space. This environment is widely used for benchmarking Reinforcement Learning algorithms that must handle both discrete action choices and continuous parameters simultaneously.

This is a modern fork of the original [gym-platform](https://github.com/cycraig/gym-platform), fully updated to use the [Gymnasium](https://github.com/Farama-Foundation/Gymnasium) API and modern `numpy`.

![gym-platform](ressources/platform_domain.png)

## Installation

You can install the package directly from PyPI:

```bash
pip install hybrid-platform
```

## Usage

```python
import gymnasium as gym
import gym_platform

# Create the environment
env = gym.make('Platform-v0', render_mode='human')

obs, info = env.reset()

for _ in range(100):
    # Action structure: (discrete_action_index, (param_0, param_1, param_2))
    # where param_X is an array of shape (1,)
    
    # Example: RUN (0) with speed 15.0
    action = (0, ([15.0], [0.0], [0.0]))
    
    obs, reward, terminated, truncated, info = env.step(action)
    
    env.render()

    if terminated or truncated:
        obs, info = env.reset()

env.close()
```

## Action Space

The action space is `spaces.Tuple((spaces.Discrete(3), spaces.Tuple((spaces.Box(1), spaces.Box(1), spaces.Box(1)))))`. It consists of:
1.  **Discrete(3)**: The high-level action choice.
    *   `0`: **Run** (Move horizontally)
    *   `1`: **Hop** (Small jump to clear gaps)
    *   `2`: **Leap** (Large jump to clear larger gaps)
2.  **Tuple(Box(1), Box(1), Box(1))**: The continuous parameters for each action.
    *   Parameter 0 (Run): Speed, range `[0, 30]`
    *   Parameter 1 (Hop): Power, range `[0, 720]`
    *   Parameter 2 (Leap): Power, range `[0, 430]`

When taking a step, the environment selects the parameter corresponding to the chosen discrete action index and ignores the others.

## Observation Space

The observation space is a `spaces.Tuple` containing:
1.  **Box(9,)**: The state vector (scaled).
    *   Basic features: `[player_x, player_vx, enemy_x, enemy_dx]`
    *   Platform features: `[platform_width_1, platform_width_2, gap, platform_position, height_diff]`
2.  **Discrete(200)**: The current time step (used for time awareness).

## Original Credits
*   Original Platform domain by Warwick Masson et al.
*   Original gym-platform implementation by [Craig Bester](https://github.com/cycraig).
e80_sdk 0.1.0a9
SDK for interacting with 8080.io
Requires Python: >=3.13

# 8080 SDK

Use the SDK to quickly build code deployed on the 8080 platform.

- Access secrets stored on the 8080 platform
- Automatic tracing, available on the 8080 platform
- Get an OpenAI SDK compatible object with:
    - Completions API
    - Responses API
- Create and interact with sandboxes
e80 0.1.0a9
CLI for interacting with 8080.io
Requires Python: >=3.13

# 8080 CLI

> [!NOTE]
> If you're just trying to use the 8080 API, see here. (TODO)

Use the 8080 CLI to build, deploy, and run hosted code on the 8080 platform.

Requirements:
  - [uv](https://astral.sh/uv)
  - Python 3.13
  - Docker version 29.1.5, build 0e6fee6 (or later)

## Quickstart

1. Create an 8080 account on https://app.8080.io

1. Install the tool: `uv tool install e80` (installs the `8080` command)

1. Login to your account `8080 login`

1. Initialize a project `8080 init hello-world; cd hello-world`

1. Run your project using the dev server: `8080 dev`

1. Deploy your project to 8080: `8080 deploy`

## More info

See the [e80_sdk](https://pypi.org/project/e80_sdk) package to interface with the 8080 API.