Python-FastUI-Widgets 1.0.0__py3-none-any.whl

fastuiwidgets/common/color.py

@@ -0,0 +1,95 @@
+# coding: utf-8
+from enum import Enum
+
+from PySide6.QtGui import QColor
+
+from .style_sheet import themeColor, Theme, isDarkTheme
+from .config import isDarkThemeMode
+
+
+class FluentThemeColor(Enum):
+    """ Fluent theme color
+
+    Refer to: https://www.figma.com/file/iM7EPX8Jn37zjeSezb43cF
+    """
+    YELLOW_GOLD = "#FFB900"
+    GOLD = "#FF8C00"
+    ORANGE_BRIGHT = "#F7630C"
+    ORANGE_DARK = "#CA5010"
+    RUST = "#DA3B01"
+    PALE_RUST = "#EF6950"
+    BRICK_RED = "#D13438"
+    MOD_RED = "#FF4343"
+    PALE_RED = "#E74856"
+    RED = "#E81123"
+    ROSE_BRIGHT = "#EA005E"
+    ROSE = "#C30052"
+    PLUM_LIGHT = "#E3008C"
+    PLUM = "#BF0077"
+    ORCHID_LIGHT = "#BF0077"
+    ORCHID = "#9A0089"
+    DEFAULT_BLUE = "#0078D7"
+    NAVY_BLUE = "#0063B1"
+    PURPLE_SHADOW = "#8E8CD8"
+    PURPLE_SHADOW_DARK = "#6B69D6"
+    IRIS_PASTEL = "#8764B8"
+    IRIS_SPRING = "#744DA9"
+    VIOLET_RED_LIGHT = "#B146C2"
+    VIOLET_RED = "#881798"
+    COOL_BLUE_BRIGHT = "#0099BC"
+    COOL_BLUR = "#2D7D9A"
+    SEAFOAM = "#00B7C3"
+    SEAFOAM_TEAL = "#038387"
+    MINT_LIGHT = "#00B294"
+    MINT_DARK = "#018574"
+    TURF_GREEN = "#00CC6A"
+    SPORT_GREEN = "#10893E"
+    GRAY = "#7A7574"
+    GRAY_BROWN = "#5D5A58"
+    STEAL_BLUE = "#68768A"
+    METAL_BLUE = "#515C6B"
+    PALE_MOSS = "#567C73"
+    MOSS = "#486860"
+    MEADOW_GREEN = "#498205"
+    GREEN = "#107C10"
+    OVERCAST = "#767676"
+    STORM = "#4C4A48"
+    BLUE_GRAY = "#69797E"
+    GRAY_DARK = "#4A5459"
+    LIDDY_GREEN = "#647C64"
+    SAGE = "#525E54"
+    CAMOUFLAGE_DESERT = "#847545"
+    CAMOUFLAGE = "#7E735F"
+
+    def color(self):
+        return QColor(self.value)
+
+
+
+class FluentSystemColor(Enum):
+
+    SUCCESS_FOREGROUND = ("#0f7b0f", "#6ccb5f")
+    CAUTION_FOREGROUND = ("#9d5d00", "#fce100")
+    CRITICAL_FOREGROUND = ("#c42b1c", "#ff99a4")
+
+    SUCCESS_BACKGROUND = ("#dff6dd", "#393d1b")
+    CAUTION_BACKGROUND = ("#fff4ce", "#433519")
+    CRITICAL_BACKGROUND = ("#fde7e9", "#442726")
+
+    def color(self, theme=Theme.AUTO) -> QColor:
+        color = self.value[1] if isDarkThemeMode(theme) else self.value[0]
+        return QColor(color)
+
+
+
+def validColor(color: QColor, default: QColor) -> QColor:
+    return color if color.isValid() else default
+
+
+def fallbackThemeColor(color: QColor):
+    return color if color.isValid() else themeColor()
+
+
+def autoFallbackThemeColor(light: QColor, dark: QColor):
+    color = dark if isDarkTheme() else light
+    return fallbackThemeColor(color)

fastuiwidgets/common/config.py

