pyloid 0.16.12__py3-none-any.whl → 0.17.0__py3-none-any.whl

pyloid/browser_window.py

@@ -36,26 +36,36 @@ if TYPE_CHECKING:
 class CustomWebPage(QWebEnginePage):
     def __init__(self, profile=None):
         super().__init__(profile)
-        # 권한 요청 시그널 연결
         self.featurePermissionRequested.connect(self._handlePermissionRequest)
+        self.desktopMediaRequested.connect(self._handleDesktopMediaRequest)
         self._permission_handlers = {}
+        self._desktop_media_handler = None
 
     def _handlePermissionRequest(self, origin: QUrl, feature: QWebEnginePage.Feature):
-        """기본 권한 요청 핸들러"""
+        print(origin, feature)
+        
+        """Default permission request handler"""
         if feature in self._permission_handlers:
-            # 등록된 핸들러가 있으면 실행
+            # Execute if a handler is registered
             handler = self._permission_handlers[feature]
             handler(origin, feature)
         else:
-            # 기본적으로 모든 권한 허용
+            # Allow all permissions by default
             self.setFeaturePermission(
                 origin, feature, QWebEnginePage.PermissionPolicy.PermissionGrantedByUser
             )
 
     def setPermissionHandler(self, feature: QWebEnginePage.Feature, handler):
-        """특정 권한에 대한 핸들러 등록"""
+        """Register a handler for a specific permission"""
         self._permission_handlers[feature] = handler
 
+    def _handleDesktopMediaRequest(self, *args, **kwargs):
+        print("Desktop media request received:", args, kwargs)
+
+    # def setDesktopMediaHandler(self, handler):
+    #     """desktop media handler"""
+    #     self._desktop_media_handler = handler
+
 
 class CustomWebEngineView(QWebEngineView):
     def __init__(self, parent: "BrowserWindow" = None):
@@ -291,6 +301,21 @@ class BrowserWindow:
         self.web_view.settings().setUnknownUrlSchemePolicy(
             QWebEngineSettings.UnknownUrlSchemePolicy.AllowAllUnknownUrlSchemes
         )
+        self.web_view.settings().setAttribute(
+            QWebEngineSettings.WebAttribute.AllowRunningInsecureContent, True
+        )
+        self.web_view.settings().setAttribute(
+            QWebEngineSettings.WebAttribute.AllowGeolocationOnInsecureOrigins, True
+        )
+        self.web_view.settings().setAttribute(
+            QWebEngineSettings.WebAttribute.AllowWindowActivationFromJavaScript, True
+        )
+        self.web_view.settings().setAttribute(
+            QWebEngineSettings.WebAttribute.JavascriptCanPaste, True
+        )
+        self.web_view.settings().setAttribute(
+            QWebEngineSettings.WebAttribute.WebRTCPublicInterfacesOnly, False
+        )
 
         # Set icon
         if self.app.icon:
@@ -1805,3 +1830,33 @@ class BrowserWindow:
             )
 
         self.set_permission_handler(feature, auto_deny)
+
+    def set_desktop_media_handler(self, handler):
+        """
+        데스크톱 미디어(화면/윈도우) 선택 핸들러를 설정합니다.
+        
+        Parameters
+        ----------
+        handler : callable
+            요청을 처리할 핸들러 함수. QWebEngineDesktopMediaRequest를 인자로 받습니다.
+            
+        Examples
+        --------
+        ```python
+        def custom_media_handler(request):
+            # 사용 가능한 화면 목록 출력
+            for screen in request.screenList():
+                print(f"Screen: {screen.name}")
+            
+            # 사용 가능한 윈도우 목록 출력
+            for window in request.windowList():
+                print(f"Window: {window.name}")
+                
+            # 첫 번째 화면 선택
+            if request.screenList():
+                request.selectScreen(request.screenList()[0])
+            
+        window.set_desktop_media_handler(custom_media_handler)
+        ```
+        """
+        self.web_view.custom_page.setDesktopMediaHandler(handler)

