py10x-universe 0.1.3__py3-none-any.whl

ui_10x/rio/components/line_edit.py

@@ -0,0 +1,37 @@
+from __future__ import annotations
+
+import rio
+
+
+class LineEditComponent(rio.Component):
+    text: str | None = None
+    tooltip: str | None = None
+    is_sensitive: bool = True
+    on_change: rio.EventHandler[[str]] = None
+    on_lose_focus: rio.EventHandler[[str]] = None
+    text_style: rio.TextStyle | None = None
+    is_secret: bool = False
+    on_pointer_up: rio.EventHandler[[rio.PointerEvent]] = None
+
+    def build(self):
+        component = rio.TextInput(
+            self.bind().text,
+            is_sensitive=self.is_sensitive,
+            on_change=self.on_change,
+            on_lose_focus=self.on_lose_focus,
+            text_style=self.text_style,
+            is_secret=self.is_secret,
+        )
+
+        if self.on_pointer_up is not None:
+            component = rio.PointerEventListener(
+                component,
+                on_pointer_up=self.on_pointer_up,
+                consume_events=False,
+                event_order='before-child',
+            )
+
+        if self.tooltip is not None:
+            component = rio.Tooltip(anchor=component, tip=self.tooltip)
+
+        return component

ui_10x/rio/components/radio_button.py

@@ -0,0 +1,32 @@
+from __future__ import annotations
+
+from functools import partial
+
+import rio
+
+
+class RadioButton(rio.Component):
+    label: str = ''
+    value: str = ''
+    checked: bool = False
+    on_select: rio.EventHandler[[]] = None
+
+    async def on_press(self, button) -> None:
+        if self.on_select:
+            self.on_select()
+        else:
+            self.checked = not self.checked
+        button.icon = self.icon_name()
+
+    def icon_name(self) -> str:
+        return f'radio_button_{"checked" if self.checked else "unchecked"}'
+
+    def build(self) -> rio.Component:
+        # Use an icon to visually represent the radio button state
+        icon_button = rio.IconButton(self.icon_name())
+        icon_button.on_press = partial(self.on_press, icon_button)
+        return rio.Row(
+            icon_button,
+            rio.Text(self.label),
+            spacing=0.5,  # Space between icon and label
+        )

ui_10x/rio/components/separator.py

@@ -0,0 +1,24 @@
+import typing
+
+import rio
+
+
+class Separator(rio.Component):
+    """
+    A component that draws a horizontal or vertical line to separate UI sections.
+
+    Attributes:
+        orientation: "horizontal" or "vertical" to define the separator's direction.
+        thickness: The width of the line in Rio units (default: 0.1).
+        color: The color of the line (default: gray).
+    """
+
+    orientation: typing.Literal['horizontal', 'vertical'] = 'horizontal'
+    thickness: float = 0.1
+    color: rio.Color = rio.Color.GRAY
+
+    def build(self) -> rio.Component:
+        if self.orientation == 'horizontal':
+            return rio.Rectangle(min_height=self.thickness, fill=self.color, margin_y=0.5, grow_y=False, align_y=0.5)
+        else:
+            return rio.Rectangle(min_width=self.thickness, fill=self.color, margin_x=0.5, grow_x=False, align_x=0.5)

ui_10x/rio/components/splitter.py