@@ -0,0 +1,423 @@
+# coding:utf-8
+import json
+from copy import deepcopy
+from enum import Enum
+from pathlib import Path
+from typing import List
+
+import darkdetect
+from PySide6.QtCore import QObject, Signal
+from PySide6.QtGui import QColor
+
+from .exception_handler import exceptionHandler
+
+
+ALERT = "\n\033[1;33m📢 Tips:\033[0m QFluentWidgets Pro is now released. Click \033[1;96mhttps://fastuiwidgets.com/pages/pro\033[0m to learn more about it.\n"
+
+
+class Theme(Enum):
+    """ Theme enumeration """
+
+    LIGHT = "Light"
+    DARK = "Dark"
+    AUTO = "Auto"
+
+
+class ConfigValidator:
+    """ Config validator """
+
+    def validate(self, value):
+        """ Verify whether the value is legal """
+        return True
+
+    def correct(self, value):
+        """ correct illegal value """
+        return value
+
+
+class RangeValidator(ConfigValidator):
+    """ Range validator """
+
+    def __init__(self, min, max):
+        self.min = min
+        self.max = max
+        self.range = (min, max)
+
+    def validate(self, value):
+        return self.min <= value <= self.max
+
+    def correct(self, value):
+        return min(max(self.min, value), self.max)
+
+
+class OptionsValidator(ConfigValidator):
+    """ Options validator """
+
+    def __init__(self, options):
+        if not options:
+            raise ValueError("The `options` can't be empty.")
+
+        if isinstance(options, Enum):
+            options = options._member_map_.values()
+
+        self.options = list(options)
+
+    def validate(self, value):
+        return value in self.options
+
+    def correct(self, value):
+        return value if self.validate(value) else self.options[0]
+
+
+class BoolValidator(OptionsValidator):
+    """ Boolean validator """
+
+    def __init__(self):
+        super().__init__([True, False])
+
+
+class FolderValidator(ConfigValidator):
+    """ Folder validator """
+
+    def validate(self, value):
+        return Path(value).exists()
+
+    def correct(self, value):
+        path = Path(value)
+        path.mkdir(exist_ok=True, parents=True)
+        return str(path.absolute()).replace("\\", "/")
+
+
+class FolderListValidator(ConfigValidator):
+    """ Folder list validator """
+
+    def validate(self, value):
+        return all(Path(i).exists() for i in value)
+
+    def correct(self, value: List[str]):
+        folders = []
+        for folder in value:
+            path = Path(folder)
+            if path.exists():
+                folders.append(str(path.absolute()).replace("\\", "/"))
+
+        return folders
+
+
+class ColorValidator(ConfigValidator):
+    """ RGB color validator """
+
+    def __init__(self, default):
+        self.default = QColor(default)
+
+    def validate(self, color):
+        try:
+            return QColor(color).isValid()
+        except:
+            return False
+
+    def correct(self, value):
+        return QColor(value) if self.validate(value) else self.default
+
+
+class ConfigSerializer:
+    """ Config serializer """
+
+    def serialize(self, value):
+        """ serialize config value """
+        return value
+
+    def deserialize(self, value):
+        """ deserialize config from config file's value """
+        return value
+
+
+class EnumSerializer(ConfigSerializer):
+    """ enumeration class serializer """
+
+    def __init__(self, enumClass):
+        self.enumClass = enumClass
+
+    def serialize(self, value):
+        return value.value
+
+    def deserialize(self, value):
+        return self.enumClass(value)
+
+
+class ColorSerializer(ConfigSerializer):
+    """ QColor serializer """
+
+    def serialize(self, value: QColor):
+        return value.name(QColor.HexArgb)
+
+    def deserialize(self, value):
+        if isinstance(value, list):
+            return QColor(*value)
+
+        return QColor(value)
+
+
+class ConfigItem(QObject):
+    """ Config item """
+
+    valueChanged = Signal(object)
+
+    def __init__(self, group, name, default, validator=None, serializer=None, restart=False):
+        """
+        Parameters
+        ----------
+        group: str
+            config group name
+
+        name: str
+            config item name, can be empty
+
+        default:
+            default value
+
+        options: list
+            options value
+
+        serializer: ConfigSerializer
+            config serializer
+
+        restart: bool
+            whether to restart the application after updating value
+        """
+        super().__init__()
+        self.group = group
+        self.name = name
+        self.validator = validator or ConfigValidator()
+        self.serializer = serializer or ConfigSerializer()
+        self.__value = default
+        self.value = default
+        self.restart = restart
+        self.defaultValue = self.validator.correct(default)
+
+    @property
+    def value(self):
+        """ get the value of config item """
+        return self.__value
+
+    @value.setter
+    def value(self, v):
+        v = self.validator.correct(v)
+        ov = self.__value
+        self.__value = v
+        if ov != v:
+            self.valueChanged.emit(v)
+
+    @property
+    def key(self):
+        """ get the config key separated by `.` """
+        return self.group+"."+self.name if self.name else self.group
+
+    def __str__(self):
+        return f'{self.__class__.__name__}[value={self.value}]'
+
+    def serialize(self):
+        return self.serializer.serialize(self.value)
+
+    def deserializeFrom(self, value):
+        self.value = self.serializer.deserialize(value)
+
+
+class RangeConfigItem(ConfigItem):
+    """ Config item of range """
+
+    @property
+    def range(self):
+        """ get the available range of config """
+        return self.validator.range
+
+    def __str__(self):
+        return f'{self.__class__.__name__}[range={self.range}, value={self.value}]'
+
+
+class OptionsConfigItem(ConfigItem):
+    """ Config item with options """
+
+    @property
+    def options(self):
+        return self.validator.options
+
+    def __str__(self):
+        return f'{self.__class__.__name__}[options={self.options}, value={self.value}]'
+
+
+class ColorConfigItem(ConfigItem):
+    """ Color config item """
+
+    def __init__(self, group, name, default, restart=False):
+        super().__init__(group, name, QColor(default), ColorValidator(default),
+                         ColorSerializer(), restart)
+
+    def __str__(self):
+        return f'{self.__class__.__name__}[value={self.value.name()}]'
+
+
+class QConfig(QObject):
+    """ Config of app """
+
+    appRestartSig = Signal()
+    themeChanged = Signal(Theme)
+    themeChangedFinished = Signal()
+    themeColorChanged = Signal(QColor)
+
+    themeMode = OptionsConfigItem(
+        "QFluentWidgets", "ThemeMode", Theme.LIGHT, OptionsValidator(Theme), EnumSerializer(Theme))
+    themeColor = ColorConfigItem("QFluentWidgets", "ThemeColor", '#009faa')
+
+    def __init__(self):
+        super().__init__()
+        self.file = Path("config/config.json")
+        self._theme = Theme.LIGHT
+        self._cfg = self
+
+    def get(self, item):
+        """ get the value of config item """
+        return item.value
+
+    def set(self, item, value, save=True, copy=True):
+        """ set the value of config item
+
+        Parameters
+        ----------
+        item: ConfigItem
+            config item
+
+        value:
+            the new value of config item
+
+        save: bool
+            whether to save the change to config file
+
+        copy: bool
+            whether to deep copy the new value
+        """
+        if item.value == value:
+            return
+
+        # deepcopy new value
+        try:
+            item.value = deepcopy(value) if copy else value
+        except:
+            item.value = value
+
+        if save:
+            self.save()
+
+        if item.restart:
+            self._cfg.appRestartSig.emit()
+
+        if item is self._cfg.themeMode:
+            self.theme = value
+            self._cfg.themeChanged.emit(value)
+
+        if item is self._cfg.themeColor:
+            self._cfg.themeColorChanged.emit(value)
+
+    def toDict(self, serialize=True):
+        """ convert config items to `dict` """
+        items = {}
+        for name in dir(self._cfg.__class__):
+            item = getattr(self._cfg.__class__, name)
+            if not isinstance(item, ConfigItem):
+                continue
+
+            value = item.serialize() if serialize else item.value
+            if not items.get(item.group):
+                if not item.name:
+                    items[item.group] = value
+                else:
+                    items[item.group] = {}
+
+            if item.name:
+                items[item.group][item.name] = value
+
+        return items
+
+    def save(self):
+        """ save config """
+        self._cfg.file.parent.mkdir(parents=True, exist_ok=True)
+        with open(self._cfg.file, "w", encoding="utf-8") as f:
+            json.dump(self._cfg.toDict(), f, ensure_ascii=False, indent=4)
+
+    @exceptionHandler()
+    def load(self, file=None, config=None):
+        """ load config
+
+        Parameters
+        ----------
+        file: str or Path
+            the path of json config file
+
+        config: Config
+            config object to be initialized
+        """
+        if isinstance(config, QConfig):
+            self._cfg = config
+            self._cfg.themeChanged.connect(self.themeChanged)
+
+        if isinstance(file, (str, Path)):
+            self._cfg.file = Path(file)
+
+        try:
+            with open(self._cfg.file, encoding="utf-8") as f:
+                cfg = json.load(f)
+        except:
+            cfg = {}
+
+        # map config items'key to item
+        items = {}
+        for name in dir(self._cfg.__class__):
+            item = getattr(self._cfg.__class__, name)
+            if isinstance(item, ConfigItem):
+                items[item.key] = item
+
+        # update the value of config item
+        for k, v in cfg.items():
+            if not isinstance(v, dict) and items.get(k) is not None:
+                items[k].deserializeFrom(v)
+            elif isinstance(v, dict):
+                for key, value in v.items():
+                    key = k + "." + key
+                    if items.get(key) is not None:
+                        items[key].deserializeFrom(value)
+
+        self.theme = self.get(self._cfg.themeMode)
+
+    @property
+    def theme(self):
+        """ get theme mode, can be `Theme.Light` or `Theme.Dark` """
+        return self._cfg._theme
+
+    @theme.setter
+    def theme(self, t):
+        """ chaneg the theme without modifying the config file """
+        if t == Theme.AUTO:
+            t = darkdetect.theme()
+            t = Theme(t) if t else Theme.LIGHT
+
+        self._cfg._theme = t
+
+
+qconfig = QConfig()
+try:
+    print(ALERT)
+except UnicodeEncodeError:
+    print(ALERT.replace("📢", ""))
+
+
+def isDarkTheme():
+    """ whether the theme is dark mode """
+    return qconfig.theme == Theme.DARK
+
+def theme():
+    """ get theme mode """
+    return qconfig.theme
+
+def isDarkThemeMode(theme=Theme.AUTO):
+    """ whether the theme is dark mode """
+    return theme == Theme.DARK if theme != Theme.AUTO else isDarkTheme()

