pyloid 0.24.8__py3-none-any.whl → 0.25.0__py3-none-any.whl

pyloid/browser_window.py

@@ -40,12 +40,11 @@ from PySide6.QtWidgets import QSplashScreen, QLabel
 from typing import TYPE_CHECKING, Any
 from PySide6.QtWebEngineCore import (
     QWebEngineSettings,
-    QWebEngineDesktopMediaRequest,
+    # QWebEngineDesktopMediaRequest, # 6.8.3 부터
 )
 import threading
 
 # from .url_interceptor import CustomUrlInterceptor
-from .rpc import PyloidRPC
 
 if TYPE_CHECKING:
     from .pyloid import _Pyloid, Pyloid
@@ -55,7 +54,7 @@ class CustomWebPage(QWebEnginePage):
     def __init__(self, profile=None):
         super().__init__(profile)
         self.featurePermissionRequested.connect(self._handlePermissionRequest)
-        self.desktopMediaRequested.connect(self._handleDesktopMediaRequest)
+        # self.desktopMediaRequested.connect(self._handleDesktopMediaRequest)
         self._permission_handlers = {}
         self._desktop_media_handler = None
         self._url_handlers = {}  # URL 핸들러 저장을 위한 딕셔너리 추가
@@ -78,31 +77,31 @@ class CustomWebPage(QWebEnginePage):
         """Register a handler for a specific permission"""
         self._permission_handlers[feature] = handler
 
-    def _handleDesktopMediaRequest(self, request: QWebEngineDesktopMediaRequest):
-        return
-        print("Desktop media request received:", request)
+    # def _handleDesktopMediaRequest(self, request: QWebEngineDesktopMediaRequest):
+    #     return
+    #     print("Desktop media request received:", request)
 
-        # 사용 가능한 화면 목록 확인
-        screens_model = request.screensModel()
-        print("\n=== Available Screens ===")
-        for i in range(screens_model.rowCount()):
-            screen_index = screens_model.index(i)
-            screen_name = screens_model.data(screen_index)
-            print(f"Screen {i}: {screen_name}")
+    #     # check the available screen list
+    #     screens_model = request.screensModel()
+    #     print("\n=== Available Screens ===")
+    #     for i in range(screens_model.rowCount()):
+    #         screen_index = screens_model.index(i)
+    #         screen_name = screens_model.data(screen_index)
+    #         print(f"Screen {i}: {screen_name}")
 
-        # 사용 가능한 창 목록 확인
-        windows_model = request.windowsModel()
-        print("\n=== Available Windows ===")
-        for i in range(windows_model.rowCount()):
-            window_index = windows_model.index(i)
-            window_name = windows_model.data(window_index)
-            print(f"Window {i}: {window_name}")
+    #     # check the available window list
+    #     windows_model = request.windowsModel()
+    #     print("\n=== Available Windows ===")
+    #     for i in range(windows_model.rowCount()):
+    #         window_index = windows_model.index(i)
+    #         window_name = windows_model.data(window_index)
+    #         print(f"Window {i}: {window_name}")
 
-        request.selectWindow(windows_model.index(3))
+    #     request.selectWindow(windows_model.index(3))
 
     # # interceptor ( navigation request )
     # def acceptNavigationRequest(self, url, navigation_type, is_main_frame):
-    #     """네비게이션 요청을 처리하는 메서드"""
+    #     """method to handle navigation requests"""
     #     print(f"Navigation Request - URL: {url.toString()}")
     #     print(f"Navigation Type: {navigation_type}")
     #     print(f"Is Main Frame: {is_main_frame}")
@@ -228,10 +227,10 @@ class CustomWebEngineView(QWebEngineView):
 
     def eventFilter(self, source, event):
         if self.focusProxy() is source:
-            # 리사이징 영역에 있을 때는 모든 클릭 이벤트를 가로채기
+            # when in the resize area, all click events are intercepted
             if self.is_in_resize_area and event.type() == QEvent.MouseButtonPress:
                 self.mouse_press_event(event)
-                return True  # 이벤트를 소비하여 웹뷰로 전달되지 않도록 함
+                return True  # consume the event so it is not passed to the web view
 
             if event.type() == QEvent.MouseButtonPress:
                 self.mouse_press_event(event)