pyloid/js_api/window_api.py

@@ -2,6 +2,7 @@ from typing import TYPE_CHECKING, Optional
 
 from ..api import PyloidAPI, Bridge
 from PySide6.QtCore import QByteArray, QBuffer, QIODeviceBase
+import base64
 
 if TYPE_CHECKING:
     from ..pyloid import Pyloid
@@ -244,3 +245,11 @@ class WindowAPI(PyloidAPI):
             base64_data = byte_array.toBase64().data().decode()
             return f"data:image/png;base64,{base64_data}"
         return ""
+    
+    ###########################################################################################
+    # Quit
+    ###########################################################################################
+    @Bridge()
+    def quit(self):
+        """Quits the application."""
+        self.app.quit()

pyloid/pyloid.py

@@ -26,6 +26,9 @@ import logging
 from .browser_window import BrowserWindow
 from .tray import TrayEvent
 from PySide6.QtCore import QCoreApplication
+from PySide6.QtCore import QRunnable, QThreadPool, Signal, QObject
+import time
+from .thread_pool import PyloidThreadPool
 
 # for linux debug
 os.environ["QTWEBENGINE_DICTIONARIES_PATH"] = "/"
@@ -431,10 +434,16 @@ class Pyloid(QApplication):
         app.quit()
         ```
         """
+        # 먼저 스레드 풀 정리
+        thread_pool = self.get_thread_pool()
+        thread_pool.clear()  # 대기 중인 작업 제거
+        
+        # 윈도우 정리
         for window in self.windows:
             window._window.close()
             window.web_page.deleteLater()
             window.web_view.deleteLater()
+
         QApplication.quit()
 
     ###########################################################################################
@@ -1395,4 +1404,4 @@ class Pyloid(QApplication):
             window.web_view.page().runJavaScript(js_code)
             window.web_view.page().setBackgroundColor(
                 Qt.GlobalColor.black if self.theme == "dark" else Qt.GlobalColor.white
-            )
+            )

pyloid/thread_pool.py

@@ -0,0 +1,501 @@
+from PySide6.QtCore import QRunnable, QThreadPool, QDeadlineTimer, QObject, Signal
+from typing import Callable, Optional, Union
+
+class PyloidRunnable(QRunnable):
+    """
+    A runnable task class that extends QRunnable from Qt.
+    
+    Defines a unit of work that can be executed in a thread pool.
+    """
+    
+    def __init__(self):
+        """
+        Initializes a PyloidRunnable instance.
+        
+        By default, auto-delete is enabled.
+        """
+        super().__init__()
+        self.setAutoDelete(True)
+    
+    def get_auto_delete(self) -> bool:
+        """
+        Returns whether the task is automatically deleted after completion in the thread pool.
+        
+        The default value is True.
+        
+        Returns
+        -------
+        bool
+            True if the task is automatically deleted after completion, False if manual deletion is required
+            
+        Examples
+        --------
+        ```python
+        from pyloid.thread_pool import PyloidRunnable
+        import time
+        
+        class Worker(PyloidRunnable):
+            def run(self):
+                time.sleep(1)
+                print("Task executed")
+        
+        worker = Worker()
+        print(worker.get_auto_delete())
+        ```
+        """
+        return self.autoDelete()
+        
+    def set_auto_delete(self, value: bool) -> None:
+        """
+        Sets whether the task is automatically deleted after completion in the thread pool.
+        
+        Parameters
+        ----------
+        value : bool
+            True to enable auto-delete after task completion, 
+            False to require manual deletion
+            
+        Examples
+        --------
+        ```python
+        from pyloid.thread_pool import PyloidRunnable
+        import time
+        
+        class Worker(PyloidRunnable):
+            def run(self):
+                time.sleep(1)
+                print("Task executed")
+        
+        worker = Worker()
+        worker.set_auto_delete(False)
+        ```
+        """
+        self.setAutoDelete(value)
+
+    def run(self) -> None:
+        """
+        Defines the actual work to be executed in the thread pool.
+        
+        This method must be implemented in subclasses.
+        
+        Examples
+        --------
+        ```python
+        from pyloid.thread_pool import PyloidRunnable, PyloidThreadPool
+        import time
+        
+        class Worker(PyloidRunnable):
+            def run(self):
+                time.sleep(1)
+                print("Task executed")
+        
+        worker = Worker()
+        thread_pool = PyloidThreadPool()
+        thread_pool.start(worker)
+        ```
+        """
+        pass
+    
+class PyloidDefaultSignals(QObject):
+    """
+    Default signal class.
+    
+    Defines signals used for task start, completion, and error occurrence in the thread pool.
+    
+    Attributes
+    ----------
+    started : Signal
+        Signal emitted when a task starts
+    finished : Signal
+        Signal emitted when a task completes
+    error : Signal(str)
+        Signal emitted when an error occurs
+    progress : Signal(int)
+        Signal emitted when progress changes
+        
+    Examples
+    --------
+    ```python
+    from pyloid.thread_pool import PyloidRunnable, PyloidThreadPool, PyloidDefaultSignals
+    import time
+    
+    class Worker(PyloidRunnable):
+        def __init__(self):
+            super().__init__()
+            self.signals = PyloidDefaultSignals()
+
+        def run(self):
+            for i in range(101):
+                self.signals.progress.emit(i)
+                time.sleep(0.1)
+                
+    worker = Worker()
+    
+    worker.signals.finished.connect(lambda: print("Task completed."))
+    worker.signals.error.connect(lambda error: print(f"Error occurred: {error}"))
+    worker.signals.progress.connect(lambda progress: print(f"Progress: {progress}%"))
+    
+    thread_pool = PyloidThreadPool()
+    thread_pool.start(worker)
+    ```
+    """
+    started = Signal()
+    finished = Signal()
+    error = Signal(str)
+    progress = Signal(int)
+    
+
+class PyloidThreadPool:
+    def __init__(self):
+        self.thread_pool = QThreadPool.globalInstance()
+
+    def start(self, runnable: Union[PyloidRunnable, Callable], priority: int = ...) -> None:
+        """
+        Adds a task to the thread pool and executes it.
+        
+        Parameters
+        ----------
+        runnable : Union[PyloidRunnable, Callable]
+            Task to be executed
+        priority : int
+            Task priority
+        
+        Examples
+        --------
+        ```python
+        from pyloid.thread_pool import PyloidRunnable, PyloidThreadPool
+        import time
+        
+        class Worker(PyloidRunnable):
+            def run(self):
+                time.sleep(1)
+                print("Task executed")
+                
+        worker = Worker()
+        thread_pool = PyloidThreadPool()
+        thread_pool.start(worker)
+        ```
+        """
+        self.thread_pool.start(runnable, priority)
+
+    def active_thread_count(self) -> int:
+        """
+        Returns the number of currently active threads.
+        
+        Returns
+        -------
+        int
+            Number of currently active threads
+            
+        Examples
+        --------
+        ```python
+        from pyloid.thread_pool import PyloidThreadPool
+        
+        thread_pool = PyloidThreadPool()
+        print(thread_pool.active_thread_count())
+        ```
+        """
+        return self.thread_pool.activeThreadCount()
+    
+    def max_thread_count(self) -> int:
+        """
+        Returns the maximum number of threads that can run simultaneously in the thread pool.
+        
+        Returns
+        -------
+        int
+            Maximum number of threads
+            
+        Examples
+        --------
+        ```python
+        from pyloid.thread_pool import PyloidThreadPool
+        
+        thread_pool = PyloidThreadPool()
+        print(thread_pool.max_thread_count())
+        ```
+        """
+        return self.thread_pool.maxThreadCount()
+
+    def set_max_thread_count(self, max_thread_count: int) -> None:
+        """
+        Sets the maximum number of threads that can run simultaneously in the thread pool.
+        
+        Parameters
+        ----------
+        max_thread_count : int
+            Maximum number of threads
+        
+        Examples
+        --------
+        ```python
+        from pyloid.thread_pool import PyloidThreadPool
+        
+        thread_pool = PyloidThreadPool()
+        thread_pool.set_max_thread_count(10)
+        ```
+        """
+        self.thread_pool.setMaxThreadCount(max_thread_count)
+
+    def reserve_thread(self) -> None:
+        """
+        Reserves a thread in the thread pool.
+        
+        Examples
+        --------
+        ```python
+        from pyloid.thread_pool import PyloidThreadPool, PyloidRunnable
+        import time
+
+        class Worker(PyloidRunnable):
+            def run(self):
+                time.sleep(1)
+                print("Task executed on reserved thread")
+
+        # Create thread pool
+        thread_pool = PyloidThreadPool()
+
+        # Reserve thread
+        thread_pool.reserve_thread()
+
+        try:
+            # Execute task on reserved thread
+            worker = Worker()
+            thread_pool.start_on_reserved_thread(worker)
+            
+            # Wait for task completion
+            thread_pool.wait_for_done()
+        finally:
+            # Important: Reserved threads must be released
+            thread_pool.release_thread()
+        ```
+        """
+        self.thread_pool.reserveThread()
+
+    def release_thread(self) -> None:
+        """
+        Releases a reserved thread in the thread pool.
+        
+        Examples
+        --------
+        ```python
+        from pyloid.thread_pool import PyloidThreadPool
+        
+        thread_pool = PyloidThreadPool()
+        thread_pool.release_thread()
+        ```
+        """
+        self.thread_pool.releaseThread()
+
+    def clear(self) -> None:
+        """
+        Removes all pending tasks from the thread pool.
+        
+        Examples
+        --------
+        ```python
+        from pyloid.thread_pool import PyloidThreadPool
+        
+        thread_pool = PyloidThreadPool()
+        thread_pool.clear()
+        ```
+        """
+        self.thread_pool.clear()
+
+    # def contains(self, thread: QThread) -> bool:
+    #     return self.thread_pool.contains(thread)
+
+    def get_expiry_timeout(self) -> int:
+        """
+        Returns the thread expiry timeout in the thread pool.
+        
+        Returns
+        -------
+        int
+            Thread expiry timeout
+            
+        Examples
+        --------
+        ```python
+        from pyloid.thread_pool import PyloidThreadPool
+        
+        thread_pool = PyloidThreadPool()
+        print(thread_pool.get_expiry_timeout())
+        ```
+        """
+        return self.thread_pool.expiryTimeout()
+
+    def set_expiry_timeout(self, expiry_timeout: int) -> None:
+        """
+        Sets the thread expiry timeout in the thread pool.
+        
+        Parameters
+        ----------
+        expiry_timeout : int
+            Thread expiry timeout
+            
+        Examples
+        --------
+        ```python
+        from pyloid.thread_pool import PyloidThreadPool
+        
+        thread_pool = PyloidThreadPool()
+        thread_pool.set_expiry_timeout(1000)
+        ```
+        """
+        self.thread_pool.setExpiryTimeout(expiry_timeout)
+
+    # def set_stack_size(self, stack_size: int) -> None:
+    #     self.thread_pool.setStackSize(stack_size)
+
+    # def stack_size(self) -> int:
+    #     return self.thread_pool.stackSize()
+
+    # def set_thread_priority(self, priority: QThread.Priority) -> None:
+    #     self.thread_pool.setThreadPriority(priority)
+
+    # def thread_priority(self) -> QThread.Priority:
+    #     return self.thread_pool.threadPriority()
+
+    def start_on_reserved_thread(self, runnable: QRunnable) -> None:
+        """
+        Executes a task on a reserved thread.
+        
+        Parameters
+        ----------
+        runnable : QRunnable
+            Task to be executed
+            
+        Examples
+        --------
+        ```python
+        from pyloid.thread_pool import PyloidThreadPool, PyloidRunnable
+        import time
+
+        class Worker(PyloidRunnable):
+            def run(self):
+                time.sleep(1)
+                print("Task executed on reserved thread")
+                
+        worker = Worker()
+        thread_pool = PyloidThreadPool()
+        thread_pool.reserve_thread()
+        thread_pool.start_on_reserved_thread(worker)
+        thread_pool.wait_for_done()
+        thread_pool.release_thread()
+        ```
+        """
+        self.thread_pool.startOnReservedThread(runnable)
+
+    def try_start(self, runnable: Union[QRunnable, Callable]) -> bool:
+        """
+        Adds a new task to the thread pool and attempts to execute it immediately.
+        
+        Only executes the task if the thread pool has available capacity.
+        Operates in a non-blocking manner and does not start the task if the thread pool is full.
+        
+        Parameters
+        ----------
+        runnable : Union[QRunnable, Callable]
+            Task to be executed
+            
+        Returns
+        -------
+        bool
+            True: Task successfully started
+            False: Task could not be started because the thread pool is full
+            
+        Examples
+        --------
+        ```python
+        from pyloid.thread_pool import PyloidThreadPool, PyloidRunnable
+        
+        class Worker(PyloidRunnable):
+            def run(self):
+                print("Task executed")
+                
+        thread_pool = PyloidThreadPool()
+        worker = Worker()
+        
+        if thread_pool.try_start(worker):
+            print("Task started")
+        else:
+            print("Task could not be started because the thread pool is full")
+        ```
+        """
+        return self.thread_pool.tryStart(runnable)
+
+    def try_take(self, runnable: QRunnable) -> bool:
+        """
+        Attempts to remove a specific task from the thread pool queue.
+        
+        Only removes tasks that have not yet been executed. Tasks that are already running cannot be removed.
+        Used when task cancellation is needed.
+        
+        Parameters
+        ----------
+        runnable : QRunnable
+            Task to be removed from the queue
+            
+        Returns
+        -------
+        bool
+            True: Task successfully removed from the queue
+            False: Task could not be removed (already running or not found)
+            
+        Examples
+        --------
+        ```python
+        from pyloid.thread_pool import PyloidThreadPool, PyloidRunnable
+        
+        class Worker(PyloidRunnable):
+            def run(self):
+                print("Task executed")
+                
+        thread_pool = PyloidThreadPool()
+        worker = Worker()
+        
+        # Add task
+        thread_pool.start(worker)
+        
+        # Attempt to remove task
+        if thread_pool.try_take(worker):
+            print("Task removed from queue")
+        else:
+            print("Task could not be removed (already running or not found)")
+        ```
+        """
+        return self.thread_pool.tryTake(runnable)
+
+    def wait_for_done(self, timeout: Optional[int] = None) -> bool:
+        """
+        Waits for tasks to complete.
+        
+        If no timeout is specified, waits indefinitely until completion.
+        
+        Parameters
+        ----------
+        timeout : Optional[int]
+            Wait time
+            
+        Returns
+        -------
+        bool
+            True if tasks completed, False otherwise
+            
+        Examples
+        --------
+        ```python
+        from pyloid.thread_pool import PyloidThreadPool
+        
+        thread_pool = PyloidThreadPool()
+        thread_pool.wait_for_done()
+        
+        print("Tasks completed.")
+        ```
+        """
+        if timeout is None:
+            return self.thread_pool.waitForDone(-1)
+        else:
+            return self.thread_pool.waitForDone(timeout)

{pyloid-0.16.12.dist-info → pyloid-0.17.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pyloid
-Version: 0.16.12
+Version: 0.17.0
 Summary: 
 Author: aesthetics-of-record
 Author-email: 111675679+aesthetics-of-record@users.noreply.github.com
@@ -10,8 +10,7 @@ Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
-Requires-Dist: mss (>=9.0.2,<10.0.0)
-Requires-Dist: pyside6 (>=6.7.3,<7.0.0)
+Requires-Dist: pyside6 (>=6.8.0.2,<7.0.0.0)
 Description-Content-Type: text/markdown
 
 # Pyloid 👋

{pyloid-0.16.12.dist-info → pyloid-0.17.0.dist-info}/RECORD

@@ -1,17 +1,18 @@
 pyloid/__init__.py,sha256=OOPhOKNQVmAM8hnfTeE7lHzxb8LsFNcgegBAvDrA-vY,293
 pyloid/api.py,sha256=np0pFVUlen_GpN0svY0A3awY_ZjVFk-RpHQZZKFUMuo,2157
 pyloid/autostart.py,sha256=K7DQYl4LHItvPp0bt1V9WwaaZmVSTeGvadkcwG-KKrI,3899
-pyloid/browser_window.py,sha256=xSf1tR1kazAIpqbrTEx0YgcMXqcHOzPpmdzU3agTqw0,58691
+pyloid/browser_window.py,sha256=YoScOpHQjxZBGZsYZ_TrDjyoyvwhBsc74ySVNzw5g1g,60873
 pyloid/custom/titlebar.py,sha256=itzK9pJbZMQ7BKca9kdbuHMffurrw15UijR6OU03Xsk,3894
 pyloid/filewatcher.py,sha256=3M5zWVUf1OhlkWJcDFC8ZA9agO4Q-U8WdgGpy6kaVz0,4601
 pyloid/js_api/event_api.py,sha256=_52yyBonqecmMvJpFW7OMNi_jX8Nrteqw_kI6r-DGG0,951
-pyloid/js_api/window_api.py,sha256=_EAZ0GG0oa0EeIIyWnys03InLQuQfv4ZPezMouOJEGc,8155
+pyloid/js_api/window_api.py,sha256=QutXXAOZkpYmytOYSenpzVSCl15-OFEjDDr75fHfLvk,8481
 pyloid/monitor.py,sha256=1mXvHm5deohnNlTLcRx4sT4x-stnOIb0dUQnnxN50Uo,28295
-pyloid/pyloid.py,sha256=ar-3yP8IqB6HCWwuxJmjJZ9kekn7LhHqnNOTH-qhxpM,43925
+pyloid/pyloid.py,sha256=klY6-O7rEZZYfhayq9RTwvO9f8KCXWxIo7G8BDFy2hg,44236
+pyloid/thread_pool.py,sha256=fKOBb8jMfZn_7crA_fJCno8dObBRZE31EIWaNQ759aw,14616
 pyloid/timer.py,sha256=RqMsChFUd93cxMVgkHWiIKrci0QDTBgJSTULnAtYT8M,8712
 pyloid/tray.py,sha256=D12opVEc2wc2T4tK9epaN1oOdeziScsIVNM2uCN7C-A,1710
 pyloid/utils.py,sha256=VGZE2liY8_AElEqxVe1YLbk3fWlcAevpRc6oOTTgi-U,1927
-pyloid-0.16.12.dist-info/LICENSE,sha256=F96EzotgWhhpnQTW2TcdoqrMDir1jyEo6H915tGQ-QE,11524
-pyloid-0.16.12.dist-info/METADATA,sha256=V0I3qXPqcx0dSLUOO0_03tgqO4wn6UBZwDl5VoqLxug,3088
-pyloid-0.16.12.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-pyloid-0.16.12.dist-info/RECORD,,
+pyloid-0.17.0.dist-info/LICENSE,sha256=F96EzotgWhhpnQTW2TcdoqrMDir1jyEo6H915tGQ-QE,11524
+pyloid-0.17.0.dist-info/METADATA,sha256=iuLvJxvORyzQNX-ZDgkOJ8TP6onbfIcFUc5OQZSuPHs,3054
+pyloid-0.17.0.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+pyloid-0.17.0.dist-info/RECORD,,