semvec/pypi-packages huggingface dataset:
suplalite 1.1.1
A lightweight implementation of SUPLA server and devices
Requires Python: >=3.10

suplalite
=========

A lightweight implementation of SUPLA server and devices in Python.

Install using `pip install suplalite`

Note: this project is not affiliated with SUPLA or Zamel -- this is not an "official" library.

suplalite.server
----------------

Provides a lightweight implementation of supla-server and supla-cloud.
Has just enough functionality to coordinate a set of SUPLA devices and
clients on a local network. Use over the public internet is not recommended.

This implementation does *not* require/provide:
 - A MySQL database
 - supla-cloud web interface
 - Logging of historical sensor data
 - Dynamic registration of devices
 - Authentication of clients

Configuration of the server is static, i.e. devices must be configured before starting the
server. Clients registration is not required -- any client is allowed to connect.

See `examples/server.py` for an example.

suplalite.device
----------------

Provides functionality necessary to create a SUPLA device using Python.

Currently supports the following kinds of channel:
 - Relay/switch
 - Temperature sensor
 - Humidity sensor
 - General purpose measurement
 - Dimmer
 - RGB dimmer

See `examples/device.py` for an example.
thunter 0.2.1
A CLI To Do list w/ time tracking.
Requires Python: >=3.10
Keywords: cli, task, todo, tracking

# Thunter

`thunter`, or task hunter, is a CLI To Do list with time tracking.

The purpose of `thunter` is to get better at time estimation, hence why you cannot create a task without a time estimate.

I made ths CLI tool so that I could piggy back off my pre-existing git workflows to estimate and track time spent on tasks.
See [git/thunter workflow](#my-gitthunter-workflow) for git hooks and aliases you can use to do the same.

<img src="img/create_task-pauses-removed.gif">

## Installation

Via pip
```
pip install thunter
```

Or via uv
```
uv tool install thunter
```

## Usage


The `thunter` CLI tool has commands for:
* `create` - create a new task and estimate it's length
* `workon` / `stop` to start and stop tracking time spent on a task
    * `thunter workon --create <task_name>` will create the task if needed and then start tracking time on it
* `finish` / `restart` to mark a task as completed or to undo that action and restart it
* `estimate` to update your estimate
* `edit` to edit any aspect of a task, including it's history
* `rm` to delete/remove tasks
* `db` will start a sqlite3 session with the thunter database. `tasks` and `history` are the 2 tables

### Configuration options
Environment variables (see [settings.py](thunter/settings.py)):
- `EDITOR` - editor to use for `thunter edit` command
- `THUNTER_DIRECTORY` - directory to store thunter files, e.g. the sqlite database of tasks
- `THUNTER_DATABASE_NAME` - filename of the database
- `THUNTER_SILENT` - silent all console output. set to true, 1, yes, or y. Useful for scripting. Commands all have the `--silent` option as well for the same effect.
- `DEBUG` - get stack traces on errors. Useful for development


## My git/thunter workflow

With the below hook and aliases:
* checking out a branch will start tracking time spent on it
* checking out `main` will stop tracking time
* deleting a branch will mark the task as finished

### *post-checkout*
```
#!/bin/bash
branch_name=$(git rev-parse --abbrev-ref HEAD)
is_branch_switch=$3
if [[ "$is_branch_switch" == "1" ]]; then
    if [[ "$branch_name" == "main" || "$branch_name" == "master" ]]; then
        # `hash thunter 2>/dev/null` is a check for the existence of thunter before calling it
        hash thunter 2>/dev/null && thunter stop
    else
        # `< /dev/tty` is needed to accept the user's time estimate input
        hash thunter 2>/dev/null && thunter workon --create "$branch_name" < /dev/tty
    fi
fi
```

### Git Aliases

```
## ~/.gitconfig

[alias]
    s = "!git status && hash thunter 2>/dev/null && if [ \"$(git rev-parse --abbrev-ref HEAD)\" = \"main\" ]; then THUNTER_SILENT=1 thunter stop; else THUNTER_SILENT=1 thunter workon --create $(git rev-parse --abbrev-ref HEAD); fi"
    bd = ! git branch -d $1 && hash thunter 2>/dev/null && THUNTER_SILENT=1 thunter finish
    bdd = ! git branch -D $1 && hash thunter 2>/dev/null && THUNTER_SILENT=1 thunter finish
```

# Coming Soon

`thunter analyze` command that will give options for some basic data analysis on how accurate your time estimates are.
keep_awake 1.1.2
Prevent your computer from going to sleep.
Requires Python: >=3.8
Keywords: sleep, prevent, awake, idle

# Keep Awake

Keep your system on and screen on, it will not fall asleep. It is useful in some long term calculations.



## How to use?

```shell
pip install keep_awake
```

This module exposes only two methods: `prevent_sleep` and `allow_sleep`, both of them taks no arguments.

`prevent_sleep` returns a boolean value that indicates whether the operation is successful. After you call this method, your system and screen will keep working until you invoke `allow_sleep`.

You won't have any exceptions by calling any methods twice, or calling `allow_sleep` without calling `prevent_sleep`, they have built-in protection.

If you forget to call `allow_sleep` before exiting your program, it doesn't matter, it will back to usual once the module is released.

We also provide a context manager for you to manage the state automatically, just like this:

```python
from keep_awake import KeepAwakeGuard

with KeepAwakeGuard():
    # do your work here
```



## Supported platforms

### macOS✅

Both arm64 and x64 are OK, this code only depends on `IOKit` and `CoreFoundation`, which is built-in macOS Framework.

Methods on macOS are concurrent safe.



### Windows✅

We didn't test widely on various versions of Windows because I have no more Windows computer :(

But basically, it can work fine on `Windows 10 x64` and `Windows 11 x64`. I have already tested.

Methods on Windows are concurrent safe.



### Linux⚠️

Linux distros are various, we can only support Gnome and KDE. They have dbus api so this part is implemented in pure python. If you need this feature, please install with this command:

```shell
pip install keep_awake[linux]
```

If you failed to install, try to use your package manager to install `cmake`, `pkg-config`, `libdbus-1-dev` and `libglib2.0-dev`.

Methods on Linux are concurrent safe.



## Building & Debugging

We use `uv` to manage the project, so it is very easy to build and test it.

For building:

```shell
uv build
```

For testing

```shell
uv run pytest
```