pyloid 0.24.9__tar.gz → 0.25.0__tar.gz

{pyloid-0.24.9 → pyloid-0.25.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: pyloid
-Version: 0.24.9
+Version: 0.25.0
 Summary: 
 Author: aesthetics-of-record
 Author-email: 111675679+aesthetics-of-record@users.noreply.github.com

{pyloid-0.24.9 → pyloid-0.25.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "pyloid"
-version = "0.24.9"
+version = "0.25.0"
 description = ""
 authors = ["aesthetics-of-record <111675679+aesthetics-of-record@users.noreply.github.com>"]
 readme = "README.md"

{pyloid-0.24.9 → pyloid-0.25.0}/src/pyloid/browser_window.py

@@ -45,7 +45,6 @@ from PySide6.QtWebEngineCore import (
 import threading
 
 # from .url_interceptor import CustomUrlInterceptor
-from .rpc import PyloidRPC
 
 if TYPE_CHECKING:
     from .pyloid import _Pyloid, Pyloid
@@ -316,7 +315,6 @@ class _BrowserWindow:
         context_menu: bool = False,
         dev_tools: bool = False,
         # js_apis: List[PyloidAPI] = [],
-        rpc: Optional[PyloidRPC] = None,
         transparent: bool = False,
     ):
         ###########################################################################################
@@ -324,15 +322,9 @@ class _BrowserWindow:
         self._window = QMainWindow()
         self.web_view = CustomWebEngineView(self)
 
-        if rpc:
-            self.rpc = rpc
-            self.rpc_url = rpc.url
-        else:
-            self.rpc = None
-            self.rpc_url = None
+
 
         # interceptor ( all url request )
-        # self.interceptor = CustomUrlInterceptor(rpc_url=self.rpc_url)
         # self.web_view.page().setUrlRequestInterceptor(self.interceptor)
 
         self._window.closeEvent = self.closeEvent  # Override closeEvent method
@@ -349,7 +341,7 @@ class _BrowserWindow:
         self.context_menu = context_menu
         self.dev_tools = dev_tools
 
-        self.js_apis = [BaseAPI(self.id, self.app.data, self.app, self.rpc_url)]
+        self.js_apis = [BaseAPI(self.id, self.app.data, self.app, self.app.server.url)]
 
         # for js_api in js_apis:
         #     self.js_apis.append(js_api)
@@ -357,25 +349,6 @@ class _BrowserWindow:
         self.shortcuts = {}
         self.close_on_load = True
         self.splash_screen = None
-        ###########################################################################################
-        # if the RPC server is not present, do not add it
-        if not self.rpc:
-            return
-
-        self.rpc.pyloid = self.app.pyloid_wrapper
-        # self.rpc.window = self.window_wrapper
-
-        # prevent duplicate RPC servers
-        if self.rpc in self.app.rpc_servers:
-            return
-
-        # add the RPC server
-        self.app.rpc_servers.add(self.rpc)
-
-        # Start unique RPC servers
-        server_thread = threading.Thread(target=self.rpc.start, daemon=True)
-        server_thread.start()
-        ###########################################################################################
 
     def _set_custom_frame(
         self,
@@ -2125,7 +2098,6 @@ class BrowserWindow(QObject):
         frame: bool = True,
         context_menu: bool = False,
         dev_tools: bool = False,
-        rpc: Optional[PyloidRPC] = None,
         transparent: bool = False,
     ):
         super().__init__()
@@ -2140,7 +2112,6 @@ class BrowserWindow(QObject):
             frame,
             context_menu,
             dev_tools,
-            rpc,
             transparent,
         )
         self.command_signal.connect(self._handle_command)

{pyloid-0.24.9 → pyloid-0.25.0}/src/pyloid/pyloid.py

@@ -32,7 +32,6 @@ from PySide6.QtCore import QEventLoop
 from typing import Any, Set
 from platformdirs import PlatformDirs
 from .store import Store
-from .rpc import PyloidRPC
 import threading
 import signal
 
@@ -100,6 +99,7 @@ class _Pyloid(QApplication):
         pyloid_wrapper: "Pyloid",
         app_name,
         single_instance=True,
+        server=None,
         data=None,
     ):
         """
@@ -132,7 +132,6 @@ class _Pyloid(QApplication):
         self.data = data
 
         self.windows_dict: Dict[str, BrowserWindow] = {}  # 윈도우 ID를 키로 사용하는 딕셔너리
-        self.server = None
 
         self.app_name = app_name
         self.icon = None
@@ -171,7 +170,14 @@ class _Pyloid(QApplication):
 
         self.dirs = PlatformDirs(self.app_name, appauthor=False)
         
-        self.rpc_servers: Set[PyloidRPC] = set()
+        
+        ###################################################
+        # Pyloid Server Integration
+        if server:
+            self.server = server
+        else:
+            self.server = None
+        ###################################################
 
     # def set_theme(self, theme: Literal["system", "dark", "light"]):
     #     """
@@ -242,7 +248,6 @@ class _Pyloid(QApplication):
         frame: bool = True,
         context_menu: bool = False,
         dev_tools: bool = False,
