Compare commits
No commits in common. "main" and "v2.0.4" have entirely different histories.
288 changed files with 984 additions and 8651 deletions
29
.github/workflows/aurpublish.yml
vendored
29
.github/workflows/aurpublish.yml
vendored
|
|
@ -1,29 +0,0 @@
|
|||
---
|
||||
name: Upload AUR Package
|
||||
|
||||
on:
|
||||
release:
|
||||
types: [created]
|
||||
|
||||
jobs:
|
||||
aur-publish:
|
||||
runs-on: ubuntu-latest
|
||||
steps:
|
||||
- uses: actions/checkout@v2
|
||||
- name: Install dependencies
|
||||
run: |
|
||||
python -m pip install --upgrade pip
|
||||
pip install requests
|
||||
- name: Create PKGBUILD
|
||||
run: |
|
||||
python ./create-pkgbuild.py > ./PKGBUILD
|
||||
- name: Publish AUR package
|
||||
uses: KSXGitHub/github-actions-deploy-aur@v2.5.0
|
||||
with:
|
||||
pkgname: bumblebee-status
|
||||
pkgbuild: ./PKGBUILD
|
||||
commit_username: ${{ secrets.AUR_USERNAME }}
|
||||
commit_email: ${{ secrets.AUR_EMAIL }}
|
||||
ssh_private_key: ${{ secrets.AUR_SSH_PRIVATE_KEY }}
|
||||
commit_message: Update AUR package
|
||||
ssh_keyscan_types: rsa,dsa,ecdsa,ed25519
|
||||
45
.github/workflows/autotest.yml
vendored
45
.github/workflows/autotest.yml
vendored
|
|
@ -1,45 +0,0 @@
|
|||
name: Tests
|
||||
|
||||
on:
|
||||
pull_request:
|
||||
types: [ opened, reopened, edited ]
|
||||
push:
|
||||
|
||||
env:
|
||||
CC_TEST_REPORTER_ID: 40cb00907f7a10e04868e856570bb997ab9c42fd3b63d980f2b2269433195fdf
|
||||
|
||||
jobs:
|
||||
test:
|
||||
runs-on: ubuntu-latest
|
||||
strategy:
|
||||
matrix:
|
||||
python-version: ['3.8', '3.9', '3.10', '3.11']
|
||||
|
||||
steps:
|
||||
- uses: actions/checkout@v3
|
||||
- name: Set up Python ${{ matrix.python-version }}
|
||||
uses: actions/setup-python@v4
|
||||
with:
|
||||
python-version: ${{ matrix.python-version }}
|
||||
cache: 'pip'
|
||||
- name: Install Ubuntu dependencies
|
||||
run: sudo apt-get install -y libdbus-1-dev libgit2-dev libvirt-dev taskwarrior
|
||||
- name: Install Python dependencies
|
||||
run: |
|
||||
python -m pip install --upgrade pip
|
||||
pip install -U coverage pytest pytest-mock freezegun
|
||||
pip install 'pygit2<1' 'libvirt-python<6.3' 'feedparser<6' || true
|
||||
pip install $(cat requirements/modules/*.txt | grep -v power | cut -d ' ' -f 1 | sort -u)
|
||||
- name: Install Code Climate dependency
|
||||
run: |
|
||||
curl -L https://codeclimate.com/downloads/test-reporter/test-reporter-latest-linux-amd64 > ./cc-test-reporter
|
||||
chmod +x ./cc-test-reporter
|
||||
./cc-test-reporter before-build
|
||||
- name: Run tests
|
||||
run: |
|
||||
coverage run --source=. -m pytest tests -v
|
||||
- name: Report coverage
|
||||
uses: paambaati/codeclimate-action@v3.2.0
|
||||
with:
|
||||
coverageCommand: coverage3 xml
|
||||
debug: true
|
||||
70
.github/workflows/codeql-analysis.yml
vendored
70
.github/workflows/codeql-analysis.yml
vendored
|
|
@ -1,70 +0,0 @@
|
|||
# For most projects, this workflow file will not need changing; you simply need
|
||||
# to commit it to your repository.
|
||||
#
|
||||
# You may wish to alter this file to override the set of languages analyzed,
|
||||
# or to provide custom queries or build logic.
|
||||
#
|
||||
# ******** NOTE ********
|
||||
# We have attempted to detect the languages in your repository. Please check
|
||||
# the `language` matrix defined below to confirm you have the correct set of
|
||||
# supported CodeQL languages.
|
||||
#
|
||||
name: "CodeQL"
|
||||
|
||||
on:
|
||||
push:
|
||||
branches: [ main ]
|
||||
pull_request:
|
||||
# The branches below must be a subset of the branches above
|
||||
branches: [ main ]
|
||||
schedule:
|
||||
- cron: '31 0 * * 4'
|
||||
|
||||
jobs:
|
||||
analyze:
|
||||
name: Analyze
|
||||
runs-on: ubuntu-latest
|
||||
permissions:
|
||||
actions: read
|
||||
contents: read
|
||||
security-events: write
|
||||
|
||||
strategy:
|
||||
fail-fast: false
|
||||
matrix:
|
||||
language: [ 'python' ]
|
||||
# CodeQL supports [ 'cpp', 'csharp', 'go', 'java', 'javascript', 'python', 'ruby' ]
|
||||
# Learn more about CodeQL language support at https://git.io/codeql-language-support
|
||||
|
||||
steps:
|
||||
- name: Checkout repository
|
||||
uses: actions/checkout@v2
|
||||
|
||||
# Initializes the CodeQL tools for scanning.
|
||||
- name: Initialize CodeQL
|
||||
uses: github/codeql-action/init@v1
|
||||
with:
|
||||
languages: ${{ matrix.language }}
|
||||
# If you wish to specify custom queries, you can do so here or in a config file.
|
||||
# By default, queries listed here will override any specified in a config file.
|
||||
# Prefix the list here with "+" to use these queries and those in the config file.
|
||||
# queries: ./path/to/local/query, your-org/your-repo/queries@main
|
||||
|
||||
# Autobuild attempts to build any compiled languages (C/C++, C#, or Java).
|
||||
# If this step fails, then you should remove it and run the build manually (see below)
|
||||
- name: Autobuild
|
||||
uses: github/codeql-action/autobuild@v1
|
||||
|
||||
# ℹ️ Command-line programs to run using the OS shell.
|
||||
# 📚 https://git.io/JvXDl
|
||||
|
||||
# ✏️ If the Autobuild fails above, remove it and uncomment the following three lines
|
||||
# and modify them (or add more) to build your code if your project
|
||||
# uses a compiled language
|
||||
|
||||
#- run: |
|
||||
# make bootstrap
|
||||
# make release
|
||||
|
||||
- name: Perform CodeQL Analysis
|
||||
uses: github/codeql-action/analyze@v1
|
||||
2
.gitignore
vendored
2
.gitignore
vendored
|
|
@ -1,5 +1,3 @@
|
|||
*.o
|
||||
|
||||
# Vim swap files
|
||||
*swp
|
||||
*~
|
||||
|
|
|
|||
|
|
@ -1,9 +0,0 @@
|
|||
version: 2
|
||||
|
||||
python:
|
||||
install:
|
||||
- requirements: docs/requirements.txt
|
||||
build:
|
||||
os: ubuntu-22.04
|
||||
tools:
|
||||
python: "3"
|
||||
18
.travis.yml
Normal file
18
.travis.yml
Normal file
|
|
@ -0,0 +1,18 @@
|
|||
sudo: false
|
||||
language: python
|
||||
python:
|
||||
- "3.4"
|
||||
- "3.5"
|
||||
- "3.6"
|
||||
- "3.7"
|
||||
before_install:
|
||||
- sudo apt-get -qq update
|
||||
install:
|
||||
- pip install -U coverage==4.3 pytest pytest-mock
|
||||
- pip install codeclimate-test-reporter
|
||||
script:
|
||||
- coverage run --source=. -m pytest tests -v
|
||||
- CODECLIMATE_REPO_TOKEN=40cb00907f7a10e04868e856570bb997ab9c42fd3b63d980f2b2269433195fdf codeclimate-test-reporter
|
||||
addons:
|
||||
code_climate:
|
||||
repo_token: 40cb00907f7a10e04868e856570bb997ab9c42fd3b63d980f2b2269433195fdf
|
||||
|
|
@ -12,5 +12,6 @@ But even if you can't provide those, any indicator that something is not working
|
|||
|
||||
### Adding a new module or theme
|
||||
If you want to add a new module, please have a look at [how to write a new module](docs/development/module.rst) and [how to write a new theme](docs/development/theme.rst). Then simply create a Pull Request and I will review the changes as soon as possible.
|
||||
If you want to do me a *big* favour, check the Travis status for any failing unit tests. Oh - and if you happen to add unit tests, that's also something I am very grateful for!
|
||||
|
||||
Thanks for reading until here! :)
|
||||
|
|
|
|||
|
|
@ -1,45 +0,0 @@
|
|||
# Maintainer: Tobias Witek <tobi@tobi-wan-kenobi.at>
|
||||
# Contributor: Daniel M. Capella <polycitizen@gmail.com>
|
||||
# Contributor: spookykidmm <https://github.com/spookykidmm>
|
||||
|
||||
pkgname=bumblebee-status
|
||||
pkgver=<PKGVERSION>
|
||||
pkgrel=1
|
||||
pkgdesc='Modular, theme-able status line generator for the i3 window manager'
|
||||
arch=('any')
|
||||
url=https://github.com/tobi-wan-kenobi/bumblebee-status
|
||||
license=('MIT')
|
||||
depends=('python' 'python-netifaces' 'python-psutil' 'python-requests')
|
||||
optdepends=('xorg-xbacklight: to display a displays brightness'
|
||||
'xorg-xset: enable/disable automatic screen locking'
|
||||
'libnotify: enable/disable automatic screen locking'
|
||||
'dnf: display DNF package update information'
|
||||
'xorg-setxkbmap: display/change the current keyboard layout'
|
||||
'redshift: display the redshifts current color'
|
||||
'pulseaudio: control pulseaudio sink/sources'
|
||||
'xorg-xrandr: enable/disable screen outputs'
|
||||
'pacman: display current status of pacman'
|
||||
'iputils: display a ping'
|
||||
'python-i3ipc: display titlebar'
|
||||
'fakeroot: dependency of the pacman module'
|
||||
'python-pytz: timezone conversion for datetimetz module'
|
||||
'python-tzlocal: retrieve system timezone for datetimetz module'
|
||||
)
|
||||
source=("$pkgname-$pkgver.tar.gz::$url/archive/v$pkgver.tar.gz")
|
||||
sha512sums=('<SHA512SUM>')
|
||||
|
||||
package() {
|
||||
install -d "$pkgdir"/usr/bin \
|
||||
"$pkgdir"/usr/share/$pkgname/bumblebee_status/{core,util} \
|
||||
"$pkgdir"/usr/share/$pkgname/bumblebee_status/modules/{core,contrib} \
|
||||
"$pkgdir"/usr/share/$pkgname/themes/icons
|
||||
ln -s /usr/share/$pkgname/$pkgname "$pkgdir"/usr/bin/$pkgname
|
||||
ln -s /usr/share/$pkgname/bumblebee-ctl "$pkgdir"/usr/bin/bumblebee-ctl
|
||||
|
||||
cd $pkgname-$pkgver
|
||||
cp -a --parents $pkgname bumblebee_status/{,core/,util/,modules/core/,modules/contrib/}*.py \
|
||||
themes/{,icons/}*.json $pkgdir/usr/share/$pkgname
|
||||
cp -r bin $pkgdir/usr/share/$pkgname/
|
||||
|
||||
install -Dm644 LICENSE "$pkgdir"/usr/share/licenses/$pkgname/LICENSE
|
||||
}
|
||||
28
README.md
28
README.md
|
|
@ -1,21 +1,13 @@
|
|||
<img src="https://github.com/kellya/bumblebee-status-icon/blob/main/img/bumblebee_status_rtl.svg" width="50" style="display:inline-block">bumblebee-status
|
||||
=====================================================
|
||||
|
||||
logo courtesy of [kellya](https://github.com/kellya) - thank you!
|
||||
# bumblebee-status
|
||||
|
||||
[](https://travis-ci.org/tobi-wan-kenobi/bumblebee-status)
|
||||
[](https://bumblebee-status.readthedocs.io/en/main/?badge=main)
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
[](https://github.com/tobi-wan-kenobi/bumblebee-status/actions/workflows/autotest.yml)
|
||||
|
||||
[](https://badge.fury.io/py/bumblebee-status)
|
||||
[](https://codeclimate.com/github/tobi-wan-kenobi/bumblebee-status)
|
||||
[](https://codeclimate.com/github/tobi-wan-kenobi/bumblebee-status/coverage)
|
||||
[](https://codeclimate.com/github/tobi-wan-kenobi/bumblebee-status)
|
||||
[](https://github.com/tobi-wan-kenobi/bumblebee-status/actions/workflows/codeql-analysis.yml)
|
||||
|
||||
|
||||
**Many, many thanks to all contributors! I am still amazed by and deeply grateful for how many PRs this project gets.**
|
||||
|
||||
|
|
@ -36,14 +28,16 @@ Thanks a lot!
|
|||
|
||||
Required i3wm version: 4.12+ (in earlier versions, blocks won't have background colors)
|
||||
|
||||
Supported Python versions: 3.4, 3.5, 3.6, 3.7, 3.8, 3.9
|
||||
Supported Python versions: 3.4, 3.5, 3.6, 3.7, 3.8
|
||||
|
||||
Supported FontAwesome version: 4 (free version of 5 doesn't include some of the icons)
|
||||
|
||||
---
|
||||
***NOTE***
|
||||
**NOTE**
|
||||
|
||||
The default branch for this project is `main`. If you are curious why: [ZDNet:github-master-alternative](https://www.zdnet.com/article/github-to-replace-master-with-alternative-term-to-avoid-slavery-references/)
|
||||
The default branch for this project is `main` - I'm keeping `master` around for backwards compatibility (I do not want to break anybody's setup), but the default branch is now `main`!
|
||||
|
||||
If you are curious why: [ZDNet:github-master-alternative](https://www.zdnet.com/article/github-to-replace-master-with-alternative-term-to-avoid-slavery-references/)
|
||||
|
||||
---
|
||||
|
||||
|
|
@ -82,16 +76,10 @@ makepkg -sicr
|
|||
pip install --user bumblebee-status
|
||||
```
|
||||
|
||||
There is also a SlackBuild available here: [slackbuilds:bumblebee-status](http://slackbuilds.org/repository/14.2/desktop/bumblebee-status/) - many thanks to [@Tonus1](https://github.com/Tonus1)!
|
||||
|
||||
An ebuild, for Gentoo Linux, is available on [gallifrey overlay](https://github.com/fedeliallalinea/gallifrey/tree/master/x11-misc/bumblebee-status). Instructions for adding the overlay can be found [here](https://github.com/fedeliallalinea/gallifrey/blob/master/README.md).
|
||||
|
||||
# Dependencies
|
||||
[Available modules](https://bumblebee-status.readthedocs.io/en/main/modules.html) lists the dependencies (Python modules and external executables)
|
||||
for each module. If you are not using a module, you don't need the dependencies.
|
||||
|
||||
Some themes (e.g. all ‘powerline’ themes) require Font Awesome http://fontawesome.io/ and a powerline-compatible font (powerline-fonts) https://github.com/powerline/fonts
|
||||
|
||||
# Usage
|
||||
## Normal usage
|
||||
In your i3wm configuration, modify the *status_command* for your i3bar like this:
|
||||
|
|
|
|||
|
|
@ -12,7 +12,6 @@ button = {
|
|||
"right-mouse": 3,
|
||||
"wheel-up": 4,
|
||||
"wheel-down": 5,
|
||||
"update": -1,
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -21,7 +20,7 @@ def main():
|
|||
parser.add_argument(
|
||||
"-b",
|
||||
"--button",
|
||||
choices=["left-mouse", "right-mouse", "middle-mouse", "wheel-up", "wheel-down", "update"],
|
||||
choices=["left-mouse", "right-mouse", "middle-mouse", "wheel-up", "wheel-down"],
|
||||
help="button to emulate",
|
||||
default="left-mouse",
|
||||
)
|
||||
|
|
|
|||
|
|
@ -1,11 +1,11 @@
|
|||
#!/usr/bin/env python3
|
||||
#!/usr/bin/env python
|
||||
|
||||
import os
|
||||
import sys
|
||||
import json
|
||||
import time
|
||||
import signal
|
||||
import socket
|
||||
import select
|
||||
import logging
|
||||
import threading
|
||||
|
||||
|
|
@ -38,48 +38,44 @@ class CommandSocket(object):
|
|||
self.__socket.close()
|
||||
os.unlink(self.__name)
|
||||
|
||||
def process_event(event_line, config, update_lock):
|
||||
|
||||
def handle_input(output, update_lock):
|
||||
with CommandSocket() as cmdsocket:
|
||||
poll = select.poll()
|
||||
poll.register(sys.stdin.fileno(), select.POLLIN)
|
||||
poll.register(cmdsocket, select.POLLIN)
|
||||
|
||||
while True:
|
||||
events = poll.poll()
|
||||
|
||||
modules = {}
|
||||
for fileno, event in events:
|
||||
if fileno == cmdsocket.fileno():
|
||||
tmp, _ = cmdsocket.accept()
|
||||
line = tmp.recv(4096).decode()
|
||||
tmp.close()
|
||||
logging.debug("socket event {}".format(line))
|
||||
else:
|
||||
line = "["
|
||||
while line.startswith("["):
|
||||
line = sys.stdin.readline().strip(",").strip()
|
||||
logging.info("input event: {}".format(line))
|
||||
try:
|
||||
event = json.loads(event_line)
|
||||
event = json.loads(line)
|
||||
core.input.trigger(event)
|
||||
if "name" in event:
|
||||
modules[event["name"]] = True
|
||||
except ValueError:
|
||||
pass
|
||||
|
||||
delay = float(config.get("engine.input_delay", 0.0))
|
||||
if delay > 0:
|
||||
time.sleep(delay)
|
||||
if update_lock.acquire(blocking=False) == True:
|
||||
core.event.trigger("update", modules.keys(), force=True)
|
||||
update_lock.acquire()
|
||||
core.event.trigger("update", modules.keys())
|
||||
core.event.trigger("draw")
|
||||
update_lock.release()
|
||||
|
||||
def handle_commands(config, update_lock):
|
||||
with CommandSocket() as cmdsocket:
|
||||
while True:
|
||||
tmp, _ = cmdsocket.accept()
|
||||
line = tmp.recv(4096).decode()
|
||||
tmp.close()
|
||||
logging.debug("socket event {}".format(line))
|
||||
process_event(line, config, update_lock)
|
||||
|
||||
|
||||
def handle_events(config, update_lock):
|
||||
while True:
|
||||
try:
|
||||
line = sys.stdin.readline().strip(",").strip()
|
||||
if line == "[": continue
|
||||
logging.info("input event: {}".format(line))
|
||||
process_event(line, config, update_lock)
|
||||
except Exception as e:
|
||||
logging.error(e)
|
||||
poll.unregister(sys.stdin.fileno())
|
||||
|
||||
|
||||
def main():
|
||||
global started
|
||||
|
||||
config = core.config.Config(sys.argv[1:])
|
||||
level = logging.DEBUG if config.debug() else logging.ERROR
|
||||
if config.logfile():
|
||||
|
|
@ -102,23 +98,10 @@ def main():
|
|||
core.input.register(None, core.input.WHEEL_UP, "i3-msg workspace prev_on_output")
|
||||
core.input.register(None, core.input.WHEEL_DOWN, "i3-msg workspace next_on_output")
|
||||
|
||||
core.event.trigger("start")
|
||||
started = True
|
||||
|
||||
update_lock = threading.Lock()
|
||||
event_thread = threading.Thread(target=handle_events, args=(config, update_lock, ))
|
||||
event_thread.daemon = True
|
||||
event_thread.start()
|
||||
|
||||
cmd_thread = threading.Thread(target=handle_commands, args=(config, update_lock, ))
|
||||
cmd_thread.daemon = True
|
||||
cmd_thread.start()
|
||||
|
||||
def sig_USR1_handler(signum,stack):
|
||||
if update_lock.acquire(blocking=False) == True:
|
||||
core.event.trigger("update", force=True)
|
||||
core.event.trigger("draw")
|
||||
update_lock.release()
|
||||
input_thread = threading.Thread(target=handle_input, args=(output, update_lock, ))
|
||||
input_thread.daemon = True
|
||||
input_thread.start()
|
||||
|
||||
if config.debug():
|
||||
modules.append(core.module.load("debug", config, theme))
|
||||
|
|
@ -135,7 +118,8 @@ def main():
|
|||
if util.format.asbool(config.get("engine.collapsible", True)) == True:
|
||||
core.input.register(None, core.input.MIDDLE_MOUSE, output.toggle_minimize)
|
||||
|
||||
signal.signal(10, sig_USR1_handler)
|
||||
core.event.trigger("start")
|
||||
started = True
|
||||
while True:
|
||||
if update_lock.acquire(blocking=False) == True:
|
||||
core.event.trigger("update")
|
||||
|
|
@ -152,7 +136,6 @@ if __name__ == "__main__":
|
|||
main()
|
||||
except Exception as e:
|
||||
# really basic errors -> make sure these are shown in the status bar by minimal config
|
||||
logging.exception(e)
|
||||
if not started:
|
||||
print("{\"version\":1}")
|
||||
print("[")
|
||||
|
|
|
|||
|
|
@ -292,7 +292,7 @@ def git_pieces_from_vcs(tag_prefix, root, verbose, run_command=run_command):
|
|||
# TAG-NUM-gHEX
|
||||
mo = re.search(r"^(.+)-(\d+)-g([0-9a-f]+)$", git_describe)
|
||||
if not mo:
|
||||
# unparsable. Maybe git-describe is misbehaving?
|
||||
# unparseable. Maybe git-describe is misbehaving?
|
||||
pieces["error"] = "unable to parse git-describe output: '%s'" % describe_out
|
||||
return pieces
|
||||
|
||||
|
|
|
|||
|
|
@ -71,11 +71,6 @@ class print_usage(argparse.Action):
|
|||
)
|
||||
|
||||
rst = {}
|
||||
|
||||
if self._format == "rst":
|
||||
print(".. THIS DOCUMENT IS AUTO-GENERATED, DO NOT MODIFY")
|
||||
print(".. To change this document, please update the docstrings in the individual modules")
|
||||
|
||||
for m in all_modules():
|
||||
try:
|
||||
module_type = "core"
|
||||
|
|
@ -147,13 +142,6 @@ class Config(util.store.Store):
|
|||
parser = argparse.ArgumentParser(
|
||||
description="bumblebee-status is a modular, theme-able status line generator for the i3 window manager. https://github.com/tobi-wan-kenobi/bumblebee-status/wiki"
|
||||
)
|
||||
parser.add_argument(
|
||||
"-c",
|
||||
"--config-file",
|
||||
action="store",
|
||||
default=None,
|
||||
help="Specify a configuration file to use"
|
||||
)
|
||||
parser.add_argument(
|
||||
"-m", "--modules", nargs="+", action="append", default=[], help=MODULE_HELP
|
||||
)
|
||||
|
|
@ -165,7 +153,7 @@ class Config(util.store.Store):
|
|||
default=[],
|
||||
help=PARAMETER_HELP,
|
||||
)
|
||||
parser.add_argument("-t", "--theme", default=None, help=THEME_HELP)
|
||||
parser.add_argument("-t", "--theme", default="default", help=THEME_HELP)
|
||||
parser.add_argument(
|
||||
"-i",
|
||||
"--iconset",
|
||||
|
|
@ -179,13 +167,6 @@ class Config(util.store.Store):
|
|||
default=[],
|
||||
help="Specify a list of modules to hide when not in warning/error state",
|
||||
)
|
||||
parser.add_argument(
|
||||
"-e",
|
||||
"--errorhide",
|
||||
nargs="+",
|
||||
default=[],
|
||||
help="Specify a list of modules that are hidden when in state error"
|
||||
)
|
||||
parser.add_argument(
|
||||
"-d", "--debug", action="store_true", help="Add debug fields to i3 output"
|
||||
)
|
||||
|
|
@ -210,11 +191,6 @@ class Config(util.store.Store):
|
|||
|
||||
self.__args = parser.parse_args(args)
|
||||
|
||||
if self.__args.config_file:
|
||||
cfg = self.__args.config_file
|
||||
cfg = os.path.expanduser(cfg)
|
||||
self.load_config(cfg)
|
||||
else:
|
||||
for cfg in [
|
||||
"~/.bumblebee-status.conf",
|
||||
"~/.config/bumblebee-status.conf",
|
||||
|
|
@ -240,24 +216,15 @@ class Config(util.store.Store):
|
|||
:param filename: path to the file to load
|
||||
"""
|
||||
|
||||
def load_config(self, filename, content=None):
|
||||
if os.path.exists(filename) or content != None:
|
||||
def load_config(self, filename):
|
||||
if os.path.exists(filename):
|
||||
log.info("loading {}".format(filename))
|
||||
tmp = RawConfigParser()
|
||||
tmp.optionxform = str
|
||||
|
||||
if content:
|
||||
tmp.read_string(content)
|
||||
else:
|
||||
tmp.read(u"{}".format(filename))
|
||||
|
||||
if tmp.has_section("module-parameters"):
|
||||
for key, value in tmp.items("module-parameters"):
|
||||
self.set(key, value)
|
||||
if tmp.has_section("core"):
|
||||
for key, value in tmp.items("core"):
|
||||
self.set(key, value)
|
||||
|
||||
|
||||
"""Returns a list of configured modules
|
||||
|
||||
|
|
@ -266,11 +233,7 @@ class Config(util.store.Store):
|
|||
"""
|
||||
|
||||
def modules(self):
|
||||
list_of_modules = [item for sub in self.__args.modules for item in sub]
|
||||
|
||||
if list_of_modules == []:
|
||||
list_of_modules = util.format.aslist(self.get('modules', []))
|
||||
return list_of_modules
|
||||
return [item for sub in self.__args.modules for item in sub]
|
||||
|
||||
"""Returns the global update interval
|
||||
|
||||
|
|
@ -281,15 +244,6 @@ class Config(util.store.Store):
|
|||
def interval(self, default=1):
|
||||
return util.format.seconds(self.get("interval", default))
|
||||
|
||||
"""Returns the global popup menu font size
|
||||
|
||||
:return: popup menu font size
|
||||
:rtype: int
|
||||
"""
|
||||
|
||||
def popup_font_size(self, default=12):
|
||||
return util.format.asint(self.get("popup_font_size", default))
|
||||
|
||||
"""Returns whether debug mode is enabled
|
||||
|
||||
:return: True if debug is enabled, False otherwise
|
||||
|
|
@ -324,7 +278,7 @@ class Config(util.store.Store):
|
|||
"""
|
||||
|
||||
def theme(self):
|
||||
return self.__args.theme or self.get("theme") or "default"
|
||||
return self.__args.theme
|
||||
|
||||
"""Returns the configured iconset name
|
||||
|
||||
|
|
@ -335,21 +289,14 @@ class Config(util.store.Store):
|
|||
def iconset(self):
|
||||
return self.__args.iconset
|
||||
|
||||
"""Returns whether a module should be hidden if their state is not warning/critical
|
||||
"""Returns which modules should be hidden if their state is not warning/critical
|
||||
|
||||
:return: True if module should be hidden automatically, False otherwise
|
||||
:rtype: bool
|
||||
:return: list of modules to hide automatically
|
||||
:rtype: list of strings
|
||||
"""
|
||||
|
||||
def autohide(self, name):
|
||||
return name in self.__args.autohide or name in util.format.aslist(self.get("autohide", []))
|
||||
return name in self.__args.autohide
|
||||
|
||||
"""Returns which modules should be hidden if they are in state error
|
||||
|
||||
:return: returns True if name should be hidden, False otherwise
|
||||
:rtype: bool
|
||||
"""
|
||||
def errorhide(self, name):
|
||||
return name in self.__args.errorhide
|
||||
|
||||
# vim: tabstop=8 expandtab shiftwidth=4 softtabstop=4
|
||||
|
|
|
|||
|
|
@ -8,16 +8,6 @@ def register(event, callback, *args, **kwargs):
|
|||
|
||||
__callbacks.setdefault(event, []).append(cb)
|
||||
|
||||
def register_exclusive(event, callback, *args, **kwargs):
|
||||
cb = callback
|
||||
if args or kwargs:
|
||||
cb = lambda: callback(*args, **kwargs)
|
||||
|
||||
__callbacks[event] = [cb]
|
||||
|
||||
def unregister(event):
|
||||
if event in __callbacks:
|
||||
del __callbacks[event]
|
||||
|
||||
def clear():
|
||||
__callbacks.clear()
|
||||
|
|
|
|||
|
|
@ -10,7 +10,6 @@ MIDDLE_MOUSE = 2
|
|||
RIGHT_MOUSE = 3
|
||||
WHEEL_UP = 4
|
||||
WHEEL_DOWN = 5
|
||||
UPDATE = -1
|
||||
|
||||
|
||||
def button_name(button):
|
||||
|
|
@ -24,8 +23,6 @@ def button_name(button):
|
|||
return "wheel-up"
|
||||
if button == WHEEL_DOWN:
|
||||
return "wheel-down"
|
||||
if button == UPDATE:
|
||||
return "update"
|
||||
return "n/a"
|
||||
|
||||
|
||||
|
|
@ -53,14 +50,10 @@ def __execute(event, cmd, wait=False):
|
|||
def register(obj, button=None, cmd=None, wait=False):
|
||||
event_id = __event_id(obj.id if obj is not None else "", button)
|
||||
logging.debug("registering callback {}".format(event_id))
|
||||
core.event.unregister(event_id) # make sure there's always only one input event
|
||||
|
||||
if callable(cmd):
|
||||
core.event.register_exclusive(event_id, cmd)
|
||||
elif obj and hasattr(obj, cmd) and callable(getattr(obj, cmd)):
|
||||
core.event.register_exclusive(event_id, lambda event: getattr(obj, cmd)(event))
|
||||
core.event.register(event_id, cmd)
|
||||
else:
|
||||
core.event.register_exclusive(event_id, lambda event: __execute(event, cmd, wait))
|
||||
core.event.register(event_id, lambda event: __execute(event, cmd, wait))
|
||||
|
||||
|
||||
def trigger(event):
|
||||
|
|
|
|||
|
|
@ -1,6 +1,5 @@
|
|||
import os
|
||||
import importlib
|
||||
import importlib.util
|
||||
import logging
|
||||
import threading
|
||||
|
||||
|
|
@ -18,27 +17,6 @@ except Exception as e:
|
|||
|
||||
log = logging.getLogger(__name__)
|
||||
|
||||
def import_user(module_short, config, theme):
|
||||
usermod = os.path.expanduser("~/.config/bumblebee-status/modules/{}.py".format(module_short))
|
||||
if os.path.exists(usermod):
|
||||
if hasattr(importlib, "machinery"):
|
||||
log.debug("importing {} from user via machinery".format(module_short))
|
||||
mod = importlib.machinery.SourceFileLoader("modules.{}".format(module_short),
|
||||
os.path.expanduser(usermod)).load_module()
|
||||
return getattr(mod, "Module")(config, theme)
|
||||
else:
|
||||
log.debug("importing {} from user via importlib.util".format(module_short))
|
||||
try:
|
||||
spec = importlib.util.spec_from_file_location("modules.{}".format(module_short), usermod)
|
||||
mod = importlib.util.module_from_spec(spec)
|
||||
spec.loader.exec_module(mod)
|
||||
return mod.Module(config, theme)
|
||||
except Exception as e:
|
||||
spec = importlib.util.find_spec("modules.{}".format(module_short), usermod)
|
||||
mod = importlib.util.module_from_spec(spec)
|
||||
spec.loader.exec_module(mod)
|
||||
return mod.Module(config, theme)
|
||||
raise ImportError("not found")
|
||||
|
||||
"""Loads a module by name
|
||||
|
||||
|
|
@ -55,25 +33,20 @@ def load(module_name, config=core.config.Config([]), theme=None):
|
|||
error = None
|
||||
module_short, alias = (module_name.split(":") + [module_name])[0:2]
|
||||
config.set("__alias__", alias)
|
||||
|
||||
for namespace in ["core", "contrib"]:
|
||||
try:
|
||||
mod = importlib.import_module("modules.core.{}".format(module_short))
|
||||
log.debug("importing {} from core".format(module_short))
|
||||
mod = importlib.import_module(
|
||||
"modules.{}.{}".format(namespace, module_short)
|
||||
)
|
||||
log.debug(
|
||||
"importing {} from {}.{}".format(module_short, namespace, module_short)
|
||||
)
|
||||
return getattr(mod, "Module")(config, theme)
|
||||
except ImportError as e:
|
||||
try:
|
||||
log.warning("failed to import {} from core: {}".format(module_short, e))
|
||||
mod = importlib.import_module("modules.contrib.{}".format(module_short))
|
||||
log.debug("importing {} from contrib".format(module_short))
|
||||
return getattr(mod, "Module")(config, theme)
|
||||
except ImportError as e:
|
||||
try:
|
||||
log.warning("failed to import {} from system: {}".format(module_short, e))
|
||||
return import_user(module_short, config, theme)
|
||||
except ImportError as e:
|
||||
log.fatal("import failed: {}".format(e))
|
||||
log.fatal("failed to import {}".format(module_short))
|
||||
return Error(config=config, module=module_name, error="unable to load module")
|
||||
log.debug("failed to import {}: {}".format(module_name, e))
|
||||
error = e
|
||||
log.fatal("failed to import {}: {}".format(module_name, error))
|
||||
return Error(config=config, module=module_name, error=error)
|
||||
|
||||
|
||||
class Module(core.input.Object):
|
||||
|
|
@ -96,8 +69,6 @@ class Module(core.input.Object):
|
|||
self.alias = self.__config.get("__alias__", None)
|
||||
self.id = self.alias if self.alias else self.name
|
||||
self.next_update = None
|
||||
self.minimized = False
|
||||
self.minimized = self.parameter("start-minimized", False)
|
||||
|
||||
self.theme = theme
|
||||
|
||||
|
|
@ -113,15 +84,6 @@ class Module(core.input.Object):
|
|||
def hidden(self):
|
||||
return False
|
||||
|
||||
"""Override this to show the module even if it normally would be scrolled away
|
||||
|
||||
:return: True if the module should be hidden, False otherwise
|
||||
:rtype: boolean
|
||||
"""
|
||||
|
||||
def scroll(self):
|
||||
return True
|
||||
|
||||
"""Retrieve CLI/configuration parameters for this module. For example, if
|
||||
the module is called "test" and the user specifies "-p test.x=123" on the
|
||||
commandline, using self.parameter("x") retrieves the value 123.
|
||||
|
|
@ -138,8 +100,6 @@ class Module(core.input.Object):
|
|||
|
||||
for prefix in [self.name, self.module_name, self.alias]:
|
||||
value = self.__config.get("{}.{}".format(prefix, key), value)
|
||||
if self.minimized:
|
||||
value = self.__config.get("{}.minimized.{}".format(prefix, key), value)
|
||||
return value
|
||||
|
||||
"""Set a parameter for this module
|
||||
|
|
@ -163,7 +123,7 @@ class Module(core.input.Object):
|
|||
|
||||
def update_wrapper(self):
|
||||
if self.background == True:
|
||||
if self.__thread and self.__thread.is_alive():
|
||||
if self.__thread and self.__thread.isAlive():
|
||||
return # skip this update interval
|
||||
self.__thread = threading.Thread(target=self.internal_update, args=(True,))
|
||||
self.__thread.start()
|
||||
|
|
@ -210,9 +170,9 @@ class Module(core.input.Object):
|
|||
:rtype: bumblebee_status.widget.Widget
|
||||
"""
|
||||
|
||||
def add_widget(self, full_text="", name=None, hidden=False):
|
||||
def add_widget(self, full_text="", name=None):
|
||||
widget_id = "{}::{}".format(self.name, len(self.widgets()))
|
||||
widget = core.widget.Widget(full_text=full_text, name=name, widget_id=widget_id, hidden=hidden)
|
||||
widget = core.widget.Widget(full_text=full_text, name=name, widget_id=widget_id)
|
||||
self.widgets().append(widget)
|
||||
widget.module = self
|
||||
return widget
|
||||
|
|
@ -305,7 +265,7 @@ class Error(Module):
|
|||
def full_text(self, widget):
|
||||
return "{}: {}".format(self.__module, self.__error)
|
||||
|
||||
"""Overridden state, always returns critical (it *is* an error, after all"""
|
||||
"""Overriden state, always returns critical (it *is* an error, after all"""
|
||||
|
||||
def state(self, widget):
|
||||
return ["critical"]
|
||||
|
|
|
|||
|
|
@ -1,7 +1,6 @@
|
|||
import sys
|
||||
import json
|
||||
import time
|
||||
import threading
|
||||
|
||||
import core.theme
|
||||
import core.event
|
||||
|
|
@ -58,9 +57,6 @@ class block(object):
|
|||
def set(self, key, value):
|
||||
self.__attributes[key] = value
|
||||
|
||||
def get(self, key, default=None):
|
||||
return self.__attributes.get(key, default)
|
||||
|
||||
def is_pango(self, attr):
|
||||
if isinstance(attr, dict) and "pango" in attr:
|
||||
return True
|
||||
|
|
@ -95,17 +91,9 @@ class block(object):
|
|||
assign(self.__attributes, result, "background", "bg")
|
||||
|
||||
if "full_text" in self.__attributes:
|
||||
prefix = self.__pad(self.pangoize(self.__attributes.get("prefix")))
|
||||
suffix = self.__pad(self.pangoize(self.__attributes.get("suffix")))
|
||||
self.set("_prefix", prefix)
|
||||
self.set("_suffix", suffix)
|
||||
self.set("_raw", self.get("full_text"))
|
||||
result["full_text"] = self.pangoize(result["full_text"])
|
||||
result["full_text"] = self.__format(self.__attributes["full_text"])
|
||||
|
||||
if "min-width" in self.__attributes and "padding" in self.__attributes:
|
||||
self.set("min-width", self.__format(self.get("min-width")))
|
||||
|
||||
for k in [
|
||||
"name",
|
||||
"instance",
|
||||
|
|
@ -135,8 +123,11 @@ class block(object):
|
|||
def __format(self, text):
|
||||
if text is None:
|
||||
return None
|
||||
prefix = self.get("_prefix")
|
||||
suffix = self.get("_suffix")
|
||||
prefix = self.__pad(self.pangoize(self.__attributes.get("prefix")))
|
||||
suffix = self.__pad(self.pangoize(self.__attributes.get("suffix")))
|
||||
self.set("_prefix", prefix)
|
||||
self.set("_suffix", suffix)
|
||||
self.set("_raw", text)
|
||||
return "{}{}{}".format(prefix, text, suffix)
|
||||
|
||||
|
||||
|
|
@ -146,14 +137,10 @@ class i3(object):
|
|||
self.__content = {}
|
||||
self.__theme = theme
|
||||
self.__config = config
|
||||
self.__offset = 0
|
||||
self.__lock = threading.Lock()
|
||||
core.event.register("update", self.update)
|
||||
core.event.register("start", self.draw, "start")
|
||||
core.event.register("draw", self.draw, "statusline")
|
||||
core.event.register("stop", self.draw, "stop")
|
||||
core.event.register("output.scroll-left", self.scroll_left)
|
||||
core.event.register("output.scroll-right", self.scroll_right)
|
||||
|
||||
def content(self):
|
||||
return self.__content
|
||||
|
|
@ -171,17 +158,10 @@ class i3(object):
|
|||
def toggle_minimize(self, event):
|
||||
widget_id = event["instance"]
|
||||
|
||||
for module in self.__modules:
|
||||
if module.widget(widget_id=widget_id) and util.format.asbool(module.parameter("minimize", False)) == True:
|
||||
# this module can customly minimize
|
||||
module.minimized = not module.minimized
|
||||
return
|
||||
|
||||
if widget_id in self.__content:
|
||||
self.__content[widget_id]["minimized"] = not self.__content[widget_id]["minimized"]
|
||||
|
||||
def draw(self, what, args=None):
|
||||
with self.__lock:
|
||||
cb = getattr(self, what)
|
||||
data = cb(args) if args else cb()
|
||||
if "blocks" in data:
|
||||
|
|
@ -226,57 +206,29 @@ class i3(object):
|
|||
blk.set("__state", state)
|
||||
return blk
|
||||
|
||||
def scroll_left(self):
|
||||
if self.__offset > 0:
|
||||
self.__offset -= 1
|
||||
|
||||
def scroll_right(self):
|
||||
self.__offset += 1
|
||||
|
||||
def blocks(self, module):
|
||||
blocks = []
|
||||
if module.minimized:
|
||||
blocks.extend(self.separator_block(module, module.widgets()[0]))
|
||||
blocks.append(self.__content_block(module, module.widgets()[0]))
|
||||
self.__widgetcount += 1
|
||||
return blocks
|
||||
|
||||
width = self.__config.get("output.width", 0)
|
||||
for widget in module.widgets():
|
||||
if module.scroll() == True and width > 0:
|
||||
self.__widgetcount += 1
|
||||
if self.__widgetcount-1 < self.__offset:
|
||||
continue
|
||||
if self.__widgetcount-1 >= self.__offset + width:
|
||||
continue
|
||||
if widget.module and self.__config.autohide(widget.module.name):
|
||||
if not any(
|
||||
state in widget.state() for state in ["warning", "critical", "no-autohide"]
|
||||
state in widget.state() for state in ["warning", "critical"]
|
||||
):
|
||||
continue
|
||||
if module.hidden():
|
||||
continue
|
||||
if widget.hidden:
|
||||
continue
|
||||
if "critical" in widget.state() and self.__config.errorhide(widget.module.name):
|
||||
continue
|
||||
blocks.extend(self.separator_block(module, widget))
|
||||
blocks.append(self.__content_block(module, widget))
|
||||
core.event.trigger("next-widget")
|
||||
core.event.trigger("output.done", self.__offset, self.__widgetcount)
|
||||
return blocks
|
||||
|
||||
def update(self, affected_modules=None, redraw_only=False, force=False):
|
||||
with self.__lock:
|
||||
self.update2(affected_modules, redraw_only, force)
|
||||
|
||||
def update2(self, affected_modules=None, redraw_only=False, force=False):
|
||||
# TODO: only updates full text, not the state!?
|
||||
def update(self, affected_modules=None, redraw_only=False):
|
||||
now = time.time()
|
||||
for module in self.__modules:
|
||||
if affected_modules and not module.id in affected_modules:
|
||||
continue
|
||||
if not affected_modules and module.next_update:
|
||||
if now < module.next_update and not force:
|
||||
if now < module.next_update:
|
||||
continue
|
||||
|
||||
if not redraw_only:
|
||||
|
|
@ -294,7 +246,6 @@ class i3(object):
|
|||
|
||||
def statusline(self):
|
||||
blocks = []
|
||||
self.__widgetcount = 0
|
||||
for module in self.__modules:
|
||||
blocks.extend(self.blocks(module))
|
||||
return {"blocks": blocks, "suffix": ","}
|
||||
|
|
|
|||
|
|
@ -7,27 +7,16 @@ import glob
|
|||
|
||||
import core.event
|
||||
import util.algorithm
|
||||
import util.xresources
|
||||
|
||||
log = logging.getLogger(__name__)
|
||||
|
||||
THEME_BASE_DIR = os.path.dirname(os.path.realpath(__file__))
|
||||
PATHS = [
|
||||
".",
|
||||
os.path.join(THEME_BASE_DIR, "../../themes")
|
||||
]
|
||||
|
||||
if os.environ.get("XDG_DATA_DIRS"):
|
||||
PATHS.extend([
|
||||
os.path.join(p, "bumblebee-status/themes") for p in os.environ["XDG_DATA_DIRS"].split(":")
|
||||
])
|
||||
|
||||
PATHS.extend([
|
||||
os.path.join(THEME_BASE_DIR, "../../themes"),
|
||||
os.path.expanduser("~/.config/bumblebee-status/themes"),
|
||||
os.path.expanduser("~/.local/share/bumblebee-status/themes"), # PIP
|
||||
os.path.expanduser("~/.local/pipx/venvs/bumblebee-status/share/bumblebee-status/themes"), # PIPX
|
||||
"/usr/share/bumblebee-status/themes",
|
||||
])
|
||||
]
|
||||
|
||||
|
||||
def themes():
|
||||
|
|
@ -64,7 +53,7 @@ class Theme(object):
|
|||
self.__data = raw_data if raw_data else self.load(name)
|
||||
|
||||
for icons in self.__data.get("icons", []):
|
||||
self.__data = util.algorithm.merge(self.__data, self.load(icons, "icons"))
|
||||
self.__data = util.algorithm.merge(self.load(icons, "icons"), self.__data)
|
||||
if iconset != "auto":
|
||||
self.__data = util.algorithm.merge(self.load(iconset, "icons"), self.__data)
|
||||
for colors in self.__data.get("colors", []):
|
||||
|
|
@ -100,20 +89,12 @@ class Theme(object):
|
|||
try:
|
||||
if isinstance(name, dict):
|
||||
return name
|
||||
|
||||
result = {}
|
||||
if name.lower() == "wal":
|
||||
wal = self.__load_json("~/.cache/wal/colors.json")
|
||||
result = {}
|
||||
for field in ["special", "colors"]:
|
||||
for key in wal.get(field, {}):
|
||||
result[key] = wal[field][key]
|
||||
if name.lower() == "xresources":
|
||||
for key in ("background", "foreground"):
|
||||
result[key] = xresources.query(key)
|
||||
for i in range(16):
|
||||
key = color + str(i)
|
||||
result[key] = xresources.query(key)
|
||||
|
||||
return result
|
||||
except Exception as e:
|
||||
log.error("failed to load colors: {}", e)
|
||||
|
|
|
|||
|
|
@ -10,13 +10,12 @@ log = logging.getLogger(__name__)
|
|||
|
||||
|
||||
class Widget(util.store.Store, core.input.Object):
|
||||
def __init__(self, full_text="", name=None, widget_id=None, hidden=False):
|
||||
def __init__(self, full_text="", name=None, widget_id=None):
|
||||
super(Widget, self).__init__()
|
||||
self.__full_text = full_text
|
||||
self.module = None
|
||||
self.name = name
|
||||
self.id = widget_id or self.id
|
||||
self.hidden = hidden
|
||||
|
||||
@property
|
||||
def module(self):
|
||||
|
|
|
|||
|
|
@ -1,18 +1,12 @@
|
|||
"""get volume level or control it
|
||||
|
||||
Requires the following executable:
|
||||
* amixer
|
||||
|
||||
Parameters:
|
||||
* amixer.card: Sound Card to use (default is 0)
|
||||
* amixer.device: Device to use (default is Master,0)
|
||||
* amixer.percent_change: How much to change volume by when scrolling on the module (default is 4%)
|
||||
|
||||
contributed by `zetxx <https://github.com/zetxx>`_ - many thanks!
|
||||
|
||||
input handling contributed by `ardadem <https://github.com/ardadem>`_ - many thanks!
|
||||
|
||||
multiple audio cards contributed by `hugoeustaquio <https://github.com/hugoeustaquio>`_ - many thanks!
|
||||
"""
|
||||
import re
|
||||
|
||||
|
|
@ -29,7 +23,6 @@ class Module(core.module.Module):
|
|||
|
||||
self.__level = "n/a"
|
||||
self.__muted = True
|
||||
self.__card = self.parameter("card", "0")
|
||||
self.__device = self.parameter("device", "Master,0")
|
||||
self.__change = util.format.asint(
|
||||
self.parameter("percent_change", "4%").strip("%"), 0, 100
|
||||
|
|
@ -66,7 +59,7 @@ class Module(core.module.Module):
|
|||
self.set_parameter("{}%-".format(self.__change))
|
||||
|
||||
def set_parameter(self, parameter):
|
||||
util.cli.execute("amixer -c {} -q set {} {}".format(self.__card, self.__device, parameter))
|
||||
util.cli.execute("amixer -q set {} {}".format(self.__device, parameter))
|
||||
|
||||
def volume(self, widget):
|
||||
if self.__level == "n/a":
|
||||
|
|
@ -83,7 +76,7 @@ class Module(core.module.Module):
|
|||
def update(self):
|
||||
try:
|
||||
self.__level = util.cli.execute(
|
||||
"amixer -c {} get {}".format(self.__card, self.__device)
|
||||
"amixer get {}".format(self.__device)
|
||||
)
|
||||
except Exception as e:
|
||||
self.__level = "n/a"
|
||||
|
|
|
|||
|
|
@ -14,7 +14,6 @@ import threading
|
|||
import core.module
|
||||
import core.widget
|
||||
import core.decorators
|
||||
import core.input
|
||||
|
||||
import util.cli
|
||||
|
||||
|
|
@ -57,8 +56,6 @@ class Module(core.module.Module):
|
|||
def __init__(self, config, theme):
|
||||
super().__init__(config, theme, core.widget.Widget(self.updates))
|
||||
self.__thread = None
|
||||
core.input.register(self, button=core.input.RIGHT_MOUSE,
|
||||
cmd=self.updates)
|
||||
|
||||
def updates(self, widget):
|
||||
if widget.get("error"):
|
||||
|
|
@ -68,7 +65,7 @@ class Module(core.module.Module):
|
|||
)
|
||||
|
||||
def update(self):
|
||||
if self.__thread and self.__thread.is_alive():
|
||||
if self.__thread and self.__thread.isAlive():
|
||||
return
|
||||
|
||||
self.__thread = threading.Thread(target=get_apt_check_info, args=(self,))
|
||||
|
|
|
|||
|
|
@ -8,9 +8,6 @@ saved screen layout as well as toggle on/off individual connected displays.
|
|||
Parameters:
|
||||
* No configuration parameters
|
||||
|
||||
Requires the following python modules:
|
||||
* tkinter
|
||||
|
||||
Requires the following executable:
|
||||
* arandr
|
||||
* xrandr
|
||||
|
|
@ -57,7 +54,7 @@ class Module(core.module.Module):
|
|||
def activate_layout(layout_path):
|
||||
log.debug("activating layout")
|
||||
log.debug(layout_path)
|
||||
execute(layout_path, ignore_errors=True)
|
||||
execute(layout_path)
|
||||
|
||||
def popup(self, widget):
|
||||
"""Create Popup that allows the user to control their displays in one
|
||||
|
|
@ -67,7 +64,7 @@ class Module(core.module.Module):
|
|||
menu = popup.menu()
|
||||
menu.add_menuitem(
|
||||
"arandr",
|
||||
callback=partial(execute, self.manager, ignore_errors=True)
|
||||
callback=partial(execute, self.manager)
|
||||
)
|
||||
menu.add_separator()
|
||||
|
||||
|
|
@ -108,12 +105,11 @@ class Module(core.module.Module):
|
|||
if count_on == 1:
|
||||
log.info("attempted to turn off last display")
|
||||
return
|
||||
execute("{} --output {} --off".format(self.toggle_cmd, display), ignore_errors=True)
|
||||
execute("{} --output {} --off".format(self.toggle_cmd, display))
|
||||
else:
|
||||
log.debug("toggling on {}".format(display))
|
||||
execute(
|
||||
"{} --output {} --auto".format(self.toggle_cmd, display),
|
||||
ignore_errors=True
|
||||
"{} --output {} --auto".format(self.toggle_cmd, display)
|
||||
)
|
||||
|
||||
@staticmethod
|
||||
|
|
@ -124,7 +120,7 @@ class Module(core.module.Module):
|
|||
connected).
|
||||
"""
|
||||
displays = {}
|
||||
for line in execute("xrandr -q", ignore_errors=True).split("\n"):
|
||||
for line in execute("xrandr -q").split("\n"):
|
||||
if "connected" not in line:
|
||||
continue
|
||||
is_on = bool(re.search(r"\d+x\d+\+(\d+)\+\d+", line))
|
||||
|
|
@ -140,7 +136,6 @@ class Module(core.module.Module):
|
|||
def _get_layouts():
|
||||
"""Loads and parses the arandr screen layout scripts."""
|
||||
layouts = {}
|
||||
try:
|
||||
for filename in os.listdir(__screenlayout_dir__):
|
||||
if fnmatch.fnmatch(filename, '*.sh'):
|
||||
fullpath = os.path.join(__screenlayout_dir__, filename)
|
||||
|
|
@ -151,8 +146,6 @@ class Module(core.module.Module):
|
|||
continue
|
||||
displays_in_file = Module._parse_layout(line)
|
||||
layouts[filename] = displays_in_file
|
||||
except Exception as e:
|
||||
log.error(str(e))
|
||||
return layouts
|
||||
|
||||
@staticmethod
|
||||
|
|
|
|||
|
|
@ -7,7 +7,6 @@ contributed by `lucassouto <https://github.com/lucassouto>`_ - many thanks!
|
|||
"""
|
||||
|
||||
import logging
|
||||
from time import sleep
|
||||
|
||||
import core.module
|
||||
import core.widget
|
||||
|
|
@ -36,13 +35,12 @@ class Module(core.module.Module):
|
|||
|
||||
def update(self):
|
||||
self.__error = False
|
||||
sleep(1)
|
||||
code, result = util.cli.execute(
|
||||
"checkupdates", ignore_errors=True, return_exitcode=True
|
||||
)
|
||||
|
||||
if code == 0:
|
||||
self.__packages = len(result.strip().split("\n"))
|
||||
self.__packages = len(result.split("\n"))
|
||||
elif code == 2:
|
||||
self.__packages = 0
|
||||
else:
|
||||
|
|
|
|||
|
|
@ -1 +0,0 @@
|
|||
arch-update.py
|
||||
|
|
@ -1,57 +0,0 @@
|
|||
"""Check updates for AUR.
|
||||
|
||||
Requires the following executable:
|
||||
* yay (https://github.com/Jguer/yay)
|
||||
|
||||
contributed by `ishaanbhimwal <https://github.com/ishaanbhimwal>`_ - many thanks!
|
||||
"""
|
||||
|
||||
import logging
|
||||
|
||||
import core.module
|
||||
import core.widget
|
||||
import core.decorators
|
||||
|
||||
import util.cli
|
||||
|
||||
|
||||
class Module(core.module.Module):
|
||||
@core.decorators.every(minutes=60)
|
||||
def __init__(self, config, theme):
|
||||
super().__init__(config, theme, core.widget.Widget(self.utilization))
|
||||
self.background = True
|
||||
self.__packages = 0
|
||||
self.__error = False
|
||||
|
||||
@property
|
||||
def __format(self):
|
||||
return self.parameter("format", "Update AUR: {}")
|
||||
|
||||
def utilization(self, widget):
|
||||
return self.__format.format(self.__packages)
|
||||
|
||||
def hidden(self):
|
||||
return self.__packages == 0
|
||||
|
||||
def update(self):
|
||||
self.__error = False
|
||||
code, result = util.cli.execute(
|
||||
"yay -Qum", ignore_errors=True, return_exitcode=True
|
||||
)
|
||||
|
||||
if code == 0:
|
||||
if result == "":
|
||||
self.__packages = 0
|
||||
else:
|
||||
self.__packages = len(result.strip().split("\n"))
|
||||
else:
|
||||
self.__error = True
|
||||
logging.error("aur-update exited with {}: {}".format(code, result))
|
||||
|
||||
def state(self, widget):
|
||||
if self.__error:
|
||||
return "warning"
|
||||
return self.threshold_state(self.__packages, 1, 100)
|
||||
|
||||
|
||||
# vim: tabstop=8 expandtab shiftwidth=4 softtabstop=4
|
||||
|
|
@ -68,7 +68,7 @@ class UPowerManager:
|
|||
isPresent = battery_proxy_interface.Get(
|
||||
self.UPOWER_NAME + ".Device", "IsPresent"
|
||||
)
|
||||
isRechargeable = battery_proxy_interface.Get(
|
||||
isRechargable = battery_proxy_interface.Get(
|
||||
self.UPOWER_NAME + ".Device", "IsRechargeable"
|
||||
)
|
||||
online = battery_proxy_interface.Get(self.UPOWER_NAME + ".Device", "Online")
|
||||
|
|
@ -128,7 +128,7 @@ class UPowerManager:
|
|||
"HasHistory": hasHistory,
|
||||
"HasStatistics": hasStatistics,
|
||||
"IsPresent": isPresent,
|
||||
"IsRechargeable": isRechargeable,
|
||||
"IsRechargeable": isRechargable,
|
||||
"Online": online,
|
||||
"PowerSupply": powersupply,
|
||||
"Capacity": capacity,
|
||||
|
|
@ -207,14 +207,6 @@ class UPowerManager:
|
|||
data = upower_interface.GetTotal()
|
||||
return data
|
||||
|
||||
def is_battery_present(self, battery):
|
||||
battery_proxy = self.bus.get_object(self.UPOWER_NAME, battery)
|
||||
battery_proxy_interface = dbus.Interface(battery_proxy, self.DBUS_PROPERTIES)
|
||||
|
||||
return bool(
|
||||
battery_proxy_interface.Get(self.UPOWER_NAME + ".Device", "IsPresent")
|
||||
)
|
||||
|
||||
def is_loading(self, battery):
|
||||
battery_proxy = self.bus.get_object(self.UPOWER_NAME, battery)
|
||||
battery_proxy_interface = dbus.Interface(battery_proxy, self.DBUS_PROPERTIES)
|
||||
|
|
@ -267,11 +259,6 @@ class Module(core.module.Module):
|
|||
widget.set("capacity", -1)
|
||||
widget.set("ac", False)
|
||||
output = "n/a"
|
||||
if not self.power.is_battery_present(self.device):
|
||||
widget.set("ac", True)
|
||||
widget.set("capacity", 100)
|
||||
output = "ac"
|
||||
return output
|
||||
try:
|
||||
capacity = int(self.power.get_device_percentage(self.device))
|
||||
capacity = capacity if capacity < 100 else 100
|
||||
|
|
@ -311,6 +298,11 @@ class Module(core.module.Module):
|
|||
if capacity < 0:
|
||||
return ["critical", "unknown"]
|
||||
|
||||
if capacity < int(self.parameter("critical", 10)):
|
||||
state.append("critical")
|
||||
elif capacity < int(self.parameter("warning", 20)):
|
||||
state.append("warning")
|
||||
|
||||
if widget.get("ac"):
|
||||
state.append("AC")
|
||||
else:
|
||||
|
|
@ -336,16 +328,6 @@ class Module(core.module.Module):
|
|||
state.append("charged")
|
||||
else:
|
||||
state.append("charging")
|
||||
if (
|
||||
capacity < int(self.parameter("critical", 10))
|
||||
and self.power.get_state(self.device) == "Discharging"
|
||||
):
|
||||
state.append("critical")
|
||||
elif (
|
||||
capacity < int(self.parameter("warning", 20))
|
||||
and self.power.get_state(self.device) == "Discharging"
|
||||
):
|
||||
state.append("warning")
|
||||
return state
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -130,19 +130,10 @@ class Module(core.module.Module):
|
|||
log.debug("adding new widget for {}".format(battery))
|
||||
widget = self.add_widget(full_text=self.capacity, name=battery)
|
||||
|
||||
try:
|
||||
with open("/sys/class/power_supply/{}/model_name".format(battery)) as f:
|
||||
widget.set("pen", ("Pen" in f.read().strip()))
|
||||
except Exception:
|
||||
pass
|
||||
|
||||
for w in self.widgets():
|
||||
if util.format.asbool(self.parameter("decorate", True)) == False:
|
||||
for widget in self.widgets():
|
||||
widget.set("theme.exclude", "suffix")
|
||||
|
||||
def hidden(self):
|
||||
return len(self._batteries) == 0
|
||||
|
||||
def ac(self, widget):
|
||||
return "ac"
|
||||
|
||||
|
|
@ -153,16 +144,15 @@ class Module(core.module.Module):
|
|||
capacity = self.__manager.capacity(widget.name)
|
||||
widget.set("capacity", capacity)
|
||||
widget.set("ac", self.__manager.isac_any(self._batteries))
|
||||
widget.set("theme.minwidth", "100%")
|
||||
|
||||
# Read power conumption
|
||||
if util.format.asbool(self.parameter("showpowerconsumption", False)):
|
||||
output = "{}% ({})".format(
|
||||
capacity, self.__manager.consumption(widget.name)
|
||||
)
|
||||
elif capacity < 100:
|
||||
output = "{}%".format(capacity)
|
||||
else:
|
||||
output = ""
|
||||
output = "{}%".format(capacity)
|
||||
|
||||
if (
|
||||
util.format.asbool(self.parameter("showremaining", True))
|
||||
|
|
@ -174,16 +164,6 @@ class Module(core.module.Module):
|
|||
output, util.format.duration(remaining, compact=True, unit=True)
|
||||
)
|
||||
|
||||
# if bumblebee.util.asbool(self.parameter("rate", True)):
|
||||
# try:
|
||||
# with open("{}/power_now".format(widget.name)) as f:
|
||||
# rate = (float(f.read())/1000000)
|
||||
# if rate > 0:
|
||||
# output = "{} {:.2f}w".format(output, rate)
|
||||
# except Exception:
|
||||
# pass
|
||||
|
||||
|
||||
if util.format.asbool(self.parameter("showdevice", False)):
|
||||
output = "{} ({})".format(output, widget.name)
|
||||
|
||||
|
|
@ -193,13 +173,15 @@ class Module(core.module.Module):
|
|||
state = []
|
||||
capacity = widget.get("capacity")
|
||||
|
||||
if widget.get("pen"):
|
||||
state.append("PEN")
|
||||
|
||||
if capacity < 0:
|
||||
log.debug("battery state: {}".format(state))
|
||||
return ["critical", "unknown"]
|
||||
|
||||
if capacity < int(self.parameter("critical", 10)):
|
||||
state.append("critical")
|
||||
elif capacity < int(self.parameter("warning", 20)):
|
||||
state.append("warning")
|
||||
|
||||
if widget.get("ac"):
|
||||
state.append("AC")
|
||||
else:
|
||||
|
|
@ -207,10 +189,16 @@ class Module(core.module.Module):
|
|||
charge = self.__manager.charge_any(self._batteries)
|
||||
else:
|
||||
charge = self.__manager.charge(widget.name)
|
||||
if charge in ["Discharging", "Unknown"]:
|
||||
if charge == "Discharging":
|
||||
state.append(
|
||||
"discharging-{}".format(
|
||||
min([5, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100], key=lambda i: abs(i - capacity))
|
||||
min([10, 25, 50, 80, 100], key=lambda i: abs(i - capacity))
|
||||
)
|
||||
)
|
||||
elif charge == "Unknown":
|
||||
state.append(
|
||||
"unknown-{}".format(
|
||||
min([10, 25, 50, 80, 100], key=lambda i: abs(i - capacity))
|
||||
)
|
||||
)
|
||||
else:
|
||||
|
|
@ -218,18 +206,6 @@ class Module(core.module.Module):
|
|||
state.append("charged")
|
||||
else:
|
||||
state.append("charging")
|
||||
|
||||
if (
|
||||
capacity < int(self.parameter("critical", 10))
|
||||
and self.__manager.charge_any(self._batteries) == "Discharging"
|
||||
):
|
||||
state.append("critical")
|
||||
elif (
|
||||
capacity < int(self.parameter("warning", 20))
|
||||
and self.__manager.charge_any(self._batteries) == "Discharging"
|
||||
):
|
||||
state.append("warning")
|
||||
|
||||
return state
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -1 +0,0 @@
|
|||
battery-upower.py
|
||||
|
|
@ -1,4 +1,4 @@
|
|||
"""Displays bluetooth status (Bluez). Left mouse click launches manager app `blueman-manager`,
|
||||
"""Displays bluetooth status (Bluez). Left mouse click launches manager app,
|
||||
right click toggles bluetooth. Needs dbus-send to toggle bluetooth state.
|
||||
|
||||
Parameters:
|
||||
|
|
@ -75,15 +75,19 @@ class Module(core.module.Module):
|
|||
|
||||
def popup(self, widget):
|
||||
"""Show a popup menu."""
|
||||
menu = util.popup.menu(self.__config)
|
||||
menu = util.popup.PopupMenu()
|
||||
if self._status == "On":
|
||||
menu.add_menuitem("Disable Bluetooth", callback=self._toggle)
|
||||
menu.add_menuitem("Disable Bluetooth")
|
||||
elif self._status == "Off":
|
||||
menu.add_menuitem("Enable Bluetooth", callback=self._toggle)
|
||||
menu.add_menuitem("Enable Bluetooth")
|
||||
else:
|
||||
return
|
||||
|
||||
menu.show(widget)
|
||||
# show menu and get return code
|
||||
ret = menu.show(widget)
|
||||
if ret == 0:
|
||||
# first (and only) item selected.
|
||||
self._toggle()
|
||||
|
||||
def _toggle(self, widget=None):
|
||||
"""Toggle bluetooth state."""
|
||||
|
|
@ -102,7 +106,7 @@ class Module(core.module.Module):
|
|||
)
|
||||
|
||||
logging.debug("bt: toggling bluetooth")
|
||||
util.cli.execute(cmd, ignore_errors=True)
|
||||
util.cli.execute(cmd)
|
||||
|
||||
def state(self, widget):
|
||||
"""Get current state."""
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
"""Displays bluetooth status. Left mouse click launches manager app `blueman-manager`,
|
||||
"""Displays bluetooth status. Left mouse click launches manager app,
|
||||
right click toggles bluetooth. Needs dbus-send to toggle bluetooth state and
|
||||
python-dbus to count the number of connections
|
||||
|
||||
|
|
@ -8,6 +8,7 @@ Parameters:
|
|||
contributed by `martindoublem <https://github.com/martindoublem>`_ - many thanks!
|
||||
"""
|
||||
|
||||
|
||||
import os
|
||||
import re
|
||||
import subprocess
|
||||
|
|
@ -21,6 +22,7 @@ import core.input
|
|||
|
||||
import util.cli
|
||||
|
||||
|
||||
class Module(core.module.Module):
|
||||
def __init__(self, config, theme):
|
||||
super().__init__(config, theme, core.widget.Widget(self.status))
|
||||
|
|
@ -35,7 +37,7 @@ class Module(core.module.Module):
|
|||
|
||||
def status(self, widget):
|
||||
"""Get status."""
|
||||
return self._status if self._status.isdigit() and int(self._status) > 1 else ""
|
||||
return self._status
|
||||
|
||||
def update(self):
|
||||
"""Update current state."""
|
||||
|
|
@ -44,7 +46,7 @@ class Module(core.module.Module):
|
|||
)
|
||||
if state > 0:
|
||||
connected_devices = self.get_connected_devices()
|
||||
self._status = "{}".format(connected_devices)
|
||||
self._status = "On - {}".format(connected_devices)
|
||||
else:
|
||||
self._status = "Off"
|
||||
adapters_cmd = "rfkill list | grep Bluetooth"
|
||||
|
|
@ -56,23 +58,31 @@ class Module(core.module.Module):
|
|||
|
||||
def _toggle(self, widget=None):
|
||||
"""Toggle bluetooth state."""
|
||||
logging.debug("bt: toggling bluetooth")
|
||||
if "On" in self._status:
|
||||
state = "false"
|
||||
else:
|
||||
state = "true"
|
||||
|
||||
SetRfkillState = self._bus.get_object("org.blueman.Mechanism", "/org/blueman/mechanism").get_dbus_method("SetRfkillState", dbus_interface="org.blueman.Mechanism")
|
||||
SetRfkillState(self._status == "Off")
|
||||
cmd = (
|
||||
"dbus-send --system --print-reply --dest=org.blueman.Mechanism /org/blueman/mechanism org.blueman.Mechanism.SetRfkillState boolean:%s"
|
||||
% state
|
||||
)
|
||||
|
||||
logging.debug("bt: toggling bluetooth")
|
||||
core.util.execute(cmd)
|
||||
|
||||
def state(self, widget):
|
||||
"""Get current state."""
|
||||
state = []
|
||||
|
||||
if self._status in [ "No Adapter Found", "Off" ]:
|
||||
if self._status == "No Adapter Found":
|
||||
state.append("critical")
|
||||
elif self._status == "0":
|
||||
state.append("enabled")
|
||||
elif self._status == "On - 0":
|
||||
state.append("warning")
|
||||
elif "On" in self._status and not (self._status == "On - 0"):
|
||||
state.append("ON")
|
||||
else:
|
||||
state.append("connected")
|
||||
state.append("good")
|
||||
|
||||
state.append("critical")
|
||||
return state
|
||||
|
||||
def get_connected_devices(self):
|
||||
|
|
@ -82,8 +92,12 @@ class Module(core.module.Module):
|
|||
).GetManagedObjects()
|
||||
for path, interfaces in objects.items():
|
||||
if "org.bluez.Device1" in interfaces:
|
||||
if dbus.Interface(self._bus.get_object("org.bluez", path), "org.freedesktop.DBus.Properties", ).Get("org.bluez.Device1", "Connected"):
|
||||
if dbus.Interface(
|
||||
self._bus.get_object("org.bluez", path),
|
||||
"org.freedesktop.DBus.Properties",
|
||||
).Get("org.bluez.Device1", "Connected"):
|
||||
devices += 1
|
||||
return devices
|
||||
|
||||
|
||||
# vim: tabstop=8 expandtab shiftwidth=4 softtabstop=4
|
||||
|
|
|
|||
|
|
@ -1,97 +0,0 @@
|
|||
"""Displays temperature of blugon and Controls it.
|
||||
|
||||
Use wheel up and down to change temperature, middle click to toggle and right click to reset temperature.
|
||||
|
||||
Default Values:
|
||||
* Minimum temperature: 1000 (red)
|
||||
* Maximum temperature: 20000 (blue)
|
||||
* Default temperature: 6600
|
||||
|
||||
Requires the following executable:
|
||||
* blugon
|
||||
|
||||
Parameters:
|
||||
* blugon.step: The amount of increase/decrease on scroll (default: 200)
|
||||
|
||||
contributed by `DTan13 <https://github.com/DTan13>`
|
||||
"""
|
||||
|
||||
import core.module
|
||||
import core.widget
|
||||
|
||||
import util.cli
|
||||
import util.format
|
||||
|
||||
import os
|
||||
|
||||
|
||||
class Module(core.module.Module):
|
||||
def __init__(self, config, theme):
|
||||
super().__init__(config, theme, core.widget.Widget(self.full_text))
|
||||
self.__state = True
|
||||
self.__default = 6600
|
||||
self.__step = (
|
||||
util.format.asint(self.parameter("step")) if self.parameter("step") else 200
|
||||
)
|
||||
self.__max, self.__min = 20000, 1000
|
||||
|
||||
file = open(os.path.expanduser("~/.config/blugon/current"))
|
||||
self.__current = int(float(file.read()))
|
||||
|
||||
events = [
|
||||
{
|
||||
"type": "toggle",
|
||||
"action": self.toggle,
|
||||
"button": core.input.MIDDLE_MOUSE,
|
||||
},
|
||||
{
|
||||
"type": "blue",
|
||||
"action": self.blue,
|
||||
"button": core.input.WHEEL_UP,
|
||||
},
|
||||
{
|
||||
"type": "red",
|
||||
"action": self.red,
|
||||
"button": core.input.WHEEL_DOWN,
|
||||
},
|
||||
{
|
||||
"type": "reset",
|
||||
"action": self.reset,
|
||||
"button": core.input.RIGHT_MOUSE,
|
||||
},
|
||||
]
|
||||
|
||||
for event in events:
|
||||
core.input.register(self, button=event["button"], cmd=event["action"])
|
||||
|
||||
def set_temp(self):
|
||||
temp = self.__current if self.__state else self.__default
|
||||
util.cli.execute("blugon --setcurrent={}".format(temp))
|
||||
|
||||
def full_text(self, widget):
|
||||
return self.__current if self.__state else self.__default
|
||||
|
||||
def state(self, widget):
|
||||
if not self.__state:
|
||||
return ["critical"]
|
||||
|
||||
def toggle(self, event):
|
||||
self.__state = not self.__state
|
||||
self.set_temp()
|
||||
|
||||
def reset(self, event):
|
||||
self.__current = 6600
|
||||
self.set_temp()
|
||||
|
||||
def blue(self, event):
|
||||
if self.__state and (self.__current < self.__max):
|
||||
self.__current += self.__step
|
||||
self.set_temp()
|
||||
|
||||
def red(self, event):
|
||||
if self.__state and (self.__current > self.__min):
|
||||
self.__current -= self.__step
|
||||
self.set_temp()
|
||||
|
||||
|
||||
# vim: tabstop=8 expandtab shiftwidth=4 softtabstop=4
|
||||
|
|
@ -2,11 +2,6 @@
|
|||
|
||||
"""Displays the brightness of a display
|
||||
|
||||
The following executables can be used if `use_acpi` is not enabled:
|
||||
* brightnessctl
|
||||
* light
|
||||
* xbacklight
|
||||
|
||||
Parameters:
|
||||
* brightness.step: The amount of increase/decrease on scroll in % (defaults to 2)
|
||||
* brightness.device_path: The device path (defaults to /sys/class/backlight/intel_backlight), can contain wildcards (in this case, the first matching path will be used); This is only used when brightness.use_acpi is set to true
|
||||
|
|
|
|||
|
|
@ -24,9 +24,9 @@ Parameters:
|
|||
* cpu2.fanspeed
|
||||
* cpu2.colored: 1 for colored per core load graph, 0 for mono (default)
|
||||
* cpu2.temp_pattern: pattern to look for in the output of 'sensors -u';
|
||||
required if cpu2.temp widget is used
|
||||
required if cpu2.temp widged is used
|
||||
* cpu2.fan_pattern: pattern to look for in the output of 'sensors -u';
|
||||
required if cpu2.fanspeed widget is used
|
||||
required if cpu2.fanspeed widged is used
|
||||
|
||||
Note: if you are getting 'n/a' for CPU temperature / fan speed, then you're
|
||||
lacking the aforementioned pattern settings or they have wrong values.
|
||||
|
|
|
|||
|
|
@ -1,158 +0,0 @@
|
|||
"""Multiwidget CPU module
|
||||
|
||||
Can display any combination of:
|
||||
|
||||
* max CPU frequency
|
||||
* total CPU load in percents (integer value)
|
||||
* per-core CPU load as graph - either mono or colored
|
||||
* CPU temperature (in Celsius degrees)
|
||||
* CPU fan speed
|
||||
|
||||
Requirements:
|
||||
|
||||
* the psutil Python module for the first three items from the list above
|
||||
* sensors executable for the rest
|
||||
|
||||
Parameters:
|
||||
* cpu3.layout: Space-separated list of widgets to add.
|
||||
Possible widgets are:
|
||||
|
||||
* cpu3.maxfreq
|
||||
* cpu3.cpuload
|
||||
* cpu3.coresload
|
||||
* cpu3.temp
|
||||
* cpu3.fanspeed
|
||||
* cpu3.colored: 1 for colored per core load graph, 0 for mono (default)
|
||||
* cpu3.temp_json: json path to look for in the output of 'sensors -j';
|
||||
required if cpu3.temp widget is used
|
||||
* cpu3.fan_json: json path to look for in the output of 'sensors -j';
|
||||
required if cpu3.fanspeed widget is used
|
||||
|
||||
Note: if you are getting 'n/a' for CPU temperature / fan speed, then you're
|
||||
lacking the aforementioned json path settings or they have wrong values.
|
||||
|
||||
Example json paths:
|
||||
* `cpu3.temp_json="coretemp-isa-0000.Package id 0.temp1_input"`
|
||||
* `cpu3.fan_json="thinkpad-isa-0000.fan1.fan1_input"`
|
||||
|
||||
contributed by `SuperQ <https://github.com/SuperQ>`
|
||||
based on cpu2 by `<somospocos <https://github.com/somospocos>`
|
||||
"""
|
||||
|
||||
import json
|
||||
import psutil
|
||||
|
||||
import core.module
|
||||
|
||||
import util.cli
|
||||
import util.graph
|
||||
import util.format
|
||||
|
||||
|
||||
class Module(core.module.Module):
|
||||
def __init__(self, config, theme):
|
||||
super().__init__(config, theme, [])
|
||||
|
||||
self.__layout = self.parameter(
|
||||
"layout", "cpu3.maxfreq cpu3.cpuload cpu3.coresload cpu3.temp cpu3.fanspeed"
|
||||
)
|
||||
self.__widget_names = self.__layout.split()
|
||||
self.__colored = util.format.asbool(self.parameter("colored", False))
|
||||
for widget_name in self.__widget_names:
|
||||
if widget_name == "cpu3.maxfreq":
|
||||
widget = self.add_widget(name=widget_name, full_text=self.maxfreq)
|
||||
widget.set("type", "freq")
|
||||
elif widget_name == "cpu3.cpuload":
|
||||
widget = self.add_widget(name=widget_name, full_text=self.cpuload)
|
||||
widget.set("type", "load")
|
||||
elif widget_name == "cpu3.coresload":
|
||||
widget = self.add_widget(name=widget_name, full_text=self.coresload)
|
||||
widget.set("type", "loads")
|
||||
elif widget_name == "cpu3.temp":
|
||||
widget = self.add_widget(name=widget_name, full_text=self.temp)
|
||||
widget.set("type", "temp")
|
||||
elif widget_name == "cpu3.fanspeed":
|
||||
widget = self.add_widget(name=widget_name, full_text=self.fanspeed)
|
||||
widget.set("type", "fan")
|
||||
if self.__colored:
|
||||
widget.set("pango", True)
|
||||
self.__temp_json = self.parameter("temp_json")
|
||||
if self.__temp_json is None:
|
||||
self.__temp = "n/a"
|
||||
self.__fan_json = self.parameter("fan_json")
|
||||
if self.__fan_json is None:
|
||||
self.__fan = "n/a"
|
||||
# maxfreq is loaded only once at startup
|
||||
if "cpu3.maxfreq" in self.__widget_names:
|
||||
self.__maxfreq = psutil.cpu_freq().max / 1000
|
||||
|
||||
def maxfreq(self, _):
|
||||
return "{:.2f}GHz".format(self.__maxfreq)
|
||||
|
||||
def cpuload(self, _):
|
||||
return "{:>3}%".format(self.__cpuload)
|
||||
|
||||
def add_color(self, bar):
|
||||
"""add color as pango markup to a bar"""
|
||||
if bar in ["▁", "▂"]:
|
||||
color = self.theme.color("green", "green")
|
||||
elif bar in ["▃", "▄"]:
|
||||
color = self.theme.color("yellow", "yellow")
|
||||
elif bar in ["▅", "▆"]:
|
||||
color = self.theme.color("orange", "orange")
|
||||
elif bar in ["▇", "█"]:
|
||||
color = self.theme.color("red", "red")
|
||||
colored_bar = '<span foreground="{}">{}</span>'.format(color, bar)
|
||||
return colored_bar
|
||||
|
||||
def coresload(self, _):
|
||||
mono_bars = [util.graph.hbar(x) for x in self.__coresload]
|
||||
if not self.__colored:
|
||||
return "".join(mono_bars)
|
||||
colored_bars = [self.add_color(x) for x in mono_bars]
|
||||
return "".join(colored_bars)
|
||||
|
||||
def temp(self, _):
|
||||
if self.__temp == "n/a" or self.__temp == 0:
|
||||
return "n/a"
|
||||
return "{}°C".format(self.__temp)
|
||||
|
||||
def fanspeed(self, _):
|
||||
if self.__fanspeed == "n/a":
|
||||
return "n/a"
|
||||
return "{}RPM".format(self.__fanspeed)
|
||||
|
||||
def _parse_sensors_output(self):
|
||||
output = util.cli.execute("sensors -j")
|
||||
json_data = json.loads(output)
|
||||
|
||||
temp = "n/a"
|
||||
fan = "n/a"
|
||||
temp_json = json_data
|
||||
fan_json = json_data
|
||||
for path in self.__temp_json.split('.'):
|
||||
temp_json = temp_json[path]
|
||||
for path in self.__fan_json.split('.'):
|
||||
fan_json = fan_json[path]
|
||||
if temp_json is not None:
|
||||
temp = float(temp_json)
|
||||
if fan_json is not None:
|
||||
fan = int(fan_json)
|
||||
return temp, fan
|
||||
|
||||
def update(self):
|
||||
if "cpu3.maxfreq" in self.__widget_names:
|
||||
self.__maxfreq = psutil.cpu_freq().max / 1000
|
||||
if "cpu3.cpuload" in self.__widget_names:
|
||||
self.__cpuload = round(psutil.cpu_percent(percpu=False))
|
||||
if "cpu3.coresload" in self.__widget_names:
|
||||
self.__coresload = psutil.cpu_percent(percpu=True)
|
||||
if "cpu3.temp" in self.__widget_names or "cpu3.fanspeed" in self.__widget_names:
|
||||
self.__temp, self.__fanspeed = self._parse_sensors_output()
|
||||
|
||||
def state(self, widget):
|
||||
"""for having per-widget icons"""
|
||||
return [widget.get("type", "")]
|
||||
|
||||
|
||||
# vim: tabstop=8 expandtab shiftwidth=4 softtabstop=4
|
||||
|
|
@ -2,10 +2,6 @@
|
|||
|
||||
"""Displays the current date and time with timezone options.
|
||||
|
||||
Requires the following python packages:
|
||||
* tzlocal
|
||||
* pytz
|
||||
|
||||
Parameters:
|
||||
* datetimetz.format : strftime()-compatible formatting string
|
||||
* datetimetz.timezone : IANA timezone name
|
||||
|
|
|
|||
|
|
@ -5,6 +5,8 @@ some media control bindings.
|
|||
Left click toggles pause, scroll up skips the current song, scroll
|
||||
down returns to the previous song.
|
||||
|
||||
Requires the following library:
|
||||
* subprocess
|
||||
Parameters:
|
||||
* deadbeef.format: Format string (defaults to '{artist} - {title}')
|
||||
Available values are: {artist}, {title}, {album}, {length},
|
||||
|
|
@ -112,7 +114,7 @@ class Module(core.module.Module):
|
|||
self._song = ""
|
||||
return
|
||||
## perform the actual query -- these can be much more sophisticated
|
||||
data = util.cli.execute(self.now_playing_tf + '"'+self._tf_format+'"')
|
||||
data = util.cli.execute(self.now_playing_tf + self._tf_format)
|
||||
self._song = data
|
||||
|
||||
def update_standard(self, widgets):
|
||||
|
|
|
|||
|
|
@ -5,8 +5,13 @@
|
|||
Requires the following executable:
|
||||
* dnf
|
||||
|
||||
Parameters:
|
||||
* dnf.interval: Time in minutes between two consecutive update checks (defaults to 30 minutes)
|
||||
|
||||
"""
|
||||
|
||||
import threading
|
||||
|
||||
import core.event
|
||||
import core.module
|
||||
import core.widget
|
||||
|
|
@ -15,21 +20,7 @@ import core.decorators
|
|||
import util.cli
|
||||
|
||||
|
||||
class Module(core.module.Module):
|
||||
@core.decorators.every(minutes=30)
|
||||
def __init__(self, config, theme):
|
||||
super().__init__(config, theme, core.widget.Widget(self.updates))
|
||||
|
||||
self.background = True
|
||||
|
||||
def updates(self, widget):
|
||||
result = []
|
||||
for t in ["security", "bugfixes", "enhancements", "other"]:
|
||||
result.append(str(widget.get(t, 0)))
|
||||
return "/".join(result)
|
||||
|
||||
def update(self):
|
||||
widget = self.widget()
|
||||
def get_dnf_info(widget):
|
||||
res = util.cli.execute("dnf updateinfo", ignore_errors=True)
|
||||
|
||||
security = 0
|
||||
|
|
@ -61,6 +52,23 @@ class Module(core.module.Module):
|
|||
widget.set("enhancements", enhancements)
|
||||
widget.set("other", other)
|
||||
|
||||
core.event.trigger("update", [widget.module.id], redraw_only=True)
|
||||
|
||||
|
||||
class Module(core.module.Module):
|
||||
@core.decorators.every(minutes=30)
|
||||
def __init__(self, config, theme):
|
||||
super().__init__(config, theme, core.widget.Widget(self.updates))
|
||||
|
||||
def updates(self, widget):
|
||||
result = []
|
||||
for t in ["security", "bugfixes", "enhancements", "other"]:
|
||||
result.append(str(widget.get(t, 0)))
|
||||
return "/".join(result)
|
||||
|
||||
def update(self):
|
||||
thread = threading.Thread(target=get_dnf_info, args=(self.widget(),))
|
||||
thread.start()
|
||||
|
||||
def state(self, widget):
|
||||
cnt = 0
|
||||
|
|
|
|||
|
|
@ -1,44 +0,0 @@
|
|||
# pylint: disable=C0111,R0903
|
||||
|
||||
"""Toggle dunst notifications using dunstctl.
|
||||
|
||||
When notifications are paused using this module dunst doesn't get killed and
|
||||
you'll keep getting notifications on the background that will be displayed when
|
||||
unpausing. This is specially useful if you're using dunst's scripting
|
||||
(https://wiki.archlinux.org/index.php/Dunst#Scripting), which requires dunst to
|
||||
be running. Scripts will be executed when dunst gets unpaused.
|
||||
|
||||
Requires:
|
||||
* dunst v1.5.0+
|
||||
|
||||
contributed by `cristianmiranda <https://github.com/cristianmiranda>`_ - many thanks!
|
||||
contributed by `joachimmathes <https://github.com/joachimmathes>`_ - many thanks!
|
||||
"""
|
||||
|
||||
import core.module
|
||||
import core.widget
|
||||
import core.input
|
||||
import util.cli
|
||||
|
||||
|
||||
class Module(core.module.Module):
|
||||
def __init__(self, config, theme):
|
||||
super().__init__(config, theme, core.widget.Widget(""))
|
||||
core.input.register(self, button=core.input.LEFT_MOUSE, cmd=self.toggle_state)
|
||||
self.__states = {"unknown": ["unknown", "critical"],
|
||||
"true": ["muted", "warning"],
|
||||
"false": ["unmuted"]}
|
||||
if util.format.asbool(self.parameter("disabled", False)):
|
||||
util.cli.execute("dunstctl set-paused true", ignore_errors=True)
|
||||
|
||||
def toggle_state(self, event):
|
||||
util.cli.execute("dunstctl set-paused toggle", ignore_errors=True)
|
||||
|
||||
def state(self, widget):
|
||||
return self.__states[self.__is_dunst_paused()]
|
||||
|
||||
def __is_dunst_paused(self):
|
||||
result = util.cli.execute("dunstctl is-paused",
|
||||
return_exitcode=True,
|
||||
ignore_errors=True)
|
||||
return result[1].rstrip() if result[0] == 0 else "unknown"
|
||||
|
|
@ -1,113 +0,0 @@
|
|||
"""Display information about the currently running emerge process.
|
||||
|
||||
Requires the following executable:
|
||||
* emerge
|
||||
|
||||
Parameters:
|
||||
* emerge_status.format: Format string (defaults to '{current}/{total} {action} {category}/{pkg}')
|
||||
|
||||
This code is based on emerge_status module from p3status [1] original created by AnwariasEu.
|
||||
|
||||
[1] https://github.com/ultrabug/py3status/blob/master/py3status/modules/emerge_status.py
|
||||
"""
|
||||
|
||||
import re
|
||||
import copy
|
||||
|
||||
import core.module
|
||||
import core.widget
|
||||
import core.decorators
|
||||
|
||||
import util.cli
|
||||
import util.format
|
||||
|
||||
|
||||
class Module(core.module.Module):
|
||||
@core.decorators.every(seconds=10)
|
||||
def __init__(self, config, theme):
|
||||
super().__init__(config, theme, [])
|
||||
self.__format = self.parameter(
|
||||
"format", "{current}/{total} {action} {category}/{pkg}"
|
||||
)
|
||||
self.__ret_default = {
|
||||
"action": "",
|
||||
"category": "",
|
||||
"current": 0,
|
||||
"pkg": "",
|
||||
"total": 0,
|
||||
}
|
||||
|
||||
def update(self):
|
||||
response = {}
|
||||
ret = copy.deepcopy(self.__ret_default)
|
||||
if self.__emerge_running():
|
||||
ret = self.__get_progress()
|
||||
|
||||
widget = self.widget("status")
|
||||
if not widget:
|
||||
widget = self.add_widget(name="status")
|
||||
|
||||
if ret["total"] == 0:
|
||||
widget.full_text("emrg calculating...")
|
||||
else:
|
||||
widget.full_text(
|
||||
" ".join(
|
||||
self.__format.format(
|
||||
current=ret["current"],
|
||||
total=ret["total"],
|
||||
action=ret["action"],
|
||||
category=ret["category"],
|
||||
pkg=ret["pkg"],
|
||||
).split()
|
||||
)
|
||||
)
|
||||
else:
|
||||
self.clear_widgets()
|
||||
|
||||
def __emerge_running(self):
|
||||
"""
|
||||
Check if emerge is running.
|
||||
Returns true if at least one instance of emerge is running.
|
||||
"""
|
||||
try:
|
||||
util.cli.execute("pgrep emerge")
|
||||
return True
|
||||
except Exception:
|
||||
return False
|
||||
|
||||
def __get_progress(self):
|
||||
"""
|
||||
Get current progress of emerge.
|
||||
Returns a dict containing current and total value.
|
||||
"""
|
||||
input_data = []
|
||||
ret = {}
|
||||
|
||||
# traverse emerge.log from bottom up to get latest information
|
||||
last_lines = util.cli.execute("tail -50 /var/log/emerge.log")
|
||||
input_data = last_lines.split("\n")
|
||||
input_data.reverse()
|
||||
|
||||
for line in input_data:
|
||||
if "*** terminating." in line:
|
||||
# copy content of ret_default, not only the references
|
||||
ret = copy.deepcopy(self.__ret_default)
|
||||
break
|
||||
else:
|
||||
status_re = re.compile(
|
||||
r"\((?P<cu>[\d]+) of (?P<t>[\d]+)\) "
|
||||
r"(?P<a>[a-zA-Z/]+( [a-zA-Z]+)?) "
|
||||
r"\((?P<ca>[\w\-]+)/(?P<p>[\w.]+)"
|
||||
)
|
||||
res = status_re.search(line)
|
||||
if res is not None:
|
||||
ret["action"] = res.group("a").lower()
|
||||
ret["category"] = res.group("ca")
|
||||
ret["current"] = res.group("cu")
|
||||
ret["pkg"] = res.group("p")
|
||||
ret["total"] = res.group("t")
|
||||
break
|
||||
return ret
|
||||
|
||||
|
||||
# vim: tabstop=8 expandtab shiftwidth=4 softtabstop=4
|
||||
|
|
@ -1,171 +0,0 @@
|
|||
"""Displays first upcoming event in google calendar.
|
||||
|
||||
Events that are set as 'all-day' will not be shown.
|
||||
|
||||
Requires credentials.json from a google api application where the google calendar api is installed.
|
||||
On first time run the browser will open and google will ask for permission for this app to access
|
||||
the google calendar and then save a .gcalendar_token.json file to the credentials_path directory
|
||||
which stores this permission.
|
||||
|
||||
A refresh is done every 15 minutes.
|
||||
|
||||
Parameters:
|
||||
* gcalendar.time_format: Format time output. Defaults to "%H:%M".
|
||||
* gcalendar.date_format: Format date output. Defaults to "%d.%m.%y".
|
||||
* gcalendar.credentials_path: Path to credentials.json. Defaults to "~/".
|
||||
* gcalendar.locale: locale to use rather than the system default.
|
||||
|
||||
Requires these pip packages:
|
||||
* google-api-python-client >= 1.8.0
|
||||
* google-auth-httplib2
|
||||
* google-auth-oauthlib
|
||||
"""
|
||||
|
||||
# This import belongs to the google code
|
||||
from __future__ import print_function
|
||||
|
||||
from dateutil.parser import parse as dtparse
|
||||
|
||||
import core.module
|
||||
import core.widget
|
||||
import core.decorators
|
||||
import util.format
|
||||
|
||||
import datetime
|
||||
import os.path
|
||||
import locale
|
||||
import time
|
||||
|
||||
from google.auth.transport.requests import Request
|
||||
from google.oauth2.credentials import Credentials
|
||||
from google_auth_oauthlib.flow import InstalledAppFlow
|
||||
from googleapiclient.discovery import build
|
||||
from googleapiclient.errors import HttpError
|
||||
|
||||
# Minutes
|
||||
update_every = 15
|
||||
|
||||
|
||||
class Module(core.module.Module):
|
||||
@core.decorators.every(minutes=update_every)
|
||||
def __init__(self, config, theme):
|
||||
super().__init__(config, theme, [core.widget.Widget(self.__datetime), core.widget.Widget(self.__summary)])
|
||||
self.__error = False
|
||||
self.__time_format = self.parameter("time_format", "%H:%M")
|
||||
self.__date_format = self.parameter("date_format", "%d.%m.%y")
|
||||
self.__credentials_path = os.path.expanduser(
|
||||
self.parameter("credentials_path", "~/")
|
||||
)
|
||||
self.__credentials = os.path.join(self.__credentials_path, "credentials.json")
|
||||
self.__token = os.path.join(self.__credentials_path, ".gcalendar_token.json")
|
||||
|
||||
l = locale.getdefaultlocale()
|
||||
if not l or l == (None, None):
|
||||
l = ("en_US", "UTF-8")
|
||||
lcl = self.parameter("locale", ".".join(l))
|
||||
try:
|
||||
locale.setlocale(locale.LC_TIME, lcl.split("."))
|
||||
except Exception:
|
||||
locale.setlocale(locale.LC_TIME, ("en_US", "UTF-8"))
|
||||
|
||||
self.__last_update = time.time()
|
||||
self.__gcalendar_date, self.__gcalendar_summary = self.__fetch_from_calendar()
|
||||
|
||||
def hidden(self):
|
||||
return self.__error
|
||||
|
||||
def __datetime(self, _):
|
||||
return self.__gcalendar_date
|
||||
|
||||
@core.decorators.scrollable
|
||||
def __summary(self, _):
|
||||
return self.__gcalendar_summary
|
||||
|
||||
|
||||
def __fetch_from_calendar(self):
|
||||
SCOPES = ["https://www.googleapis.com/auth/calendar.readonly"]
|
||||
|
||||
creds = None
|
||||
|
||||
try:
|
||||
# The file token.json stores the user's access and refresh tokens, and is
|
||||
# created automatically when the authorization flow completes for the first
|
||||
# time.
|
||||
if os.path.exists(self.__token):
|
||||
creds = Credentials.from_authorized_user_file(self.__token, SCOPES)
|
||||
# If there are no (valid) credentials available, let the user log in.
|
||||
if not creds or not creds.valid:
|
||||
if creds and creds.expired and creds.refresh_token:
|
||||
creds.refresh(Request())
|
||||
else:
|
||||
flow = InstalledAppFlow.from_client_secrets_file(
|
||||
self.__credentials, SCOPES
|
||||
)
|
||||
creds = flow.run_local_server(port=0)
|
||||
# Save the credentials for the next run
|
||||
with open(self.__token, "w") as token:
|
||||
token.write(creds.to_json())
|
||||
|
||||
service = build("calendar", "v3", credentials=creds)
|
||||
|
||||
# Call the Calendar API
|
||||
now = datetime.datetime.utcnow().isoformat() + "Z" # 'Z' indicates UTC time
|
||||
end = (
|
||||
datetime.datetime.utcnow() + datetime.timedelta(days=7)
|
||||
).isoformat() + "Z" # 'Z' indicates UTC time
|
||||
# Get all calendars
|
||||
calendar_list = service.calendarList().list().execute()
|
||||
event_list = []
|
||||
for calendar_list_entry in calendar_list["items"]:
|
||||
calendar_id = calendar_list_entry["id"]
|
||||
events_result = (
|
||||
service.events()
|
||||
.list(
|
||||
calendarId=calendar_id,
|
||||
timeMin=now,
|
||||
timeMax=end,
|
||||
singleEvents=True,
|
||||
orderBy="startTime",
|
||||
)
|
||||
.execute()
|
||||
)
|
||||
events = events_result.get("items", [])
|
||||
|
||||
for event in events:
|
||||
start = dtparse(
|
||||
event["start"].get("dateTime", event["start"].get("date"))
|
||||
)
|
||||
# Only add to list if not an whole day event
|
||||
if start.tzinfo:
|
||||
event_list.append(
|
||||
{
|
||||
"date": start,
|
||||
"summary": event["summary"],
|
||||
"type": event["eventType"],
|
||||
}
|
||||
)
|
||||
sorted_list = sorted(event_list, key=lambda t: t["date"])
|
||||
next_event = sorted_list[0]
|
||||
|
||||
if next_event["date"] >= datetime.datetime.now(datetime.timezone.utc):
|
||||
if next_event["date"].date() == datetime.datetime.utcnow().date():
|
||||
dt = next_event["date"].astimezone()\
|
||||
.strftime(f"{self.__time_format}")
|
||||
else:
|
||||
dt = next_event["date"].astimezone()\
|
||||
.strftime(f"{self.__date_format} {self.__time_format}")
|
||||
return (dt, next_event["summary"])
|
||||
|
||||
return (None, "No upcoming events.")
|
||||
except:
|
||||
self.__error = True
|
||||
|
||||
def update(self):
|
||||
# Since scrolling runs the update command and therefore negates the
|
||||
# every decorator, this need to be stopped
|
||||
# to not break the API rules of google.
|
||||
if self.__last_update+(update_every*60) < time.time():
|
||||
self.__last_update = time.time()
|
||||
self.__gcalendar_date, self.__gcalendar_summary = self.__fetch_from_calendar()
|
||||
|
||||
# vim: tabstop=8 expandtab shiftwidth=4 softtabstop=4
|
||||
|
|
@ -5,8 +5,6 @@ Displays the unread GitHub notifications count for a GitHub user using the follo
|
|||
|
||||
* https://developer.github.com/v3/activity/notifications/#notification-reasons
|
||||
|
||||
Uses `xdg-open` or `x-www-browser` to open web-pages.
|
||||
|
||||
Requires the following library:
|
||||
* requests
|
||||
|
||||
|
|
@ -83,6 +81,7 @@ class Module(core.module.Module):
|
|||
self.__label += "/".join(counts)
|
||||
|
||||
except Exception as err:
|
||||
print(err)
|
||||
self.__label = "n/a"
|
||||
|
||||
def __getUnreadNotificationsCountByReason(self, notifications, reason):
|
||||
|
|
|
|||
|
|
@ -1,87 +0,0 @@
|
|||
# pylint: disable=C0111,R0903
|
||||
|
||||
"""
|
||||
Displays the GitLab todo count:
|
||||
|
||||
* https://docs.gitlab.com/ee/user/todos.html
|
||||
* https://docs.gitlab.com/ee/api/todos.html
|
||||
|
||||
Uses `xdg-open` or `x-www-browser` to open web-pages.
|
||||
|
||||
Requires the following library:
|
||||
* requests
|
||||
|
||||
Errors:
|
||||
if the GitLab todo query failed, the shown value is `n/a`
|
||||
|
||||
Parameters:
|
||||
* gitlab.token: GitLab personal access token, the token needs to have the "read_api" scope.
|
||||
* gitlab.host: Host of the GitLab instance, default is "gitlab.com".
|
||||
* gitlab.actions: Comma separated actions to be parsed (e.g.: gitlab.actions=assigned,approval_required)
|
||||
"""
|
||||
|
||||
import shutil
|
||||
|
||||
import requests
|
||||
|
||||
import core.decorators
|
||||
import core.input
|
||||
import core.module
|
||||
import core.widget
|
||||
import util
|
||||
|
||||
|
||||
class Module(core.module.Module):
|
||||
@core.decorators.every(minutes=5)
|
||||
def __init__(self, config, theme):
|
||||
super().__init__(config, theme, core.widget.Widget(self.gitlab))
|
||||
|
||||
self.background = True
|
||||
self.__label = ""
|
||||
self.__host = self.parameter("host", "gitlab.com")
|
||||
|
||||
self.__actions = []
|
||||
actions = self.parameter("actions", "")
|
||||
if actions:
|
||||
self.__actions = util.format.aslist(actions)
|
||||
|
||||
self.__requests = requests.Session()
|
||||
self.__requests.headers.update({"PRIVATE-TOKEN": self.parameter("token", "")})
|
||||
|
||||
cmd = "xdg-open"
|
||||
if not shutil.which(cmd):
|
||||
cmd = "x-www-browser"
|
||||
|
||||
core.input.register(
|
||||
self,
|
||||
button=core.input.LEFT_MOUSE,
|
||||
cmd="{cmd} https:/{host}//dashboard/todos".format(
|
||||
cmd=cmd, host=self.__host
|
||||
),
|
||||
)
|
||||
|
||||
def gitlab(self, _):
|
||||
return self.__label
|
||||
|
||||
def update(self):
|
||||
try:
|
||||
url = "https://{host}/api/v4/todos".format(host=self.__host)
|
||||
response = self.__requests.get(url)
|
||||
todos = response.json()
|
||||
if self.__actions:
|
||||
todos = [t for t in todos if t["action_name"] in self.__actions]
|
||||
self.__label = str(len(todos))
|
||||
except Exception as e:
|
||||
self.__label = "n/a"
|
||||
|
||||
def state(self, widget):
|
||||
state = []
|
||||
|
||||
try:
|
||||
if int(self.__label) > 0:
|
||||
state.append("warning")
|
||||
except ValueError:
|
||||
pass
|
||||
return state
|
||||
|
||||
# vim: tabstop=8 expandtab shiftwidth=4 softtabstop=4
|
||||
|
|
@ -1,6 +1,6 @@
|
|||
# -*- coding: utf-8 -*-
|
||||
|
||||
"""Fetch hard drive temperature data from a hddtemp daemon
|
||||
"""Fetch hard drive temeperature data from a hddtemp daemon
|
||||
that runs on localhost and default port (7634)
|
||||
|
||||
contributed by `somospocos <https://github.com/somospocos>`_ - many thanks!
|
||||
|
|
|
|||
|
|
@ -2,9 +2,6 @@
|
|||
|
||||
"""Displays the indicator status, for numlock, scrolllock and capslock
|
||||
|
||||
Requires the following executable:
|
||||
* xset
|
||||
|
||||
Parameters:
|
||||
* indicator.include: Comma-separated list of interface prefixes to include (defaults to 'numlock,capslock')
|
||||
* indicator.signalstype: If you want the signali type color to be 'critical' or 'warning' (defaults to 'warning')
|
||||
|
|
|
|||
|
|
@ -19,13 +19,13 @@ class Module(core.module.Module):
|
|||
def __init__(self, config, theme):
|
||||
super().__init__(config, theme, core.widget.Widget(self.current_layout))
|
||||
|
||||
core.input.register(self, button=core.input.LEFT_MOUSE, cmd=self.next_keymap)
|
||||
core.input.register(self, button=core.input.LEFT_MOUSE, cmd=self.__next_keymap)
|
||||
self.__current_layout = self.__get_current_layout()
|
||||
|
||||
def current_layout(self, _):
|
||||
return self.__current_layout
|
||||
|
||||
def next_keymap(self, event):
|
||||
def __next_keymap(self, event):
|
||||
util.cli.execute("xkb-switch -n", ignore_errors=True)
|
||||
|
||||
def __get_current_layout(self):
|
||||
|
|
|
|||
|
|
@ -1 +0,0 @@
|
|||
layout-xkbswitch.py
|
||||
|
|
@ -1,85 +0,0 @@
|
|||
# pylint: disable=C0111,R0903
|
||||
|
||||
"""
|
||||
Displays the message that's received via unix socket.
|
||||
|
||||
Parameters:
|
||||
* messagereceiver : Unix socket address (e.g: /tmp/bumblebee_messagereceiver.sock)
|
||||
|
||||
Example:
|
||||
The following examples assume that /tmp/bumblebee_messagereceiver.sock is used as unix socket address.
|
||||
|
||||
In order to send the string "I bumblebee-status" to your status bar, use the following command:
|
||||
echo -e '{"message":"I bumblebee-status", "state": ""}' | socat unix-connect:/tmp/bumblebee_messagereceiver.sock STDIO
|
||||
|
||||
In order to highlight the text, the state variable can be used:
|
||||
echo -e '{"message":"I bumblebee-status", "state": "warning"}' | socat unix-connect:/tmp/bumblebee_messagereceiver.sock STDIO
|
||||
|
||||
contributed by `bbernhard <https://github.com/bbernhard>`_ - many thanks!
|
||||
"""
|
||||
|
||||
import socket
|
||||
import logging
|
||||
import os
|
||||
import json
|
||||
|
||||
import core.module
|
||||
import core.widget
|
||||
import core.input
|
||||
|
||||
|
||||
class Module(core.module.Module):
|
||||
@core.decorators.never
|
||||
def __init__(self, config, theme):
|
||||
super().__init__(config, theme, core.widget.Widget(self.message))
|
||||
|
||||
self.background = True
|
||||
|
||||
self.__unix_socket_address = self.parameter("address", "")
|
||||
|
||||
self.__message = ""
|
||||
self.__state = []
|
||||
|
||||
def message(self, widget):
|
||||
return self.__message
|
||||
|
||||
def __read_data_from_socket(self):
|
||||
while True:
|
||||
try:
|
||||
os.unlink(self.__unix_socket_address)
|
||||
except OSError:
|
||||
if os.path.exists(self.__unix_socket_address):
|
||||
logging.exception(
|
||||
"Couldn't bind to unix socket %s", self.__unix_socket_address
|
||||
)
|
||||
raise
|
||||
|
||||
with socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) as s:
|
||||
s.bind(self.__unix_socket_address)
|
||||
s.listen()
|
||||
|
||||
conn, _ = s.accept()
|
||||
with conn:
|
||||
while True:
|
||||
data = conn.recv(1024)
|
||||
if not data:
|
||||
break
|
||||
yield data.decode("utf-8")
|
||||
|
||||
def update(self):
|
||||
try:
|
||||
for received_data in self.__read_data_from_socket():
|
||||
parsed_data = json.loads(received_data)
|
||||
self.__message = parsed_data["message"]
|
||||
self.__state = parsed_data["state"]
|
||||
core.event.trigger("update", [self.id], redraw_only=True)
|
||||
except json.JSONDecodeError:
|
||||
logging.exception("Couldn't parse message")
|
||||
except Exception:
|
||||
logging.exception("Unexpected exception while reading from socket")
|
||||
|
||||
def state(self, widget):
|
||||
return self.__state
|
||||
|
||||
|
||||
# vim: tabstop=8 expandtab shiftwidth=4 softtabstop=4
|
||||
|
|
@ -42,7 +42,6 @@ Parameters:
|
|||
if {file} = '/foo/bar.baz', then {file2} = 'bar'
|
||||
|
||||
* mpd.host: MPD host to connect to. (mpc behaviour by default)
|
||||
* mpd.port: MPD port to connect to. (mpc behaviour by default)
|
||||
* mpd.layout: Space-separated list of widgets to add. Possible widgets are the buttons/toggles mpd.prev, mpd.next, mpd.shuffle and mpd.repeat, and the main display with play/pause function mpd.main.
|
||||
|
||||
contributed by `alrayyes <https://github.com/alrayyes>`_ - many thanks!
|
||||
|
|
@ -74,12 +73,10 @@ class Module(core.module.Module):
|
|||
self._repeat = False
|
||||
self._tags = defaultdict(lambda: "")
|
||||
|
||||
if not self.parameter("host"):
|
||||
self._hostcmd = ""
|
||||
if self.parameter("host"):
|
||||
self._hostcmd = " -h {}".format(self.parameter("host"))
|
||||
if self.parameter("port"):
|
||||
self._hostcmd += " -p {}".format(self.parameter("port"))
|
||||
|
||||
else:
|
||||
self._hostcmd = " -h " + self.parameter("host")
|
||||
|
||||
# Create widgets
|
||||
widget_map = {}
|
||||
|
|
@ -97,12 +94,6 @@ class Module(core.module.Module):
|
|||
"cmd": "mpc toggle" + self._hostcmd,
|
||||
}
|
||||
widget.full_text(self.description)
|
||||
elif widget_name == "mpd.toggle":
|
||||
widget_map[widget] = {
|
||||
"button": core.input.LEFT_MOUSE,
|
||||
"cmd": "mpc toggle" + self._hostcmd,
|
||||
}
|
||||
widget.full_text(self.toggle)
|
||||
elif widget_name == "mpd.next":
|
||||
widget_map[widget] = {
|
||||
"button": core.input.LEFT_MOUSE,
|
||||
|
|
@ -136,9 +127,6 @@ class Module(core.module.Module):
|
|||
def description(self, widget):
|
||||
return string.Formatter().vformat(self._fmt, (), self._tags)
|
||||
|
||||
def toggle(self, widget):
|
||||
return str(util.cli.execute("mpc status %currenttime%/%totaltime%", ignore_errors=True)).strip()
|
||||
|
||||
def update(self):
|
||||
self._load_song()
|
||||
|
||||
|
|
|
|||
|
|
@ -1,128 +0,0 @@
|
|||
"""
|
||||
A module to show the currently active network connection (ethernet or wifi) and connection strength if the connection is wireless.
|
||||
|
||||
Requires the Python netifaces package and iw installed on Linux.
|
||||
|
||||
A simpler take on nic and network_traffic. No extra config necessary!
|
||||
|
||||
"""
|
||||
|
||||
|
||||
import util.cli
|
||||
import util.format
|
||||
|
||||
import core.module
|
||||
import core.widget
|
||||
import core.input
|
||||
|
||||
import netifaces
|
||||
import socket
|
||||
|
||||
|
||||
class Module(core.module.Module):
|
||||
@core.decorators.every(seconds=5)
|
||||
def __init__(self, config, theme):
|
||||
super().__init__(config, theme, core.widget.Widget(self.network))
|
||||
self.__is_wireless = False
|
||||
self.__is_connected = False
|
||||
self.__interface = None
|
||||
self.__message = None
|
||||
self.__signal = -110
|
||||
|
||||
# Get network information to display to the user
|
||||
def network(self, widgets):
|
||||
# Determine whether there is an internet connection
|
||||
self.__is_connected = self.__attempt_connection()
|
||||
|
||||
# Attempt to extract a valid network interface device
|
||||
try:
|
||||
self.__interface = netifaces.gateways()["default"][netifaces.AF_INET][1]
|
||||
except Exception:
|
||||
self.__interface = None
|
||||
|
||||
# Check to see if the interface (if connected to the internet) is wireless
|
||||
if self.__is_connected and self.__interface:
|
||||
self.__is_wireless = self.__interface_is_wireless(self.__interface)
|
||||
|
||||
# setup message to send to the user
|
||||
if not self.__is_connected or not self.__interface:
|
||||
self.__message = "No connection"
|
||||
elif not self.__is_wireless:
|
||||
# Assuming that if user is connected via non-wireless means that it will be ethernet
|
||||
self.__signal = -30
|
||||
self.__message = "Ethernet"
|
||||
else:
|
||||
# We have a wireless connection
|
||||
iw_dat = util.cli.execute("iwgetid")
|
||||
has_ssid = "ESSID" in iw_dat
|
||||
signal = self.__compute_signal(self.__interface)
|
||||
|
||||
# If signal is None, that means that we can't compute the default interface's signal strength
|
||||
self.__signal = (
|
||||
util.format.asint(signal, minimum=-110, maximum=-30) if signal else None
|
||||
)
|
||||
|
||||
ssid = (
|
||||
iw_dat[iw_dat.index(":") + 1 :].replace('"', "").strip()
|
||||
if has_ssid
|
||||
else "Unknown"
|
||||
)
|
||||
self.__message = self.__generate_wireles_message(ssid, self.__signal)
|
||||
|
||||
return self.__message
|
||||
|
||||
# State determined by signal strength
|
||||
def state(self, widget):
|
||||
if self.__compute_strength(self.__signal) < 50:
|
||||
return "critical"
|
||||
if self.__compute_strength(self.__signal) < 75:
|
||||
return "warning"
|
||||
|
||||
return None
|
||||
|
||||
# manually done for better granularity / ease of parsing strength data
|
||||
def __generate_wireles_message(self, ssid, signal):
|
||||
computed_strength = self.__compute_strength(signal)
|
||||
strength_str = str(computed_strength) if computed_strength else "?"
|
||||
|
||||
return "{} {}%".format(ssid, strength_str)
|
||||
|
||||
def __compute_strength(self, signal):
|
||||
return int(100 * ((signal + 100) / 70.0)) if signal else None
|
||||
|
||||
# get signal strength in decibels/milliwat
|
||||
def __compute_signal(self, interface):
|
||||
# Get connection strength
|
||||
cmd = "iwconfig {}".format(interface)
|
||||
config_dat = " ".join(util.cli.execute(cmd).split())
|
||||
config_tokens = config_dat.replace("=", " ").split()
|
||||
|
||||
# handle weird output
|
||||
try:
|
||||
signal = config_tokens[config_tokens.index("level") + 1]
|
||||
except Exception:
|
||||
signal = None
|
||||
|
||||
return signal
|
||||
|
||||
def __attempt_connection(self):
|
||||
can_connect = False
|
||||
try:
|
||||
socket.create_connection(("1.1.1.1", 53))
|
||||
can_connect = True
|
||||
except Exception:
|
||||
can_connect = False
|
||||
|
||||
return can_connect
|
||||
|
||||
def __interface_is_wireless(self, interface):
|
||||
is_wireless = False
|
||||
try:
|
||||
with open("/proc/net/wireless", "r") as f:
|
||||
is_wireless = interface in f.read()
|
||||
f.close()
|
||||
except Exception:
|
||||
is_wireless = False
|
||||
|
||||
return is_wireless
|
||||
|
||||
|
|
@ -38,8 +38,8 @@ class Module(core.module.Module):
|
|||
try:
|
||||
self._bandwidth = BandwidthInfo()
|
||||
|
||||
self._rate_recv = 0
|
||||
self._rate_sent = 0
|
||||
self._rate_recv = "?"
|
||||
self._rate_sent = "?"
|
||||
self._bytes_recv = self._bandwidth.bytes_recv()
|
||||
self._bytes_sent = self._bandwidth.bytes_sent()
|
||||
except Exception:
|
||||
|
|
@ -97,6 +97,9 @@ class BandwidthInfo(object):
|
|||
"""Return default active network adapter"""
|
||||
gateway = netifaces.gateways()["default"]
|
||||
|
||||
if not gateway:
|
||||
raise "No default gateway found"
|
||||
|
||||
return gateway[netifaces.AF_INET][1]
|
||||
|
||||
@classmethod
|
||||
|
|
|
|||
|
|
@ -4,15 +4,11 @@
|
|||
|
||||
Parameters:
|
||||
* nvidiagpu.format: Format string (defaults to '{name}: {temp}°C %{usedmem}/{totalmem} MiB')
|
||||
Available values are: {name} {temp} {mem_used} {mem_total} {fanspeed} {clock_gpu} {clock_mem} {gpu_usage_pct} {mem_usage_pct} {mem_io_pct}
|
||||
Available values are: {name} {temp} {mem_used} {mem_total} {fanspeed} {clock_gpu} {clock_mem}
|
||||
|
||||
Requires nvidia-smi
|
||||
|
||||
contributed by `RileyRedpath <https://github.com/RileyRedpath>`_ - many thanks!
|
||||
|
||||
Note: mem_io_pct is (from `man nvidia-smi`):
|
||||
> Percent of time over the past sample period during which global (device)
|
||||
> memory was being read or written.
|
||||
"""
|
||||
|
||||
import core.module
|
||||
|
|
@ -45,9 +41,6 @@ class Module(core.module.Module):
|
|||
clockMem = ""
|
||||
clockGpu = ""
|
||||
fanspeed = ""
|
||||
gpuUsagePct = ""
|
||||
memIoPct = ""
|
||||
memUsage = "not found"
|
||||
for item in sp.split("\n"):
|
||||
try:
|
||||
key, val = item.split(":")
|
||||
|
|
@ -68,18 +61,10 @@ class Module(core.module.Module):
|
|||
name = val
|
||||
elif key == "Fan Speed":
|
||||
fanspeed = val.split(" ")[0]
|
||||
elif title == "Utilization":
|
||||
if key == "Gpu":
|
||||
gpuUsagePct = val.split(" ")[0]
|
||||
elif key == "Memory":
|
||||
memIoPct = val.split(" ")[0]
|
||||
|
||||
except:
|
||||
title = item.strip()
|
||||
|
||||
if totalMem and usedMem:
|
||||
memUsage = int(int(usedMem) / int(totalMem) * 100)
|
||||
|
||||
str_format = self.parameter(
|
||||
"format", "{name}: {temp}°C {mem_used}/{mem_total} MiB"
|
||||
)
|
||||
|
|
@ -91,9 +76,6 @@ class Module(core.module.Module):
|
|||
clock_gpu=clockGpu,
|
||||
clock_mem=clockMem,
|
||||
fanspeed=fanspeed,
|
||||
gpu_usage_pct=gpuUsagePct,
|
||||
mem_io_pct=memIoPct,
|
||||
mem_usage_pct=memUsage,
|
||||
)
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -1,12 +1,9 @@
|
|||
# pylint: disable=C0111,R0903
|
||||
|
||||
"""Displays the Octorrint status and the printer's bed/tools temperature in the status bar.
|
||||
"""Displays the Octorpint status and the printer's bed/tools temperature in the status bar.
|
||||
|
||||
Left click opens a popup which shows the bed & tools temperatures and additionally a livestream of the webcam (if enabled).
|
||||
|
||||
Prerequisites:
|
||||
* tk python library (usually python-tk or python3-tk, depending on your distribution)
|
||||
|
||||
Parameters:
|
||||
* octoprint.address : Octoprint address (e.q: http://192.168.1.3)
|
||||
* octoprint.apitoken : Octorpint API Token (can be obtained from the Octoprint Webinterface)
|
||||
|
|
@ -85,15 +82,8 @@ class Module(core.module.Module):
|
|||
core.input.register(self, button=core.input.LEFT_MOUSE, cmd=self.__show_popup)
|
||||
|
||||
def octoprint_status(self, widget):
|
||||
if (
|
||||
self.__octoprint_state.startswith("Offline")
|
||||
or self.__octoprint_state == "Unknown"
|
||||
):
|
||||
return (
|
||||
(self.__octoprint_state[:25] + "...")
|
||||
if len(self.__octoprint_state) > 25
|
||||
else self.__octoprint_state
|
||||
)
|
||||
if self.__octoprint_state == "Offline" or self.__octoprint_state == "Unknown":
|
||||
return self.__octoprint_state
|
||||
return (
|
||||
self.__octoprint_state
|
||||
+ " | B: "
|
||||
|
|
|
|||
|
|
@ -1,30 +0,0 @@
|
|||
"""Displays currently active gpu by optimus-manager
|
||||
Requires the following packages:
|
||||
|
||||
* optimus-manager
|
||||
|
||||
"""
|
||||
|
||||
import core.module
|
||||
import core.widget
|
||||
|
||||
import util.cli
|
||||
|
||||
class Module(core.module.Module):
|
||||
def __init__(self, config, theme):
|
||||
super().__init__(config, theme, core.widget.Widget(self.output))
|
||||
self.__gpumode = ""
|
||||
|
||||
def output(self, _):
|
||||
return "GPU: {}".format(self.__gpumode)
|
||||
|
||||
def update(self):
|
||||
cmd = "optimus-manager --print-mode"
|
||||
output = util.cli.execute(cmd).strip()
|
||||
|
||||
if "intel" in output:
|
||||
self.__gpumode = "Intel"
|
||||
elif "nvidia" in output:
|
||||
self.__gpumode = "Nvidia"
|
||||
elif "amd" in output:
|
||||
self.__gpumode = "AMD"
|
||||
|
|
@ -3,7 +3,7 @@
|
|||
"""Displays update information per repository for pacman.
|
||||
|
||||
Parameters:
|
||||
* pacman.sum: If you prefer displaying updates with a single digit (defaults to 'False')
|
||||
* pacman.sum: If you prefere displaying updates with a single digit (defaults to 'False')
|
||||
|
||||
Requires the following executables:
|
||||
* fakeroot
|
||||
|
|
|
|||
|
|
@ -1,88 +0,0 @@
|
|||
"""get volume level or control it
|
||||
|
||||
Requires the following executable:
|
||||
* pamixer
|
||||
|
||||
Parameters:
|
||||
* pamixer.percent_change: How much to change volume by when scrolling on the module (default is 4%)
|
||||
|
||||
heavily based on amixer module
|
||||
"""
|
||||
import re
|
||||
|
||||
import core.module
|
||||
import core.widget
|
||||
import core.input
|
||||
|
||||
import util.cli
|
||||
import util.format
|
||||
|
||||
class Module(core.module.Module):
|
||||
def __init__(self, config, theme):
|
||||
super().__init__(config, theme, core.widget.Widget(self.volume))
|
||||
|
||||
self.__level = "volume 0%"
|
||||
self.__muted = True
|
||||
self.__change = util.format.asint(
|
||||
self.parameter("percent_change", "4%").strip("%"), 0, 200
|
||||
)
|
||||
|
||||
events = [
|
||||
{
|
||||
"type": "mute",
|
||||
"action": self.toggle,
|
||||
"button": core.input.LEFT_MOUSE,
|
||||
},
|
||||
{
|
||||
"type": "volume",
|
||||
"action": self.increase_volume,
|
||||
"button": core.input.WHEEL_UP,
|
||||
},
|
||||
{
|
||||
"type": "volume",
|
||||
"action": self.decrease_volume,
|
||||
"button": core.input.WHEEL_DOWN,
|
||||
},
|
||||
]
|
||||
|
||||
for event in events:
|
||||
core.input.register(self, button=event["button"], cmd=event["action"])
|
||||
|
||||
def toggle(self, event):
|
||||
self.set_parameter("--toggle-mute")
|
||||
|
||||
def increase_volume(self, event):
|
||||
self.set_parameter("--increase {}".format(self.__change))
|
||||
|
||||
def decrease_volume(self, event):
|
||||
self.set_parameter("--decrease {}".format(self.__change))
|
||||
|
||||
def set_parameter(self, parameter):
|
||||
util.cli.execute("pamixer {}".format(parameter))
|
||||
|
||||
def volume(self, widget):
|
||||
if self.__level == "volume 0%":
|
||||
self.__muted = True
|
||||
return self.__level
|
||||
m = re.search(r"([\d]+)\%", self.__level)
|
||||
if m:
|
||||
if m.group(1) != "0%" in self.__level:
|
||||
self.__muted = False
|
||||
return "volume {}%".format(m.group(1))
|
||||
else:
|
||||
return "volume 0%"
|
||||
|
||||
def update(self):
|
||||
try:
|
||||
volume = util.cli.execute("pamixer --get-volume-human".format())
|
||||
self.__level = volume
|
||||
self.__muted = False
|
||||
except Exception as e:
|
||||
self.__level = "volume 0%"
|
||||
|
||||
def state(self, widget):
|
||||
if self.__muted:
|
||||
return ["warning", "muted"]
|
||||
return ["unmuted"]
|
||||
|
||||
# vim: tabstop=8 expandtab shiftwidth=4 softtabstop=4
|
||||
|
|
@ -1,31 +0,0 @@
|
|||
# pylint: disable=C0111,R0903
|
||||
|
||||
"""Displays the current date and time in Persian(Jalali) Calendar.
|
||||
|
||||
Requires the following python packages:
|
||||
* jdatetime
|
||||
|
||||
Parameters:
|
||||
* datetime.format: strftime()-compatible formatting string. default: "%A %d %B" e.g., "جمعه ۱۳ اسفند"
|
||||
* datetime.locale: locale to use. default: "fa_IR"
|
||||
"""
|
||||
|
||||
import jdatetime
|
||||
|
||||
import core.decorators
|
||||
from modules.core.datetime import Module as dtmodule
|
||||
|
||||
|
||||
class Module(dtmodule):
|
||||
@core.decorators.every(minutes=1)
|
||||
def __init__(self, config, theme):
|
||||
super().__init__(config, theme, dtlibrary=jdatetime)
|
||||
|
||||
def default_format(self):
|
||||
return "%A %d %B"
|
||||
|
||||
def default_locale(self):
|
||||
return ("fa_IR", "UTF-8")
|
||||
|
||||
|
||||
# vim: tabstop=8 expandtab shiftwidth=4 softtabstop=4
|
||||
|
|
@ -4,20 +4,13 @@
|
|||
|
||||
Parameters:
|
||||
* pihole.address : pi-hole address (e.q: http://192.168.1.3)
|
||||
|
||||
|
||||
* pihole.apitoken : pi-hole API token (can be obtained in the pi-hole webinterface (Settings -> API)
|
||||
|
||||
OR (deprecated!)
|
||||
|
||||
* pihole.pwhash : pi-hole webinterface password hash (can be obtained from the /etc/pihole/SetupVars.conf file)
|
||||
|
||||
|
||||
contributed by `bbernhard <https://github.com/bbernhard>`_ - many thanks!
|
||||
"""
|
||||
|
||||
import requests
|
||||
import logging
|
||||
|
||||
import core.module
|
||||
import core.widget
|
||||
import core.input
|
||||
|
|
@ -29,18 +22,7 @@ class Module(core.module.Module):
|
|||
super().__init__(config, theme, core.widget.Widget(self.pihole_status))
|
||||
|
||||
self._pihole_address = self.parameter("address", "")
|
||||
pihole_pw_hash = self.parameter("pwhash", "")
|
||||
pihole_api_token = self.parameter("apitoken", "")
|
||||
|
||||
self._pihole_secret = (
|
||||
pihole_api_token if pihole_api_token != "" else pihole_pw_hash
|
||||
)
|
||||
|
||||
if pihole_pw_hash != "":
|
||||
logging.warn(
|
||||
"pihole: The 'pwhash' parameter is deprecated - consider using the 'apitoken' parameter instead!"
|
||||
)
|
||||
|
||||
self._pihole_pw_hash = self.parameter("pwhash", "")
|
||||
self._pihole_status = None
|
||||
self._ads_blocked_today = "-"
|
||||
self.update_pihole_status()
|
||||
|
|
@ -60,11 +42,7 @@ class Module(core.module.Module):
|
|||
|
||||
def update_pihole_status(self):
|
||||
try:
|
||||
data = requests.get(
|
||||
self._pihole_address
|
||||
+ "/admin/api.php?summary&auth="
|
||||
+ self._pihole_secret
|
||||
).json()
|
||||
data = requests.get(self._pihole_address + "/admin/api.php?summary").json()
|
||||
self._pihole_status = True if data["status"] == "enabled" else False
|
||||
self._ads_blocked_today = data["ads_blocked_today"]
|
||||
except Exception as e:
|
||||
|
|
@ -78,13 +56,13 @@ class Module(core.module.Module):
|
|||
req = requests.get(
|
||||
self._pihole_address
|
||||
+ "/admin/api.php?disable&auth="
|
||||
+ self._pihole_secret
|
||||
+ self._pihole_pw_hash
|
||||
)
|
||||
else:
|
||||
req = requests.get(
|
||||
self._pihole_address
|
||||
+ "/admin/api.php?enable&auth="
|
||||
+ self._pihole_secret
|
||||
+ self._pihole_pw_hash
|
||||
)
|
||||
if req is not None:
|
||||
if req.status_code == 200:
|
||||
|
|
|
|||
|
|
@ -1,90 +0,0 @@
|
|||
"""get volume level or control it
|
||||
|
||||
Requires the following executable:
|
||||
* wpctl
|
||||
|
||||
Parameters:
|
||||
* wpctl.percent_change: How much to change volume by when scrolling on the module (default is 4%)
|
||||
|
||||
heavily based on amixer module
|
||||
"""
|
||||
import re
|
||||
|
||||
import core.module
|
||||
import core.widget
|
||||
import core.input
|
||||
|
||||
import util.cli
|
||||
import util.format
|
||||
|
||||
|
||||
class Module(core.module.Module):
|
||||
def __init__(self, config, theme):
|
||||
super().__init__(config, theme, core.widget.Widget(self.volume))
|
||||
|
||||
self.__level = "N/A"
|
||||
self.__muted = True
|
||||
self.__change = (
|
||||
util.format.asint(self.parameter("percent_change", "4%").strip("%"), 0, 200)
|
||||
/ 100.0
|
||||
) # divide by 100 because wpctl represents 100% volume as 1.00, 50% as 0.50, etc
|
||||
|
||||
self.__id = self.parameter("sink_id") or "@DEFAULT_AUDIO_SINK@"
|
||||
|
||||
events = [
|
||||
{
|
||||
"type": "mute",
|
||||
"action": self.toggle,
|
||||
"button": core.input.LEFT_MOUSE,
|
||||
},
|
||||
{
|
||||
"type": "volume",
|
||||
"action": self.increase_volume,
|
||||
"button": core.input.WHEEL_UP,
|
||||
},
|
||||
{
|
||||
"type": "volume",
|
||||
"action": self.decrease_volume,
|
||||
"button": core.input.WHEEL_DOWN,
|
||||
},
|
||||
]
|
||||
|
||||
for event in events:
|
||||
core.input.register(self, button=event["button"], cmd=event["action"])
|
||||
|
||||
def toggle(self, event):
|
||||
util.cli.execute("wpctl set-mute {} toggle".format(self.__id))
|
||||
|
||||
def increase_volume(self, event):
|
||||
util.cli.execute(
|
||||
"wpctl set-volume --limit 1.0 {} {}+".format(self.__id, self.__change)
|
||||
)
|
||||
|
||||
def decrease_volume(self, event):
|
||||
util.cli.execute(
|
||||
"wpctl set-volume --limit 1.0 {} {}-".format(self.__id, self.__change)
|
||||
)
|
||||
|
||||
def volume(self, widget):
|
||||
if self.__level == "N/A":
|
||||
return self.__level
|
||||
return "{}%".format(int(float(self.__level) * 100))
|
||||
|
||||
def update(self):
|
||||
try:
|
||||
# `wpctl get-volume` will return a string like "Volume: n.nn" or "Volume: n.nn [MUTED]"
|
||||
volume = util.cli.execute("wpctl get-volume {}".format(self.__id))
|
||||
v = re.search("\d\.\d+", volume)
|
||||
m = re.search("MUTED", volume)
|
||||
self.__level = v.group()
|
||||
self.__muted = True if m else False
|
||||
except Exception:
|
||||
self.__level = "N/A"
|
||||
|
||||
def state(self, widget):
|
||||
if self.__muted:
|
||||
return ["warning", "muted"]
|
||||
return ["unmuted"]
|
||||
|
||||
|
||||
# vim: tabstop=8 expandtab shiftwidth=4 softtabstop=4
|
||||
146
bumblebee_status/modules/contrib/playerctl.py
Normal file → Executable file
146
bumblebee_status/modules/contrib/playerctl.py
Normal file → Executable file
|
|
@ -5,131 +5,57 @@
|
|||
Requires the following executable:
|
||||
* playerctl
|
||||
|
||||
Parameters:
|
||||
* playerctl.format: Format string (defaults to '{{artist}} - {{title}} {{duration(position)}}/{{duration(mpris:length)}}').
|
||||
The format string is passed to 'playerctl -f' as an argument. Read `the README <https://github.com/altdesktop/playerctl#printing-properties-and-metadata>`_ for more information.
|
||||
* playerctl.layout: Comma-separated list to change order of widgets (defaults to song, previous, pause, next)
|
||||
Widget names are: playerctl.song, playerctl.prev, playerctl.pause, playerctl.next
|
||||
* playerctl.args: The arguments added to playerctl.
|
||||
You can check 'playerctl --help' or `its README <https://github.com/altdesktop/playerctl#using-the-cli>`_. For example, it could be '-p vlc,%any'.
|
||||
* playerctl.hide: Hide the widgets when no players are found. Defaults to "false".
|
||||
|
||||
Parameters are inspired by the `spotify` module, many thanks to its developers!
|
||||
|
||||
contributed by `smitajit <https://github.com/smitajit>`_ - many thanks!
|
||||
|
||||
"""
|
||||
|
||||
import core.module
|
||||
import core.widget
|
||||
import core.input
|
||||
import util.cli
|
||||
import util.format
|
||||
|
||||
import logging
|
||||
|
||||
class Module(core.module.Module):
|
||||
def __init__(self,config , theme):
|
||||
super(Module, self).__init__(config, theme, [])
|
||||
|
||||
self.background = True
|
||||
|
||||
self.__hide = util.format.asbool(self.parameter("hide", "false"));
|
||||
self.__hidden = self.__hide
|
||||
|
||||
self.__layout = util.format.aslist(
|
||||
self.parameter(
|
||||
"layout", "playerctl.prev, playerctl.song, playerctl.pause, playerctl.next"
|
||||
)
|
||||
)
|
||||
|
||||
self.__cmd = "playerctl " + self.parameter("args", "") + " "
|
||||
self.__format = self.parameter("format", "{{artist}} - {{title}} {{duration(position)}}/{{duration(mpris:length)}}")
|
||||
|
||||
widget_map = {}
|
||||
for widget_name in self.__layout:
|
||||
widget = self.add_widget(name=widget_name)
|
||||
if widget_name == "playerctl.prev":
|
||||
widget_map[widget] = {
|
||||
"button": core.input.LEFT_MOUSE,
|
||||
"cmd": self.__cmd + "previous",
|
||||
}
|
||||
elif widget_name == "playerctl.pause":
|
||||
widget_map[widget] = {
|
||||
"button": core.input.LEFT_MOUSE,
|
||||
"cmd": self.__cmd + "play-pause",
|
||||
}
|
||||
elif widget_name == "playerctl.next":
|
||||
widget_map[widget] = {
|
||||
"button": core.input.LEFT_MOUSE,
|
||||
"cmd": self.__cmd + "next",
|
||||
}
|
||||
elif widget_name == "playerctl.song":
|
||||
widget_map[widget] = [
|
||||
{
|
||||
"button": core.input.LEFT_MOUSE,
|
||||
"cmd": self.__cmd + "play-pause",
|
||||
}, {
|
||||
"button": core.input.WHEEL_UP,
|
||||
"cmd": self.__cmd + "next",
|
||||
}, {
|
||||
"button": core.input.WHEEL_DOWN,
|
||||
"cmd": self.__cmd + "previous",
|
||||
}
|
||||
widgets = [
|
||||
core.widget.Widget(name="playerctl.prev"),
|
||||
core.widget.Widget(name="playerctl.main", full_text=self.description),
|
||||
core.widget.Widget(name="playerctl.next"),
|
||||
]
|
||||
else:
|
||||
raise KeyError(
|
||||
"The playerctl module does not have a {widget_name!r} widget".format(
|
||||
widget_name=widget_name
|
||||
)
|
||||
)
|
||||
super(Module, self).__init__(config, theme , widgets)
|
||||
|
||||
for widget, callback_options in widget_map.items():
|
||||
if isinstance(callback_options, dict):
|
||||
core.input.register(widget, **callback_options)
|
||||
core.input.register(widgets[0], button=core.input.LEFT_MOUSE,
|
||||
cmd="playerctl previous")
|
||||
core.input.register(widgets[1], button=core.input.LEFT_MOUSE,
|
||||
cmd="playerctl play-pause")
|
||||
core.input.register(widgets[2], button=core.input.LEFT_MOUSE,
|
||||
cmd="playerctl next")
|
||||
|
||||
def hidden(self):
|
||||
return self.__hidden
|
||||
self._status = None
|
||||
self._tags = None
|
||||
|
||||
def status(self):
|
||||
try:
|
||||
playback_status = str(util.cli.execute(self.__cmd + "status 2>&1 || true", shell = True)).strip()
|
||||
if playback_status == "No players found":
|
||||
return None
|
||||
return playback_status
|
||||
except Exception as e:
|
||||
logging.exception(e)
|
||||
return None
|
||||
def description(self, widget):
|
||||
return self._tags if self._tags else "..."
|
||||
|
||||
def update(self):
|
||||
playback_status = self.status()
|
||||
if not playback_status:
|
||||
self.__hidden = self.__hide
|
||||
else:
|
||||
self.__hidden = False
|
||||
for widget in self.widgets():
|
||||
if playback_status:
|
||||
if widget.name == "playerctl.pause":
|
||||
if playback_status == "Playing":
|
||||
widget.set("state", "playing")
|
||||
elif playback_status == "Paused":
|
||||
widget.set("state", "paused")
|
||||
elif playback_status == "Stopped":
|
||||
widget.set("state", "stopped")
|
||||
else:
|
||||
widget.set("state", "")
|
||||
elif widget.name == "playerctl.next":
|
||||
widget.set("state", "next")
|
||||
elif widget.name == "playerctl.prev":
|
||||
widget.set("state", "prev")
|
||||
elif widget.name == "playerctl.song":
|
||||
widget.full_text(self.__get_song())
|
||||
else:
|
||||
widget.set("state", "")
|
||||
widget.full_text(" ")
|
||||
self._load_song()
|
||||
|
||||
def __get_song(self):
|
||||
def state(self, widget):
|
||||
if widget.name == "playerctl.prev":
|
||||
return "prev"
|
||||
if widget.name == "playerctl.next":
|
||||
return "next"
|
||||
return self._status
|
||||
|
||||
def _load_song(self):
|
||||
info = ""
|
||||
try:
|
||||
return str(util.cli.execute(self.__cmd + "metadata -f '" + self.__format + "'")).strip()
|
||||
except Exception as e:
|
||||
logging.exception(e)
|
||||
return " "
|
||||
status = util.cli.execute("playerctl status").lower()
|
||||
info = util.cli.execute("playerctl metadata xesam:title")
|
||||
except :
|
||||
self._status = None
|
||||
self._tags = None
|
||||
return
|
||||
self._status = status.split("\n")[0].lower()
|
||||
self._tags = info.split("\n")[0][:20]
|
||||
|
||||
# vim: tabstop=8 expandtab shiftwidth=4 softtabstop=4
|
||||
|
|
|
|||
|
|
@ -13,7 +13,7 @@ Parameters:
|
|||
Example: 'notify-send 'Time up!''. If you want to chain multiple commands,
|
||||
please use an external wrapper script and invoke that. The module itself does
|
||||
not support command chaining (see https://github.com/tobi-wan-kenobi/bumblebee-status/issues/532
|
||||
for a detailed explanation)
|
||||
for a detailled explanation)
|
||||
|
||||
contributed by `martindoublem <https://github.com/martindoublem>`_, inspired by `karthink <https://github.com/karthink>`_ - many thanks!
|
||||
"""
|
||||
|
|
|
|||
|
|
@ -1,72 +0,0 @@
|
|||
"""Displays the status of Gentoo portage operations.
|
||||
|
||||
Parameters:
|
||||
* portage_status.logfile: logfile for portage (default is /var/log/emerge.log)
|
||||
|
||||
contributed by `andrewreisner <https://github.com/andrewreisner>`_ - many thanks!
|
||||
"""
|
||||
|
||||
import os
|
||||
|
||||
import core.module
|
||||
import core.widget
|
||||
|
||||
|
||||
class Module(core.module.Module):
|
||||
def __init__(self, config, theme):
|
||||
super().__init__(config, theme, core.widget.Widget(self.output))
|
||||
self.__logfile = self.parameter("logfile", "/var/log/emerge.log")
|
||||
self.clear()
|
||||
|
||||
def clear(self):
|
||||
self.__action = ""
|
||||
self.__package = ""
|
||||
self.__status = ""
|
||||
|
||||
def output(self, widget):
|
||||
return " ".join(
|
||||
[
|
||||
atom
|
||||
for atom in (self.__action, self.__package, self.__status)
|
||||
if atom != ""
|
||||
]
|
||||
)
|
||||
|
||||
def state(self, widgets):
|
||||
if self.__action == "":
|
||||
return "idle"
|
||||
return "active"
|
||||
|
||||
def update(self):
|
||||
try:
|
||||
with open(self.__logfile, "rb") as f:
|
||||
f.seek(-2, os.SEEK_END)
|
||||
while f.read(1) != b"\n":
|
||||
f.seek(-2, os.SEEK_CUR)
|
||||
last_line = f.readline().decode()
|
||||
if "===" in last_line:
|
||||
if "Unmerging..." in last_line:
|
||||
self.__action = "Unmerging"
|
||||
package_beg = last_line.find("(") + 1
|
||||
package_end = last_line.find("-", last_line.find("/")) - 1
|
||||
self.__package = last_line[package_beg : package_end + 1]
|
||||
else: # merging
|
||||
status_beg = last_line.find("(")
|
||||
status_end = last_line.find(")")
|
||||
self.__status = last_line[status_beg : status_end + 1]
|
||||
package_beg = last_line.find("(", status_end) + 1
|
||||
package_end = (
|
||||
package_beg
|
||||
+ last_line[package_beg:].find(
|
||||
"-", last_line[package_beg:].find("/")
|
||||
)
|
||||
- 1
|
||||
)
|
||||
self.__package = last_line[package_beg : package_end + 1]
|
||||
action_beg = status_end + 2
|
||||
action_end = package_beg - 3
|
||||
self.__action = last_line[action_beg : action_end + 1]
|
||||
else:
|
||||
self.clear()
|
||||
except Exception:
|
||||
self.clear()
|
||||
|
|
@ -1,99 +0,0 @@
|
|||
# pylint: disable=C0111,R0903
|
||||
"""
|
||||
Displays the current Power-Profile active
|
||||
|
||||
|
||||
Left-Click or Right-Click as well as Scrolling up / down changes the active Power-Profile
|
||||
|
||||
Prerequisites:
|
||||
* dbus-python
|
||||
* power-profiles-daemon
|
||||
"""
|
||||
|
||||
import dbus
|
||||
import core.module
|
||||
import core.widget
|
||||
import core.input
|
||||
|
||||
|
||||
class PowerProfileManager:
|
||||
def __init__(self):
|
||||
self.POWER_PROFILES_NAME = "net.hadess.PowerProfiles"
|
||||
self.POWER_PROFILES_PATH = "/net/hadess/PowerProfiles"
|
||||
self.PP_PROPERTIES_CURRENT_POWER_PROFILE = "ActiveProfile"
|
||||
self.PP_PROPERTIES_ALL_POWER_PROFILES = "Profiles"
|
||||
|
||||
self.DBUS_PROPERTIES = "org.freedesktop.DBus.Properties"
|
||||
bus = dbus.SystemBus()
|
||||
pp_proxy = bus.get_object(self.POWER_PROFILES_NAME, self.POWER_PROFILES_PATH)
|
||||
self.pp_interface = dbus.Interface(pp_proxy, self.DBUS_PROPERTIES)
|
||||
|
||||
def get_current_power_profile(self):
|
||||
return self.pp_interface.Get(
|
||||
self.POWER_PROFILES_NAME, self.PP_PROPERTIES_CURRENT_POWER_PROFILE
|
||||
)
|
||||
|
||||
def __get_all_power_profile_names(self):
|
||||
power_profiles = self.pp_interface.Get(
|
||||
self.POWER_PROFILES_NAME, self.PP_PROPERTIES_ALL_POWER_PROFILES
|
||||
)
|
||||
power_profiles_names = []
|
||||
for pp in power_profiles:
|
||||
power_profiles_names.append(pp["Profile"])
|
||||
|
||||
return power_profiles_names
|
||||
|
||||
def next_power_profile(self, event):
|
||||
all_pp_names = self.__get_all_power_profile_names()
|
||||
current_pp_index = self.__get_current_pp_index()
|
||||
next_index = 0
|
||||
if current_pp_index != (len(all_pp_names) - 1):
|
||||
next_index = current_pp_index + 1
|
||||
|
||||
self.pp_interface.Set(
|
||||
self.POWER_PROFILES_NAME,
|
||||
self.PP_PROPERTIES_CURRENT_POWER_PROFILE,
|
||||
all_pp_names[next_index],
|
||||
)
|
||||
|
||||
def prev_power_profile(self, event):
|
||||
all_pp_names = self.__get_all_power_profile_names()
|
||||
current_pp_index = self.__get_current_pp_index()
|
||||
last_index = len(all_pp_names) - 1
|
||||
if current_pp_index is not 0:
|
||||
last_index = current_pp_index - 1
|
||||
|
||||
self.pp_interface.Set(
|
||||
self.POWER_PROFILES_NAME,
|
||||
self.PP_PROPERTIES_CURRENT_POWER_PROFILE,
|
||||
all_pp_names[last_index],
|
||||
)
|
||||
|
||||
def __get_current_pp_index(self):
|
||||
all_pp_names = self.__get_all_power_profile_names()
|
||||
current_pp = self.get_current_power_profile()
|
||||
return all_pp_names.index(current_pp)
|
||||
|
||||
|
||||
class Module(core.module.Module):
|
||||
def __init__(self, config, theme):
|
||||
super().__init__(config, theme, core.widget.Widget(self.full_text))
|
||||
self.pp_manager = PowerProfileManager()
|
||||
core.input.register(
|
||||
self, button=core.input.WHEEL_UP, cmd=self.pp_manager.next_power_profile
|
||||
)
|
||||
core.input.register(
|
||||
self, button=core.input.WHEEL_DOWN, cmd=self.pp_manager.prev_power_profile
|
||||
)
|
||||
core.input.register(
|
||||
self, button=core.input.LEFT_MOUSE, cmd=self.pp_manager.next_power_profile
|
||||
)
|
||||
core.input.register(
|
||||
self, button=core.input.RIGHT_MOUSE, cmd=self.pp_manager.prev_power_profile
|
||||
)
|
||||
|
||||
def full_text(self, widgets):
|
||||
return self.pp_manager.get_current_power_profile()
|
||||
|
||||
|
||||
# vim: tabstop=8 expandtab shiftwidth=4 softtabstop=4
|
||||
|
|
@ -20,8 +20,7 @@ Parameters:
|
|||
* prime.nvidiastring: String to use when nvidia is selected (defaults to 'intel')
|
||||
* prime.intelstring: String to use when intel is selected (defaults to 'intel')
|
||||
|
||||
Requires the following executables:
|
||||
* sudo
|
||||
Requires the following executable:
|
||||
* prime-select
|
||||
|
||||
contributed by `jeffeb3 <https://github.com/jeffeb3>`_ - many thanks!
|
||||
|
|
|
|||
|
|
@ -29,9 +29,6 @@ class Module(core.module.Module):
|
|||
super().__init__(config, theme, core.widget.Widget(self.get_progress_text))
|
||||
self.__active = False
|
||||
|
||||
def hidden(self):
|
||||
return not self.__active
|
||||
|
||||
def get_progress_text(self, widget):
|
||||
if self.update_progress_info(widget):
|
||||
width = util.format.asint(self.parameter("barwidth", 8))
|
||||
|
|
@ -56,7 +53,7 @@ class Module(core.module.Module):
|
|||
return self.parameter("placeholder", "n/a")
|
||||
|
||||
def update_progress_info(self, widget):
|
||||
"""Update widget's information about the copy"""
|
||||
"""Update widget's informations about the copy"""
|
||||
if not self.__active:
|
||||
return
|
||||
|
||||
|
|
@ -64,8 +61,8 @@ class Module(core.module.Module):
|
|||
# 1. pid
|
||||
# 2. command
|
||||
# 3. arguments
|
||||
# 4. progress (xx.x formatted)
|
||||
# 5. quantity (.. unit / .. unit formatted)
|
||||
# 4. progress (xx.x formated)
|
||||
# 5. quantity (.. unit / .. unit formated)
|
||||
# 6. speed
|
||||
# 7. time remaining
|
||||
extract_nospeed = re.compile(
|
||||
|
|
@ -80,7 +77,7 @@ class Module(core.module.Module):
|
|||
result = extract_wtspeed.match(raw)
|
||||
|
||||
if not result:
|
||||
# Abort speed measures
|
||||
# Abord speed measures
|
||||
raw = util.cli.execute("progress -q")
|
||||
result = extract_nospeed.match(raw)
|
||||
|
||||
|
|
@ -104,7 +101,7 @@ class Module(core.module.Module):
|
|||
|
||||
def state(self, widget):
|
||||
if self.__active:
|
||||
return ["copying", "no-autohide"]
|
||||
return "copying"
|
||||
return "pending"
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -1,155 +1,28 @@
|
|||
"""Displays public IP address
|
||||
"""
|
||||
Displays information about the public IP address associated with the default route:
|
||||
* Public IP address
|
||||
* Country Name
|
||||
* Country Code
|
||||
* City Name
|
||||
* Geographic Coordinates
|
||||
|
||||
Left mouse click on the widget forces immediate update.
|
||||
Any change to the default route will cause the widget to update.
|
||||
|
||||
Requirements:
|
||||
* netifaces
|
||||
|
||||
Parameters:
|
||||
* publicip.format: Format string (defaults to ‘{ip} ({country_code})’)
|
||||
* Available format strings - ip, country_name, country_code, city_name, coordinates
|
||||
|
||||
Examples:
|
||||
* bumblebee-status -m publicip -p publicip.format="{ip} ({country_code})"
|
||||
* bumblebee-status -m publicip -p publicip.format="{ip} which is in {city_name}"
|
||||
* bumblebee-status -m publicip -p publicip.format="Your packets are right here: {coordinates}"
|
||||
|
||||
contributed by `tfwiii <https://github.com/tfwiii>` - many thanks!
|
||||
"""
|
||||
|
||||
import re
|
||||
import threading
|
||||
import netifaces
|
||||
import time
|
||||
|
||||
import core.module
|
||||
import core.widget
|
||||
import core.input
|
||||
import core.decorators
|
||||
|
||||
import util.format
|
||||
import util.location
|
||||
import logging
|
||||
|
||||
log = logging.getLogger(__name__)
|
||||
|
||||
|
||||
class Module(core.module.Module):
|
||||
@core.decorators.every(minutes=60)
|
||||
def __init__(self, config, theme):
|
||||
super().__init__(config, theme, core.widget.Widget(self.publicip))
|
||||
super().__init__(config, theme, core.widget.Widget(self.public_ip))
|
||||
|
||||
self.__previous_default_route = None
|
||||
self.__current_default_route = None
|
||||
self.background = True
|
||||
self.__ip = ""
|
||||
|
||||
# Immediate update (override default) when left click on widget
|
||||
core.input.register(self, button=core.input.LEFT_MOUSE, cmd=self.__click_update)
|
||||
|
||||
# By default show: <ip> (<2 letter country code>)
|
||||
self._format = self.parameter("format", "{ip} ({country_code})")
|
||||
|
||||
self.__monitor = threading.Thread(target=self.monitor, args=())
|
||||
self.__monitor.start()
|
||||
|
||||
def monitor(self):
|
||||
__previous_ips = set()
|
||||
__current_ips = set()
|
||||
# Initially set to True to force an info update on first pass
|
||||
__information_changed = True
|
||||
|
||||
self.update()
|
||||
|
||||
while threading.main_thread().is_alive():
|
||||
__current_ips.clear()
|
||||
# Look for any changes to IP addresses
|
||||
try:
|
||||
for interface in netifaces.interfaces():
|
||||
try:
|
||||
__current_ips.add(netifaces.ifaddresses(interface)[2][0]['addr'])
|
||||
except:
|
||||
pass
|
||||
except:
|
||||
# If not ip address information found clear __current_ips
|
||||
__current_ips.clear()
|
||||
|
||||
# If a change of any interfaces' IP then flag change
|
||||
if __current_ips.symmetric_difference(__previous_ips):
|
||||
__previous_ips = __current_ips.copy()
|
||||
__information_changed = True
|
||||
|
||||
# Update if change is flagged
|
||||
if __information_changed:
|
||||
__information_changed = False
|
||||
self.update()
|
||||
|
||||
# Throttle the calls to netifaces
|
||||
time.sleep(1)
|
||||
|
||||
def publicip(self, widget):
|
||||
if widget.get("public_ip") is None:
|
||||
return "n/a"
|
||||
return self._format.format(
|
||||
ip = widget.get("public_ip", "-"),
|
||||
country_name = widget.get("country_name", "-"),
|
||||
country_code = widget.get("country_code", "-"),
|
||||
city_name = widget.get("city_name", "-"),
|
||||
coordinates = widget.get("coordinates", "-"),
|
||||
)
|
||||
|
||||
def __click_update(self, event):
|
||||
util.location.reset()
|
||||
def public_ip(self, widget):
|
||||
return self.__ip
|
||||
|
||||
def update(self):
|
||||
widget = self.widget()
|
||||
|
||||
try:
|
||||
util.location.reset()
|
||||
time.sleep(5) # wait for reset to complete before querying results
|
||||
|
||||
# Fetch fresh location information
|
||||
__info = util.location.location_info()
|
||||
__raw_lat = __info["latitude"]
|
||||
__raw_lon = __info["longitude"]
|
||||
|
||||
# Contstruct coordinates string if util.location has provided required info
|
||||
if isinstance(__raw_lat, float) and isinstance(__raw_lon, float):
|
||||
__lat = float("{:.2f}".format(__raw_lat))
|
||||
__lon = float("{:.2f}".format(__raw_lon))
|
||||
if __lat < 0:
|
||||
__coords = str(__lat) + "°S"
|
||||
else:
|
||||
__coords = str(__lat) + "°N"
|
||||
__coords += ","
|
||||
if __lon < 0:
|
||||
__coords += str(__lon) + "°W"
|
||||
else:
|
||||
__coords += str(__lon) + "°E"
|
||||
else:
|
||||
__coords = "Unknown"
|
||||
|
||||
# Set widget values
|
||||
widget.set("public_ip", __info["public_ip"])
|
||||
widget.set("country_name", __info["country"])
|
||||
widget.set("country_code", __info["country_code"])
|
||||
widget.set("city_name", __info["city_name"])
|
||||
widget.set("coordinates", __coords)
|
||||
|
||||
# Update widget values
|
||||
core.event.trigger("update", [widget.module.id], redraw_only=True)
|
||||
except Exception as ex:
|
||||
widget.set("public_ip", None)
|
||||
logging.error(str(ex))
|
||||
|
||||
def state(self, widget):
|
||||
return widget.get("state", None)
|
||||
self.__ip = util.location.public_ip()
|
||||
except Exception:
|
||||
self.__ip = "n/a"
|
||||
|
||||
|
||||
# vim: tabstop=8 expandtab shiftwidth=4 softtabstop=4
|
||||
|
|
|
|||
|
|
@ -1,59 +0,0 @@
|
|||
"""Rofication indicator
|
||||
|
||||
https://github.com/DaveDavenport/Rofication
|
||||
simple module to show an icon + the number of notifications stored in rofication
|
||||
module will have normal highlighting if there are zero notifications,
|
||||
"warning" highlighting if there are nonzero notifications,
|
||||
"critical" highlighting if there are any critical notifications
|
||||
|
||||
Parameters:
|
||||
* rofication.regolith: Switch to regolith fork of rofication, see <https://github.com/regolith-linux/regolith-rofication>.
|
||||
|
||||
"""
|
||||
|
||||
import core.module
|
||||
import core.widget
|
||||
import core.decorators
|
||||
|
||||
import sys
|
||||
import socket
|
||||
|
||||
class Module(core.module.Module):
|
||||
@core.decorators.every(seconds=5)
|
||||
def __init__(self, config, theme):
|
||||
super().__init__(config, theme, core.widget.Widget(self.full_text))
|
||||
self.__critical = False
|
||||
self.__numnotifications = 0
|
||||
self.__regolith = self.parameter("regolith", False)
|
||||
|
||||
|
||||
def full_text(self, widgets):
|
||||
with socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) as client:
|
||||
client.connect("/tmp/rofi_notification_daemon")
|
||||
# below code will fetch two numbers in a list, e.g. ['22', '1']
|
||||
# first is total number of notifications, second is number of critical notifications
|
||||
if self.__regolith:
|
||||
client.sendall(bytes("num\n", "utf-8"))
|
||||
else:
|
||||
client.sendall(bytes("num", "utf-8"))
|
||||
val = client.recv(512)
|
||||
val = val.decode("utf-8")
|
||||
if self.__regolith:
|
||||
l = val.split(',',2)
|
||||
else:
|
||||
l = val.split('\n',2)
|
||||
self.__numnotifications = int(l[0])
|
||||
self.__critical = bool(int(l[1]))
|
||||
return self.__numnotifications
|
||||
|
||||
def state(self, widget):
|
||||
# rofication doesn't really support the idea of seen vs unseen notifications
|
||||
# marking a message as "seen" actually just sets its urgency to normal
|
||||
# so, doing highlighting if any notifications are present
|
||||
if self.__critical:
|
||||
return ["critical"]
|
||||
elif self.__numnotifications:
|
||||
return ["warning"]
|
||||
return []
|
||||
|
||||
# vim: tabstop=8 expandtab shiftwidth=4 softtabstop=4
|
||||
|
|
@ -31,13 +31,14 @@ class Module(core.module.Module):
|
|||
orientation = curr_orient
|
||||
break
|
||||
|
||||
widget = self.widget(name=display)
|
||||
widget = self.widget(display)
|
||||
if not widget:
|
||||
widget = self.add_widget(full_text=display, name=display)
|
||||
core.input.register(
|
||||
widget, button=core.input.LEFT_MOUSE, cmd=self.__toggle
|
||||
)
|
||||
widget.set("orientation", orientation)
|
||||
widgets.append(widget)
|
||||
|
||||
def state(self, widget):
|
||||
return widget.get("orientation", "normal")
|
||||
|
|
|
|||
|
|
@ -55,7 +55,7 @@ class Module(core.module.Module):
|
|||
|
||||
self._state = []
|
||||
|
||||
self._newspaper_file = tempfile.NamedTemporaryFile(mode="w", suffix=".html")
|
||||
self._newspaper_filename = tempfile.mktemp(".html")
|
||||
|
||||
self._last_refresh = 0
|
||||
self._last_update = 0
|
||||
|
|
@ -308,11 +308,10 @@ class Module(core.module.Module):
|
|||
|
||||
while newspaper_items:
|
||||
content += self._create_news_section(newspaper_items)
|
||||
self._newspaper_file.write(
|
||||
open(self._newspaper_filename, "w").write(
|
||||
HTML_TEMPLATE.replace("[[CONTENT]]", content)
|
||||
)
|
||||
self._newspaper_file.flush()
|
||||
webbrowser.open("file://" + self._newspaper_file.name)
|
||||
webbrowser.open("file://" + self._newspaper_filename)
|
||||
self._update_history("newspaper")
|
||||
self._save_history()
|
||||
|
||||
|
|
|
|||
|
|
@ -4,7 +4,6 @@
|
|||
"""Displays sensor temperature
|
||||
|
||||
Parameters:
|
||||
* sensors.use_sensors: whether to use the sensors command
|
||||
* sensors.path: path to temperature file (default /sys/class/thermal/thermal_zone0/temp).
|
||||
* sensors.json: if set to 'true', interpret sensors.path as JSON 'path' in the output
|
||||
of 'sensors -j' (i.e. <key1>/<key2>/.../<value>), for example, path could
|
||||
|
|
@ -19,7 +18,6 @@ contributed by `mijoharas <https://github.com/mijoharas>`_ - many thanks!
|
|||
"""
|
||||
|
||||
import re
|
||||
import os
|
||||
import json
|
||||
import logging
|
||||
|
||||
|
|
@ -48,25 +46,22 @@ class Module(core.module.Module):
|
|||
self._json = util.format.asbool(self.parameter("json", False))
|
||||
self._freq = util.format.asbool(self.parameter("show_freq", True))
|
||||
core.input.register(self, button=core.input.LEFT_MOUSE, cmd="xsensors")
|
||||
self.use_sensors = self.determine_method()
|
||||
self.determine_method()
|
||||
|
||||
def determine_method(self):
|
||||
if util.format.asbool(self.parameter("use_sensors")) == True:
|
||||
return True
|
||||
if util.format.asbool(self.parameter("use_sensors")) == False:
|
||||
return False
|
||||
if self.parameter("path") != None and self._json == False:
|
||||
return False
|
||||
self.use_sensors = False # use thermal zone
|
||||
else:
|
||||
# try to use output of sensors -u
|
||||
try:
|
||||
_ = util.cli.execute("sensors -u")
|
||||
output = util.cli.execute("sensors -u")
|
||||
self.use_sensors = True
|
||||
log.debug("Sensors command available")
|
||||
return True
|
||||
except FileNotFoundError as e:
|
||||
log.info(
|
||||
"Sensors command not available, using /sys/class/thermal/thermal_zone*/"
|
||||
)
|
||||
return False
|
||||
self.use_sensors = False
|
||||
|
||||
def _get_temp_from_sensors(self):
|
||||
if self._json == True:
|
||||
|
|
@ -97,31 +92,22 @@ class Module(core.module.Module):
|
|||
|
||||
def get_temp(self):
|
||||
if self.use_sensors:
|
||||
temperature = self._get_temp_from_sensors()
|
||||
log.debug("Retrieve temperature from sensors -u")
|
||||
return self._get_temp_from_sensors()
|
||||
try:
|
||||
path = None
|
||||
# use path provided by the user
|
||||
if self.parameter("path") is not None:
|
||||
path = self.parameter("path")
|
||||
# find the thermal zone that provides cpu temperature
|
||||
else:
|
||||
for zone in os.listdir("/sys/class/thermal"):
|
||||
if not zone.startswith("thermal_zone"):
|
||||
continue
|
||||
if open(f"/sys/class/thermal/{zone}/type").read().strip() != "x86_pkg_temp":
|
||||
continue
|
||||
path = f"/sys/class/thermal/{zone}/temp"
|
||||
# use zone 0 as fallback
|
||||
if path is None:
|
||||
log.info("Can not determine temperature path, using thermal_zone0")
|
||||
path = "/sys/class/thermal/thermal_zone0/temp"
|
||||
log.debug(f"retrieving temperature from {path}")
|
||||
# the values are t°C * 1000, so divide by 1000
|
||||
return str(int(open(path).read()) / 1000)
|
||||
try:
|
||||
temperature = open(
|
||||
self.parameter("path", "/sys/class/thermal/thermal_zone0/temp")
|
||||
).read()[:2]
|
||||
log.debug("retrieved temperature from /sys/class/")
|
||||
# TODO: Iterate through all thermal zones to determine the correct one and use its value
|
||||
# https://unix.stackexchange.com/questions/304845/discrepancy-between-number-of-cores-and-thermal-zones-in-sys-class-thermal
|
||||
|
||||
except IOError:
|
||||
temperature = "unknown"
|
||||
log.info("Can not determine temperature, please install lm-sensors")
|
||||
return "unknown"
|
||||
|
||||
return temperature
|
||||
|
||||
def get_mhz(self):
|
||||
mhz = None
|
||||
|
|
|
|||
|
|
@ -41,21 +41,19 @@ class Module(core.module.Module):
|
|||
super().__init__(config, theme, core.widget.Widget(self.get_output))
|
||||
|
||||
self.__command = self.parameter("command", 'echo "no command configured"')
|
||||
self.__command = os.path.expanduser(self.__command)
|
||||
self.__async = util.format.asbool(self.parameter("async"))
|
||||
|
||||
if self.__async:
|
||||
self.__output = "please wait..."
|
||||
self.__current_thread = threading.Thread()
|
||||
|
||||
if self.parameter("scrolling.makewide") is None:
|
||||
self.set("scrolling.makewide", False)
|
||||
# LMB and RMB will update output regardless of timer
|
||||
core.input.register(self, button=core.input.LEFT_MOUSE, cmd=self.update)
|
||||
core.input.register(self, button=core.input.RIGHT_MOUSE, cmd=self.update)
|
||||
|
||||
def set_output(self, value):
|
||||
self.__output = value
|
||||
core.event.trigger("update", [self.id], redraw_only=True)
|
||||
|
||||
@core.decorators.scrollable
|
||||
def get_output(self, _):
|
||||
return self.__output
|
||||
|
||||
|
|
|
|||
|
|
@ -4,12 +4,12 @@
|
|||
when clicking on it.
|
||||
|
||||
For more than one shortcut, the commands and labels are strings separated by
|
||||
a delimiter (; semicolon by default).
|
||||
a demiliter (; semicolon by default).
|
||||
|
||||
For example in order to create two shortcuts labeled A and B with commands
|
||||
cmdA and cmdB you could do:
|
||||
|
||||
./bumblebee-status -m shortcut -p shortcut.cmd='firefox https://www.google.com;google-chrome https://google.com' shortcut.label='Google (Firefox);Google (Chrome)'
|
||||
./bumblebee-status -m shortcut -p shortcut.cmd='ls;ps' shortcut.label='A;B'
|
||||
|
||||
Parameters:
|
||||
* shortcut.cmds : List of commands to execute
|
||||
|
|
|
|||
|
|
@ -5,12 +5,8 @@
|
|||
|
||||
"""Displays HDD smart status of different drives or all drives
|
||||
|
||||
Requires the following executables:
|
||||
* sudo
|
||||
* smartctl
|
||||
|
||||
Parameters:
|
||||
* smartstatus.display: how to display (defaults to 'combined', other choices: 'combined_singles', 'separate' or 'singles')
|
||||
* smartstatus.display: how to display (defaults to 'combined', other choices: 'seperate' or 'singles')
|
||||
* smartstatus.drives: in the case of singles which drives to display, separated comma list value, multiple accepted (defaults to 'sda', example:'sda,sdc')
|
||||
* smartstatus.show_names: boolean in the form of "True" or "False" to show the name of the drives in the form of sda, sbd, combined or none at all.
|
||||
"""
|
||||
|
|
@ -38,7 +34,7 @@ class Module(core.module.Module):
|
|||
self.create_widgets()
|
||||
|
||||
def create_widgets(self):
|
||||
if self.display == "combined" or self.display == "combined_singles":
|
||||
if self.display == "combined":
|
||||
widget = self.add_widget()
|
||||
widget.set("device", "combined")
|
||||
widget.set("assessment", self.combined())
|
||||
|
|
@ -81,8 +77,6 @@ class Module(core.module.Module):
|
|||
|
||||
def combined(self):
|
||||
for device in self.devices:
|
||||
if self.display == "combined_singles" and device not in self.drives:
|
||||
continue
|
||||
result = self.smart(device)
|
||||
if result == "Fail":
|
||||
return "Fail"
|
||||
|
|
|
|||
|
|
@ -1,58 +0,0 @@
|
|||
"""Shows status and load percentage of logitech's unifying device
|
||||
|
||||
Requires the following executable:
|
||||
* solaar (from community)
|
||||
|
||||
contributed by `cambid <https://github.com/cambid>`_ - many thanks!
|
||||
"""
|
||||
|
||||
import logging
|
||||
|
||||
import core.module
|
||||
import core.widget
|
||||
import core.decorators
|
||||
|
||||
import util.cli
|
||||
|
||||
|
||||
class Module(core.module.Module):
|
||||
@core.decorators.every(seconds=30)
|
||||
def __init__(self, config, theme):
|
||||
super().__init__(config, theme, core.widget.Widget(self.utilization))
|
||||
self.__battery = self.parameter("device", "")
|
||||
self.background = True
|
||||
self.__battery_status = ""
|
||||
self.__error = False
|
||||
if self.__battery != "":
|
||||
self.__cmd = f"solaar show '{self.__battery}'"
|
||||
else:
|
||||
self.__cmd = "solaar show"
|
||||
|
||||
@property
|
||||
def __format(self):
|
||||
return self.parameter("format", "{}")
|
||||
|
||||
def utilization(self, widget):
|
||||
return self.__format.format(self.__battery_status)
|
||||
|
||||
def update(self):
|
||||
self.__error = False
|
||||
code, result = util.cli.execute(
|
||||
self.__cmd, ignore_errors=True, return_exitcode=True
|
||||
)
|
||||
|
||||
if code == 0:
|
||||
for line in result.split('\n'):
|
||||
if line.count('Battery') > 0:
|
||||
self.__battery_status = line.split(':')[1].strip()
|
||||
else:
|
||||
self.__error = True
|
||||
logging.error(f"solaar exited with {code}: {result}")
|
||||
|
||||
def state(self, widget):
|
||||
if self.__error:
|
||||
return "warning"
|
||||
return "okay"
|
||||
|
||||
|
||||
# vim: tabstop=8 expandtab shiftwidth=4 softtabstop=4
|
||||
|
|
@ -9,6 +9,7 @@ an example.
|
|||
|
||||
Requires the following libraries:
|
||||
* requests
|
||||
* regex
|
||||
|
||||
Parameters:
|
||||
* spaceapi.url: String representation of the api endpoint
|
||||
|
|
@ -16,7 +17,7 @@ Parameters:
|
|||
|
||||
Format Strings:
|
||||
* Format strings are indicated by double %%
|
||||
* They represent a leaf in the JSON tree, layers separated by '.'
|
||||
* They represent a leaf in the JSON tree, layers seperated by '.'
|
||||
* Boolean values can be overwritten by appending '%true%false'
|
||||
in the format string
|
||||
* Example: to reference 'open' in '{'state':{'open': true}}'
|
||||
|
|
|
|||
|
|
@ -8,16 +8,10 @@ Parameters:
|
|||
Available values are: {album}, {title}, {artist}, {trackNumber}
|
||||
* spotify.layout: Comma-separated list to change order of widgets (defaults to song, previous, pause, next)
|
||||
Widget names are: spotify.song, spotify.prev, spotify.pause, spotify.next
|
||||
* spotify.concise_controls: When enabled, allows spotify to be controlled from just the spotify.song widget.
|
||||
Concise controls are: Left Click: Toggle Pause; Wheel Up: Next; Wheel Down; Previous.
|
||||
* spotify.bus_name: String (defaults to `spotify`)
|
||||
Available values: spotify, spotifyd
|
||||
|
||||
contributed by `yvesh <https://github.com/yvesh>`_ - many thanks!
|
||||
|
||||
added controls by `LtPeriwinkle <https://github.com/LtPeriwinkle>`_ - many thanks!
|
||||
|
||||
fixed icons and layout parameter by `gkeep <https://github.com/gkeep>`_ - many thanks!
|
||||
"""
|
||||
|
||||
import sys
|
||||
|
|
@ -29,34 +23,52 @@ import core.input
|
|||
import core.decorators
|
||||
import util.format
|
||||
|
||||
import logging
|
||||
|
||||
class Module(core.module.Module):
|
||||
def __init__(self, config, theme):
|
||||
super().__init__(config, theme, [])
|
||||
|
||||
self.background = True
|
||||
|
||||
self.__bus_name = self.parameter("bus_name", "spotify")
|
||||
|
||||
self.__layout = util.format.aslist(
|
||||
self.parameter(
|
||||
"layout", "spotify.song,spotify.prev,spotify.pause,spotify.next",
|
||||
)
|
||||
self.__layout = self.parameter(
|
||||
"layout",
|
||||
util.format.aslist("spotify.song,spotify.prev,spotify.pause,spotify.next"),
|
||||
)
|
||||
|
||||
self.__bus = dbus.SessionBus()
|
||||
self.__song = ""
|
||||
self.__pause = ""
|
||||
self.__format = self.parameter("format", "{artist} - {title}")
|
||||
|
||||
if self.__bus_name == "spotifyd":
|
||||
self.__cmd = "dbus-send --session --type=method_call --dest=org.mpris.MediaPlayer2.spotifyd \
|
||||
/org/mpris/MediaPlayer2 org.mpris.MediaPlayer2.Player."
|
||||
else:
|
||||
self.__cmd = "dbus-send --session --type=method_call --dest=org.mpris.MediaPlayer2.spotify \
|
||||
/org/mpris/MediaPlayer2 org.mpris.MediaPlayer2.Player."
|
||||
|
||||
def hidden(self):
|
||||
return self.string_song == ""
|
||||
|
||||
def __get_song(self):
|
||||
bus = dbus.SessionBus()
|
||||
spotify = bus.get_object(
|
||||
"org.mpris.MediaPlayer2.spotify", "/org/mpris/MediaPlayer2"
|
||||
)
|
||||
spotify_iface = dbus.Interface(spotify, "org.freedesktop.DBus.Properties")
|
||||
props = spotify_iface.Get("org.mpris.MediaPlayer2.Player", "Metadata")
|
||||
playback_status = str(
|
||||
spotify_iface.Get("org.mpris.MediaPlayer2.Player", "PlaybackStatus")
|
||||
)
|
||||
if playback_status == "Playing":
|
||||
self.__pause = "\u258D\u258D"
|
||||
else:
|
||||
self.__pause = "\u25B6"
|
||||
self.__song = self.__format.format(
|
||||
album=str(props.get("xesam:album")),
|
||||
title=str(props.get("xesam:title")),
|
||||
artist=",".join(props.get("xesam:artist")),
|
||||
trackNumber=str(props.get("xesam:trackNumber")),
|
||||
)
|
||||
|
||||
def update(self):
|
||||
try:
|
||||
self.clear_widgets()
|
||||
self.__get_song()
|
||||
|
||||
widget_map = {}
|
||||
for widget_name in self.__layout:
|
||||
widget = self.add_widget(name=widget_name)
|
||||
|
|
@ -65,100 +77,31 @@ class Module(core.module.Module):
|
|||
"button": core.input.LEFT_MOUSE,
|
||||
"cmd": self.__cmd + "Previous",
|
||||
}
|
||||
widget.set("state", "prev")
|
||||
widget.full_text("\u258F\u25C0")
|
||||
elif widget_name == "spotify.pause":
|
||||
widget_map[widget] = {
|
||||
"button": core.input.LEFT_MOUSE,
|
||||
"cmd": self.__cmd + "PlayPause",
|
||||
}
|
||||
widget.full_text(self.__pause)
|
||||
elif widget_name == "spotify.next":
|
||||
widget_map[widget] = {
|
||||
"button": core.input.LEFT_MOUSE,
|
||||
"cmd": self.__cmd + "Next",
|
||||
}
|
||||
widget.set("state", "next")
|
||||
widget.full_text("\u25B6\u2595")
|
||||
elif widget_name == "spotify.song":
|
||||
if util.format.asbool(self.parameter("concise_controls", "false")):
|
||||
widget_map[widget] = [
|
||||
{
|
||||
"button": core.input.LEFT_MOUSE,
|
||||
"cmd": self.__cmd + "PlayPause",
|
||||
}, {
|
||||
"button": core.input.WHEEL_UP,
|
||||
"cmd": self.__cmd + "Next",
|
||||
}, {
|
||||
"button": core.input.WHEEL_DOWN,
|
||||
"cmd": self.__cmd + "Previous",
|
||||
}
|
||||
]
|
||||
widget.full_text(self.__song)
|
||||
else:
|
||||
raise KeyError(
|
||||
"The spotify module does not have a {widget_name!r} widget".format(
|
||||
widget_name=widget_name
|
||||
)
|
||||
)
|
||||
# is there any reason the inputs can't be directly registered above?
|
||||
for widget, callback_options in widget_map.items():
|
||||
if isinstance(callback_options, dict):
|
||||
core.input.register(widget, **callback_options)
|
||||
|
||||
elif isinstance(callback_options, list): # used by concise_controls
|
||||
for opts in callback_options:
|
||||
core.input.register(widget, **opts)
|
||||
|
||||
|
||||
def hidden(self):
|
||||
return self.string_song == ""
|
||||
|
||||
@core.decorators.scrollable
|
||||
def __get_song(self, widget):
|
||||
bus = self.__bus
|
||||
if self.__bus_name == "spotifyd":
|
||||
spotify = bus.get_object(
|
||||
"org.mpris.MediaPlayer2.spotifyd", "/org/mpris/MediaPlayer2"
|
||||
)
|
||||
else:
|
||||
spotify = bus.get_object(
|
||||
"org.mpris.MediaPlayer2.spotify", "/org/mpris/MediaPlayer2"
|
||||
)
|
||||
spotify_iface = dbus.Interface(spotify, "org.freedesktop.DBus.Properties")
|
||||
props = spotify_iface.Get("org.mpris.MediaPlayer2.Player", "Metadata")
|
||||
self.__song = self.__format.format(
|
||||
album=str(props.get("xesam:album")),
|
||||
title=str(props.get("xesam:title")),
|
||||
artist=",".join(props.get("xesam:artist")),
|
||||
trackNumber=str(props.get("xesam:trackNumber")),
|
||||
)
|
||||
return self.__song
|
||||
|
||||
def update(self):
|
||||
try:
|
||||
if self.__bus_name == "spotifyd":
|
||||
bus = self.__bus.get_object(
|
||||
"org.mpris.MediaPlayer2.spotifyd", "/org/mpris/MediaPlayer2"
|
||||
)
|
||||
else:
|
||||
bus = self.__bus.get_object(
|
||||
"org.mpris.MediaPlayer2.spotify", "/org/mpris/MediaPlayer2"
|
||||
)
|
||||
|
||||
for widget in self.widgets():
|
||||
if widget.name == "spotify.pause":
|
||||
playback_status = str(
|
||||
dbus.Interface(
|
||||
bus,
|
||||
"org.freedesktop.DBus.Properties",
|
||||
).Get("org.mpris.MediaPlayer2.Player", "PlaybackStatus")
|
||||
)
|
||||
if playback_status == "Playing":
|
||||
widget.set("state", "playing")
|
||||
else:
|
||||
widget.set("state", "paused")
|
||||
elif widget.name == "spotify.song":
|
||||
widget.set("state", "song")
|
||||
widget.full_text(self.__get_song(widget))
|
||||
|
||||
except Exception as e:
|
||||
except Exception:
|
||||
self.__song = ""
|
||||
|
||||
@property
|
||||
|
|
|
|||
|
|
@ -1,13 +1,14 @@
|
|||
# -*- coding: UTF-8 -*-
|
||||
# pylint: disable=C0111,R0903
|
||||
|
||||
"""Display a stock quote from finance.yahoo.com
|
||||
"""Display a stock quote from worldtradingdata.com
|
||||
|
||||
Requires the following python packages:
|
||||
* requests
|
||||
|
||||
Parameters:
|
||||
* stock.symbols : Comma-separated list of symbols to fetch
|
||||
* stock.apikey : API key created on https://alphavantage.co
|
||||
* stock.url : URL to use, defaults to "https://www.alphavantage.co/query?function=GLOBAL_QUOTE&symbol={symbol}&apikey={apikey}"
|
||||
* stock.fields : Fields from the response to show, defaults to "01. symbol,05. price,10. change percent"
|
||||
* stock.change : Should we fetch change in stock value (defaults to True)
|
||||
|
||||
|
||||
contributed by `msoulier <https://github.com/msoulier>`_ - many thanks!
|
||||
|
|
@ -24,12 +25,6 @@ import core.decorators
|
|||
|
||||
import util.format
|
||||
|
||||
def flatten(d, result):
|
||||
for k, v in d.items():
|
||||
if type(v) is dict:
|
||||
flatten(v, result)
|
||||
else:
|
||||
result[k] = v
|
||||
|
||||
class Module(core.module.Module):
|
||||
@core.decorators.every(hours=1)
|
||||
|
|
@ -37,41 +32,37 @@ class Module(core.module.Module):
|
|||
super().__init__(config, theme, core.widget.Widget(self.value))
|
||||
|
||||
self.__symbols = self.parameter("symbols", "")
|
||||
self.__apikey = self.parameter("apikey", None)
|
||||
self.__fields = self.parameter("fields", "01. symbol,05. price,10. change percent").split(",")
|
||||
self.__url = self.parameter("url", "https://www.alphavantage.co/query?function=GLOBAL_QUOTE&symbol={symbol}&apikey={apikey}")
|
||||
self.__change = util.format.asbool(self.parameter("change", True))
|
||||
self.__values = []
|
||||
|
||||
self.__value = None
|
||||
|
||||
def value(self, widget):
|
||||
result = ""
|
||||
results = []
|
||||
if not self.__value:
|
||||
return "n/a"
|
||||
data = json.loads(self.__value)
|
||||
|
||||
for value in self.__values:
|
||||
res = {}
|
||||
flatten(value, res)
|
||||
for field in self.__fields:
|
||||
result += res.get(field, "n/a") + " "
|
||||
result = result[:-1]
|
||||
return result
|
||||
for symbol in data["quoteResponse"]["result"]:
|
||||
valkey = "regularMarketChange" if self.__change else "regularMarketPrice"
|
||||
sym = symbol.get("symbol", "n/a")
|
||||
currency = symbol.get("currency", "USD")
|
||||
val = "n/a" if not valkey in symbol else "{:.2f}".format(symbol[valkey])
|
||||
results.append("{} {} {}".format(sym, val, currency))
|
||||
return " ".join(results)
|
||||
|
||||
def fetch(self):
|
||||
results = []
|
||||
if self.__symbols:
|
||||
for symbol in self.__symbols.split(","):
|
||||
url = self.__url.format(symbol=symbol, apikey=self.__apikey)
|
||||
try:
|
||||
results.append(json.loads(urllib.request.urlopen(url).read().strip()))
|
||||
except urllib.request.URLError:
|
||||
logging.error("unable to open stock exchange url")
|
||||
return []
|
||||
url = "https://query1.finance.yahoo.com/v7/finance/quote?symbols="
|
||||
url += (
|
||||
self.__symbols
|
||||
+ "&fields=regularMarketPrice,currency,regularMarketChange"
|
||||
)
|
||||
return urllib.request.urlopen(url).read().strip()
|
||||
else:
|
||||
logging.error("unable to retrieve stock exchange rate")
|
||||
return []
|
||||
return results
|
||||
return None
|
||||
|
||||
def update(self):
|
||||
self.__values = self.fetch()
|
||||
self.__value = self.fetch()
|
||||
|
||||
|
||||
# vim: tabstop=8 expandtab shiftwidth=4 softtabstop=4
|
||||
|
|
|
|||
|
|
@ -5,11 +5,10 @@
|
|||
Requires the following python packages:
|
||||
* requests
|
||||
* suntime
|
||||
* python-dateutil
|
||||
|
||||
Parameters:
|
||||
* sun.lat : Latitude of your location
|
||||
* sun.lon : Longitude of your location
|
||||
* cpu.lat : Latitude of your location
|
||||
* cpu.lon : Longitude of your location
|
||||
|
||||
(if none of those are set, location is determined automatically via location APIs)
|
||||
|
||||
|
|
@ -39,11 +38,7 @@ class Module(core.module.Module):
|
|||
self.__sun = None
|
||||
|
||||
if not lat or not lon:
|
||||
try:
|
||||
lat, lon = util.location.coordinates()
|
||||
except Exception:
|
||||
pass
|
||||
|
||||
if lat and lon:
|
||||
self.__sun = Sun(float(lat), float(lon))
|
||||
|
||||
|
|
@ -59,10 +54,6 @@ class Module(core.module.Module):
|
|||
return "n/a"
|
||||
|
||||
def __calculate_times(self):
|
||||
if not self.__sun:
|
||||
self.__sunset = self.__sunrise = None
|
||||
return
|
||||
|
||||
self.__isup = False
|
||||
|
||||
order_matters = True
|
||||
|
|
|
|||
|
|
@ -21,9 +21,6 @@ Parameters:
|
|||
* system.suspend: specify a command for suspending (defaults to 'i3exit suspend')
|
||||
* system.hibernate: specify a command for hibernating (defaults to 'i3exit hibernate')
|
||||
|
||||
Requirements:
|
||||
tkinter (python3-tk package on debian based systems either you can install it as python package)
|
||||
|
||||
contributed by `bbernhard <https://github.com/bbernhard>`_ - many thanks!
|
||||
"""
|
||||
|
||||
|
|
@ -72,12 +69,7 @@ class Module(core.module.Module):
|
|||
util.cli.execute(command)
|
||||
|
||||
def popup(self, widget):
|
||||
popupcmd = self.parameter("popupcmd", "");
|
||||
if (popupcmd != ""):
|
||||
util.cli.execute(popupcmd)
|
||||
return
|
||||
|
||||
menu = util.popup.menu(self.__config)
|
||||
menu = util.popup.menu()
|
||||
reboot_cmd = self.parameter("reboot", "reboot")
|
||||
shutdown_cmd = self.parameter("shutdown", "shutdown -h now")
|
||||
logout_cmd = self.parameter("logout", "i3exit logout")
|
||||
|
|
@ -101,7 +93,7 @@ class Module(core.module.Module):
|
|||
menu.add_menuitem(
|
||||
"log out",
|
||||
callback=functools.partial(
|
||||
self.__on_command, "Log out", "Log out?", logout_cmd
|
||||
self.__on_command, "Log out", "Log out?", "i3exit logout"
|
||||
),
|
||||
)
|
||||
# don't ask for these
|
||||
|
|
|
|||
|
|
@ -5,7 +5,6 @@ Requires the following library:
|
|||
|
||||
Parameters:
|
||||
* taskwarrior.taskrc : path to the taskrc file (defaults to ~/.taskrc)
|
||||
* taskwarrior.show_active: true/false(default) to show the active task ID and description when one is active, otherwise show the total number pending.
|
||||
|
||||
|
||||
contributed by `chdorb <https://github.com/chdorb>`_ - many thanks!
|
||||
|
|
@ -23,45 +22,20 @@ class Module(core.module.Module):
|
|||
super().__init__(config, theme, core.widget.Widget(self.output))
|
||||
|
||||
self.__pending_tasks = "0"
|
||||
self.__status = "stopped"
|
||||
|
||||
def update(self):
|
||||
"""Return a string with the number of pending tasks from TaskWarrior
|
||||
or the descripton of an active task.
|
||||
|
||||
if show.active is set in the config, show the description of the
|
||||
current active task, otherwise the number of pending tasks will be displayed.
|
||||
"""
|
||||
"""Return a string with the number of pending tasks from TaskWarrior."""
|
||||
try:
|
||||
taskrc = self.parameter("taskrc", "~/.taskrc")
|
||||
show_active = self.parameter("show_active", False)
|
||||
w = TaskWarrior(config_filename=taskrc)
|
||||
active_tasks = (
|
||||
w.filter_tasks({"start.any": "", "status": "pending"}) or None
|
||||
)
|
||||
if show_active and active_tasks:
|
||||
# this is using the first element of the list, if there happen
|
||||
# to be other active tasks, they won't be displayed.
|
||||
reporting_tasks = (
|
||||
f"{active_tasks[0]['id']} - {active_tasks[0]['description']}"
|
||||
)
|
||||
self.__status = "active"
|
||||
else:
|
||||
reporting_tasks = len(w.filter_tasks({"status": "pending"}))
|
||||
self.__status = "stopped"
|
||||
self.__pending_tasks = reporting_tasks
|
||||
pending_tasks = w.filter_tasks({"status": "pending"})
|
||||
self.__pending_tasks = str(len(pending_tasks))
|
||||
except:
|
||||
self.__pending_tasks = "n/a"
|
||||
self.__status = "stopped"
|
||||
|
||||
@core.decorators.scrollable
|
||||
def output(self, _):
|
||||
"""Format the task counter to output in bumblebee."""
|
||||
return "{}".format(self.__pending_tasks)
|
||||
|
||||
def state(self, widget):
|
||||
"""Return the set status to reflect state"""
|
||||
return self.__status
|
||||
|
||||
|
||||
# vim: tabstop=8 expandtab shiftwidth=4 softtabstop=4
|
||||
|
|
|
|||
|
|
@ -1,89 +0,0 @@
|
|||
# pylint: disable=C0111,R0903
|
||||
|
||||
"""
|
||||
Displays the unread emails count for one or more Thunderbird inboxes
|
||||
|
||||
Parameters:
|
||||
* thunderbird.home: Absolute path of your .thunderbird directory (e.g.: /home/pi/.thunderbird)
|
||||
* thunderbird.inboxes: Comma separated values for all MSF inboxes and their parent directory (account) (e.g.: imap.gmail.com/INBOX.msf,outlook.office365.com/Work.msf)
|
||||
|
||||
Tips:
|
||||
* You can run the following command in order to list all your Thunderbird inboxes
|
||||
|
||||
find ~/.thunderbird -name '*.msf' | awk -F '/' '{print $(NF-1)"/"$(NF)}'
|
||||
|
||||
contributed by `cristianmiranda <https://github.com/cristianmiranda>`_ - many thanks!
|
||||
"""
|
||||
|
||||
import core.module
|
||||
import core.widget
|
||||
import core.decorators
|
||||
import core.input
|
||||
|
||||
import util.cli
|
||||
|
||||
|
||||
class Module(core.module.Module):
|
||||
@core.decorators.every(minutes=1)
|
||||
def __init__(self, config, theme):
|
||||
super().__init__(config, theme, core.widget.Widget(self.thunderbird))
|
||||
|
||||
self.__total = 0
|
||||
self.__label = ""
|
||||
self.__inboxes = []
|
||||
|
||||
self.__home = self.parameter("home", "")
|
||||
inboxes = self.parameter("inboxes", "")
|
||||
if inboxes:
|
||||
self.__inboxes = util.format.aslist(inboxes)
|
||||
|
||||
def thunderbird(self, _):
|
||||
return str(self.__label)
|
||||
|
||||
def update(self):
|
||||
try:
|
||||
self.__total = 0
|
||||
self.__label = ""
|
||||
|
||||
stream = self.__getThunderbirdStream()
|
||||
unread = self.__getUnreadMessagesByInbox(stream)
|
||||
|
||||
counts = []
|
||||
for inbox in self.__inboxes:
|
||||
count = unread[inbox]
|
||||
self.__total += int(count)
|
||||
counts.append(count)
|
||||
|
||||
self.__label = "/".join(counts)
|
||||
|
||||
except Exception as err:
|
||||
self.__label = err
|
||||
|
||||
def __getThunderbirdStream(self):
|
||||
cmd = (
|
||||
"find "
|
||||
+ self.__home
|
||||
+ " -name '*.msf' -exec grep -REo 'A2=[0-9]' {} + | grep"
|
||||
)
|
||||
for inbox in self.__inboxes:
|
||||
cmd += " -e {}".format(inbox)
|
||||
cmd += "| awk -F / '{print $(NF-1)\"/\"$(NF)}'"
|
||||
|
||||
return util.cli.execute(cmd, shell=True).strip().split("\n")
|
||||
|
||||
def __getUnreadMessagesByInbox(self, stream):
|
||||
unread = {}
|
||||
for line in stream:
|
||||
entry = line.split(":A2=")
|
||||
inbox = entry[0]
|
||||
count = entry[1]
|
||||
unread[inbox] = count
|
||||
|
||||
return unread
|
||||
|
||||
def state(self, widget):
|
||||
if self.__total > 0:
|
||||
return ["warning"]
|
||||
|
||||
|
||||
# vim: tabstop=8 expandtab shiftwidth=4 softtabstop=4
|
||||
|
|
@ -9,7 +9,6 @@ Parameters:
|
|||
* title.max : Maximum character length for title before truncating. Defaults to 64.
|
||||
* title.placeholder : Placeholder text to be placed if title was truncated. Defaults to '...'.
|
||||
* title.scroll : Boolean flag for scrolling title. Defaults to False
|
||||
* title.short : Boolean flag for short title. Defaults to False
|
||||
|
||||
|
||||
contributed by `UltimatePancake <https://github.com/UltimatePancake>`_ - many thanks!
|
||||
|
|
@ -36,7 +35,6 @@ class Module(core.module.Module):
|
|||
|
||||
# parsing of parameters
|
||||
self.__scroll = util.format.asbool(self.parameter("scroll", False))
|
||||
self.__short = util.format.asbool(self.parameter("short", False))
|
||||
self.__max = int(self.parameter("max", 64))
|
||||
self.__placeholder = self.parameter("placeholder", "...")
|
||||
self.__title = ""
|
||||
|
|
@ -50,9 +48,8 @@ class Module(core.module.Module):
|
|||
|
||||
# create a connection with i3ipc
|
||||
self.__i3 = i3ipc.Connection()
|
||||
# event is called both on focus change and title change, and on workspace change
|
||||
# event is called both on focus change and title change
|
||||
self.__i3.on("window", lambda __p_i3, __p_e: self.__pollTitle())
|
||||
self.__i3.on("workspace", lambda __p_i3, __p_e: self.__pollTitle())
|
||||
# begin listening for events
|
||||
threading.Thread(target=self.__i3.main).start()
|
||||
|
||||
|
|
@ -69,9 +66,7 @@ class Module(core.module.Module):
|
|||
def __pollTitle(self):
|
||||
"""Updating current title."""
|
||||
try:
|
||||
focused = self.__i3.get_tree().find_focused().name
|
||||
self.__full_title = focused.split(
|
||||
"-")[-1].strip() if self.__short else focused
|
||||
self.__full_title = self.__i3.get_tree().find_focused().name
|
||||
except:
|
||||
self.__full_title = no_title
|
||||
if self.__full_title is None:
|
||||
|
|
|
|||
|
|
@ -21,10 +21,9 @@ class Module(core.module.Module):
|
|||
super().__init__(config, theme, core.widget.Widget(self.output))
|
||||
|
||||
self.__doc = os.path.expanduser(self.parameter("file", "~/Documents/todo.txt"))
|
||||
self.__editor = self.parameter("editor", "xdg-open")
|
||||
self.__todos = self.count_items()
|
||||
core.input.register(
|
||||
self, button=core.input.LEFT_MOUSE, cmd="{} {}".format(self.__editor, self.__doc)
|
||||
self, button=core.input.LEFT_MOUSE, cmd="xdg-open {}".format(self.__doc)
|
||||
)
|
||||
|
||||
def output(self, widget):
|
||||
|
|
@ -40,12 +39,11 @@ class Module(core.module.Module):
|
|||
|
||||
def count_items(self):
|
||||
try:
|
||||
i = 0
|
||||
i = -1
|
||||
with open(self.__doc) as f:
|
||||
for l in f.readlines():
|
||||
if l.strip() != '':
|
||||
i += 1
|
||||
return i
|
||||
for i, l in enumerate(f):
|
||||
pass
|
||||
return i + 1
|
||||
except Exception:
|
||||
return 0
|
||||
|
||||
|
|
|
|||
|
|
@ -1,57 +0,0 @@
|
|||
# pylint: disable=C0111,R0903
|
||||
"""Displays the number of todo items from an org-mode file
|
||||
Parameters:
|
||||
* todo_org.file: File to read TODOs from (defaults to ~/org/todo.org)
|
||||
* todo_org.remaining: False by default. When true, will output the number of remaining todos instead of the number completed (i.e. 1/4 means 1 of 4 todos remaining, rather than 1 of 4 todos completed)
|
||||
Based on the todo module by `codingo <https://github.com/codingo>`
|
||||
"""
|
||||
|
||||
import re
|
||||
import os.path
|
||||
|
||||
import core.module
|
||||
import core.widget
|
||||
import core.input
|
||||
from util.format import asbool
|
||||
|
||||
class Module(core.module.Module):
|
||||
def __init__(self, config, theme):
|
||||
super().__init__(config, theme, core.widget.Widget(self.output))
|
||||
|
||||
self.__todo_regex = re.compile("^\\s*\\*+\\s*TODO")
|
||||
self.__done_regex = re.compile("^\\s*\\*+\\s*DONE")
|
||||
|
||||
self.__doc = os.path.expanduser(
|
||||
self.parameter("file", "~/org/todo.org")
|
||||
)
|
||||
self.__remaining = asbool(self.parameter("remaining", "False"))
|
||||
self.__todo, self.__total = self.count_items()
|
||||
core.input.register(
|
||||
self,
|
||||
button=core.input.LEFT_MOUSE,
|
||||
cmd="emacs {}".format(self.__doc)
|
||||
)
|
||||
|
||||
def output(self, widget):
|
||||
if self.__remaining:
|
||||
return "TODO: {}/{}".format(self.__todo, self.__total)
|
||||
return "TODO: {}/{}".format(self.__total-self.__todo, self.__total)
|
||||
|
||||
def update(self):
|
||||
self.__todo, self.__total = self.count_items()
|
||||
|
||||
def count_items(self):
|
||||
todo, total = 0, 0
|
||||
try:
|
||||
with open(self.__doc, "r") as f:
|
||||
for line in f:
|
||||
if self.__todo_regex.match(line.upper()) is not None:
|
||||
todo += 1
|
||||
total += 1
|
||||
elif self.__done_regex.match(line.upper()) is not None:
|
||||
total += 1
|
||||
return todo, total
|
||||
except OSError:
|
||||
return -1, -1
|
||||
|
||||
# vim: tabstop=8 expandtab shiftwidth=4 softtabstop=4
|
||||
|
|
@ -1,76 +0,0 @@
|
|||
# pylint: disable=C0111,R0903
|
||||
|
||||
"""
|
||||
Displays the nº of Todoist tasks that are due:
|
||||
|
||||
* https://developer.todoist.com/rest/v2/#get-active-tasks
|
||||
|
||||
Uses `xdg-open` or `x-www-browser` to open web-pages.
|
||||
|
||||
Requires the following library:
|
||||
* requests
|
||||
|
||||
Errors:
|
||||
if the Todoist get active tasks query failed, the shown value is `n/a`
|
||||
|
||||
Parameters:
|
||||
* todoist.token: Todoist api token, you can get it in https://todoist.com/app/settings/integrations/developer.
|
||||
* todoist.filter: a filter statement defined by Todoist (https://todoist.com/help/articles/introduction-to-filters), eg: "!assigned to: others & (Overdue | due: today)"
|
||||
"""
|
||||
|
||||
import shutil
|
||||
|
||||
import requests
|
||||
|
||||
import core.decorators
|
||||
import core.input
|
||||
import core.module
|
||||
import core.widget
|
||||
|
||||
HOST_API = "https://api.todoist.com"
|
||||
HOST_WEBSITE = "https://todoist.com/app/today"
|
||||
|
||||
TASKS_URL = f"{HOST_API}/rest/v2/tasks"
|
||||
|
||||
|
||||
class Module(core.module.Module):
|
||||
@core.decorators.every(minutes=5)
|
||||
def __init__(self, config, theme):
|
||||
super().__init__(config, theme, core.widget.Widget(self.todoist))
|
||||
|
||||
self.__user_id = None
|
||||
self.background = True
|
||||
self.__label = ""
|
||||
|
||||
token = self.parameter("token", "")
|
||||
self.__filter = self.parameter("filter", "")
|
||||
|
||||
self.__requests = requests.Session()
|
||||
self.__requests.headers.update({"Authorization": f"Bearer {token}"})
|
||||
|
||||
cmd = "xdg-open"
|
||||
if not shutil.which(cmd):
|
||||
cmd = "x-www-browser"
|
||||
|
||||
core.input.register(
|
||||
self,
|
||||
button=core.input.LEFT_MOUSE,
|
||||
cmd=f"{cmd} {HOST_WEBSITE}",
|
||||
)
|
||||
|
||||
def todoist(self, _):
|
||||
return self.__label
|
||||
|
||||
def update(self):
|
||||
try:
|
||||
self.__label = self.__get_pending_tasks()
|
||||
except Exception:
|
||||
self.__label = "n/a"
|
||||
|
||||
def __get_pending_tasks(self) -> str:
|
||||
params = {"filter": self.__filter} if self.__filter else None
|
||||
|
||||
response = self.__requests.get(TASKS_URL, params=params)
|
||||
data = response.json()
|
||||
|
||||
return str(len(data))
|
||||
|
|
@ -8,7 +8,7 @@ Parameters:
|
|||
* traffic.showname: If set to False, hide network interface name (defaults to True)
|
||||
* traffic.format: Format string for download/upload speeds.
|
||||
Defaults to '{:.2f}'
|
||||
* traffic.graphlen: Graph length in seconds. Positive even integer. Each
|
||||
* traffic.graphlen: Graph lenth in seconds. Positive even integer. Each
|
||||
char shows 2 seconds. If set, enables up/down traffic
|
||||
graphs
|
||||
|
||||
|
|
|
|||
|
|
@ -2,9 +2,6 @@
|
|||
|
||||
"""Toggle twmn notifications.
|
||||
|
||||
Requires the following executable:
|
||||
* systemctl
|
||||
|
||||
contributed by `Pseudonick47 <https://github.com/Pseudonick47>`_ - many thanks!
|
||||
"""
|
||||
|
||||
|
|
|
|||
|
|
@ -1,78 +0,0 @@
|
|||
# pylint: disable=C0111,R0903
|
||||
|
||||
"""
|
||||
Module for ActivityWatch (https://activitywatch.net/)
|
||||
Displays the amount of time the system was used actively.
|
||||
|
||||
Requirements:
|
||||
* sqlite3 module for python
|
||||
* ActivityWatch
|
||||
|
||||
Errors:
|
||||
* when you get 'error: unable to open database file', modify the parameter 'database' to your ActivityWatch database file
|
||||
-> often found by running 'locate aw-server/peewee-sqlite.v2.db'
|
||||
|
||||
Parameters:
|
||||
* usage.database: path to your database file
|
||||
* usage.format: Specify what gets printed to the bar
|
||||
-> use 'HH', 'MM' or 'SS', they will get replaced by the number of hours, minutes and seconds, respectively
|
||||
|
||||
contributed by lasnikr (https://github.com/lasnikr)
|
||||
"""
|
||||
|
||||
import sqlite3
|
||||
import os
|
||||
|
||||
import core.module
|
||||
import core.widget
|
||||
|
||||
|
||||
class Module(core.module.Module):
|
||||
def __init__(self, config, theme):
|
||||
super().__init__(config, theme, core.widget.Widget(self.output))
|
||||
self.__usage = ""
|
||||
|
||||
def output(self, _):
|
||||
return "{}".format(self.__usage)
|
||||
|
||||
def update(self):
|
||||
database_loc = self.parameter(
|
||||
"database", "~/.local/share/activitywatch/aw-server/peewee-sqlite.v2.db"
|
||||
)
|
||||
home = os.path.expanduser("~")
|
||||
|
||||
database = sqlite3.connect(database_loc.replace("~", home))
|
||||
cursor = database.cursor()
|
||||
|
||||
cursor.execute("SELECT key, id FROM bucketmodel")
|
||||
|
||||
bucket_id = 1
|
||||
|
||||
for tuple in cursor.fetchall():
|
||||
if "aw-watcher-afk" in tuple[1]:
|
||||
bucket_id = tuple[0]
|
||||
|
||||
cursor.execute(
|
||||
f"SELECT duration, datastr FROM eventmodel WHERE bucket_id = {bucket_id} "
|
||||
+ 'AND strftime("%Y,%m,%d", timestamp) = strftime("%Y,%m,%d", "now")'
|
||||
)
|
||||
|
||||
duration = 0
|
||||
|
||||
for tuple in cursor.fetchall():
|
||||
if '{"status": "not-afk"}' in tuple[1]:
|
||||
duration += tuple[0]
|
||||
|
||||
hours = "%.0f" % (duration // 3600)
|
||||
minutes = "%.0f" % ((duration % 3600) // 60)
|
||||
seconds = "%.0f" % (duration % 60)
|
||||
|
||||
formatting = self.parameter("format", "HHh, MMmin")
|
||||
self.__usage = (
|
||||
formatting.replace("HH", hours)
|
||||
.replace("MM", minutes)
|
||||
.replace("SS", seconds)
|
||||
)
|
||||
|
||||
|
||||
# vim: tabstop=8 expandtab shiftwidth=4 softtabstop=4
|
||||
|
|
@ -1,5 +1,4 @@
|
|||
# pylint: disable=C0111,R0903
|
||||
# -*- coding: utf-8 -*-
|
||||
|
||||
""" Displays the VPN profile that is currently in use.
|
||||
|
||||
|
|
@ -69,7 +68,7 @@ class Module(core.module.Module):
|
|||
|
||||
def vpn_status(self, widget):
|
||||
if self.__connected_vpn_profile is None:
|
||||
return ""
|
||||
return "off"
|
||||
return self.__connected_vpn_profile
|
||||
|
||||
def __on_vpndisconnect(self):
|
||||
|
|
@ -94,7 +93,7 @@ class Module(core.module.Module):
|
|||
self.__connected_vpn_profile = None
|
||||
|
||||
def popup(self, widget):
|
||||
menu = util.popup.menu(self.__config)
|
||||
menu = util.popup.menu()
|
||||
|
||||
if self.__connected_vpn_profile is not None:
|
||||
menu.add_menuitem("Disconnect", callback=self.__on_vpndisconnect)
|
||||
|
|
|
|||
|
|
@ -1,94 +0,0 @@
|
|||
# pylint: disable=C0111,R0903
|
||||
|
||||
"""
|
||||
Displays the WakaTime daily/weekly/monthly times:
|
||||
|
||||
* https://wakatime.com/developers#stats
|
||||
|
||||
Uses `xdg-open` or `x-www-browser` to open web-pages.
|
||||
|
||||
Requires the following library:
|
||||
* requests
|
||||
|
||||
Errors:
|
||||
if the Wakatime status query failed, the shown value is `n/a`
|
||||
|
||||
Parameters:
|
||||
* wakatime.token: Wakatime secret api key, you can get it in https://wakatime.com/settings/account.
|
||||
* wakatime.range: Range of the output, default is "Today". Can be one of “Today”, “Yesterday”, “Last 7 Days”, “Last 7 Days from Yesterday”, “Last 14 Days”, “Last 30 Days”, “This Week”, “Last Week”, “This Month”, or “Last Month”.
|
||||
* wakatime.format: Format of the output, default is "digital"
|
||||
Valid inputs are:
|
||||
* "decimal" -> 1.37
|
||||
* "digital" -> 1:22
|
||||
* "seconds" -> 4931.29
|
||||
* "text" -> 1 hr 22 mins
|
||||
* "%H:%M:%S" -> 01:22:31 (or any other valid format)
|
||||
"""
|
||||
|
||||
import base64
|
||||
import shutil
|
||||
import time
|
||||
|
||||
import requests
|
||||
|
||||
import core.decorators
|
||||
import core.input
|
||||
import core.module
|
||||
import core.widget
|
||||
|
||||
HOST_API = "https://wakatime.com"
|
||||
SUMMARIES_URL = f"{HOST_API}/api/v1/users/current/summaries"
|
||||
UTF8 = "utf-8"
|
||||
FORMAT_PARAMETERS = ["decimal", "digital", "seconds", "text"]
|
||||
|
||||
|
||||
class Module(core.module.Module):
|
||||
@core.decorators.every(minutes=5)
|
||||
def __init__(self, config, theme):
|
||||
super().__init__(config, theme, core.widget.Widget(self.wakatime))
|
||||
|
||||
self.background = True
|
||||
self.__label = ""
|
||||
|
||||
self.__output_format = self.parameter("format", "digital")
|
||||
self.__range = self.parameter("range", "Today")
|
||||
|
||||
self.__requests = requests.Session()
|
||||
|
||||
token = self.__encode_to_base_64(self.parameter("token", ""))
|
||||
self.__requests.headers.update({"Authorization": f"Basic {token}"})
|
||||
|
||||
cmd = "xdg-open"
|
||||
if not shutil.which(cmd):
|
||||
cmd = "x-www-browser"
|
||||
|
||||
core.input.register(
|
||||
self,
|
||||
button=core.input.LEFT_MOUSE,
|
||||
cmd=f"{cmd} {HOST_API}/dashboard",
|
||||
)
|
||||
|
||||
def wakatime(self, _):
|
||||
return self.__label
|
||||
|
||||
def update(self):
|
||||
try:
|
||||
self.__label = self.__get_waka_time(self.__range)
|
||||
except Exception:
|
||||
self.__label = "n/a"
|
||||
|
||||
def __get_waka_time(self, since_date: str) -> str:
|
||||
response = self.__requests.get(f"{SUMMARIES_URL}?range={since_date}")
|
||||
|
||||
data = response.json()
|
||||
grand_total = data["cumulative_total"]
|
||||
|
||||
if self.__output_format in FORMAT_PARAMETERS:
|
||||
return str(grand_total[self.__output_format])
|
||||
else:
|
||||
total_seconds = int(grand_total["seconds"])
|
||||
return time.strftime(self.__output_format, time.gmtime(total_seconds))
|
||||
|
||||
@staticmethod
|
||||
def __encode_to_base_64(s: str) -> str:
|
||||
return base64.b64encode(s.encode(UTF8)).decode(UTF8)
|
||||
|
|
@ -5,10 +5,6 @@
|
|||
Requires the following executable:
|
||||
* watson
|
||||
|
||||
Parameters:
|
||||
* watson.format: Output format, defaults to "{project} [{tags}]"
|
||||
Supported fields are: {project}, {tags}, {relative_start}, {absolute_start}
|
||||
|
||||
contributed by `bendardenne <https://github.com/bendardenne>`_ - many thanks!
|
||||
"""
|
||||
|
||||
|
|
@ -30,11 +26,11 @@ class Module(core.module.Module):
|
|||
super().__init__(config, theme, core.widget.Widget(self.text))
|
||||
|
||||
self.__tracking = False
|
||||
self.__info = {}
|
||||
self.__format = self.parameter("format", "{project} [{tags}]")
|
||||
self.__project = ""
|
||||
core.input.register(self, button=core.input.LEFT_MOUSE, cmd=self.toggle)
|
||||
|
||||
def toggle(self, widget):
|
||||
self.__project = "hit"
|
||||
if self.__tracking:
|
||||
util.cli.execute("watson stop")
|
||||
else:
|
||||
|
|
@ -43,27 +39,20 @@ class Module(core.module.Module):
|
|||
|
||||
def text(self, widget):
|
||||
if self.__tracking:
|
||||
return self.__format.format(**self.__info)
|
||||
return self.__project
|
||||
else:
|
||||
return "Paused"
|
||||
|
||||
def update(self):
|
||||
output = util.cli.execute("watson status")
|
||||
|
||||
m = re.search(r"Project ([^\[\]]+)(?: \[(.+)\])? started (.+) \((.+)\)", output)
|
||||
|
||||
if m:
|
||||
self.__tracking = True
|
||||
self.__info = {
|
||||
"project": m.group(1),
|
||||
"tags": m.group(2) or "",
|
||||
"relative_start": m.group(3),
|
||||
"absolute_start": m.group(4),
|
||||
}
|
||||
else:
|
||||
if re.match(r"No project started", output):
|
||||
self.__tracking = False
|
||||
return
|
||||
|
||||
self.__tracking = True
|
||||
m = re.search(r"Project (.+) started", output)
|
||||
self.__project = m.group(1)
|
||||
|
||||
def state(self, widget):
|
||||
return "on" if self.__tracking else "off"
|
||||
|
||||
|
|
|
|||
|
|
@ -13,7 +13,7 @@ Parameters:
|
|||
* weather.unit: metric (default), kelvin, imperial
|
||||
* weather.showcity: If set to true, show location information, otherwise hide it (defaults to true)
|
||||
* weather.showminmax: If set to true, show the minimum and maximum temperature, otherwise hide it (defaults to false)
|
||||
* weather.apikey: API key from https://api.openweathermap.org
|
||||
* weather.apikey: API key from http://api.openweathermap.org
|
||||
|
||||
|
||||
contributed by `TheEdgeOfRage <https://github.com/TheEdgeOfRage>`_ - many thanks!
|
||||
|
|
@ -116,7 +116,7 @@ class Module(core.module.Module):
|
|||
|
||||
def update(self):
|
||||
try:
|
||||
weather_url = "https://api.openweathermap.org/data/2.5/weather?appid={}".format(
|
||||
weather_url = "http://api.openweathermap.org/data/2.5/weather?appid={}".format(
|
||||
self.__apikey
|
||||
)
|
||||
weather_url = "{}&units={}".format(weather_url, self.__unit)
|
||||
|
|
|
|||
|
|
@ -1,126 +0,0 @@
|
|||
# pylint: disable=C0111,R0903
|
||||
# -*- coding: utf-8 -*-
|
||||
|
||||
"""Shows a widget for each connected screen and allows the user to loop through different orientations.
|
||||
|
||||
Parameters:
|
||||
* wlrotation.display : Name of the output display that will be rotated
|
||||
+ wlrotation.auto : Boolean value if the display should be rotatet automatic by default
|
||||
|
||||
Requires the following executable:
|
||||
* swaymsg
|
||||
"""
|
||||
|
||||
import core.module
|
||||
import core.input
|
||||
import util.cli
|
||||
|
||||
import iio
|
||||
import json
|
||||
from math import degrees, atan2, sqrt
|
||||
from os import environ, path
|
||||
|
||||
possible_orientations = ["normal", "90", "180", "270"]
|
||||
|
||||
class iioValue:
|
||||
def __init__(self, channel):
|
||||
self.channel = channel
|
||||
self.scale = self.read('scale')
|
||||
self.offset = self.read('offset')
|
||||
|
||||
def read(self, attr):
|
||||
return float(self.channel.attrs[attr].value)
|
||||
|
||||
def value(self):
|
||||
return (self.read('raw') + self.offset) * self.scale
|
||||
|
||||
class iioAccelDevice:
|
||||
def __init__(self):
|
||||
self.ctx = iio.Context() # store ctx pointer
|
||||
d = self.ctx.find_device('accel_3d')
|
||||
self.x = iioValue(d.find_channel('accel_x'))
|
||||
self.y = iioValue(d.find_channel('accel_y'))
|
||||
self.z = iioValue(d.find_channel('accel_z'))
|
||||
|
||||
def orientation(self):
|
||||
"""
|
||||
returns tuple of `[success, value]` where `success` indicates, if an accurate value could be meassured and `value` the sway output api compatible value or `normal` if success is `False`
|
||||
"""
|
||||
x_deg, y_deg, z_deg = self._deg()
|
||||
if abs(z_deg) < 70: # checks if device is angled too shallow
|
||||
if x_deg >= 70: return True, "270"
|
||||
if x_deg <= -70: return True, "90"
|
||||
if abs(x_deg) <= 20:
|
||||
if y_deg < 0: return True, "normal"
|
||||
if y_deg > 0: return True, "180"
|
||||
return False, "normal"
|
||||
|
||||
def _deg(self):
|
||||
gravity = 9.81
|
||||
x, y, z = self.x.value() / gravity, self.y.value() / gravity, self.z.value() / gravity
|
||||
return degrees(atan2(x, sqrt(pow(y, 2) + pow(z, 2)))), degrees(atan2(y, sqrt(pow(z, 2) + pow(x, 2)))), degrees(atan2(z, sqrt(pow(x, 2) + pow(y, 2))))
|
||||
|
||||
class Display():
|
||||
def __init__(self, name, widget, display_data, auto=False):
|
||||
self.name = name
|
||||
self.widget = widget
|
||||
self.accelDevice = iioAccelDevice()
|
||||
self._lock_auto_rotation(not auto)
|
||||
|
||||
self.widget.set("orientation", display_data['transform'])
|
||||
|
||||
core.input.register(widget, button=core.input.LEFT_MOUSE, cmd=self.rotate_90deg)
|
||||
core.input.register(widget, button=core.input.RIGHT_MOUSE, cmd=self.toggle)
|
||||
|
||||
def rotate_90deg(self, event):
|
||||
# compute new orientation based on current orientation
|
||||
current = self.widget.get("orientation")
|
||||
self._set_rotation(possible_orientations[(possible_orientations.index(current) + 1) % len(possible_orientations)])
|
||||
# disable auto rotation
|
||||
self._lock_auto_rotation(True)
|
||||
|
||||
def toggle(self, event):
|
||||
self._lock_auto_rotation(not self.locked)
|
||||
|
||||
def auto_rotate(self):
|
||||
# automagically rotate the display based on sensor values
|
||||
# this is only called if rotation lock is disabled
|
||||
success, value = self.accelDevice.orientation()
|
||||
if success:
|
||||
self._set_rotation(value)
|
||||
|
||||
def _set_rotation(self, new_orientation):
|
||||
self.widget.set("orientation", new_orientation)
|
||||
util.cli.execute("swaymsg 'output {} transform {}'".format(self.name, new_orientation))
|
||||
|
||||
def _lock_auto_rotation(self, locked):
|
||||
self.locked = locked
|
||||
self.widget.set("locked", self.locked)
|
||||
|
||||
class Module(core.module.Module):
|
||||
@core.decorators.every(seconds=1)
|
||||
def __init__(self, config, theme):
|
||||
super().__init__(config, theme, [])
|
||||
|
||||
self.display = None
|
||||
display_filter = self.parameter("display", None)
|
||||
for display in json.loads(util.cli.execute("swaymsg -t get_outputs -r")):
|
||||
name = display['name']
|
||||
if display_filter == None or display_filter == name:
|
||||
self.display = Display(name, self.add_widget(name=name), display, auto=util.format.asbool(self.parameter("auto", False)))
|
||||
break # I assume that it makes only sense to rotate a single screen
|
||||
|
||||
def update(self):
|
||||
if self.display == None:
|
||||
return
|
||||
if self.display.locked:
|
||||
return
|
||||
|
||||
self.display.auto_rotate()
|
||||
|
||||
def state(self, widget):
|
||||
state = []
|
||||
state.append("locked" if widget.get("locked", True) else "auto")
|
||||
return state
|
||||
|
||||
# vim: tabstop=8 expandtab shiftwidth=4 softtabstop=4
|
||||
|
|
@ -1,8 +1,5 @@
|
|||
"""Displays info about zpools present on the system
|
||||
|
||||
Requires the following executable:
|
||||
* sudo (if `zpool.sudo` is explicitly set to `true`)
|
||||
|
||||
Parameters:
|
||||
* zpool.list: Comma-separated list of zpools to display info for. If empty, info for all zpools
|
||||
is displayed. (Default: '')
|
||||
|
|
|
|||
|
|
@ -2,17 +2,13 @@
|
|||
|
||||
"""Displays CPU utilization across all CPUs.
|
||||
|
||||
By default, opens `gnome-system-monitor` on left mouse click.
|
||||
|
||||
Requirements:
|
||||
* the psutil Python module for the first three items from the list above
|
||||
* gnome-system-monitor for default mouse click action
|
||||
|
||||
Parameters:
|
||||
* cpu.warning : Warning threshold in % of CPU usage (defaults to 70%)
|
||||
* cpu.critical: Critical threshold in % of CPU usage (defaults to 80%)
|
||||
* cpu.format : Format string (defaults to '{:.01f}%')
|
||||
* cpu.percpu : If set to true, show each individual cpu (defaults to false)
|
||||
"""
|
||||
|
||||
import psutil
|
||||
|
|
@ -21,19 +17,12 @@ import core.module
|
|||
import core.widget
|
||||
import core.input
|
||||
|
||||
import util.format
|
||||
|
||||
|
||||
class Module(core.module.Module):
|
||||
def __init__(self, config, theme):
|
||||
super().__init__(config, theme, [])
|
||||
self._percpu = util.format.asbool(self.parameter("percpu", False))
|
||||
|
||||
for idx, cpu_perc in enumerate(self.cpu_utilization()):
|
||||
widget = self.add_widget(name="cpu#{}".format(idx), full_text=self.utilization)
|
||||
widget.set("utilization", cpu_perc)
|
||||
widget.set("theme.minwidth", self._format.format(100.0 - 10e-20))
|
||||
|
||||
super().__init__(config, theme, core.widget.Widget(self.utilization))
|
||||
self.widget().set("theme.minwidth", self._format.format(100.0 - 10e-20))
|
||||
self._utilization = psutil.cpu_percent(percpu=False)
|
||||
core.input.register(
|
||||
self, button=core.input.LEFT_MOUSE, cmd="gnome-system-monitor"
|
||||
)
|
||||
|
|
@ -42,19 +31,14 @@ class Module(core.module.Module):
|
|||
def _format(self):
|
||||
return self.parameter("format", "{:.01f}%")
|
||||
|
||||
def utilization(self, widget):
|
||||
return self._format.format(widget.get("utilization", 0.0))
|
||||
|
||||
def cpu_utilization(self):
|
||||
tmp = psutil.cpu_percent(percpu=self._percpu)
|
||||
return tmp if self._percpu else [tmp]
|
||||
def utilization(self, _):
|
||||
return self._format.format(self._utilization)
|
||||
|
||||
def update(self):
|
||||
for idx, cpu_perc in enumerate(self.cpu_utilization()):
|
||||
self.widgets()[idx].set("utilization", cpu_perc)
|
||||
self._utilization = psutil.cpu_percent(percpu=False)
|
||||
|
||||
def state(self, widget):
|
||||
return self.threshold_state(widget.get("utilization", 0.0), 70, 80)
|
||||
def state(self, _):
|
||||
return self.threshold_state(self._utilization, 70, 80)
|
||||
|
||||
|
||||
# vim: tabstop=8 expandtab shiftwidth=4 softtabstop=4
|
||||
|
|
|
|||
|
|
@ -17,33 +17,26 @@ import core.input
|
|||
|
||||
|
||||
class Module(core.module.Module):
|
||||
def __init__(self, config, theme, dtlibrary=None):
|
||||
def __init__(self, config, theme):
|
||||
super().__init__(config, theme, core.widget.Widget(self.full_text))
|
||||
|
||||
core.input.register(self, button=core.input.LEFT_MOUSE, cmd="calendar")
|
||||
self.dtlibrary = dtlibrary or datetime
|
||||
|
||||
def set_locale(self):
|
||||
l = self.default_locale()
|
||||
self._fmt = self.parameter("format", self.default_format())
|
||||
l = locale.getdefaultlocale()
|
||||
if not l or l == (None, None):
|
||||
l = ("en_US", "UTF-8")
|
||||
lcl = self.parameter("locale", ".".join(l))
|
||||
try:
|
||||
locale.setlocale(locale.LC_ALL, lcl.split("."))
|
||||
locale.setlocale(locale.LC_TIME, lcl.split("."))
|
||||
except Exception as e:
|
||||
locale.setlocale(locale.LC_ALL, ("en_US", "UTF-8"))
|
||||
locale.setlocale(locale.LC_TIME, ("en_US", "UTF-8"))
|
||||
|
||||
def default_format(self):
|
||||
return "%x %X"
|
||||
|
||||
def default_locale(self):
|
||||
return locale.getdefaultlocale()
|
||||
|
||||
def full_text(self, widget):
|
||||
self.set_locale()
|
||||
enc = locale.getpreferredencoding()
|
||||
fmt = self.parameter("format", self.default_format())
|
||||
retval = self.dtlibrary.datetime.now().strftime(fmt)
|
||||
retval = datetime.datetime.now().strftime(self._fmt)
|
||||
if hasattr(retval, "decode"):
|
||||
return retval.decode(enc)
|
||||
return retval
|
||||
|
|
|
|||
|
|
@ -4,11 +4,10 @@
|
|||
|
||||
Parameters:
|
||||
* disk.warning: Warning threshold in % of disk space (defaults to 80%)
|
||||
* disk.critical: Critical threshold in % of disk space (defaults to 90%)
|
||||
* disk.critical: Critical threshold in % of disk space (defaults ot 90%)
|
||||
* disk.path: Path to calculate disk usage from (defaults to /)
|
||||
* disk.open: Which application / file manager to launch (default xdg-open)
|
||||
* disk.format: Format string, tags {path}, {used}, {left}, {size} and {percent} (defaults to '{path} {used}/{size} ({percent:05.02f}%)')
|
||||
* disk.system: Unit system to use - SI (KB, MB, ...) or IEC (KiB, MiB, ...) (defaults to 'IEC')
|
||||
"""
|
||||
|
||||
import os
|
||||
|
|
@ -26,7 +25,6 @@ class Module(core.module.Module):
|
|||
|
||||
self._path = self.parameter("path", "/")
|
||||
self._format = self.parameter("format", "{used}/{size} ({percent:05.02f}%)")
|
||||
self._system = self.parameter("system", "IEC")
|
||||
|
||||
self._used = 0
|
||||
self._left = 0
|
||||
|
|
@ -40,9 +38,9 @@ class Module(core.module.Module):
|
|||
)
|
||||
|
||||
def diskspace(self, widget):
|
||||
used_str = util.format.byte(self._used, sys=self._system)
|
||||
size_str = util.format.byte(self._size, sys=self._system)
|
||||
left_str = util.format.byte(self._left, sys=self._system)
|
||||
used_str = util.format.byte(self._used)
|
||||
size_str = util.format.byte(self._size)
|
||||
left_str = util.format.byte(self._left)
|
||||
percent_str = self._percent
|
||||
|
||||
return self._format.format(
|
||||
|
|
|
|||
|
|
@ -1,56 +0,0 @@
|
|||
# pylint: disable=C0111,R0903
|
||||
|
||||
"""Shows when a key is pressed
|
||||
|
||||
Parameters:
|
||||
* keys.keys: Comma-separated list of keys to monitor (defaults to "")
|
||||
"""
|
||||
|
||||
import core.module
|
||||
import core.widget
|
||||
import core.decorators
|
||||
import core.event
|
||||
|
||||
import util.format
|
||||
|
||||
from pynput.keyboard import Listener
|
||||
|
||||
NAMES = {
|
||||
"Key.cmd": "cmd",
|
||||
"Key.ctrl": "ctrl",
|
||||
"Key.shift": "shift",
|
||||
"Key.alt": "alt",
|
||||
}
|
||||
|
||||
class Module(core.module.Module):
|
||||
@core.decorators.never
|
||||
def __init__(self, config, theme):
|
||||
super().__init__(config, theme, [])
|
||||
|
||||
self._listener = Listener(on_press=self._key_press, on_release=self._key_release)
|
||||
|
||||
self._keys = util.format.aslist(self.parameter("keys", "Key.cmd,Key.ctrl,Key.alt,Key.shift"))
|
||||
|
||||
for k in self._keys:
|
||||
self.add_widget(name=k, full_text=self._display_name(k), hidden=True)
|
||||
self._listener.start()
|
||||
|
||||
def _display_name(self, key):
|
||||
return NAMES.get(key, key)
|
||||
|
||||
def _key_press(self, key):
|
||||
key = str(key)
|
||||
if not key in self._keys: return
|
||||
self.widget(key).hidden = False
|
||||
core.event.trigger("update", [self.id], redraw_only=False)
|
||||
|
||||
def _key_release(self, key):
|
||||
key = str(key)
|
||||
if not key in self._keys: return
|
||||
self.widget(key).hidden = True
|
||||
core.event.trigger("update", [self.id], redraw_only=False)
|
||||
|
||||
def state(self, widget):
|
||||
return widget.name
|
||||
|
||||
# vim: tabstop=8 expandtab shiftwidth=4 softtabstop=4
|
||||
|
|
@ -53,7 +53,7 @@ class Module(core.module.Module):
|
|||
log.debug("group num: {}".format(xkb.group_num))
|
||||
name = (
|
||||
xkb.group_name
|
||||
if util.format.asbool(self.parameter("showname", False))
|
||||
if util.format.asbool(self.parameter("showname"), False)
|
||||
else xkb.group_symbol
|
||||
)
|
||||
if self.__show_variant:
|
||||
|
|
|
|||
|
|
@ -1 +0,0 @@
|
|||
layout-xkb.py
|
||||
|
|
@ -1 +0,0 @@
|
|||
layout-xkb.py
|
||||
Some files were not shown because too many files have changed in this diff Show more
Loading…
Add table
Reference in a new issue