def get_unit_status(unit_name: str) -> Dict[str, Any]:
bus = SystemBus()
systemd = bus.get('org.freedesktop.systemd1')
path = systemd.GetUnit(unit_name)
unit = bus.get('org.freedesktop.systemd1', path)
properties = dict_from_attributes(unit['org.freedesktop.systemd1.Unit'],
unit_properties)
if unit_name.endswith('.service'):
properties.update(dict_from_attributes(
unit['org.freedesktop.systemd1.Service'], service_properties))
elif unit_name.endswith('.timer'):
properties.update(dict_from_attributes(
unit['org.freedesktop.systemd1.Timer'], timer_properties))
return properties
def loop():
bus = SystemBus()
bus.own_name('net.lvht.btk')
obj_path = '/net/lvht/btk/HIDProfile'
sock = bt.BluetoothSocket(bt.L2CAP)
sock.setblocking(False)
try:
sock.bind(('', PSM_INTR))
except:
print("For bluez5 add --noplugin=input to the bluetoothd commandline")
print("Else there is another application running that has it open.")
sys.exit(errno.EACCES)
sock.listen(1)
profile = HIDProfile(bus.con, obj_path, sock)
opts = {
"PSM": GLib.Variant.new_uint16(PSM_CTRL),
"ServiceRecord": GLib.Variant.new_string(open('./sdp_record.xml', 'r').read()),
"RequireAuthentication": GLib.Variant.new_boolean(True),
"RequireAuthorization": GLib.Variant.new_boolean(False),
}
manager = bus.get('org.bluez')['.ProfileManager1']
manager.RegisterProfile(obj_path, str(uuid.uuid4()), opts)
profile.run()
def quit(bus=None):
if bus is None:
bus = SystemBus()
try:
bts = bus.get(BTSDBusService.interface_name)
bts.Quit()
except GLib.Error:
return -1
def _start_loop(self):
"""Starts main event handler loop, run in handler thread t."""
# Create our main loop, get our bus, and add the signal handler
loop = GObject.MainLoop()
bus = SystemBus()
manager = bus.get(".NetworkManager")
manager.onPropertiesChanged = self._vpn_signal_handler
# Loop forever
loop.run()
def inject(mail, bus=None):
if bus is None:
bus = SystemBus()
mail = base64.b64encode(mail).decode('ascii')
try:
bts = bus.get(BTSDBusService.interface_name)
return bts.Inject(mail)
except GLib.Error:
return -1
def _get_vpn_status(self):
"""Returns None if no VPN active, Id if active."""
# Sleep for a bit to let any changes in state finish
sleep(0.3)
# Check if any active connections are a VPN
bus = SystemBus()
for name in self.active:
conn = bus.get(".NetworkManager", name)
if conn.Vpn:
return conn.Id
# No active VPN
return None
def dbus_main():
global sysbus, avahi, dbus_loop
dbg('Connecting to system DBus')
sysbus = SystemBus()
dbg('Subscribing to .Avahi.RecordBrowser signals')
sysbus.con.signal_subscribe('org.freedesktop.Avahi',
'org.freedesktop.Avahi.RecordBrowser',
None, None, None, 0, signal_dispatcher)
avahi = sysbus.get('.Avahi', '/')
dbg("Connected to Avahi Daemon: %s (API %s) [%s]"
% (avahi.GetVersionString(), avahi.GetAPIVersion(), avahi.GetHostNameFqdn()))
dbg('Starting DBus main loop')
dbus_loop = GLib.MainLoop()
dbus_loop.run()
class MediaDeviceThread(threading.Thread):
def __init__(self):
threading.Thread.__init__(self)
self.bus = SystemBus()
try:
self.dev = self.bus.get('org.freedesktop.UDisks2', '/org/freedesktop/UDisks2/drives/TSSTcorp_CDDVDW_SE_S084C_SATASLIM00003008cae')
#self.dev = self.bus.get('org.freedesktop.UDisks2', '/org/freedesktop/UDisks/devices/sr0')
except KeyError:
print "CD LW not connected"
quit()
self.media = self.dev.MediaAvailable
def _print(*a):
print a
def run(self):
with self.dev.PropertiesChanged.connect(self._print) as d:
if self.media:
print "Media still inserted..."
# self.dev.Eject()
GObject.MainLoop().run()
class WelcomedClient(GObject.GObject):
_name = 'com.antergos.welcome'
_object_path = '/com/antergos/welcome'
_interface_name = 'com.antergos.welcome'
__gsignals__ = {
'command-finished': (GObject.SignalFlags.RUN_FIRST, None,
(str, str, GObject.TYPE_PYOBJECT))
}
def __init__(self):
GObject.GObject.__init__(self)
self.interface = None
self.welcomed_ok = False
try:
self.bus = SystemBus()
self.dbus_proxy = self.bus.get(WelcomedClient._name,
WelcomedClient._object_path)
if not self.dbus_proxy:
self.welcomed_ok = False
else:
self.dbus_proxy.PropertiesChanged.connect(
self.on_properties_changed)
self.welcomed_ok = self.dbus_proxy.is_alpm_on()
except Exception as err:
print(err)
finally:
if not self.welcomed_ok:
msg = _(
"Can't find Welcome d-bus service. Is it really installed?"
)
Notify.init("antergos-welcome")
Notify.Notification.new(_("ERROR!"), msg,
'dialog-error').show()
def refresh(self):
""" pacman -Sy """
return self.dbus_proxy.refresh_alpm()
def on_properties_changed(self, *params):
""" A d-bus server property has changed """
(sender, prop, not_used) = params
# print("PARAMS:", params)
if sender == WelcomedClient._name and 'command_finished' in prop.keys(
):
(uid, command, pkgs) = prop['command_finished']
self.emit("command-finished", uid, command, pkgs)
def install_package(self, pkg):
""" pacman -S pkg """
return self.dbus_proxy.install_package(pkgs)
def install_packages(self, pkgs):
""" pacman -S pkgs """
return self.dbus_proxy.install_packages(pkgs)
def remove_package(self, package):
""" pacman -R pkg """
return self.dbus_proxy.remove_package(package)
def remove_packages(self, pkgs):
""" pacman -R pkgs """
for pkg in pkgs:
self.remove_package(pkg)
def check_updates(self):
return self.dbus_proxy.check_updates()
def system_upgrade(self):
return self.dbus_proxy.system_upgrade()
class WelcomedClient(GObject.GObject):
_name = 'com.antergos.welcome'
_object_path = '/com/antergos/welcome'
_interface_name = 'com.antergos.welcome'
__gsignals__ = {
'command-finished': (GObject.SignalFlags.RUN_FIRST, None,
(str, str, GObject.TYPE_PYOBJECT))
}
def __init__(self):
GObject.GObject.__init__(self)
self.interface = None
self.welcomed_ok = False
try:
self.bus = SystemBus()
self.dbus_proxy = self.bus.get(
WelcomedClient._name,
WelcomedClient._object_path)
if not self.dbus_proxy:
self.welcomed_ok = False
else:
self.dbus_proxy.PropertiesChanged.connect(
self.on_properties_changed)
self.welcomed_ok = self.dbus_proxy.is_alpm_on()
except Exception as err:
print(err)
finally:
if not self.welcomed_ok:
msg = _("Can't find Welcome d-bus service. Is it really installed?")
Notify.init("antergos-welcome")
Notify.Notification.new(
_("ERROR!"), msg, 'dialog-error').show()
def refresh(self):
""" pacman -Sy """
return self.dbus_proxy.refresh_alpm()
def on_properties_changed(self, *params):
""" A d-bus server property has changed """
(sender, prop, not_used) = params
# print("PARAMS:", params)
if sender == WelcomedClient._name and 'command_finished' in prop.keys():
(uid, command, pkgs) = prop['command_finished']
self.emit("command-finished", uid, command, pkgs)
def install_package(self, pkg):
""" pacman -S pkg """
return self.dbus_proxy.install_package(pkgs)
def install_packages(self, pkgs):
""" pacman -S pkgs """
return self.dbus_proxy.install_packages(pkgs)
def remove_package(self, package):
""" pacman -R pkg """
return self.dbus_proxy.remove_package(package)
def remove_packages(self, pkgs):
""" pacman -R pkgs """
for pkg in pkgs:
self.remove_package(pkg)
def check_updates(self):
return self.dbus_proxy.check_updates()
def system_upgrade(self):
return self.dbus_proxy.system_upgrade()
from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.common.action_chains import ActionChains
from selenium.webdriver.common.keys import Keys
from time import sleep
from command import Thuisbezorgd, LaatsteNieuws, Screenshot, Weersverwachting, Bieraanbieding, Fap
from selenium.webdriver.chrome.options import Options
from pydbus import SystemBus
import re
bus = SystemBus()
signal = bus.get('org.asamk.Signal')
chrome_options = Options()
chrome_options.add_experimental_option("debuggerAddress", "127.0.0.1:9222")
class Bot:
last_message = None
def __init__(self):
self.driver = webdriver.Firefox()
# self.driver = webdriver.Chrome(executable_path='/Users/oscar/Github/WhatsApp-Web-Bot/chromedriver')
# self.driver.maximize_window()
def get_qr(self):
"""
Waits for the QR-code to be scanned.
:return: void
"""
self.driver.get('https://web.whatsapp.com/')
from pydbus import SystemBus
bus = SystemBus()
systemd = bus.get(".systemd1")
#systemd = bus.get("org.freedesktop.systemd1")
manager = systemd[".Manager"]
#manager = systemd["org.freedesktop.systemd1.Manager"]
#manager = systemd # works but may break if systemd adds another interface
import sys
try:
if len(sys.argv) < 2:
for unit in manager.ListUnits():
print(unit)
else:
if sys.argv[1] == "--help":
help(manager)
else:
command = sys.argv[1]
command = "".join(x.capitalize() for x in command.split("-"))
result = getattr(manager, command)(*sys.argv[2:])
for var in result:
if type(var) == list:
for line in var:
print(line)
else:
print(var)
class Py3status:
"""
"""
# available configuration parameters
cache_timeout = 5
format = (
"\?color=state WW: [\?if=state_name=connected "
"({signal_quality_0}% at {m3gpp_operator_name}) "
"[{format_ipv4}[\?soft ]{format_ipv6}]"
"|{state_name}][ SMS {messages} [{format_message}]]"
)
format_ipv4 = u"[{address}]"
format_ipv6 = u"[{address}]"
format_message = u"\?if=index<2 {number} [\?max_length=10 {text}...]"
format_message_separator = u" "
format_notification = None
format_stats = u"{duration_hms}"
modem = None
thresholds = [(0, "bad"), (11, "good")]
def post_config_hook(self):
modem_manager = ["ModemManager", "/usr/sbin/ModemManager"]
network_manager = ["NetworkManager", "/usr/sbin/NetworkManager"]
for command in (modem_manager, network_manager):
if not self.py3.check_commands(command):
raise Exception("%s %s" % (command[0], STRING_NOT_INSTALLED))
# search: modemmanager flags and enumerations
# enum 1: #MMModemState
# enum 2: #MMModemAccessTechnology
# enum 3: #MMModem3gppRegistrationState
# enum 4: #MMModemBand
# enum 1: network states
self.network_states = {
-1: "failed",
0: "unknown",
1: "initializing",
2: "locked",
3: "disabled",
4: "disabling",
5: "enabling",
6: "enabled",
7: "searching",
8: "registered",
9: "disconnecting",
10: "connecting",
11: "connected",
}
# enum 2: network speed
self.network_speed = {
0: "Unknown",
1 << 0: "POTS", # 2
1 << 1: "GSM",
1 << 2: "GSM Compact",
1 << 3: "GPRS",
1 << 4: "EDGE",
1 << 5: "UMTS", # 32
1 << 6: "HSDPA",
1 << 7: "HSUPA",
1 << 8: "HSPA",
1 << 9: "HSPA+", # 512
1 << 10: "1XRTT",
1 << 11: "EVDO0",
1 << 12: "EVDOA",
1 << 13: "EVDOB",
1 << 14: "LTE", # 16384
}
# enum 3: network registration state
self.registration_states = {
0: "IDLE",
1: "HOME",
2: "SEARCHING",
3: "DENIED",
4: "UNKNOWN",
5: "ROAMING",
}
# enum 4: modem bands
self.modem_bands = {
0: "Unknown or invalid band",
1: "GSM/GPRS/EDGE 900 MHz",
2: "GSM/GPRS/EDGE 1800 MHz",
3: "GSM/GPRS/EDGE 1900 MHz",
4: "GSM/GPRS/EDGE 850 MHz",
5: "WCDMA 2100 MHz (Class I)",
6: "WCDMA 3GPP 1800 MHz (Class III)",
7: "WCDMA 3GPP AWS 1700/2100 MHz (Class IV)",
8: "WCDMA 3GPP UMTS 800 MHz (Class VI)",
9: "WCDMA 3GPP UMTS 850 MHz (Class V)",
10: "WCDMA 3GPP UMTS 900 MHz (Class VIII)",
11: "WCDMA 3GPP UMTS 1700 MHz (Class IX)",
12: "WCDMA 3GPP UMTS 1900 MHz (Class II)",
13: "WCDMA 3GPP UMTS 2600 MHz (Class VII, internal)",
31: "E-UTRAN band I",
32: "E-UTRAN band II",
33: "E-UTRAN band III",
34: "E-UTRAN band IV",
35: "E-UTRAN band V",
36: "E-UTRAN band VI",
37: "E-UTRAN band VII",
38: "E-UTRAN band VIII",
39: "E-UTRAN band IX",
40: "E-UTRAN band X",
41: "E-UTRAN band XI",
42: "E-UTRAN band XII",
43: "E-UTRAN band XIII",
44: "E-UTRAN band XIV",
47: "E-UTRAN band XVII",
48: "E-UTRAN band XVIII",
49: "E-UTRAN band XIX",
50: "E-UTRAN band XX",
51: "E-UTRAN band XXI",
52: "E-UTRAN band XXII",
53: "E-UTRAN band XXIII",
54: "E-UTRAN band XXIV",
55: "E-UTRAN band XXV",
56: "E-UTRAN band XXVI",
63: "E-UTRAN band XXXIII",
64: "E-UTRAN band XXXIV",
65: "E-UTRAN band XXXV",
66: "E-UTRAN band XXXVI",
67: "E-UTRAN band XXXVII",
68: "E-UTRAN band XXXVIII",
69: "E-UTRAN band XXXIX",
70: "E-UTRAN band XL",
71: "E-UTRAN band XLI",
72: "E-UTRAN band XLII",
73: "E-UTRAN band XLIII",
128: "CDMA Band Class 0 (US Cellular 850MHz)",
129: "CDMA Band Class 1 (US PCS 1900MHz)",
130: "CDMA Band Class 2 (UK TACS 900MHz)",
131: "CDMA Band Class 3 (Japanese TACS)",
132: "CDMA Band Class 4 (Korean PCS)",
134: "CDMA Band Class 5 (NMT 450MHz)",
135: "CDMA Band Class 6 (IMT2000 2100MHz)",
136: "CDMA Band Class 7 (Cellular 700MHz)",
137: "CDMA Band Class 8 (1800MHz)",
138: "CDMA Band Class 9 (900MHz)",
139: "CDMA Band Class 10 (US Secondary 800)",
140: "CDMA Band Class 11 (European PAMR 400MHz)",
141: "CDMA Band Class 12 (PAMR 800MHz)",
142: "CDMA Band Class 13 (IMT2000 2500MHz Expansion)",
143: "CDMA Band Class 14 (More US PCS 1900MHz)",
144: "CDMA Band Class 15 (AWS 1700MHz)",
145: "CDMA Band Class 16 (US 2500MHz)",
146: "CDMA Band Class 17 (US 2500MHz Forward Link Only)",
147: "CDMA Band Class 18 (US 700MHz Public Safety)",
148: "CDMA Band Class 19 (US Lower 700MHz)",
256: "auto",
}
self.bus = SystemBus()
self.init = {
"ip": [],
"sms_message": [],
"thresholds": self.py3.get_color_names_list(self.format),
}
self.last_messages = 0
self.last_notification = self.py3.storage_get("notification")
names = [
"current_bands_name",
"access_technologies_name",
"m3gpp_registration_name",
"interface_name",
"ipv4",
"ipv6",
"stats",
"format_message",
"message",
]
placeholders = [
"current_bands_name",
"access_technologies_name",
"m3gpp_registration_name",
"interface_name",
"format_ipv4",
"format_ipv6",
"format_stats",
"format_message",
"message*",
]
# init methods
format_strings = [self.format, self.format_notification]
for name, placeholder in zip(names, placeholders):
self.init[name] = []
for format_string in format_strings:
if format_string: # fails on None, [], '', etc
if self.py3.format_contains(format_string, placeholder):
self.init[name].append(format_string)
if name in ["ipv4", "ipv6"]:
if name not in self.init["ip"]:
self.init["ip"].append(name)
if name in ["message", "format_message"]:
if name not in self.init["sms_message"]:
self.init["sms_message"].append(name)
def _get_modem_proxy(self):
modemmanager_proxy = self.bus.get(STRING_MODEMMANAGER_DBUS)
modems = modemmanager_proxy.GetManagedObjects()
for objects in modems.items():
modem_path = objects[0]
modem_proxy = self.bus.get(STRING_MODEMMANAGER_DBUS, modem_path)
eqid = modem_proxy.EquipmentIdentifier
if self.modem is None or self.modem == eqid:
return modem_proxy
else:
return {}
def _get_modem_status_data(self, modem_proxy):
modem_data = {}
try:
modem_data = modem_proxy.GetStatus()
except: # noqa e722
pass
return modem_data
def _get_bearer(self, modem_proxy):
bearer = {}
try:
bearer = modem_proxy.Bearers[0]
except: # noqa e722
pass
return bearer
def _get_interface(self, bearer):
return self.bus.get(STRING_MODEMMANAGER_DBUS, bearer).Interface
def _get_message_data(self, modem_proxy):
message_data = {}
try:
message_data = modem_proxy.Messages
except: # noqa e722
pass
return message_data
def _count_messages(self, message_data):
count_messages = len(message_data)
count_message = max(0, count_messages - self.last_messages)
self.last_messages = count_messages
return count_message, count_messages
def _manipulate_message(self, data):
new_message = []
for index, msg in sorted(enumerate(data, 1), reverse=True):
try:
sms_proxy = self.bus.get(STRING_MODEMMANAGER_DBUS, msg)
new_message.append(
self.py3.safe_format(
self.format_message,
{
"index": index,
"number": sms_proxy.Number,
"text": sms_proxy.Text,
},
)
)
except: # noqa e722
break
format_message_separator = self.py3.safe_format(self.format_message_separator)
format_message = self.py3.composite_join(format_message_separator, new_message)
return format_message
def _get_network_config(self, bearer):
bearer_proxy = self.bus.get(STRING_MODEMMANAGER_DBUS, bearer)
return {"ipv4": bearer_proxy.Ip4Config, "ipv6": bearer_proxy.Ip6Config}
def _get_stats(self, bearer):
return self.bus.get(STRING_MODEMMANAGER_DBUS, bearer).Stats
def _organize(self, data):
new_data = {}
for key, value in data.items():
key = key.lower().replace("-", "_")
if isinstance(value, (list, tuple)):
if len(value) > 1:
for i, v in enumerate(value):
new_data["%s_%s" % (key, i)] = v
elif len(value) == 1:
new_data[key] = value[0]
else:
new_data[key] = None
else:
new_data[key] = value
return new_data
def wwan(self):
urgent = False
name = "_name"
# get wwan data
modem_proxy = self._get_modem_proxy()
wwan_data = self._get_modem_status_data(modem_proxy)
wwan_data = self._organize(wwan_data)
# state and name
key = "state"
wwan_data[key] = wwan_data.get(key, 0)
wwan_data[key + name] = self.network_states[wwan_data[key]]
# if state is -1, modem failed. stop here. report error.
# if state is less than 8, we are not connected. skip.
# if state is 8 or more, we are connected. start work.
if wwan_data[key] == -1:
self.py3.error(STRING_MODEM_ERROR)
elif wwan_data[key] < 8:
pass
else:
# access technologies and name
if self.init["access_technologies_name"]:
key = "access_technologies"
if wwan_data[key]:
bit = 1 << (wwan_data[key].bit_length() - 1)
else:
bit = 0
wwan_data[key + name] = self.network_speed[bit]
# modem band
if self.init["current_bands_name"]:
key = "current_bands"
wwan_data[key + name] = self.modem_bands[wwan_data[key]]
# registration state and name
if self.init["m3gpp_registration_name"]:
key = "m3gpp_registration_state"
new_key = key + name
wwan_data[new_key] = self.registration_states[wwan_data[key]]
# get bearer
bearer = self._get_bearer(modem_proxy)
if bearer:
# interface name
if self.init["interface_name"]:
wwan_data["interface_name"] = self._get_interface(bearer)
# ipv4 and ipv6 network config
if self.init["ip"]:
network_config = self._get_network_config(bearer)
format_ip = {"ipv4": self.format_ipv4, "ipv6": self.format_ipv6}
for ip in self.init["ip"]:
wwan_data["format_" + ip] = self.py3.safe_format(
format_ip[ip], network_config.get(ip, {})
)
# network connection statistics
if self.init["stats"]:
stats = self._organize(self._get_stats(bearer))
if stats:
stats["duration_hms"] = format(
timedelta(seconds=stats["duration"])
)
wwan_data["format_stats"] = self.py3.safe_format(
self.format_stats, stats
)
# message and format message
if self.init["sms_message"]:
if wwan_data["state"] >= 1:
message_data = self._get_message_data(modem_proxy)
# count messages
keys = ["message", "messages"]
wwan_data.update(zip(keys, self._count_messages(message_data)))
if wwan_data["message"]:
urgent = True
# format sms messages
if self.init["format_message"]:
wwan_data["format_message"] = self._manipulate_message(message_data)
# thresholds
for x in self.init["thresholds"]:
if x in wwan_data:
self.py3.threshold_get_color(wwan_data[x], x)
# notifications
if self.format_notification:
# get a notification
format_notification = self.py3.safe_format(
self.format_notification, wwan_data
)
notification = self.py3.get_composite_string(format_notification)
if notification and notification != self.last_notification:
self.last_notification = notification
self.py3.storage_set("notification", notification)
self.py3.notify_user(notification)
response = {
"cached_until": self.py3.time_in(self.cache_timeout),
"full_text": self.py3.safe_format(self.format, wwan_data),
}
if urgent:
response["urgent"] = True
return response
class Py3status:
"""
"""
# available configuration parameters
cache_timeout = 5
format = ('\?color=state WW: [\?if=state_name=connected '
'({signal_quality_0}% at {m3gpp_operator_name}) '
'[{format_ipv4}[\?soft ]{format_ipv6}]'
'|{state_name}][ SMS {messages} [{format_message}]]')
format_ipv4 = u'[{address}]'
format_ipv6 = u'[{address}]'
format_message = u'\?if=index<2 {number} [\?max_length=10 {text}...]'
format_message_separator = u' '
format_notification = None
format_stats = u'{duration_hms}'
modem = None
thresholds = [(0, 'bad'), (11, 'good')]
def post_config_hook(self):
modem_manager = ['ModemManager', '/usr/sbin/ModemManager']
network_manager = ['NetworkManager', '/usr/sbin/NetworkManager']
for command in (modem_manager, network_manager):
if not self.py3.check_commands(command):
raise Exception('%s %s' % (command[0], STRING_NOT_INSTALLED))
# search: modemmanager flags and enumerations
# enum 1: #MMModemState
# enum 2: #MMModemAccessTechnology
# enum 3: #MMModem3gppRegistrationState
# enum 4: #MMModemBand
# enum 1: network states
self.network_states = {
-1: 'failed',
0: 'unknown',
1: 'initializing',
2: 'locked',
3: 'disabled',
4: 'disabling',
5: 'enabling',
6: 'enabled',
7: 'searching',
8: 'registered',
9: 'disconnecting',
10: 'connecting',
11: 'connected'
}
# enum 2: network speed
self.network_speed = {
0: 'Unknown',
1 << 0: 'POTS', # 2
1 << 1: 'GSM',
1 << 2: 'GSM Compact',
1 << 3: 'GPRS',
1 << 4: 'EDGE',
1 << 5: 'UMTS', # 32
1 << 6: 'HSDPA',
1 << 7: 'HSUPA',
1 << 8: 'HSPA',
1 << 9: 'HSPA+', # 512
1 << 10: '1XRTT',
1 << 11: 'EVDO0',
1 << 12: 'EVDOA',
1 << 13: 'EVDOB',
1 << 14: 'LTE' # 16384
}
# enum 3: network registration state
self.registration_states = {
0: 'IDLE',
1: 'HOME',
2: 'SEARCHING',
3: 'DENIED',
4: 'UNKNOWN',
5: 'ROAMING'
}
# enum 4: modem bands
self.modem_bands = {
0: 'Unknown or invalid band',
1: 'GSM/GPRS/EDGE 900 MHz',
2: 'GSM/GPRS/EDGE 1800 MHz',
3: 'GSM/GPRS/EDGE 1900 MHz',
4: 'GSM/GPRS/EDGE 850 MHz',
5: 'WCDMA 2100 MHz (Class I)',
6: 'WCDMA 3GPP 1800 MHz (Class III)',
7: 'WCDMA 3GPP AWS 1700/2100 MHz (Class IV)',
8: 'WCDMA 3GPP UMTS 800 MHz (Class VI)',
9: 'WCDMA 3GPP UMTS 850 MHz (Class V)',
10: 'WCDMA 3GPP UMTS 900 MHz (Class VIII)',
11: 'WCDMA 3GPP UMTS 1700 MHz (Class IX)',
12: 'WCDMA 3GPP UMTS 1900 MHz (Class II)',
13: 'WCDMA 3GPP UMTS 2600 MHz (Class VII, internal)',
31: 'E-UTRAN band I',
32: 'E-UTRAN band II',
33: 'E-UTRAN band III',
34: 'E-UTRAN band IV',
35: 'E-UTRAN band V',
36: 'E-UTRAN band VI',
37: 'E-UTRAN band VII',
38: 'E-UTRAN band VIII',
39: 'E-UTRAN band IX',
40: 'E-UTRAN band X',
41: 'E-UTRAN band XI',
42: 'E-UTRAN band XII',
43: 'E-UTRAN band XIII',
44: 'E-UTRAN band XIV',
47: 'E-UTRAN band XVII',
48: 'E-UTRAN band XVIII',
49: 'E-UTRAN band XIX',
50: 'E-UTRAN band XX',
51: 'E-UTRAN band XXI',
52: 'E-UTRAN band XXII',
53: 'E-UTRAN band XXIII',
54: 'E-UTRAN band XXIV',
55: 'E-UTRAN band XXV',
56: 'E-UTRAN band XXVI',
63: 'E-UTRAN band XXXIII',
64: 'E-UTRAN band XXXIV',
65: 'E-UTRAN band XXXV',
66: 'E-UTRAN band XXXVI',
67: 'E-UTRAN band XXXVII',
68: 'E-UTRAN band XXXVIII',
69: 'E-UTRAN band XXXIX',
70: 'E-UTRAN band XL',
71: 'E-UTRAN band XLI',
72: 'E-UTRAN band XLII',
73: 'E-UTRAN band XLIII',
128: 'CDMA Band Class 0 (US Cellular 850MHz)',
129: 'CDMA Band Class 1 (US PCS 1900MHz)',
130: 'CDMA Band Class 2 (UK TACS 900MHz)',
131: 'CDMA Band Class 3 (Japanese TACS)',
132: 'CDMA Band Class 4 (Korean PCS)',
134: 'CDMA Band Class 5 (NMT 450MHz)',
135: 'CDMA Band Class 6 (IMT2000 2100MHz)',
136: 'CDMA Band Class 7 (Cellular 700MHz)',
137: 'CDMA Band Class 8 (1800MHz)',
138: 'CDMA Band Class 9 (900MHz)',
139: 'CDMA Band Class 10 (US Secondary 800)',
140: 'CDMA Band Class 11 (European PAMR 400MHz)',
141: 'CDMA Band Class 12 (PAMR 800MHz)',
142: 'CDMA Band Class 13 (IMT2000 2500MHz Expansion)',
143: 'CDMA Band Class 14 (More US PCS 1900MHz)',
144: 'CDMA Band Class 15 (AWS 1700MHz)',
145: 'CDMA Band Class 16 (US 2500MHz)',
146: 'CDMA Band Class 17 (US 2500MHz Forward Link Only)',
147: 'CDMA Band Class 18 (US 700MHz Public Safety)',
148: 'CDMA Band Class 19 (US Lower 700MHz)',
256: 'auto'
}
self.bus = SystemBus()
self.init = {
'ip': [],
'sms_message': [],
'thresholds': self.py3.get_color_names_list(self.format),
}
self.last_messages = 0
self.last_notification = self.py3.storage_get('notification')
names = [
'current_bands_name', 'access_technologies_name',
'm3gpp_registration_name', 'interface_name', 'ipv4', 'ipv6',
'stats', 'format_message', 'message'
]
placeholders = [
'current_bands_name', 'access_technologies_name',
'm3gpp_registration_name', 'interface_name', 'format_ipv4',
'format_ipv6', 'format_stats', 'format_message', 'message*'
]
# init methods
format_strings = [self.format, self.format_notification]
for name, placeholder in zip(names, placeholders):
self.init[name] = []
for format_string in format_strings:
if format_string: # fails on None, [], '', etc
if self.py3.format_contains(format_string, placeholder):
self.init[name].append(format_string)
if name in ['ipv4', 'ipv6']:
if name not in self.init['ip']:
self.init['ip'].append(name)
if name in ['message', 'format_message']:
if name not in self.init['sms_message']:
self.init['sms_message'].append(name)
def _get_modem_proxy(self):
modemmanager_proxy = self.bus.get(STRING_MODEMMANAGER_DBUS)
modems = modemmanager_proxy.GetManagedObjects()
for objects in modems.items():
modem_path = objects[0]
modem_proxy = self.bus.get(STRING_MODEMMANAGER_DBUS, modem_path)
eqid = modem_proxy.EquipmentIdentifier
if self.modem is None or self.modem == eqid:
return modem_proxy
else:
return {}
def _get_modem_status_data(self, modem_proxy):
modem_data = {}
try:
modem_data = modem_proxy.GetStatus()
except: # noqa e722
pass
return modem_data
def _get_bearer(self, modem_proxy):
bearer = {}
try:
bearer = modem_proxy.Bearers[0]
except: # noqa e722
pass
return bearer
def _get_interface(self, bearer):
return self.bus.get(STRING_MODEMMANAGER_DBUS, bearer).Interface
def _get_message_data(self, modem_proxy):
message_data = {}
try:
message_data = modem_proxy.Messages
except: # noqa e722
pass
return message_data
def _count_messages(self, message_data):
count_messages = len(message_data)
count_message = max(0, count_messages - self.last_messages)
self.last_messages = count_messages
return count_message, count_messages
def _manipulate_message(self, data):
new_message = []
for index, msg in sorted(enumerate(data, 1), reverse=True):
try:
sms_proxy = self.bus.get(STRING_MODEMMANAGER_DBUS, msg)
new_message.append(
self.py3.safe_format(
self.format_message, {
'index': index,
'number': sms_proxy.Number,
'text': sms_proxy.Text
}))
except: # noqa e722
break
format_message_separator = self.py3.safe_format(
self.format_message_separator
)
format_message = self.py3.composite_join(
format_message_separator, new_message
)
return format_message
def _get_network_config(self, bearer):
bearer_proxy = self.bus.get(STRING_MODEMMANAGER_DBUS, bearer)
return {
'ipv4': bearer_proxy.Ip4Config,
'ipv6': bearer_proxy.Ip6Config,
}
def _get_stats(self, bearer):
return self.bus.get(STRING_MODEMMANAGER_DBUS, bearer).Stats
def _organize(self, data):
new_data = {}
for key, value in data.items():
key = key.lower().replace('-', '_')
if isinstance(value, (list, tuple)):
if len(value) > 1:
for i, v in enumerate(value):
new_data['%s_%s' % (key, i)] = v
elif len(value) == 1:
new_data[key] = value[0]
else:
new_data[key] = None
else:
new_data[key] = value
return new_data
def wwan(self):
urgent = False
name = '_name'
# get wwan data
modem_proxy = self._get_modem_proxy()
wwan_data = self._get_modem_status_data(modem_proxy)
wwan_data = self._organize(wwan_data)
# state and name
key = 'state'
wwan_data[key] = wwan_data.get(key, 0)
wwan_data[key + name] = self.network_states[wwan_data[key]]
# if state is -1, modem failed. stop here. report error.
# if state is less than 8, we are not connected. skip.
# if state is 8 or more, we are connected. start work.
if wwan_data[key] == -1:
self.py3.error(STRING_MODEM_ERROR)
elif wwan_data[key] < 8:
pass
else:
# access technologies and name
if self.init['access_technologies_name']:
key = 'access_technologies'
if wwan_data[key]:
bit = 1 << (wwan_data[key].bit_length() - 1)
else:
bit = 0
wwan_data[key + name] = self.network_speed[bit]
# modem band
if self.init['current_bands_name']:
key = 'current_bands'
wwan_data[key + name] = self.modem_bands[wwan_data[key]]
# registration state and name
if self.init['m3gpp_registration_name']:
key = 'm3gpp_registration_state'
new_key = key + name
wwan_data[new_key] = self.registration_states[wwan_data[key]]
# get bearer
bearer = self._get_bearer(modem_proxy)
if bearer:
# interface name
if self.init['interface_name']:
wwan_data['interface_name'] = self._get_interface(bearer)
# ipv4 and ipv6 network config
if self.init['ip']:
network_config = self._get_network_config(bearer)
format_ip = {
'ipv4': self.format_ipv4,
'ipv6': self.format_ipv6,
}
for ip in self.init['ip']:
wwan_data['format_' + ip] = self.py3.safe_format(
format_ip[ip], network_config.get(ip, {}))
# network connection statistics
if self.init['stats']:
stats = self._organize(self._get_stats(bearer))
if stats:
stats['duration_hms'] = format(
timedelta(seconds=stats['duration'])
)
wwan_data['format_stats'] = self.py3.safe_format(
self.format_stats, stats
)
# message and format message
if self.init['sms_message']:
if wwan_data['state'] >= 1:
message_data = self._get_message_data(modem_proxy)
# count messages
keys = ['message', 'messages']
wwan_data.update(zip(keys, self._count_messages(message_data)))
if wwan_data['message']:
urgent = True
# format sms messages
if self.init['format_message']:
wwan_data['format_message'] = self._manipulate_message(
message_data
)
# thresholds
for x in self.init['thresholds']:
if x in wwan_data:
self.py3.threshold_get_color(wwan_data[x], x)
# notifications
if self.format_notification:
# get a notification
format_notification = self.py3.safe_format(
self.format_notification, wwan_data
)
notification = self.py3.get_composite_string(
format_notification
)
if notification and notification != self.last_notification:
self.last_notification = notification
self.py3.storage_set('notification', notification)
self.py3.notify_user(notification)
response = {
'cached_until': self.py3.time_in(self.cache_timeout),
'full_text': self.py3.safe_format(self.format, wwan_data)
}
if urgent:
response['urgent'] = True
return response
from pydbus import SystemBus
from gi.repository import GObject
def print_state(a, b, c):
print a
print b.keys()
print c
bus = SystemBus()
dev = bus.get('org.freedesktop.UDisks2', '/org/freedesktop/UDisks2/drives/TSSTcorp_CDDVDW_SE_S084C_SATASLIM00003008cae')
dev.PropertiesChanged.connect(print_state)
GObject.MainLoop().run()
class Services():
'''
Services provides an easy access to systemd services
'''
def __init__(self):
'''
Services constructor
'''
self.include_static_services = False
self._reload = True
self._services = {}
self._xinetd_services = {}
self._bus = SystemBus()
self._systemd = self._bus.get(".systemd1")
self._manager = self._systemd[".Manager"]
def check_permission(action, dbus_context):
'''
Check authorizations
'''
return dbus_context.is_authorized(action, {'polkit.icon_name': 'manatools.png',}, interactive=True)
@property
def service_info(self):
'''
A dictionary collecting all the service information.
if include_static_services (default is false) is set also static
services are included.
'''
if not self._reload:
return self._services
units = self._manager.ListUnits()
self._services = {}
self._reload = False
for u in units:
unitName = u[0]
pos = unitName.find(".service")
if pos != -1:
try:
if unitName.find("@") == -1:
st = self._manager.GetUnitFileState(unitName)
name = unitName[0:pos]
if st and (self.include_static_services or st != 'static'):
self._services[name] = {
'name': u[0],
'description': u[1],
'load_state': u[2],
'active_state': u[3],
'sub_state': u[4],
'unit_path': u[6],
'enabled': st == 'enabled',
}
# TODO if not st check unit files see Services.pm:167
except:
pass
unit_files = self._manager.ListUnitFiles()
for u in unit_files:
unitName = u[0]
st = u[1]
pos = unitName.find(".service")
if pos != -1:
name = os.path.basename(unitName)
name = name[0:name.find(".service")]
if (not name in self._services.keys()) and (name.find('@') == -1) \
and (os.path.isfile(unitName) or os.path.isfile("/etc/rc.d/init.d/"+name)) \
and not os.path.islink(unitName) and (st == "disabled" or st == "enabled"):
self._services[name] = {
'name': name+".service",
# 'description': ####TODO get property,
'description': "---",
'enabled': st == 'enabled',
}
return self._services
@property
def xinetd_services(self):
'''
This function returns all the xinetd services in the system.
NOTE that xinetd *must* be enable at boot to get this info
'''
try:
service_info = self.service_info()['xinetd']
if service_info['enabled']:
env = {'LANGUAGE': 'C', 'PATH': "/usr/bin:/usr/sbin"}
# TODO : Change to force root command
try:
chkconf = subprocess.run(['/usr/sbin/chkconfig', '--list', '--type', 'xinetd'],
env=env, timeout=120, check=True, capture_output=True, text=True)
for serv in chkconf.stdout.strip().split('\n'):
servT = serv.split()
try:
self._xinetd_services[servT[0].strip(":")] = servT[1] == 'on'
except IndexError:
continue
except (subprocess.CalledProcessError, subprocess.TimeoutExpired):
# TODO return an exception to the exterior
print("chkconfig error when trying to list xinetd services", stderr)
except KeyError:
return self._xinetd_services
def _running_systemd(self):
# TODO : Change to force root command
try:
return subprocess.run(['/usr/bin/mountpoint', '-q', '/sys/fs/cgroup/systemd'], env={'PATH': '/usr/bin:/usr/sbin'}, timeout=120).returncode == 0
except subprocess.TimeoutExpired:
# TODO : return an exception outside of the function
print("moutnpoint error when checking systemd: timeout expired.\n")
return False
def _has_systemd(self):
# TODO : Change to force root command
try:
return subprocess.run(['/usr/bin/rpm', '-q', 'systemd'], env={'PATH': '/usr/bin:/usr/sbin'}, timeout=120).returncode == 0
except subprocess.TimeoutExpired:
# TODO : return an exception outside of the function
print("rpm error when checking systemd: timeout expired.\n")
return False
def set_service(self, service, enable):
'''
This function enable/disable at boot the given service
'''
# NOTE EnableUnitFiles and DisableUnitFiles don't work with legacy services
# and return file not found
legacy = os.path.isfile("/etc/rc.d/init.d/{}".format(service))
if service in self._xinetd_services.keys():
env = {'LANGUAGE': 'C', 'PATH': "/usr/bin:/usr/sbin"}
# if dbus_context.is_authorized('org.freeedesktop.policykit.exec', {'polkit.icon': 'abcd', 'aaaa': 'zzzz'}, interactive=True):
# try:
# chkconf = subprocess.run(['/usr/sbin/chkconfig', "-add" if enable else "--del",
# service], env=env, timeout=120, check=True, capture_output=True, text=True)
# except (subprocess.CalledProcessError, subprocess.TimeoutExpired):
# # TODO return an exception to the exterior
# print("chkconfig error when trying to add/delete service", stderr)
# else:
# # TODO return an excpetion to the exterior
# print("You are not authorized to perform this action", stderr)
elif not legacy and (self._running_systemd() or self._has_systemd()):
service = "{}.service".format(service)
if enable:
# if self.check_permission(self._manager.EnableUnitFiles(), dbus_context):
# self._manager.EnableUnitFiles([service.encode()], False, True)
#!/usr/bin/python3
# Based on http://stackoverflow.com/questions/22390064/use-dbus-to-just-send-a-message-in-python
# Python script to call the methods of the DBUS Test Server
from pydbus import SystemBus
import sys
#get the session bus
bus = SystemBus()
o2 = bus.get("org.freedesktop.DBus")
pat = "it.pook.DelcomClock."
if len(sys.argv) > 1:
name = pat + sys.argv[1]
else:
for n in o2.ListNames():
if n.startswith("it.pook.DelcomClock."):
name = n
break
else:
sys.exit("no delcom")
print("anme", name)
#get the object
the_object = bus.get(name)
#call the methods and print the results
reply = the_object.Hello()
class BatteryApp:
def __init__(self):
self.prefix = 'B:'
self.separator = '/'
self.suffix = ' '
self.tooltip_heading = 'Battery Status:\n'
self.low_battery_alarm_threshold = 5
self.low_battery_alarm_visible = False
self.build_ui()
self.dbus = SystemBus()
self.upower = self.dbus.get('.UPower', '/org/freedesktop/UPower')
self.battery_subscriptions = []
self.upower.DeviceAdded.connect(lambda name, vals, a: self.get_upower_batteries())
self.upower.DeviceRemoved.connect(lambda name, vals, a: self.get_upower_batteries())
self.get_upower_batteries()
self.start_signal_thread()
def build_ui(self):
self.tray = tray = Gtkti.TrayIcon()
self.eventbox = eventbox = Gtk.EventBox()
eventbox.set_tooltip_text(self.tooltip_heading+'Unknown')
tray.add(eventbox)
self.tray_label = tray_label = Gtk.Label(self.prefix+'?'+self.suffix)
eventbox.add(tray_label)
tray.show_all()
menu = Gtk.Menu()
item_quit = Gtk.MenuItem('Quit')
def quit(menu_item):
if sys.version_info < (3, 0):
os.kill(os.getpid(), signal.SIGINT)
else:
Gtk.main_quit()
item_quit.connect('activate', quit)
menu.append(item_quit)
menu.show_all()
def button_pressed(eventbox, event, menu=menu):
if event.type == Gdk.EventType.BUTTON_PRESS and event.button == 3:
menu.popup(None, None, None, None, event.button, event.time)
eventbox.connect('button-press-event', button_pressed)
# Update the UI (thread-safe)
def update_ui(self):
GLib.idle_add(self.gtk_update_ui)
# Update the UI (within the GTK main thread ; not thread-safe)
def gtk_update_ui(self):
display_str = ''
tooltip_str = ''
max_percentage = 0
for battery in self.upower_batteries:
if display_str:
display_str += '/'
tooltip_str += '\n'
tooltip_str += battery.NativePath+': '
state = battery.State
if state == 1 or state == 5:
tooltip_str += 'Charging ('+str(battery.Percentage)+'%)'
display_str += str(int(battery.Percentage))+'+'
elif state == 2 or state == 3 or state == 6:
tooltip_str += 'Discharging ('+str(battery.Percentage)+'%)'
display_str += str(int(battery.Percentage))+'-'
elif state == 4:
tooltip_str += 'Full ('+str(battery.Percentage)+'%)'
display_str += str(int(battery.Percentage))
else:
tooltip_str += 'Unknown ('+str(battery.Percentage)+'%)'
display_str += '?'
if battery.TimeToFull:
m, s = divmod(battery.TimeToFull, 60)
h, m = divmod(m, 60)
tooltip_str += ', Remaining Charge Time: '+('%dh %02dm %02ds' % (h, m, s))
if battery.TimeToEmpty:
m, s = divmod(battery.TimeToEmpty, 60)
h, m = divmod(m, 60)
tooltip_str += ', Remaining Discharge Time: '+('%dh %02dm %02ds' % (h, m, s))
if battery.Percentage > max_percentage:
max_percentage = battery.Percentage
self.tray_label.set_text(self.prefix+display_str+self.suffix)
self.eventbox.set_tooltip_text(self.tooltip_heading+tooltip_str)
if max_percentage < self.low_battery_alarm_threshold and not self.low_battery_alarm_visible:
self.low_battery_alarm_visible = True
dialog = Gtk.Dialog()
dialog.set_title('Warning')
dialog.set_default_size(250, 100)
label = Gtk.Label('Low Battery')
dialog.get_content_area().add(label)
dialog.add_button('_Close', -1) # GTK_RESPONSE_NONE == -1
def close_pressed(dialog, response_id, self=self):
self.low_battery_alarm_visible = False
dialog.destroy()
dialog.connect('response', close_pressed)
dialog.show_all()
# Return false to unregister this method as a GLib idle handler
return False
def get_upower_batteries(self):
paths = self.upower.EnumerateDevices()
devices = map(lambda p: self.dbus.get('.UPower', p), paths)
batteries = filter(lambda d: d.Type == 2, devices)
for s in self.battery_subscriptions:
s.disconnect()
self.battery_subscriptions = []
for battery in batteries:
s = battery.PropertiesChanged.connect(lambda name, vals, a: self.update_ui())
self.battery_subscriptions.append(s)
self.upower_batteries = batteries
self.update_ui()
def start_signal_thread(self):
thread = threading.Thread(target=GLib.MainLoop().run)
thread.daemon = True
thread.start()
class NetworkManager(EventDispatcher, Thread):
connected_ssid = StringProperty()
connection_type = OptionProperty("none", options=["none", "ethernet", "wireless"])
def __init__(self, **kwargs):
self.available = False
super().__init__(**kwargs)
self.loop = GLib.MainLoop()
self.bus = SystemBus()
# ID used to cancel the scan timer and to find out whether it is running
# Will be None whenever the timer isn't running
self.scan_timer_id = None
self.new_connection_subscription = None
self.access_points = []
self.saved_ssids = []
# Register kivy events
self.register_event_type('on_access_points')
self.register_event_type('on_connect_failed')
# Get proxy objects
try:
self.nm = self.bus.get(_NM, "/org/freedesktop/NetworkManager")
except GLib.GError as e:
# Occurs when NetworkManager was not installed
if "org.freedesktop.DBus.Error.ServiceUnknown" in e.message:
return # Leaves self.available = False
raise
self.settings = self.bus.get(_NM, "/org/freedesktop/NetworkManager/Settings")
devices = self.nm.Devices # Type: ao
self.eth_dev = self.wifi_dev = None
for dev in devices:
dev_obj = self.bus.get(_NM, dev)
if dev_obj.Capabilities & 0x1: # NetworkManager supports this device
if dev_obj.DeviceType == 1: # a wired ethernet device
self.eth_dev = dev_obj
elif dev_obj.DeviceType == 2: # an 802.11 Wi-Fi device
self.wifi_dev = dev_obj
# For simplicity require both devices to be available
if not(self.eth_dev and self.wifi_dev):
return # Leaves self.available = False
#UNUSED Does the wifi device support 5gGHz (flag 0x400)
#self.freq_5ghz = bool(self.wifi_dev.WirelessCapabilities & 0x400)
# Connect DBus signals to their callbacks
# Pick out the .DBus.Properties interface because the .NetworkManager
# interface overwrites that with a less functioning one.
nm_prop = self.nm['org.freedesktop.DBus.Properties']
nm_prop.PropertiesChanged.connect(self._handle_nm_props)
wifi_prop = self.wifi_dev['org.freedesktop.DBus.Properties']
wifi_prop.PropertiesChanged.connect(self._handle_wifi_dev_props)
# Initiate the values handled by signal handlers by simply
# sending all the properties that are being listened to.
self._handle_nm_props(None, self.nm.GetAll('org.freedesktop.NetworkManager'), None)
self._handle_wifi_dev_props(None, self.wifi_dev.GetAll(_NM + ".Device"), None)
self._handle_wifi_dev_props(None, self.wifi_dev.GetAll(_NM + ".Device.Wireless"), None)
self.available = True
def run(self):
"""
Executed by Thread.start(). This thread stops when this method finishes.
Stop the loop by calling self.loop.quit().
"""
self.loop.run()
def stop(self):
self.loop.quit()
def _handle_nm_props(self, iface, props, inval):
"""Receives all property changes of self.nm"""
if "PrimaryConnectionType" in props:
# Connection Type changed
con_type = props['PrimaryConnectionType']
if con_type == '802-3-ethernet':
self.connection_type = "ethernet"
elif con_type == '802-11-wireless': # Wi-Fi connected
self.connection_type = "wireless"
else: # No active connection
self.connection_type = "none"
def _handle_wifi_dev_props(self, iface, props, inval):
"""
Receives all property changes of self.wifi_dev and calls the
appropriate methods.
"""
if "LastScan" in props:
self._handle_scan_complete()
if "ActiveAccessPoint" in props:
self._handle_connected_ssid(props['ActiveAccessPoint'])
def _handle_new_connection(self, state, reason):
"""
Receives state changes from newly added connections.
Required to ensure everything went OK and to dispatch events
in case it didn't. The most important case would be a wrong
password which isn't clearly identifiable from the reason.
The signal subscription will be canceled when the connection
was successfully activated.
"""
if state > 2: # DEACTIVATING or DEACTIVATED
self.dispatch('on_connect_failed')
if state in (2, 4): # ACTIVATED or DEACTIVATED
# done, no need to listen further
self.new_connection_subscription.disconnect()
def _handle_scan_complete(self):
"""
Called on changes in wifi_dev.LastScan, which is changed whenever
a scan completed. Parses the access points into wrapper objects
containing the relevant attributes and methods
WARNING: Because of some DBus calls, this function can take
from 0.5 up to 5 seconds to complete.
"""
# Needed to accurately build AccessPoint objects
self.saved_ssids = self.get_saved_ssids()
access_points = []
for path in self.wifi_dev.AccessPoints:
try:
ap = AccessPoint(self, path)
except: # DBus sometimes throws a random error here
continue
# Ignore unnamed access points
if ap.ssid:
access_points.append(ap)
# Sort by signal strength, frequency and then by 'in-use'
access_points.sort(key=lambda x: x.signal, reverse=True)
# We only really want to differentiate between 2.4 GHz and 5 GHz
access_points.sort(key=lambda x: x.freq // 2000, reverse=True)
access_points.sort(key=lambda x: x.in_use, reverse=True)
# Filter out access points with duplicate ssids
seen_ssids = set()
unique_aps = []
for ap in access_points:
# Because access_points are already sorted most wanted first
# we just add the first occurence of each ssid
if ap.ssid not in seen_ssids:
unique_aps.append(ap)
seen_ssids.add(ap.ssid)
self.access_points = unique_aps # update the property
self.dispatch('on_access_points', self.access_points)
def _handle_connected_ssid(self, active_path):
"""
Called whenever the active wifi connection changes.
Sets the ssid of the currently connected wifi connection.
If no wifi connection currently exists, set "".
active_path references the AccessPoint object currently in use.
"""
if active_path == "/":
# There is no wifi connection right now
self.connected_ssid = ""
else:
active = self.bus.get(_NM, active_path)
self.connected_ssid = _bytes_to_string(active.Ssid)
def set_scan_frequency(self, freq):
"""
Set the frequency at which to scan for wifi networks.
freq is the frequency in seconds and should be an int.
If freq is 0, the rescan clock is cancelled.
"""
if freq == 0:
if self.scan_timer_id:
GLib.source_remove(self.scan_timer_id)
self.scan_timer_id = None
else:
self.scan_timer_id = GLib.timeout_add_seconds(freq, self.wifi_scan)
def wifi_scan(self):
"""
Request a rescan on the wifi device.
When finished, self._handle_scan_complete() is called. In case
the previous scan is still running a new scan isn't allowed and
this method returns False, otherwise True.
"""
try:
# Provide empty dict to scan for all ssids
self.wifi_dev.RequestScan({})
return True
except GLib.GError as e:
if "org.freedesktop.NetworkManager.Device.NotAllowed" in e.message:
return False
raise
def wifi_connect(self, ap, password=None):
"""
From AccessPoint and password as plaintext string get all the
information needed to either create and connect or just connect
the connection.
This method is likely to raise a ValueError or GLib.GError in
AddAndActivateConnection. Exception catching is advised.
Returns path to the new connection (in settings)
"""
if ap._path not in self.wifi_dev.AccessPoints:
# Network got out of view since previous scan
raise ValueError("Network " + ap.ssid + " is not in view.")
if ap.encrypted:
if not ap.supports_psk:
raise Exception("Access Point " + ap.ssid + " doesn't support PSK verification")
if password is None:
raise ValueError("No password provided")
password = GLib.Variant('s', password)
connection_info = {'802-11-wireless-security': {'psk': password}} # Type: a{sa{sv}}
con, act_path = self.nm.AddAndActivateConnection(
connection_info, self.wifi_dev._path, ap._path)
else:
# Open network, no password needed
con, act_path = self.nm.AddAndActivateConnection(
{}, self.wifi_dev._path, ap._path)
active = self.bus.get(_NM, act_path)
self.new_connection_subscription = active.StateChanged.connect(self._handle_new_connection)
self.wifi_scan()
return con
def wifi_up(self, ap):
"""Activate a connection that is already stored"""
if not (ap._path in self.wifi_dev.AccessPoints and ap.saved):
raise Exception("Can't activate connection " + ap.ssid)
active = self.nm.ActivateConnection("/", self.wifi_dev._path, ap._path)
active = self.bus.get(_NM, active)
self.new_connection_subscription = active.StateChanged.connect(self._handle_new_connection)
self.wifi_scan()
def wifi_down(self):
"""Deactivate the currently active wifi connection, if any"""
active = self.wifi_dev.ActiveConnection
if active == "/":
return False
self.nm.DeactivateConnection(active)
self.wifi_scan()
return True
def wifi_delete(self, ap):
"""Delete a saved connection"""
connection_paths = self.settings.Connections # Type: ao
for path in connection_paths:
con = self.bus.get(_NM, path)
settings = con.GetSettings() # Type: a{sa{sv}}
if '802-11-wireless' in settings: # Only check wifi connections
if ap.b_ssid == settings['802-11-wireless']['ssid']:
con.Delete()
self.wifi_scan()
return True
return False
def get_saved_ssids(self):
"""Return list of ssid bytearrays of all stored Wi-Fi connections"""
connection_paths = self.settings.Connections # Type: ao
ssids = []
for path in connection_paths:
con = self.bus.get(_NM, path)
settings = con.GetSettings() # Type: a{sa{sv}}
if '802-11-wireless' in settings: # Wired connections don't have ssids
ssid_b = settings['802-11-wireless']['ssid']
ssids.append(ssid_b)
return ssids
def get_ip4_address(self):
"""
Return the IPv4 Address of the network device currently in use.
Return None if there is no active connection.
"""
active_path = self.nm.PrimaryConnection
if active_path == "/":
return None
active = self.bus.get(_NM, active_path)
config = self.bus.get(_NM, active.Ip4Config)
return config.AddressData[0]['address'] # Type: aa{sv}
def get_connection_strength(self):
"""
Return the connection strength in percent of the currently connected
wifi access point. If no wifi connection currently exists, return None.
"""
active_ap_path = self.wifi_dev.ActiveAccessPoint
if active_ap_path == "/":
# There is no wifi connection right now
return None
active_ap = self.bus.get(_NM, active_ap_path)
return active_ap.Strength
def on_access_points(self, aps):
pass
def on_connect_failed(self):
pass
#!/usr/bin/python3
from pydbus import SessionBus,SystemBus
BATTERY_LEVELS = ""
CHARGING_FULL = ''
CHARGING = ''
sys = SystemBus()
power = sys.get('.UPower')
all_capacity = 0
all_rate = 0
charge_time = 0
bat_no = 0
percentages = []
all_full = True
for a in power.EnumerateDevices():
dev = sys.get('.UPower', a)
# check if battery
if dev.Type == 2:
# change all full, if not all fully charged
if dev.State != 4:
all_full = False
# check if battery is charging
if dev.State == 1:
charge_time += (dev.EnergyFull - dev.Energy) / dev.EnergyRate
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Connects the interface applications (cli and gui) with the backend daemon.
See also :mod:`weresync.daemon.daemon`"""
from pydbus import SystemBus
from gi.repository import GLib
import threading
import gi.repository.GLib
try:
bus = SystemBus()
drive_copier = bus.get("net.manilas.weresync.DriveCopier")
copy_drive = drive_copier.CopyDrive
"""A function which connects to :meth:`weresync.daemon.device.copy_drive`:.
For arguments see that function's documentation. If False, WereSync failed
to connect to dbus."""
error = None
except gi.repository.GLib.Error as e:
error = e
"""The error created by connecting to dbus. If no error, then None."""
copy_drive = False
def _unthreaded_subscribe_to_signals(partition_status_callback,
copy_status_callback,
boot_status_callback):
drive_copier.PartitionStatus.connect(partition_status_callback)
def post_config_hook(self):
bus = SystemBus()
systemd = bus.get('org.freedesktop.systemd1')
self.systemd_unit = bus.get('.systemd1', systemd.LoadUnit(self.unit))
#INITIALIZATION
app = Flask(__name__)
app.config.from_object(__name__)
app.wsgi_app = DebuggedApplication(app.wsgi_app, True)
login_manager = LoginManager()
login_manager.init_app(app)
bootstrap = Bootstrap(app)
db = SQLAlchemy(app)
manager = Manager(app)
migrate = Migrate(app, db)
manager.add_command('db', MigrateCommand)
mail = Mail(app)
bus = SystemBus()
bus.timeout = -1
sysd = bus.get("org.freedesktop.systemd1")
sysd.get_unit = types.MethodType(lambda self,name: self._bus.get('.systemd1',self.LoadUnit(name)[0]), sysd)
def send_email(to, subject, template, **kwargs):
msg = Message(app.config['FLASKY_MAIL_SUBJECT_PREFIX'] + subject,
sender=app.config['FLASKY_MAIL_SENDER'], recipients=[to])
msg.body = render_template(template + '.txt', **kwargs)
msg.html = render_template(template + '.html', **kwargs)
mail.send(msg)
#DATABASE MODEL
class User(db.Model):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(10), unique=True, index=True)
role_id = db.Column(db.Integer, db.ForeignKey("roles.id"))
