PyWebWinUI3 1.0.0__py3-none-any.whl

pywebwinui3/__init__.py

@@ -0,0 +1,3 @@
+__all__ = ["core", "event", "util", "type"]
+
+__version__ = '1.0.0'

pywebwinui3/core.py

@@ -0,0 +1,176 @@
+from __future__ import annotations
+
+import inspect
+import logging
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+from .event import Event
+from .type import Status
+from .util import AccentColorWatcher, SyncDict, loadPage
+
+logger = logging.getLogger("pywebwinui3")
+
+from .qt import WebviewAPI
+
+DEFAULT_WINDOW_WIDTH = 900
+DEFAULT_WINDOW_HEIGHT = 600
+DEFAULT_WINDOW_MIN_WIDTH = 100
+DEFAULT_WINDOW_MIN_HEIGHT = 100
+ABSOLUTE_WINDOW_MIN_WIDTH = 1
+ABSOLUTE_WINDOW_MIN_HEIGHT = 1
+
+
+class WindowEvents:
+	def __init__(self) -> None:
+		self.windowReady = Event()
+		self.closed = Event()
+		self.accentColorChange = Event()
+		self.themeChange = Event()
+		self.valueChange = Event()
+
+
+class MainWindow:
+	def __init__(self, title: str, icon: str | None = None):
+		self.rootPath = Path(inspect.currentframe().f_back.f_code.co_filename).parent.resolve()
+		self.packagePath = Path(__file__).parent.resolve() / "web"
+		self._title = title
+		self._icon = icon
+
+		self.accent = AccentColorWatcher()
+		self.events = WindowEvents()
+		self.api = WebviewAPI(self, self._title, self._icon)
+
+		self.values = SyncDict(
+			{
+				"system_title": title,
+				"system_icon": icon,
+				"system_theme": "system",
+				"system_theme_resolved": self.accent.theme,
+				"system_accent": self.accent.palette,
+				"system_pages": None,
+				"system_settings": None,
+				"system_nofication": [],
+				"system_pin": False,
+				"system_window_width": 900,
+				"system_window_height": 600,
+			}
+		)
+		self.values.sync = self.api.queue_sync_value
+
+		self.events.accentColorChange = self.accent.event
+		self.events.themeChange = self.accent.theme_event
+		self.events.valueChange = self.values.event
+		self.events.accentColorChange += lambda palette: self.values.set("system_accent", palette)
+		self.events.themeChange += lambda theme: self.values.set("system_theme_resolved", theme)
+
+	def onValueChange(self, key):
+		def decorator(func):
+			self.events.valueChange += (key, func)
+			return func
+
+		return decorator
+
+	def onAccentColorChange(self):
+		def decorator(func):
+			self.events.accentColorChange += func
+			return func
+
+		return decorator
+
+	def onThemeChange(self):
+		def decorator(func):
+			self.events.themeChange += func
+			return func
+
+		return decorator
+
+	def onSetup(self):
+		def decorator(func):
+			self.events.windowReady += func
+			return func
+
+		return decorator
+
+	def onExit(self):
+		def decorator(func):
+			self.events.closed += func
+			return func
+
+		return decorator
+
+	def notice(self, level: Status, title: str, description: str, item: dict | None = None):
+		self.values["system_nofication"] = [
+			*(self.values["system_nofication"] or []),
+			[level, title, description, item],
+		]
+
+	def init(self) -> dict:
+		return dict(self.values)
+
+	def pin(self, state: bool):
+		state = bool(state)
+		self.values.set("system_pin", state, self.api is not None)
+		if self.api is not None:
+			self.api.set_on_top(state)
+		return state
+
+	def syncValue(self, key, value):
+		return self.values.set(key, value, False)
+
+	def addSettings(self, pageFile: str | Path | None = None, pageData: dict | None = None):
+		if pageFile and not pageData:
+			pageData = loadPage(pageFile)
+		logger.debug("Setting page: %s", pageData["attr"]["path"])
+		self.values["system_settings"] = pageData
+
+	def addPage(self, pageFile: str | Path | None = None, pageData: dict | None = None):
+		if pageFile and not pageData:
+			pageData = loadPage(pageFile)
+		logger.debug("Page added: %s", pageData["attr"]["path"])
+		self.values["system_pages"] = {
+			**(self.values["system_pages"] or {}),
+			pageData["attr"]["path"]: pageData,
+		}
+
+	def resolve_path(self, value: str | Path | None) -> Path | None:
+		if value is None:
+			return None
+
+		path = Path(value)
+		if path.is_absolute():
+			return path
+
+		root_candidate = self.rootPath / path
+		if root_candidate.exists():
+			return root_candidate.resolve()
+
+		package_candidate = self.packagePath / path
+		if package_candidate.exists():
+			return package_candidate.resolve()
+
+		return root_candidate.resolve()
+
+	def resolve_resource_url(self, value):
+		if not isinstance(value, (str, Path)):
+			return value
+
+		raw_value = str(value).strip()
+		if not raw_value:
+			return value
+
+		lowered = raw_value.lower()
+		if lowered.startswith(("http://", "https://", "file://", "data:", "qrc://", "qrc:", "about:")):
+			return raw_value
+
+		resolved = self.resolve_path(raw_value)
+		if resolved is None or not resolved.exists():
+			return raw_value
+
+		return resolved.as_uri()
+
+	def start(self, debug: bool = False, min_width=900, min_height=600):
+		# if self.api is not None and getattr(self.api, "_window", None) is not None:
+		self.api.set_window_minimum_size(min_width, min_height)
+		self.accent.start()
+		self.api.start(debug=debug)