@@ -0,0 +1,121 @@
+from __future__ import annotations
+
+import typing as t
+
+import rio
+
+
+class Splitter(rio.Component):
+    """
+    A custom Rio component that arranges children horizontally like a Row,
+    or vertically as a column with draggable splitters between them for resizing.
+    """
+
+    # Props
+    children: list[rio.Component] = []
+    direction: t.Literal['horizontal', 'vertical'] = 'vertical'
+    handle_size: float = 0.25  # Width of the splitter handle
+    min_size_percent: float = 10.0  # Minimum width for each child (%)
+    child_proportions: t.Literal['homogeneous'] | t.Sequence[float] = 'homogeneous'
+    _component_width: float = 0.0
+    _component_height: float = 0.0
+
+    def __post_init__(self):
+        if not isinstance(self.child_proportions, (list, tuple)):
+            num_children = len(self.children)
+            self.child_proportions = [1.0] * num_children if num_children else []
+        else:
+            assert len(self.child_proportions) == len(self.children)
+            assert all(p >= 0 for p in self.child_proportions), 'Proportions must be non-negative'
+            self.child_proportions = list(self.child_proportions)
+
+    def on_drag(self, index: int, event: rio.PointerMoveEvent) -> None:
+        """
+        Handle drag events on the splitter at the given index.
+        Adjusts the proportions of the two adjacent children.
+        """
+        horizontal = self.direction == 'horizontal'
+        total_size = self._component_width if horizontal else self._component_height
+
+        # Convert drag movement to a proportion change
+        total_proportion = sum(self.child_proportions)
+        relative_size = event.relative_x if horizontal else event.relative_y
+        delta_proportion = (relative_size / total_size) * total_proportion
+
+        # Adjust the proportions of the left and right children
+        prev_index = index
+        next_index = index + 1
+
+        # Calculate current sizes as percentages to check minimum constraints
+        current_sizes = [(p / total_proportion * 100.0) for p in self.child_proportions]
+        new_left_size = current_sizes[prev_index] + (delta_proportion / total_proportion * 100.0)
+        new_right_size = current_sizes[next_index] - (delta_proportion / total_proportion * 100.0)
+
+        # Check minimum size constraints
+        if new_left_size >= self.min_size_percent and new_right_size >= self.min_size_percent:
+            self.child_proportions[prev_index] += delta_proportion
+            self.child_proportions[next_index] -= delta_proportion
+            # Ensure proportions don't go negative
+            self.child_proportions[prev_index] = max(0.0, self.child_proportions[prev_index])
+            self.child_proportions[next_index] = max(0.0, self.child_proportions[next_index])
+
+        self.child_proportions = self.child_proportions  # force refresh
+
+    def build(self) -> rio.Component:
+        # If no children, return an empty component
+        if not self.children:
+            return rio.Rectangle()
+
+        # Build the layout with children and splitters
+        components = []
+        horizontal = self.direction == 'horizontal'
+        for i, child in enumerate(self.children):
+            # Wrap child in ScrollArea
+            scrollable_content = rio.ScrollContainer(
+                content=child,
+                # scroll_x='never' if horizontal else 'auto',
+                # scroll_y='auto' if horizontal else 'never',
+            )
+            # Create the pane
+            pane = rio.Rectangle(
+                content=scrollable_content,
+                **{'grow_x' if horizontal else 'grow_y': True},  # Stretch to fill proportional space
+                margin=1,  # Spacing around the child content
+            )
+            # Add a splitter handle to the right of all but the last pane
+            if i < len(self.children) - 1:
+                splitter = rio.PointerEventListener(
+                    content=rio.Rectangle(
+                        **{'grow_x' if horizontal else 'grow_y': False, 'min_width' if horizontal else 'min_height': self.handle_size},
+                        fill=rio.Color.from_hex('#808080'),
+                        cursor='move',  # Valid CursorStyle for dragging
+                    ),
+                    on_drag_move=lambda event, idx=i: self.on_drag(idx, event),
+                    **{
+                        'align_x' if horizontal else 'align_y': 1.0,  # Position at the right edge
+                        'margin_right' if horizontal else 'margin_bottom': -self.handle_size / 2,  # Extend slightly into the next pane
+                    },
+                )
+                # Combine pane and splitter in a Stack
+                components.append(
+                    rio.Stack(
+                        pane,
+                        splitter,
+                        **{'grow_x' if horizontal else 'grow_y': True},  # Ensure the Stack follows the proportion
+                    )
+                )
+            else:
+                # Last pane has no splitter
+                components.append(pane)
+
+        container = rio.Row if self.direction == 'horizontal' else rio.Column
+        return container(
+            *components,
+            spacing=0,
+            proportions=self.bind().child_proportions,  # Dynamically control pane sizes
+        )
+
+    @rio.event.on_resize
+    def _on_resize(self, event: rio.event.ComponentResizeEvent) -> None:
+        self._component_width = event.width
+        self._component_height = event.height

ui_10x/rio/components/tree_view.py