-        rpc: Optional[PyloidRPC] = None,
         transparent: bool = False,
     ) -> BrowserWindow:
         """
@@ -266,8 +271,6 @@ class _Pyloid(QApplication):
             Whether to use the context menu (default is False)
         dev_tools : bool, optional
             Whether to use developer tools (default is False)
-        rpc : PyloidRPC, optional
-            The RPC server instance to be used in the window
         transparent : bool, optional
             Whether the window is transparent (default is False)
 
@@ -292,7 +295,6 @@ class _Pyloid(QApplication):
             frame,
             context_menu,
             dev_tools,
-            rpc,
             transparent,
         )
         self.windows_dict[window._window.id] = window
@@ -315,17 +317,9 @@ class _Pyloid(QApplication):
         ```
         """
         
-        # # Collect and deduplicate RPC servers
-        # rpc_servers: Set[PyloidRPC] = set()
-        # for window in self.windows_dict.values():
-        #     if window._window.rpc is not None:
-        #         rpc_servers.add(window._window.rpc)
-        
-        # # Start unique RPC servers
-        # for rpc in rpc_servers:
-        #     server_thread = threading.Thread(target=rpc.start, daemon=True)
-        #     server_thread.start()
-            
+        # Start Pyloid Integrated Server
+        if self.server:
+            self.server.run()
         
         if is_production():
             sys.exit(self.exec())
@@ -341,10 +335,10 @@ class _Pyloid(QApplication):
             # Another instance is already running
             sys.exit(1)
 
-        # Create a new server
-        self.server = QLocalServer()
-        self.server.listen(self.app_name)
-        self.server.newConnection.connect(self._handle_new_connection)
+        # Create a new Single Instance server
+        self.single_instance_server = QLocalServer()
+        self.single_instance_server.listen(self.app_name)
+        self.single_instance_server.newConnection.connect(self._handle_new_connection)
 
     def _handle_new_connection(self):
         """Handles new connections for the single instance server."""
@@ -1616,6 +1610,7 @@ class Pyloid(QObject):
         self,
         app_name: str,
         single_instance: bool = True,
+        server = None,
         # data: Optional[Dict[str, Any]] = None,
     ):
         """
@@ -1631,12 +1626,14 @@ class Pyloid(QObject):
             The name of the application.
         single_instance : bool, optional
             Determines whether to run as a single instance. (Default is True)
+        server : optional
+            The pyloid server instance to be used in the application
         """
         super().__init__()
 
         self.data = None # 나중에 데이터 필요 시 수정
 
-        self.app = _Pyloid(self, app_name, single_instance, self.data)
+        self.app = _Pyloid(self, app_name, single_instance, server, self.data)
 
         self.command_signal.connect(self._handle_command)
 
@@ -1657,7 +1654,6 @@ class Pyloid(QObject):
                 frame=params.get("frame", True),
                 context_menu=params.get("context_menu", False),
                 dev_tools=params.get("dev_tools", False),
-                rpc=params.get("rpc", None),
                 transparent=params.get("transparent", False),
             )
             result = window
@@ -1833,7 +1829,6 @@ class Pyloid(QObject):
         frame: bool = True,
         context_menu: bool = False,
         dev_tools: bool = False,
-        rpc: Optional[PyloidRPC] = None,
         transparent: bool = False,
     ) -> BrowserWindow:
         """
@@ -1857,8 +1852,6 @@ class Pyloid(QObject):
             Whether to use the context menu (default is False)
         dev_tools : bool, optional
             Whether to use developer tools (default is False)
-        rpc : PyloidRPC, optional
-            The RPC server instance to be used in the window
         transparent : bool, optional
             Whether the window is transparent (default is False)
 
@@ -1881,7 +1874,6 @@ class Pyloid(QObject):
             "frame": frame,
             "context_menu": context_menu,
             "dev_tools": dev_tools,
-            "rpc": rpc,
             "transparent": transparent,
         }
         return self.execute_command("create_window", params)

{pyloid-0.24.9 → pyloid-0.25.0}/src/pyloid/rpc.py

@@ -220,7 +220,7 @@ class PyloidRPC:
 
             # Store the original function
             self._functions[rpc_name] = func
-            log.info(f"RPC function registered: {rpc_name}")
+            # log.info(f"RPC function registered: {rpc_name}")
 
             @wraps(func)
             async def wrapper(*args, _pyloid_window_id=None, **kwargs):
@@ -518,3 +518,31 @@ class PyloidRPC:
         except Exception as e:
             log.exception(f"Failed to start or run the server: {e}")
             raise
+        
+    def run(self):
+        """
+        Runs start_async in a separate thread.
+
+        This method is useful when you want to start the aiohttp server in the background
+        without blocking the main thread. It creates a new thread, sets up a new asyncio event loop
+        in that thread, and starts the asynchronous server. The thread is marked as daemon so that
+        it will not prevent the program from exiting if only daemon threads remain.
+        """
+        import asyncio
+
+        def _run_asyncio():
+            # Create a new event loop for this thread.
+            loop = asyncio.new_event_loop()
+            # Set the newly created event loop as the current event loop for this thread.
+            asyncio.set_event_loop(loop)
+            # Start the asynchronous server; this coroutine will set up the server.
+            loop.run_until_complete(self.start_async())
+            # Keep the event loop running forever to handle incoming requests.
+            loop.run_forever()
+
+        # Create a new thread to run the event loop and server in the background.
+        # The thread is set as a daemon so it will not block program exit.
+        server_thread = threading.Thread(target=_run_asyncio, daemon=True)
+        # Start the background server thread.
+        server_thread.start()
+