@@ -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
-        ###########################################################################################
-        # RPC 서버가 없으면 추가하지 않음
-        if not self.rpc:
-            return
-
-        self.rpc.pyloid = self.app.pyloid_wrapper
-        # self.rpc.window = self.window_wrapper
-
-        # RPC 서버 중복 방지
-        if self.rpc in self.app.rpc_servers:
-            return
-
-        # RPC 서버 추가
-        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,
@@ -405,7 +378,7 @@ class _BrowserWindow:
             central_widget.setLayout(layout)
             self._window.setCentralWidget(central_widget)
 
-            # Add properties for window movement
+            # add properties for window movement
             self._window.moving = False
             self._window.offset = QPoint()
         else:
@@ -543,10 +516,10 @@ class _BrowserWindow:
         # Set F12 shortcut
         self.set_dev_tools(self.dev_tools)
 
-        # 프로필 가져오기 및 인터셉터 설정
+        # get the profile and set the interceptor
         profile = self.web_view.page().profile()
 
-        # # 기존 인터셉터가 있다면 제거
+        # # if the existing interceptor is present, remove it
         # if self.interceptor:
         #     profile.setUrlRequestInterceptor(None)
 
@@ -565,15 +538,15 @@ class _BrowserWindow:
                 new QWebChannel(qt.webChannelTransport, function (channel) {
                     window.pyloid = {
                         EventAPI: {
-                            _listeners: {},  // 콜백 함수들을 저장할 객체
+                            _listeners: {},  // object to store the callback functions
                             
                             listen: function(eventName, callback) {
-                                // 이벤트에 대한 콜백 배열이 없다면 생성
+                                // if the callback array for the event is not present, create it
                                 if (!this._listeners[eventName]) {
                                     this._listeners[eventName] = [];
                                 }
                                 
-                                // 콜백 함수 저장
+                                // save the callback function
                                 this._listeners[eventName].push(callback);
                                 
                                 document.addEventListener(eventName, function(event) {
@@ -588,12 +561,12 @@ class _BrowserWindow:
                             },
                             
                             unlisten: function(eventName) {
-                                // 해당 이벤트의 모든 리스너 제거
+                                // remove all listeners for the event
                                 if (this._listeners[eventName]) {
                                     this._listeners[eventName].forEach(callback => {
                                         document.removeEventListener(eventName, callback);
                                     });
-                                    // 저장된 콜백 제거
+                                    // remove the saved callback
                                     delete this._listeners[eventName];
                                 }
                             }
@@ -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/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/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()
+    

pyloid/serve.py

@@ -1,21 +1,180 @@
 import threading
-from http.server import HTTPServer, SimpleHTTPRequestHandler
+import asyncio
+import mimetypes
+import aiofiles
+from aiohttp import web
+from aiohttp.web_fileresponse import FileResponse
 from typing import Optional
-from .utils import get_free_port
+from pathlib import Path
+from .utils import get_free_port, is_production
+import logging
 
-class CustomStaticHandler(SimpleHTTPRequestHandler):
-    def __init__(self, *args, directory=None, **kwargs):
-        super().__init__(*args, directory=directory, **kwargs)
+# 로깅 설정
+logging.getLogger('aiohttp').setLevel(logging.WARNING)
+
+
+class ZeroCopyFileResponse(FileResponse):
+    """zero-copy optimized file response class"""
+    
+    def __init__(self, path, chunk_size=65536, headers=None):
+        """
+        Args:
+            path: file path
+            chunk_size: streaming chunk size (64KB default)
+            headers: additional HTTP headers
+        """
+        super().__init__(path, chunk_size=chunk_size, headers=headers)
+        self._enable_sendfile = True  # sendfile() system call activation
+
+
+class ZeroCopyStaticHandler:
+    """zero-copy optimized static file handler"""
+    
+    def __init__(self, directory: str):
+        self.directory = Path(directory).resolve()
+        self.chunk_size = 65536  # 64KB chunk
+        
+    async def handle_request(self, request):
+        """HTTP request processing"""
+        try:
+            # URL path parsing
+            path = request.path_qs.split('?')[0]  # 쿼리 파라미터 제거
+            if path.endswith('/'):
+                path += 'index.html'
+            
+            # Security: prevent directory traversal attacks
+            file_path = (self.directory / path.lstrip('/')).resolve()
+            if not str(file_path).startswith(str(self.directory)):
+                return web.Response(status=403, text="Forbidden")
+            
+            # Check if the file exists
+            if not file_path.exists() or not file_path.is_file():
+                return web.Response(status=404, text="File not found")
+            
+            # Check the file size and type
+            stat = file_path.stat()
+            file_size = stat.st_size
+            content_type, _ = mimetypes.guess_type(str(file_path))
+            
+            # Range request processing (partial download supported)
+            range_header = request.headers.get('Range')
+            if range_header:
+                return await self._handle_range_request(file_path, range_header, file_size, content_type, request)
+            
+            if is_production():
+                cache_control = 'public, max-age=3600'  # 1 hour caching
+            else:
+                cache_control = 'no-cache'
+                
+            # zero-copy file response creation
+            headers = {
+                'Content-Type': content_type or 'application/octet-stream',
+                'Content-Length': str(file_size),
+                'Accept-Ranges': 'bytes',
+                'Cache-Control': cache_control,
+                'ETag': f'"{stat.st_mtime}-{file_size}"'
+            }
+            
+            # ETag based cache check
+            if_none_match = request.headers.get('If-None-Match')
+            if if_none_match == headers['ETag']:
+                return web.Response(status=304, headers=headers)
+            
+            # zero-copy response return (sendfile used)
+            return ZeroCopyFileResponse(
+                path=file_path,
+                chunk_size=self.chunk_size,
+                headers=headers
+            )
+            
+        except Exception as e:
+            return web.Response(status=500, text=f"Internal Server Error: {str(e)}")
+    
+    async def _handle_range_request(self, file_path, range_header, file_size, content_type, request):
+        """Range request processing (partial download)"""
+        try:
+            # Range header parsing: bytes=start-end
+            range_match = range_header.replace('bytes=', '').split('-')
+            start = int(range_match[0]) if range_match[0] else 0
+            end = int(range_match[1]) if range_match[1] else file_size - 1
+            
+            # Range validation
+            if start >= file_size or end >= file_size or start > end:
+                return web.Response(
+                    status=416,  # Range Not Satisfiable
+                    headers={'Content-Range': f'bytes */{file_size}'}
+                )
+            
+            content_length = end - start + 1
+            
+            headers = {
+                'Content-Type': content_type or 'application/octet-stream',
+                'Content-Length': str(content_length),
+                'Content-Range': f'bytes {start}-{end}/{file_size}',
+                'Accept-Ranges': 'bytes'
+            }
+            
+            # zero-copy partial response
+            response = web.StreamResponse(status=206, headers=headers)
+            await response.prepare(request)
+            
+            # aiofiles to async zero-copy transfer
+            async with aiofiles.open(file_path, 'rb') as f:
+                await f.seek(start)
+                remaining = content_length
+                
+                while remaining > 0:
+                    chunk_size = min(self.chunk_size, remaining)
+                    chunk = await f.read(chunk_size)
+                    if not chunk:
+                        break
+                    await response.write(chunk)
+                    remaining -= len(chunk)
+            
+            await response.write_eof()
+            return response
+            
+        except Exception as e:
+            return web.Response(status=500, text=f"Range Request Error: {str(e)}")
+
+
+async def start_zero_copy_server(directory: str, port: int):
+    """zero-copy optimized server starts"""
+    handler = ZeroCopyStaticHandler(directory)
     
-    def log_message(self, format, *args):
-        pass
+    # aiohttp app creation
+    app = web.Application()
+    app.router.add_route('GET', '/{path:.*}', handler.handle_request)
+    
+    # server configuration optimization
+    runner = web.AppRunner(
+        app,
+        access_log=None,  # access log disabled (performance improvement)
+        keepalive_timeout=75,  # Keep-Alive timeout
+        client_timeout=600,    # client timeout
+    )
+    
+    await runner.setup()
+    
+    site = web.TCPSite(
+        runner, 
+        '127.0.0.1', 
+        port,
+        backlog=1024,  # connection backlog size
+        reuse_address=True  # port reuse only
+    )
+    
+    await site.start()
+    
+    return runner, site
+
 
 def pyloid_serve(
     directory: str,
     port: Optional[int] = None,
 ) -> str:
     """
-    Static file server starts.
+    zero-copy optimized static file server starts.
     
     Args
     ----
@@ -44,13 +203,30 @@ def pyloid_serve(
     if port is None:
         port = get_free_port()
     
-    handler = lambda *args: CustomStaticHandler(*args, directory=directory)
-    server = HTTPServer(("127.0.0.1", port), handler)
+    def run_zero_copy_server():
+        """run async server in a separate thread"""
+        loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(loop)
+        
+        try:
+            runner, site = loop.run_until_complete(
+                start_zero_copy_server(directory, port)
+            )
+            
+            print(f"🚀 Zero-copy server started on http://127.0.0.1:{port}")
+            print(f"📁 Serving directory: {directory}")
+            print(f"⚡ Features: sendfile, Range requests, ETag caching")
+            
+            # wait until the server starts
+            loop.run_forever()
+            
+        except Exception as e:
+            print(f"Zero-copy server error: {e}")
+        finally:
+            loop.close()
     
-    thread = threading.Thread(
-        target=server.serve_forever,
-        daemon=True
-    )
+    # start server in a daemon thread
+    thread = threading.Thread(target=run_zero_copy_server, daemon=True)
     thread.start()
     
     return f"http://127.0.0.1:{port}"

pyloid/store.py

@@ -20,7 +20,7 @@ class Store:
         os.makedirs(os.path.dirname(path), exist_ok=True)
         self.db = PickleDB(path)
 
-    def get(self, key: str) -> Any:
+    def get(self, key: str, default: Any = None) -> Any:
         """
         Retrieve the value associated with the specified key.
 
@@ -28,6 +28,8 @@ class Store:
         ----------
         key: str
             The key to look up in the database
+        default: Any
+            The value to return if the value does not exist in the database
 
         Returns
         -------
@@ -44,8 +46,11 @@ class Store:
         {'name': 'John Doe', 'age': 30}
         >>> print(store.get("non_existent_key"))
         None
+        >>> print(store.get("non_existent_key", "default_value"))
+        'default_value'
         """
-        return self.db.get(key)
+        stored_value = self.db.get(key)
+        return stored_value if stored_value is not None else default
 
     def set(self, key: str, value: Any) -> bool:
         """

{pyloid-0.24.8.dist-info → pyloid-0.25.0.dist-info}/LICENSE

@@ -198,4 +198,4 @@ Apache License
    distributed under the License is distributed on an "AS IS" BASIS,
    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    See the License for the specific language governing permissions and
-   limitations under the License.
+   limitations under the License.

{pyloid-0.24.8.dist-info → pyloid-0.25.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: pyloid
-Version: 0.24.8
+Version: 0.25.0
 Summary: 
 Author: aesthetics-of-record
 Author-email: 111675679+aesthetics-of-record@users.noreply.github.com
@@ -11,10 +11,11 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Requires-Dist: aiofiles (>=24.1.0,<25.0.0)
 Requires-Dist: aiohttp-cors (>=0.8.1,<0.9.0)
 Requires-Dist: pickledb (>=1.3.2,<2.0.0)
 Requires-Dist: platformdirs (>=4.3.7,<5.0.0)
-Requires-Dist: pyside6 (==6.9.1)
+Requires-Dist: pyside6 (==6.9.2)
 Description-Content-Type: text/markdown
 
 <h1 style="text-align: center; font-size: 200px; font-weight: 500;">
@@ -23,7 +24,7 @@ Description-Content-Type: text/markdown
 
 ![example image](example.png)
 
-<h2 align="center" style="font-size: 28px;"><b>Pyloid: Thread-Safe Desktop Apps—Unified with Any Frontend and Python Technology</b></h2>
+<h2 align="center" style="font-size: 28px;"><b>Pyloid: Electron for Python Developer • Web-based desktop app framework</b></h2>
 
 ## 💡 Key Features
 

{pyloid-0.24.8.dist-info → pyloid-0.25.0.dist-info}/RECORD

@@ -1,23 +1,23 @@
 pyloid/__init__.py,sha256=YKwMCSOds1QVi9N7EGfY0Z7BEjJn8j6HGqRblZlZClA,235
 pyloid/api.py,sha256=A61Kmddh8BlpT3LfA6NbPQNzFmD95vQ4WKX53oKsGYU,2419
 pyloid/autostart.py,sha256=K7DQYl4LHItvPp0bt1V9WwaaZmVSTeGvadkcwG-KKrI,3899
-pyloid/browser_window.py,sha256=xy_AOZiqY5kffMXgkeDa5a1u1VSPv860_W9xg3wyWEI,104349
+pyloid/browser_window.py,sha256=u9DfdlPHUZFpwdVprPs_Vhkj1aV3K_16KIub0vLCrLc,103284
 pyloid/custom/titlebar.py,sha256=itzK9pJbZMQ7BKca9kdbuHMffurrw15UijR6OU03Xsk,3894
 pyloid/filewatcher.py,sha256=3M5zWVUf1OhlkWJcDFC8ZA9agO4Q-U8WdgGpy6kaVz0,4601
 pyloid/js_api/base.py,sha256=Z3ID-4AJ0eHusmljRltlSaK4m2RKvRNfmqX76NLF77o,8585
 pyloid/js_api/event_api.py,sha256=w0z1DcmwcmseqfcoZWgsQmFC2iBCgTMVJubTaHeXI1c,957
 pyloid/js_api/window_api.py,sha256=-isphU3m2wGB5U0yZrSuK_4XiBz2mG45HsjYTUq7Fxs,7348
 pyloid/monitor.py,sha256=1mXvHm5deohnNlTLcRx4sT4x-stnOIb0dUQnnxN50Uo,28295
-pyloid/pyloid.py,sha256=DSHpMRDW4WvZgAAo2nJMesMJuOkNTVEEsDhCFIvjB5w,84509
-pyloid/rpc.py,sha256=OnF1sRGok9OJ-Q5519eQARD4oZTohyPhsPAT2Mg4_Gg,20377
-pyloid/serve.py,sha256=wJIBqiLr1-8FvBdV3yybeBtVXsu94FfWYKjHL0eQ68s,1444
-pyloid/store.py,sha256=teoa-HYzwm93Rivcw3AhKw6rAmQqQ_kmF6XYSkC3G_I,4541
+pyloid/pyloid.py,sha256=Ioq_jmyaKTvW3KsmqZX3uhSUc3xRW9FgOtWcH96cVfo,84152
+pyloid/rpc.py,sha256=6UzQc-CDA72VYeF3Xy-7AbBculE-T0MIokR39jVdlcg,21726
+pyloid/serve.py,sha256=KOs9984J2qboEXsquorkXgcQvvao_C2c9F6N2gSLfiA,8122
+pyloid/store.py,sha256=8PnBxtkUgbF8Lxh-iYlEuhbLE76bGBF8t5KV5u5NzoQ,4831
 pyloid/thread_pool.py,sha256=fKOBb8jMfZn_7crA_fJCno8dObBRZE31EIWaNQ759aw,14616
 pyloid/timer.py,sha256=RqMsChFUd93cxMVgkHWiIKrci0QDTBgJSTULnAtYT8M,8712
 pyloid/tray.py,sha256=D12opVEc2wc2T4tK9epaN1oOdeziScsIVNM2uCN7C-A,1710
 pyloid/url_interceptor.py,sha256=AFjPANDELc9-E-1TnVvkNVc-JZBJYf0677dWQ8LDaqw,726
 pyloid/utils.py,sha256=J6owgVE1YDOEfcOPmoP9m9Q6nbYDyNEo9uqPsJs5p5g,6644
-pyloid-0.24.8.dist-info/LICENSE,sha256=MTYF-6xpRekyTUglRweWtbfbwBL1I_3Bgfbm_SNOuI8,11525
-pyloid-0.24.8.dist-info/METADATA,sha256=IGiJsO7-sG69DSi9Rw_Hn4Ttuf-T2nquIacuZBWSI5Q,2264
-pyloid-0.24.8.dist-info/WHEEL,sha256=IYZQI976HJqqOpQU6PHkJ8fb3tMNBFjg-Cn-pwAbaFM,88
-pyloid-0.24.8.dist-info/RECORD,,
+pyloid-0.25.0.dist-info/LICENSE,sha256=F96EzotgWhhpnQTW2TcdoqrMDir1jyEo6H915tGQ-QE,11524
+pyloid-0.25.0.dist-info/METADATA,sha256=289p55TOz7kF41q9lyHqgB9h0fRlxCyR1zZSF9OTDYw,2298
+pyloid-0.25.0.dist-info/WHEEL,sha256=IYZQI976HJqqOpQU6PHkJ8fb3tMNBFjg-Cn-pwAbaFM,88
+pyloid-0.25.0.dist-info/RECORD,,