fastuiwidgets/common/exception_handler.py

@@ -0,0 +1,31 @@
+# coding:utf-8
+from copy import deepcopy
+
+
+
+def exceptionHandler(*default):
+    """ decorator for exception handling
+
+    Parameters
+    ----------
+    *default:
+        the default value returned when an exception occurs
+    """
+
+    def outer(func):
+
+        def inner(*args, **kwargs):
+            try:
+                return func(*args, **kwargs)
+            except BaseException as e:
+                value = deepcopy(default)
+                if len(value) == 0:
+                    return None
+                elif len(value) == 1:
+                    return value[0]
+
+                return value
+
+        return inner
+
+    return outer

fastuiwidgets/common/font.py

@@ -0,0 +1,38 @@
+# coding: utf-8
+from PySide6.QtGui import QFont
+from PySide6.QtWidgets import QWidget
+
+
+def setFont(widget: QWidget, fontSize=14, weight=QFont.Normal):
+    """ set the font of widget
+
+    Parameters
+    ----------
+    widget: QWidget
+        the widget to set font
+
+    fontSize: int
+        font pixel size
+
+    weight: `QFont.Weight`
+        font weight
+    """
+    widget.setFont(getFont(fontSize, weight))
+
+
+def getFont(fontSize=14, weight=QFont.Normal):
+    """ create font
+
+    Parameters
+    ----------
+    fontSize: int
+        font pixel size
+
+    weight: `QFont.Weight`
+        font weight
+    """
+    font = QFont()
+    font.setFamilies(['Segoe UI', 'Microsoft YaHei', 'PingFang SC'])
+    font.setPixelSize(fontSize)
+    font.setWeight(weight)
+    return font