pyloid 0.25.0__tar.gz → 0.26.1__tar.gz

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

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

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

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

{pyloid-0.25.0 → pyloid-0.26.1}/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,9 +42,8 @@ from PySide6.QtWebEngineCore import (
     QWebEngineSettings,
     # QWebEngineDesktopMediaRequest, # 6.8.3 부터
 )
-import threading
 
-# from .url_interceptor import CustomUrlInterceptor
+# from .url_interceptor import ServerUrlInterceptor
 
 if TYPE_CHECKING:
     from .pyloid import _Pyloid, Pyloid
@@ -112,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):
@@ -322,10 +321,8 @@ class _BrowserWindow:
         self._window = QMainWindow()
         self.web_view = CustomWebEngineView(self)
 
-
-
         # interceptor ( all url request )
-        # self.web_view.page().setUrlRequestInterceptor(self.interceptor)
+        # self.web_view.page().profile().setUrlRequestInterceptor(CustomInterceptor())
 
         self._window.closeEvent = self.closeEvent  # Override closeEvent method
         ###########################################################################################
@@ -477,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)
@@ -517,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."""

{pyloid-0.25.0 → pyloid-0.26.1}/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.25.0 → pyloid-0.26.1}/src/pyloid/pyloid.py

@@ -97,10 +97,10 @@ class _Pyloid(QApplication):
     def __init__(
         self,
         pyloid_wrapper: "Pyloid",
-        app_name,
-        single_instance=True,
-        server=None,
-        data=None,
+        app_name: str,
+        single_instance: bool = True,
+        server = None,
+        data = None,
     ):
         """
         Initializes the Pyloid application.
@@ -150,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)
@@ -1632,6 +1632,10 @@ class Pyloid(QObject):
         super().__init__()
 
         self.data = None # 나중에 데이터 필요 시 수정
+        
+        # server 에 Pyloid 주입
+        if server:
+            server.pyloid = self
 
         self.app = _Pyloid(self, app_name, single_instance, server, self.data)
 

{pyloid-0.25.0 → pyloid-0.26.1}/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.1/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.25.0/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))