pyloid 0.24.9__tar.gz → 0.26.0__tar.gz

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

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

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

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

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

@@ -24,10 +24,10 @@ from PySide6.QtCore import (
 from PySide6.QtWebEngineCore import (
     QWebEnginePage,
     QWebEngineSettings,
+    # QWebEngineUrlRequestInterceptor,
 )
-from .api import PyloidAPI
 import uuid
-from typing import List, Optional, Dict, Callable
+from typing import Optional, Dict, Callable
 import json
 from PySide6.QtWidgets import (
     QWidget,
@@ -42,10 +42,8 @@ from PySide6.QtWebEngineCore import (
     QWebEngineSettings,
     # QWebEngineDesktopMediaRequest, # 6.8.3 부터
 )
-import threading
 
-# from .url_interceptor import CustomUrlInterceptor
-from .rpc import PyloidRPC
+# from .url_interceptor import ServerUrlInterceptor
 
 if TYPE_CHECKING:
     from .pyloid import _Pyloid, Pyloid
@@ -113,7 +111,7 @@ class CustomWebPage(QWebEnginePage):
 # class CustomInterceptor(QWebEngineUrlRequestInterceptor):
 #     def __init__(self, index_path=None):
 #         super().__init__()
-#         self.index_path = get_production_path()
+#         # self.index_path = get_production_path()
 #         self.last_path = "/"
 
 #     def interceptRequest(self, info):
@@ -316,7 +314,6 @@ class _BrowserWindow:
         context_menu: bool = False,
         dev_tools: bool = False,
         # js_apis: List[PyloidAPI] = [],
-        rpc: Optional[PyloidRPC] = None,
         transparent: bool = False,
     ):
         ###########################################################################################
@@ -324,16 +321,8 @@ 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.web_view.page().profile().setUrlRequestInterceptor(CustomInterceptor())
 
         self._window.closeEvent = self.closeEvent  # Override closeEvent method
         ###########################################################################################
@@ -349,7 +338,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 +346,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,
@@ -504,7 +474,7 @@ class _BrowserWindow:
         if sys.platform == "win32":
             import ctypes
 
-            myappid = "mycompany.myproduct.subproduct.version"
+            myappid = f"pyloid.{self.app.app_name}.com"
             ctypes.windll.shell32.SetCurrentProcessExplicitAppUserModelID(myappid)
 
         # Remove title bar and borders (if needed)
@@ -544,11 +514,10 @@ class _BrowserWindow:
         self.set_dev_tools(self.dev_tools)
 
         # get the profile and set the interceptor
-        profile = self.web_view.page().profile()
+        # profile = self.web_view.page().profile()
+        # profile.setUrlRequestInterceptor(ServerUrlInterceptor(self.app.server.url, self.id))
+
 
-        # # if the existing interceptor is present, remove it
-        # if self.interceptor:
-        #     profile.setUrlRequestInterceptor(None)
 
     def _on_load_finished(self, ok):
         """Handles the event when the web page finishes loading."""
@@ -2125,7 +2094,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 +2108,6 @@ class BrowserWindow(QObject):
             frame,
             context_menu,
             dev_tools,
-            rpc,
             transparent,
         )
         self.command_signal.connect(self._handle_command)

{pyloid-0.24.9 → pyloid-0.26.0}/src/pyloid/js_api/base.py

@@ -11,13 +11,13 @@ if TYPE_CHECKING:
 
 class BaseAPI(PyloidAPI):
     def __init__(
-        self, window_id: str, data: dict, app: "_Pyloid", rpc_url: Optional[str] = None
+        self, window_id: str, data: dict, app: "_Pyloid", server_url: Optional[str] = None
     ):
         super().__init__()
         self.window_id: str = window_id
         self.data: dict = data
         self.app: "_Pyloid" = app
-        self.rpc_url: Optional[str] = rpc_url
+        self.server_url: Optional[str] = server_url
 
     @Bridge(result=dict)
     def getData(self):
@@ -254,6 +254,6 @@ class BaseAPI(PyloidAPI):
         return get_production_path(path)
 
     @Bridge(result=str)
-    def getRpcUrl(self):
+    def getServerUrl(self):
         """Returns the RPC URL of the application."""
-        return self.rpc_url
+        return self.server_url