pywebwinui3/event.py

@@ -0,0 +1,147 @@
+from __future__ import annotations
+
+import re
+import fnmatch
+import logging
+import traceback
+from typing import Any, Callable
+
+logger = logging.getLogger("pywebwinui3.eventmanager")
+
+class Event:
+	def __init__(self) -> None:
+		self.items: list[Callable[..., Any]] = []
+
+	def set(self, *args: Any):
+		listeners = tuple(self.items)
+		if not listeners:
+			return
+
+		for func in listeners:
+			try:
+				func(*args)
+			except Exception:
+				logger.error(traceback.format_exc())
+
+	def __add__(self, item: Callable[..., Any]):
+		self.items.append(item)
+		return self
+
+	def __sub__(self, item: Callable[..., Any]):
+		self.items.remove(item)
+		return self
+
+	def __iadd__(self, item: Callable[..., Any]):
+		self.items.append(item)
+		return self
+
+	def __isub__(self, item: Callable[..., Any]):
+		self.items.remove(item)
+		return self
+
+	def __len__(self) -> int:
+		return len(self.items)
+
+
+class PathEvent:
+	def __init__(self) -> None:
+		self.exact_items: dict[str, Event] = {}
+		self.pattern_items: dict[str, Event] = {}
+		self._compiled_patterns: dict[str, re.Pattern[str]] = {}
+		self._pattern_cache: dict[str, tuple[Event, ...]] = {}
+
+	@staticmethod
+	def _is_pattern(target: str) -> bool:
+		return any(char in target for char in "*?[]")
+
+	def _bucket(self, target: str) -> dict[str, Event]:
+		return self.pattern_items if self._is_pattern(target) else self.exact_items
+
+	def _clear_pattern_cache(self) -> None:
+		self._pattern_cache.clear()
+
+	def _compile_pattern(self, pattern: str) -> re.Pattern[str]:
+		regex = self._compiled_patterns.get(pattern)
+		if regex is None:
+			regex = re.compile(fnmatch.translate(pattern))
+			self._compiled_patterns[pattern] = regex
+		return regex
+
+	def _get_pattern_events(self, target: str) -> tuple[Event, ...]:
+		cached = self._pattern_cache.get(target)
+		if cached is not None:
+			return cached
+
+		matched_events: list[Event] = []
+		for key, event in tuple(self.pattern_items.items()):
+			try:
+				if self._compile_pattern(key).match(target):
+					matched_events.append(event)
+			except Exception:
+				logger.error(traceback.format_exc())
+
+		result = tuple(matched_events)
+		self._pattern_cache[target] = result
+		return result
+
+	def set(self, target: str, *args: Any):
+		if not self.exact_items and not self.pattern_items:
+			return
+
+		exact_event = self.exact_items.get(target)
+		if exact_event is not None:
+			try:
+				exact_event.set(target, *args)
+			except Exception:
+				logger.error(traceback.format_exc())
+
+		for event in self._get_pattern_events(target):
+			try:
+				event.set(target, *args)
+			except Exception:
+				logger.error(traceback.format_exc())
+
+	def __add__(self, item: list):
+		target, callback = item[0], item[1]
+		bucket = self._bucket(target)
+		bucket.setdefault(target, Event()).__iadd__(callback)
+
+		if self._is_pattern(target):
+			self._compiled_patterns.setdefault(target, self._compile_pattern(target))
+			self._clear_pattern_cache()
+
+		return self
+
+	def __sub__(self, item: list):
+		target, callback = item[0], item[1]
+		bucket = self._bucket(target)
+		bucket.setdefault(target, Event()).__isub__(callback)
+
+		if self._is_pattern(target):
+			self._clear_pattern_cache()
+
+		return self
+
+	def __iadd__(self, item: list):
+		target, callback = item[0], item[1]
+		bucket = self._bucket(target)
+		bucket.setdefault(target, Event()).__iadd__(callback)
+
+		if self._is_pattern(target):
+			self._compiled_patterns.setdefault(target, self._compile_pattern(target))
+			self._clear_pattern_cache()
+
+		return self
+
+	def __isub__(self, item: list):
+		target, callback = item[0], item[1]
+		bucket = self._bucket(target)
+		bucket.setdefault(target, Event()).__isub__(callback)
+
+		if self._is_pattern(target):
+			self._clear_pattern_cache()
+
+		return self
+
+	def __len__(self) -> int:
+		return len(self.exact_items) + len(self.pattern_items)