@@ -0,0 +1,75 @@
+from __future__ import annotations
+
+from typing import Literal
+
+import rio
+
+
+class RioTreeItem(rio.Component):
+    """same as SimpleTreeItem, but includes tooltip and supports double-click"""
+
+    text: str = ''
+    on_double_press: rio.EventHandler[[]] = None
+    on_press: rio.EventHandler[[]] = None
+    on_change: rio.EventHandler[[]] = None
+    tooltip: str | None = None
+    editable: bool = False
+    editing: bool = False
+    children: list[RioTreeItem] = []
+    is_expanded: bool = False
+
+    def build_primary_text(self):
+        if not self.editing:
+            return rio.Text(self.text, justify='left', selectable=False)
+        return rio.TextInput(
+            self.text,
+            align_x=0,  # justify left?
+            on_confirm=self.handle_edit_confirm,
+        )
+
+    def build_content(self):
+        content = self.build_primary_text()
+        if self.tooltip:
+            content = rio.Row(content, rio.Tooltip(anchor=content, tip=self.tooltip))
+        if self.on_double_press:
+            content = rio.PointerEventListener(content, on_double_press=self.handle_double_press)
+        return content
+
+    def handle_double_press(self, ev: rio.PointerEvent):
+        if self.editable:
+            self.editing = True
+        if self.on_double_press:
+            self.on_double_press()
+
+    def handle_edit_confirm(self, text):
+        assert self.editing
+        self.text = text
+        if self.on_change:
+            self.on_change()
+
+    def build(self):
+        return rio.SimpleTreeItem(
+            content=self.build_content(),
+            children=[child.build() for child in self.children],
+            is_expanded=self.is_expanded,
+            on_press=self.on_press,
+        )
+
+
+class RioTreeView(rio.Component):
+    """makes item-level callbacks available on the tree level"""
+
+    children: list[rio.Component] = None
+    selection_mode: Literal['none', 'single', 'multiple'] = ('none',)
+    col_count: int = 1
+    header_labels: list[str] | None = None
+
+    def __post__init__(self):
+        if self.header_labels is None:
+            self.header_labels = ['header']
+
+    def build(self):
+        return rio.TreeView(
+            *[item.build() for item in self.children],  # TODO: should not need to build each item
+            selection_mode=self.selection_mode,
+        )

ui_10x/rio/conftest.py

@@ -0,0 +1,35 @@
+import os
+
+import pytest
+import rio.testing.browser_client
+
+
+def running_with_coverage(config):
+    if not config.pluginmanager.getplugin('pytest_cov'):
+        return False
+
+    if not config.getoption('--cov', default='COV_CORE_SOURCE' in os.environ):
+        return False
+
+    return not config.getoption('--no-cov', default=False)
+
+
+@pytest.fixture(scope='session', autouse=True)
+async def manage_server(request):
+    if running_with_coverage(request.config):
+        # run headless client even if running with coverage
+        rio.testing.browser_client.DEBUGGER_ACTIVE = False
+        pytest.mark.timeout(180)
+    else:
+        if rio.testing.browser_client.DEBUGGER_ACTIVE:
+            pytest.mark.timeout(0 if rio.testing.browser_client.DEBUGGER_ACTIVE else 90)
+
+    async with rio.testing.browser_client.prepare_browser_client():
+        yield
+
+
+@pytest.fixture(autouse=True)
+def setup_ui_platform(monkeypatch):
+    monkeypatch.setenv('UI_PLATFORM', 'Rio')
+    yield
+    monkeypatch.undo()

ui_10x/rio/internals/app.py

