chore(initial):

This commit is contained in:
sankalp committed 2025-05-11 12:17:00 +05:45
1 parent b0b8c19562
commit 7f956a59b7
42 files changed
+21627

No files matched your search

+9
View File
@@ -0,0 +1,9 @@
from fabric.audio import Audio
from .brightness import Brightness
from .network import NetworkClient
from .battery import *
network_client = NetworkClient()
brightness = Brightness()
audio = Audio()
+112
View File
@@ -0,0 +1,112 @@
from fabric.core import Service, Property, Signal
from pydbus import SystemBus
from loguru import logger
DeviceState = {
0: "UNKNOWN",
1: "CHARGING",
2: "DISCHARGING",
3: "EMPTY",
4: "FULLY_CHARGED",
5: "PENDING_CHARGE",
6: "PENDING_DISCHARGE",
}
class Battery(Service):
@staticmethod
def seconds_to_hours_minutes(seconds):
hours = seconds // 3600
minutes = (seconds % 3600) // 60
return f"{hours}h {minutes}m" if hours else f"{minutes}m"
@Signal
def changed(self) -> None: ...
@Signal
def profile_changed(self, value: str) -> None: ...
@Property(int, "readable")
def percentage(self):
return int(self._battery.Percentage)
@Property(str, "readable")
def temperature(self):
return f"{self._battery.Temperature}°C" if hasattr(self._battery, "Temperature") else "N/A"
@Property(str, "readable")
def time_to_empty(self):
return self.seconds_to_hours_minutes(getattr(self._battery, "TimeToEmpty", 0))
@Property(str, "readable")
def time_to_full(self):
return self.seconds_to_hours_minutes(getattr(self._battery, "TimeToFull", 0))
@Property(str, "readable")
def icon_name(self):
return self._battery.IconName
@Property(str, "readable")
def state(self):
return DeviceState.get(self._battery.State, "UNKNOWN")
@Property(str, "readable")
def capacity(self):
return f"{self._battery.Capacity}%"
@Property(bool, "readable", default_value=False)
def is_present(self):
return self._battery.IsPresent
@Property(str, "readable")
def power_profile(self):
return self._profile_proxy.ActiveProfile
def set_power_profile(self, profile: str) -> bool:
if profile not in [p.Profile for p in self._profile_proxy.Profiles]:
logger.warning(f"[Battery] Invalid profile: {profile}")
return False
try:
self._profile_proxy.ActiveProfile = profile
logger.info(f"[Battery] Power profile set to {profile}")
self.profile_changed.emit(profile)
self.changed.emit()
return True
except Exception as e:
logger.error(f"[Battery] Failed to set profile: {e}")
return False
def __init__(self):
super().__init__()
self._bus = SystemBus()
# Battery device
try:
self._battery = self._bus.get("org.freedesktop.UPower", "/org/freedesktop/UPower/devices/battery_BAT0")
self._battery.onPropertiesChanged = self.handle_battery_change
logger.info("[Battery] UPower device connected.")
except Exception as e:
logger.error(f"[Battery] Failed to connect to UPower battery: {e}")
return
# PowerProfiles
try:
self._profile_proxy = self._bus.get("net.hadess.PowerProfiles", "/net/hadess/PowerProfiles")
self._profile_proxy.onPropertiesChanged = self.handle_profile_change
logger.info("[Battery] PowerProfiles daemon connected.")
except Exception as e:
logger.error(f"[Battery] Failed to connect to PowerProfiles daemon: {e}")
self._profile_proxy = None
self.changed.emit()
def handle_battery_change(self, iface, changed, invalidated):
logger.debug(f"[Battery] UPower properties changed: {changed}")
self.changed.emit()
def handle_profile_change(self, iface, changed, invalidated):
if "ActiveProfile" in changed:
new_profile = changed["ActiveProfile"]
logger.info(f"[Battery] Power profile changed: {new_profile}")
self.profile_changed.emit(new_profile)
self.changed.emit()
+81
View File
@@ -0,0 +1,81 @@
import os
from loguru import logger
from fabric.core import Service, Property, Signal
from fabric.utils import exec_shell_command_async, monitor_file
class Brightness(Service):
@Signal
def changed(self) -> None: ...
@Property(int, "readable")
def max_brightness(self):
if self._cached_max_brightness is not None:
return self._cached_max_brightness
try:
with open(self._max_brightness_path) as f:
self._cached_max_brightness = int(f.read().strip())
return self._cached_max_brightness
except Exception as e:
logger.error(f"[Brightness] Failed to read max brightness: {e}")
return -1
@Property(int, "read-write")
def brightness(self):
try:
with open(self._brightness_path) as f:
return int(f.read().strip())
except Exception as e:
logger.error(f"[Brightness] Failed to read current brightness: {e}")
return -1
@brightness.setter
def brightness(self, value: int):
max_brightness = self.max_brightness
if max_brightness <= 0:
logger.error("[Brightness] Invalid max brightness; cannot set brightness.")
return
value = max(0, min(value, max_brightness))
try:
exec_shell_command_async(
f"brightnessctl --device '{self._device}' set {value}"
)
logger.info(f"[Brightness] Set screen brightness to {value}")
except Exception as e:
logger.exception(f"[Brightness] Failed to set brightness: {e}")
@Property(int, "readable")
def brightness_percentage(self):
max_brightness = self.max_brightness
current_brightness = self.brightness
if max_brightness <= 0:
return 0
return int((current_brightness / max_brightness) * 100)
def __init__(self):
super().__init__()
self._device = None
self._cached_max_brightness = None
self._backlight_path = "/sys/class/backlight"
try:
devices = os.listdir(self._backlight_path)
if devices:
self._device = devices[0]
else:
raise FileNotFoundError
except FileNotFoundError:
logger.error("[Brightness] No backlight device found; brightness control disabled.")
return
self._brightness_path = f"{self._backlight_path}/{self._device}/brightness"
self._max_brightness_path = f"{self._backlight_path}/{self._device}/max_brightness"
try:
self._screen_monitor = monitor_file(self._brightness_path)
self._screen_monitor.connect("changed", lambda *args: self.changed.emit())
except Exception as e:
logger.error(f"[Brightness] Failed to monitor brightness file: {e}")
+334
View File
@@ -0,0 +1,334 @@
from typing import Any, List, Literal
import gi
from fabric.core.service import Property, Service, Signal
from fabric.utils import bulk_connect, exec_shell_command_async
from gi.repository import Gio
from loguru import logger
try:
gi.require_version("NM", "1.0")
from gi.repository import NM
except ValueError:
logger.error("Failed to start network manager")
class Wifi(Service):
"""A service to manage wifi devices"""
@Signal
def changed(self) -> None: ...
@Signal
def enabled(self) -> bool: ...
@Signal
def scanning(self, is_scanning: bool) -> None: ...
def __init__(self, client: NM.Client, device: NM.DeviceWifi, **kwargs):
self._client: NM.Client = client
self._device: NM.DeviceWifi = device
self._ap: NM.AccessPoint | None = None
self._ap_signal: int | None = None
super().__init__(**kwargs)
self._client.connect(
"notify::wireless-enabled",
lambda *args: self.notifier("enabled", args),
)
if self._device:
bulk_connect(
self._device,
{
"notify::active-access-point": lambda *args: self._activate_ap(),
"access-point-added": lambda *args: self.emit("changed"),
"access-point-removed": lambda *args: self.emit("changed"),
"state-changed": lambda *args: self.ap_update(),
},
)
self._activate_ap()
def ap_update(self):
self.emit("changed")
for sn in [
"enabled",
"internet",
"strength",
"frequency",
"access-points",
"ssid",
"state",
"icon-name",
]:
self.notify(sn)
def _activate_ap(self):
if self._ap:
self._ap.disconnect(self._ap_signal)
self._ap = self._device.get_active_access_point()
if not self._ap:
return
self._ap_signal = self._ap.connect(
"notify::strength", lambda *args: self.ap_update()
) # type: ignore
def toggle_wifi(self):
self._client.wireless_set_enabled(not self._client.wireless_get_enabled())
# def set_active_ap(self, ap):
# self._device.access
def scan(self):
"""Start scanning for WiFi networks and emit scanning signal"""
if self._device:
self.emit("scanning", True) # Emit signal that scanning has started
self._device.request_scan_async(
None,
lambda device, result: [
device.request_scan_finish(result),
self.emit(
"scanning", False
), # Emit signal that scanning has stopped
],
)
def notifier(self, name: str, *args):
self.notify(name)
self.emit("changed")
return
@Property(bool, "read-write", default_value=False)
def enabled(self) -> bool: # type: ignore
return bool(self._client.wireless_get_enabled())
@enabled.setter
def enabled(self, value: bool):
self._client.wireless_set_enabled(value)
@Property(int, "readable")
def strength(self):
return self._ap.get_strength() if self._ap else -1
@Property(str, "readable")
def icon_name(self):
if not self._ap:
return "network-wireless-disabled-symbolic"
if self.internet == "activated":
return {
80: "network-wireless-signal-excellent-symbolic",
60: "network-wireless-signal-good-symbolic",
40: "network-wireless-signal-ok-symbolic",
20: "network-wireless-signal-weak-symbolic",
00: "network-wireless-signal-none-symbolic",
}.get(
min(80, 20 * round(self._ap.get_strength() / 20)),
"network-wireless-no-route-symbolic",
)
if self.internet == "activating":
return "network-wireless-acquiring-symbolic"
return "network-wireless-offline-symbolic"
@Property(int, "readable")
def frequency(self):
return self._ap.get_frequency() if self._ap else -1
@Property(int, "readable")
def internet(self):
return {
NM.ActiveConnectionState.ACTIVATED: "activated",
NM.ActiveConnectionState.ACTIVATING: "activating",
NM.ActiveConnectionState.DEACTIVATING: "deactivating",
NM.ActiveConnectionState.DEACTIVATED: "deactivated",
}.get(
self._device.get_active_connection().get_state(),
"unknown",
)
@Property(object, "readable")
def access_points(self) -> List[object]:
points: list[NM.AccessPoint] = self._device.get_access_points()
def make_ap_dict(ap: NM.AccessPoint):
return {
"bssid": ap.get_bssid(),
# "address": ap.get_
"last_seen": ap.get_last_seen(),
"ssid": NM.utils_ssid_to_utf8(ap.get_ssid().get_data())
if ap.get_ssid()
else "Unknown",
"active-ap": self._ap,
"strength": ap.get_strength(),
"frequency": ap.get_frequency(),
"icon-name": {
80: "network-wireless-signal-excellent-symbolic",
60: "network-wireless-signal-good-symbolic",
40: "network-wireless-signal-ok-symbolic",
20: "network-wireless-signal-weak-symbolic",
00: "network-wireless-signal-none-symbolic",
}.get(
min(80, 20 * round(ap.get_strength() / 20)),
"network-wireless-no-route-symbolic",
),
}
return list(map(make_ap_dict, points))
@Property(str, "readable")
def ssid(self):
if not self._ap:
return "Disconnected"
ssid = self._ap.get_ssid().get_data()
return NM.utils_ssid_to_utf8(ssid) if ssid else "Unknown"
@Property(int, "readable")
def state(self):
return {
NM.DeviceState.UNMANAGED: "unmanaged",
NM.DeviceState.UNAVAILABLE: "unavailable",
NM.DeviceState.DISCONNECTED: "disconnected",
NM.DeviceState.PREPARE: "prepare",
NM.DeviceState.CONFIG: "config",
NM.DeviceState.NEED_AUTH: "need_auth",
NM.DeviceState.IP_CONFIG: "ip_config",
NM.DeviceState.IP_CHECK: "ip_check",
NM.DeviceState.SECONDARIES: "secondaries",
NM.DeviceState.ACTIVATED: "activated",
NM.DeviceState.DEACTIVATING: "deactivating",
NM.DeviceState.FAILED: "failed",
}.get(self._device.get_state(), "unknown")
class Ethernet(Service):
"""A service to manage ethernet devices"""
@Signal
def changed(self) -> None: ...
@Signal
def enabled(self) -> bool: ...
@Property(int, "readable")
def speed(self) -> int:
return self._device.get_speed()
@Property(str, "readable")
def internet(self) -> str:
return {
NM.ActiveConnectionState.ACTIVATED: "activated",
NM.ActiveConnectionState.ACTIVATING: "activating",
NM.ActiveConnectionState.DEACTIVATING: "deactivating",
NM.ActiveConnectionState.DEACTIVATED: "deactivated",
}.get(
self._device.get_active_connection().get_state(),
"disconnected",
)
@Property(str, "readable")
def icon_name(self) -> str:
network = self.internet
if network == "activated":
return "network-wired-symbolic"
elif network == "activating":
return "network-wired-acquiring-symbolic"
elif self._device.get_connectivity != NM.ConnectivityState.FULL:
return "network-wired-no-route-symbolic"
return "network-wired-disconnected-symbolic"
def __init__(self, client: NM.Client, device: NM.DeviceEthernet, **kwargs) -> None:
super().__init__(**kwargs)
self._client: NM.Client = client
self._device: NM.DeviceEthernet = device
for names in (
"active-connection",
"icon-name",
"internet",
"speed",
"state",
):
self._device.connect(f"notify::{names}", lambda *_: self.notifier(names))
self._device.connect("notify::speed", lambda *_: print(_))
def notifier(self, names):
self.notify(names)
self.emit("changed")
class NetworkClient(Service):
"""A service to manage network devices"""
@Signal
def device_ready(self) -> None: ...
def __init__(self, **kwargs):
self._client: NM.Client | None = None
self.wifi_device: Wifi | None = None
self.ethernet_device: Ethernet | None = None
super().__init__(**kwargs)
NM.Client.new_async(
cancellable=None,
callback=self._init_network_client,
**kwargs,
)
def _init_network_client(self, client: NM.Client, task: Gio.Task, **kwargs):
self._client = client
wifi_device: NM.DeviceWifi | None = self._get_device(NM.DeviceType.WIFI) # type: ignore
ethernet_device: NM.DeviceEthernet | None = self._get_device(
NM.DeviceType.ETHERNET
)
if wifi_device:
self.wifi_device = Wifi(self._client, wifi_device)
self.emit("device-ready")
if ethernet_device:
self.ethernet_device = Ethernet(client=self._client, device=ethernet_device)
self.emit("device-ready")
self.notify("primary-device")
def _get_device(self, device_type) -> Any:
devices: List[NM.Device] = self._client.get_devices() # type: ignore
return next(
(
x
for x in devices
if x.get_device_type() == device_type
and x.get_active_connection() is not None
),
None,
)
def _get_primary_device(self) -> Literal["wifi", "wired"] | None:
if not self._client:
return None
if self._client.get_primary_connection() is None:
return "wifi"
return (
"wifi"
if "wireless"
in str(self._client.get_primary_connection().get_connection_type())
else "wired"
if "ethernet"
in str(self._client.get_primary_connection().get_connection_type())
else None
)
def connect_wifi_bssid(self, bssid):
# We are using nmcli here, idk im lazy
exec_shell_command_async(
f"nmcli device wifi connect {bssid}", lambda *args: print(args)
)
@Property(str, "readable")
def primary_device(self) -> Literal["wifi", "wired"] | None:
return self._get_primary_device()