{pyloid-0.24.9 → pyloid-0.26.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
 
@@ -98,9 +97,10 @@ class _Pyloid(QApplication):
     def __init__(
         self,
         pyloid_wrapper: "Pyloid",
-        app_name,
-        single_instance=True,
-        data=None,
+        app_name: str,
+        single_instance: bool = True,
+        server = None,
+        data = None,
     ):
         """
         Initializes the Pyloid application.
@@ -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
@@ -151,7 +150,7 @@ class _Pyloid(QApplication):
         self.tray_menu_items = []
         self.tray_actions = {}
 
-        self.app_name = app_name
+        self.app_name: str = app_name
         self.app_path = sys.executable
 
         self.auto_start = AutoStart(self.app_name, self.app_path)
@@ -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.26.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()
+    

{pyloid-0.24.9 → pyloid-0.26.0}/src/pyloid/serve.py

@@ -1,232 +1,232 @@
-import threading
-import asyncio
-import mimetypes
-import aiofiles
-from aiohttp import web
-from aiohttp.web_fileresponse import FileResponse
-from typing import Optional
-from pathlib import Path
-from .utils import get_free_port, is_production
-import logging
-
-# 로깅 설정
-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)
-    
-    # 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:
-    """
-    zero-copy optimized static file server starts.
-    
-    Args
-    ----
-    directory (str): Path to the static file directory to serve
-    port (int, optional): Server port (default: None - will use a random free port)
-    
-    Returns
-    -------
-    str
-        URL of the started server
-        
-    Examples
-    --------
-    ```python
-    from pyloid import Pyloid
-    from pyloid.serve import pyloid_serve
-    
-    app = Pyloid("Pyloid-App")
-    url = pyloid_serve("dist")
-    window = app.create_window("Pyloid-App")
-    window.load_url(url)
-    window.show_and_focus()
-    ```
-    """
-    
-    if port is None:
-        port = get_free_port()
-    
-    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()
-    
-    # start server in a daemon thread
-    thread = threading.Thread(target=run_zero_copy_server, daemon=True)
-    thread.start()
-    
+import threading
+import asyncio
+import mimetypes
+import aiofiles
+from aiohttp import web
+from aiohttp.web_fileresponse import FileResponse
+from typing import Optional
+from pathlib import Path
+from .utils import get_free_port, is_production
+import logging
+
+# 로깅 설정
+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)
+    
+    # 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:
+    """
+    zero-copy optimized static file server starts.
+    
+    Args
+    ----
+    directory (str): Path to the static file directory to serve
+    port (int, optional): Server port (default: None - will use a random free port)
+    
+    Returns
+    -------
+    str
+        URL of the started server
+        
+    Examples
+    --------
+    ```python
+    from pyloid import Pyloid
+    from pyloid.serve import pyloid_serve
+    
+    app = Pyloid("Pyloid-App")
+    url = pyloid_serve("dist")
+    window = app.create_window("Pyloid-App")
+    window.load_url(url)
+    window.show_and_focus()
+    ```
+    """
+    
+    if port is None:
+        port = get_free_port()
+    
+    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()
+    
+    # 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-0.26.0/src/pyloid/url_interceptor.py

@@ -0,0 +1,25 @@
+from PySide6.QtWebEngineCore import QWebEngineUrlRequestInterceptor, QWebEngineUrlRequestInfo
+
+# interceptor ( all url request )
+class ServerUrlInterceptor(QWebEngineUrlRequestInterceptor):
+    def __init__(self, server_url: str, window_id: str):
+        super().__init__()
+        self.server_url = server_url
+        self.headers = {
+            "X-Pyloid-Window-Id": window_id,
+        }
+        
+        print("interceptor init")
+
+    def interceptRequest(self, info):
+        # host = info.requestUrl().host()
+        url = info.requestUrl().toString()
+        
+        print(url)
+
+        if url.startswith(self.server_url):
+            headers = info.httpHeaders()
+            print("before", headers)
+            headers.update(self.headers)
+            print("after", headers)
+            return

pyloid-0.24.9/src/pyloid/url_interceptor.py

@@ -1,24 +0,0 @@
-from PySide6.QtWebEngineCore import QWebEngineUrlRequestInterceptor
-from PySide6.QtCore import QUrl
-from typing import Optional
-
-# interceptor ( all url request )
-class CustomUrlInterceptor(QWebEngineUrlRequestInterceptor):
-    def __init__(self, rpc_url: Optional[str] = None):
-        super().__init__()
-        self.rpc_url = rpc_url
-
-    def interceptRequest(self, info):
-        host = info.requestUrl().host()
-        url = info.requestUrl().toString()
-
-        server_url = self.rpc_url
-        
-        if self.rpc_url is None:
-            return
-        
-        if url.startswith(self.rpc_url):
-            return
-
-        if host == "pyloid.rpc":
-            info.redirect(QUrl(server_url))