@@ -0,0 +1,192 @@
+from __future__ import annotations
+
+import asyncio
+import pathlib
+from dataclasses import dataclass
+from functools import partial
+from typing import TYPE_CHECKING
+
+import ordered_set
+from webview_proc import WebViewProcess
+
+import rio
+from rio import app_server, errors, utils
+
+if TYPE_CHECKING:
+    from collections.abc import Callable, Iterable
+
+    import uvicorn
+
+
+@dataclass
+class App10x:
+    """
+    # App10x - a custom App to use in dialog.
+    # rio.App is t.final, so App10x wraps rio.App and implements run_in_window
+    # --> run webview out-of-process
+    # --> run fastapi server in-process
+    # --> uses a subclass fo FastAPIServer to create a custom session class
+    #   --> custom session class communicates with out-of-process webview (rather than using webview_shim)
+    """
+
+    app: rio.App
+    webview: WebViewProcess | None = None
+
+    @staticmethod
+    def _update_window_size(width: float | None, height: float | None) -> None:
+        import webview  # imported here as called in separate process
+
+        if width is None and height is None:
+            return
+        window = webview.windows[0]
+        print(f'Current window size: {window.width}x{window.height} pixels')
+        pixels_per_rem = window.evaluate_js("""
+            let measure = document.createElement('div');
+            document.body.appendChild(measure);
+            measure.style.height = '1rem';
+            let pixels_per_rem = measure.getBoundingClientRect().height * window.devicePixelRatio;
+            measure.remove();
+            pixels_per_rem;
+        """)
+        width_in_pixels = window.width if width is None else round(width * pixels_per_rem)
+        height_in_pixels = window.height if height is None else round(height * pixels_per_rem)
+        print(f'Resizing window to {width_in_pixels}x{height_in_pixels} pixels ({width}x{height} rem at {pixels_per_rem} pixels/rem)')
+        window.resize(width_in_pixels, height_in_pixels)
+
+    def _run_in_window(
+        self,
+        *,
+        quiet: bool = True,
+        maximized: bool = False,
+        fullscreen: bool = False,
+        width: float | None = None,
+        height: float | None = None,
+        debug_mode: bool = False,
+        on_server_created: Callable[[uvicorn.Server], None] | None = None,
+    ) -> None:
+        host = 'localhost'
+        port = utils.ensure_valid_port(host, None)
+        url = f'http://{host}:{port}'
+
+        server: uvicorn.Server | None = None
+
+        icon_path = asyncio.run(self.app._fetch_icon_as_png_path())
+
+        self.webview = webview = WebViewProcess(
+            url=url,
+            title=self.app.name,
+            maximized=maximized,
+            fullscreen=fullscreen,
+            icon_path=icon_path,
+            func=partial(self._update_window_size, width, height),
+            on_close=lambda: server and setattr(server, 'should_exit', True),
+        )
+
+        def _on_server_created(_server: uvicorn.Server) -> None:
+            nonlocal server
+            server = _server
+
+            fastapi_server = server.config.app
+            fastapi_server.__class__ = FastapiServer
+            fastapi_server.app10x = self
+            if on_server_created:
+                on_server_created(server)
+
+        try:
+            self.app._run_as_web_server(
+                host=host,
+                port=port,
+                quiet=quiet,
+                running_in_window=True,
+                internal_on_app_start=webview.start,
+                internal_on_server_created=_on_server_created,
+                debug_mode=debug_mode,
+            )
+        except Exception as e:
+            print(f'Error running app: {e}')
+        finally:
+            if webview.is_alive():
+                webview.close()
+                webview.join()
+
+
+class FastapiServer(app_server.FastapiServer):
+    app10x: App10x
+
+    async def create_session(self, *args, **kwargs) -> rio.Session:
+        session = await super().create_session(*args, **kwargs)
+        session.__class__ = Session
+        session.app10x = self.app10x
+        return session
+
+
+class Session(rio.Session):
+    app10x: App10x
+
+    async def _close(self, close_remote_session: bool) -> None:
+        if not self.running_in_window:
+            await super()._close(close_remote_session=close_remote_session)
+
+        await super()._close(close_remote_session=False)
+        if close_remote_session:
+            self.app10x.webview.close()
+
+    async def _get_webview_window(self):
+        raise RuntimeError('Should not be called required in out-of-process webview')
+
+    async def set_title(self, title: str) -> None:
+        if not self.running_in_window:
+            await super().set_title(title)
+
+        self.app10x.webview.set_title(title)
+
+    async def pick_folder(self) -> pathlib.Path:
+        if not self.running_in_window:
+            return await super().pick_folder()
+
+        return pathlib.Path(self.app10x.webview.pick_folder())
+
+    async def pick_file(
+        self,
+        *,
+        file_types: Iterable[str] | None = None,
+        multiple: bool = False,
+    ) -> utils.FileInfo | list[utils.FileInfo]:
+        if not self.running_in_window:
+            return await super().pick_file(file_types=file_types, multiple=multiple)
+
+        # Normalize the file types
+        if file_types is not None:
+            # Normalize and deduplicate, but maintain the order
+            file_types = list(ordered_set.OrderedSet(utils.normalize_file_extension(file_type) for file_type in file_types))
+
+        selected = self.app10x.webview.pick_file(
+            file_types=[f'{extension} (*.{extension})' for extension in file_types],
+            multiple=multiple,
+        )
+
+        if not selected:
+            raise errors.NoFileSelectedError()
+
+        return [utils.FileInfo._from_path(path) for path in selected] if multiple else utils.FileInfo._from_path(selected)
+
+    async def save_file(
+        self,
+        file_contents: pathlib.Path | str | bytes,
+        file_name: str = 'Unnamed File',
+        *,
+        media_type: str | None = None,
+        directory: pathlib.Path | None = None,
+    ) -> None:
+        if not self.running_in_window:
+            return await super().save_file(file_contents, file_name, media_type=media_type, directory=directory)
+
+        self.app10x.webview.save_file(
+            file_contents=file_contents,
+            directory='' if directory is None else str(directory),
+            file_name=file_name,
+        )
+
+
+Session._local_methods_ = rio.Session._local_methods_.copy()
+Session._remote_methods_ = rio.Session._remote_methods_.copy()

ui_10x/rio/manual_tests/basic_test.py

@@ -0,0 +1,24 @@
+import os
+
+if __name__ == '__main__':
+    assert os.environ.setdefault('UI_PLATFORM', 'Rio') == os.getenv('UI_PLATFORM')
+    from ui_10x.platform import ux
+
+    print(ux.Dialog(children=[ux.Label('Message'), ux.Label('Message2')], title='Title').exec())
+
+    # from functools import partial
+    #
+    # from rio import project_config, App, Text, TextStyle, ComponentPage, page
+
+    # app = App(
+    #     pages=[
+    #         ComponentPage( '', '',
+    #             build=lambda: ux.VBoxLayout(
+    #                 ux.Label('a'),
+    #                 ux.PushButton('b',on_press=partial(print, 'b pressed')),
+    #             )(),
+    #         )
+    #     ]
+    # )
+    # app.run_in_window()
+    #

ui_10x/rio/manual_tests/splitter.py

@@ -0,0 +1,27 @@
+from rio.debug.monkeypatches import apply_monkeypatches
+
+import rio
+from ui_10x.rio.components.splitter import Splitter
+
+
+# Example app to demonstrate the Splitter component
+class SplitterApp(rio.Component):
+    def build(self) -> rio.Component:
+        splitter = Splitter(
+            children=[
+                rio.Text('Pane 1', style='heading3'),
+                rio.Text('Pane 2', style='heading3'),
+                rio.Rectangle(content=rio.Container(rio.Container(rio.FlowContainer()))),
+            ],
+            handle_size=0.3,  # Splitter handle width
+            direction='horizontal',
+        )
+        return rio.Container(rio.Column(rio.Column(rio.Row(rio.Button('A'), rio.Button('B')), rio.Container(splitter))))
+
+
+# Run the app
+if __name__ == '__main__':
+    app = rio.App(build=SplitterApp)
+    apply_monkeypatches()
+    # app._run_in_window(debug_mode=True)
+    app._run_as_web_server(debug_mode=True, port=8080, host='')

ui_10x/rio/platform_implementation.py

@@ -0,0 +1,91 @@
+from __future__ import annotations
+
+from core_10x.global_cache import cache
+
+from ui_10x.rio import component_builder, widgets
+
+
+@cache
+def init(): ...
+
+
+class Object: ...
+
+
+Application = widgets.Application
+
+
+DirectConnection = component_builder.ConnectionType.DIRECT
+QueuedConnection = component_builder.ConnectionType.QUEUED
+
+
+SignalDecl = component_builder.SignalDecl
+
+
+def signal_decl(arg=object):
+    assert arg is object, 'arg must be object'
+    return SignalDecl()
+
+
+MouseEvent = component_builder.MouseEvent
+
+
+SCROLL = widgets.SCROLL
+
+Point = component_builder.Point
+FontMetrics = component_builder.FontMetrics
+SizePolicy = component_builder.FontMetrics
+TEXT_ALIGN = component_builder.TEXT_ALIGN
+
+Widget = component_builder.Widget
+Layout = component_builder.Layout
+FlowLayout = component_builder.FlowLayout
+
+LineEdit = widgets.LineEdit
+Label = widgets.Label
+PushButton = widgets.PushButton
+
+Spacer = widgets.Spacer
+
+HBoxLayout = widgets.HBoxLayout
+VBoxLayout = widgets.VBoxLayout
+FormLayout = widgets.FormLayout
+
+Dialog = widgets.Dialog
+
+MessageBox = widgets.MessageBox
+
+RadioButton = widgets.RadioButton
+ButtonGroup = widgets.ButtonGroup
+
+GroupBox = widgets.GroupBox
+
+TextEdit = widgets.TextEdit
+CheckBox = widgets.CheckBox
+ScrollArea = widgets.ScrollArea
+Separator = widgets.Separator
+
+
+def separator(horizontal=True) -> Separator:
+    return Separator() if horizontal else Separator(orientation='vertical')
+
+
+Direction = widgets.Direction
+
+Vertical = Direction.VERTICAL
+Horizontal = Direction.HORIZONTAL
+
+Splitter = widgets.Splitter
+
+Style = widgets.Style
+
+FindFlags = widgets.FindFlags
+MatchExactly = FindFlags.MATCH_EXACTLY
+
+ListWidget = widgets.ListWidget
+ListItem = widgets.ListItem
+
+TreeWidget = widgets.TreeWidget
+TreeItem = widgets.TreeItem
+
+CalendarWidget = widgets.CalendarWidget