dearfy 0.1.0a1__tar.gz

dearfy-0.1.0a1/LICENSE

@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) 2025 Romanin
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

dearfy-0.1.0a1/PKG-INFO

@@ -0,0 +1,53 @@
+Metadata-Version: 2.4
+Name: dearfy
+Version: 0.1.0a1
+Summary: A library for simplifying the creation of complex GUIs using DearPyGUI.
+Author-email: Romanin <semina054@gmail.com>
+License: MIT
+Requires-Python: <3.15,>=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: dearpygui>=2.3.1
+Requires-Dist: loguru>=0.7.3
+Requires-Dist: rich>=15.0.0
+Requires-Dist: typing-extensions>=4.16.0
+Dynamic: license-file
+
+# dearfy
+
+## Desription
+A library to simplify the creation of complex applications using DearPyGUI (based on DearImGUI).
+
+## Using
+
+```python
+from dearfy.app import App, action
+from dearfy.widgets import *
+from dearfy.handlers import ClickedHandler
+from dearfy.typing import Tag
+
+
+class MyApp(App):
+    def compose(self) -> ComposeResult:
+        with Window(label='Title'):
+            with Group(horizontal=True):
+                with Text('Click for SURPRISE: '):
+                    yield ClickedHandler(callback='test0')
+                yield Button(label='*click*', callback='test1')
+    
+    # Attribute handling is used, 
+    # i.e. all functions that start with `action_` will be wrapped in `Action`.
+    def action_test0(self, sender: Tag):
+        print('!!! SURPRISE #1 !!!')
+    
+    # And it is possible not to write them through self, 
+    # although if you decide to do it, 
+    # you will have to wrap them in the action decorator anyway.
+    @action('test1')
+    def action_test1(self):
+        print('!!! SURPRISE #2 !!!')
+```
+
+## Installing
+
+So far, the project is still under development. So I don't recommend to use it as a basis for any project.

dearfy-0.1.0a1/README.md

@@ -0,0 +1,38 @@
+# dearfy
+
+## Desription
+A library to simplify the creation of complex applications using DearPyGUI (based on DearImGUI).
+
+## Using
+
+```python
+from dearfy.app import App, action
+from dearfy.widgets import *
+from dearfy.handlers import ClickedHandler
+from dearfy.typing import Tag
+
+
+class MyApp(App):
+    def compose(self) -> ComposeResult:
+        with Window(label='Title'):
+            with Group(horizontal=True):
+                with Text('Click for SURPRISE: '):
+                    yield ClickedHandler(callback='test0')
+                yield Button(label='*click*', callback='test1')
+    
+    # Attribute handling is used, 
+    # i.e. all functions that start with `action_` will be wrapped in `Action`.
+    def action_test0(self, sender: Tag):
+        print('!!! SURPRISE #1 !!!')
+    
+    # And it is possible not to write them through self, 
+    # although if you decide to do it, 
+    # you will have to wrap them in the action decorator anyway.
+    @action('test1')
+    def action_test1(self):
+        print('!!! SURPRISE #2 !!!')
+```
+
+## Installing
+
+So far, the project is still under development. So I don't recommend to use it as a basis for any project.

dearfy-0.1.0a1/dearfy/__init__.py

@@ -0,0 +1,19 @@
+import loguru
+import logging as std_logging
+# > Local Imports
+from dearfy.logging import LoguruRichHandler, spetific_format_log
+
+# ! Logging
+
+loguru.logger.configure(
+    handlers=[
+        {
+            'sink': LoguruRichHandler(
+                markup=True,
+                show_path=False,
+            ),
+            'format': spetific_format_log,
+            'level': std_logging.NOTSET,
+        }
+    ]
+)

dearfy-0.1.0a1/dearfy/action.py

@@ -0,0 +1,309 @@
+import loguru
+import inspect
+import datetime
+import threading
+from enum import Enum, Flag, auto
+# > Typing
+from typing_extensions import (
+    Any,
+    Iterable,
+    Callable,
+    Literal,
+    TypeAlias, TypeVar,
+)
+# > Local Imports
+from dearfy.typing import Tag
+
+# ! Types
+
+T = TypeVar('T')
+
+ReturnType = TypeVar('ReturnType')
+
+ActionName: TypeAlias = str
+ActionGroup: TypeAlias = str
+ActionIndeficator: TypeAlias = tuple[ActionName, ActionGroup]
+ActionMethod: TypeAlias = \
+    Callable[[Tag, dict[str, Any] | str, Any | None], ReturnType] | \
+    Callable[[Tag, dict[str, Any] | str], ReturnType] | \
+    Callable[[Tag], ReturnType] | \
+    Callable[[], ReturnType]
+
+class ActionState(Flag):
+    RUNNING = auto()
+    ENABLED = auto()
+
+class ActionCallMode(Enum):
+    ONE = 0
+    MANY = 1
+
+class ActionBlockMode(Enum):
+    NONE = 0
+    ALL = 1
+    GROUP = 2
+    SPETIFIC = 3
+
+ActionCallModeLiteral: TypeAlias = Literal['one', 'many'] | Literal[0, 1]
+ActionBlockModeLiteral: TypeAlias = Literal['none', 'all', 'group', 'spetific'] | Literal[0, 1, 2, 3]
+
+def __sample_action_method__(sender: Tag, app_data: dict[str, Any] | str, user_data: Any | None) -> Any: ...
+
+def _match_call_args(self: object | None, method: ActionMethod, *args: object) -> tuple[object, ...]:
+    params = list(inspect.signature(method).parameters.keys())
+    if self is not None:
+        if ('self' in params) or ('app' in params):
+            return (self, *(args[:len(params) - 1]))
+    return args[:len(params)]
+
+# ! Methods
+
+def validate_enum(enum_type: type[T], value: ActionBlockMode | str | int) -> T:
+    if isinstance(value, str):
+        value: T = getattr(enum_type, value.upper())
+    elif isinstance(value, int):
+        value: T = enum_type(value)
+    return value
+
+# ! Action Class
+
+class Action:
+    def __init__(
+        self,
+        parent: 'Actioner',
+        name: str,
+        method: ActionMethod,
+        group: str='main',
+        callmode: ActionCallModeLiteral | ActionCallMode = ActionCallMode.MANY,
+        blockmode: ActionBlockModeLiteral | ActionBlockMode = ActionBlockMode.NONE,
+        blocks: Iterable[ActionName | tuple[ActionName, ActionGroup]]=[],
+        threaded: bool=False,
+        /
+    ) -> None:
+        self.actions = parent
+        self.__name = name
+        self.__method = method
+        self.__group = group
+        self.__indeficator: tuple[str, str] = (name, group)
+        self.__threaded = threaded
+        self.__thread: threading.Thread | None = None
+        self.callmode = validate_enum(ActionCallMode, callmode)
+        self.blockmode = validate_enum(ActionBlockMode, blockmode)
+        self.blocks = list(blocks)
+        self.state = ActionState.ENABLED
+        self.last_call = None
+    
+    # ^ Dunder Methods
+    
+    def __str__(self) -> str:
+        return f'{self.__class__.__name__}(<{self.__name!r}, {self.__group!r}>)'
+    
+    def __repr__(self) -> str:
+        return self.__str__()
+    
+    def __hash__(self) -> int:
+        return hash(self.__indeficator)
+    
+    def __eq__(self, other: 'Action | tuple[ActionName, ActionGroup]') -> bool:
+        if not (isinstance(other, Action) or isinstance(other, tuple)):
+            return False
+        return hash(self) == hash(other)
+    
+    def __ne__(self, other: 'Action | tuple[ActionName, ActionGroup]') -> bool:
+        return not self.__eq__(other)
+    
+    def __getattr__(self, name: str):
+        return getattr(__sample_action_method__, name)
+    
+    # ^ Propetyes
+
+    @property
+    def name(self) -> str:
+        return self.__name
+    
+    @property
+    def group(self) -> str:
+        return self.__group
+    
+    @property
+    def indeficator(self) -> tuple[ActionName, ActionGroup]:
+        return self.__indeficator
+    
+    @property
+    def method(self) -> ActionMethod:
+        return self.__method
+    
+    @property
+    def blocked(self) -> bool:
+        for block_mode, owner, blocks in self.actions.blocks.copy():
+            if block_mode == ActionBlockMode.NONE:
+                continue
+            elif block_mode == ActionBlockMode.ALL:
+                return True
+            elif block_mode == ActionBlockMode.GROUP:
+                return owner[1] == self.__group
+            elif block_mode == ActionBlockMode.SPETIFIC:
+                for blocked_iderficator in blocks:
+                    if isinstance(blocked_iderficator, str):
+                        if blocked_iderficator == self.__name:
+                            return True
+                    elif isinstance(blocked_iderficator, tuple):
+                        if blocked_iderficator == self.__indeficator:
+                            return True
+        return False
+    
+    @property
+    def enabled(self) -> bool:
+        return ActionState.ENABLED in self.state
+    
+    @enabled.setter
+    def enabled(self, value: bool) -> None:
+        if value:
+            self.state |= ActionState.ENABLED
+        else:
+            self.state &= ~ActionState.ENABLED
+    
+    @property
+    def threaded(self) -> bool:
+        return self.__threaded
+    
+    # ^ Action Methods
+
+    def can_call(self) -> bool:
+        return (not ((ActionCallMode.ONE == self.callmode) and (ActionState.RUNNING in self.state))) or self.blocked
+    
+    # ^ Call Methods
+
+    def __call_main__(
+        self,
+        sender: Tag,
+        app_data: dict[str, Any] | str | None,
+        user_data: Any | None=None
+    ) -> Any | None:
+        self.state |= ActionState.RUNNING
+        self.last_call = datetime.datetime.now()
+        self.actions.set_block(True, self.indeficator, self.blockmode, self.blocks)
+        try:
+            result = self.method(*_match_call_args(self.actions._app, self.method, sender, app_data, user_data))
+        except:
+            result = None
+            loguru.logger.exception('An error has occurred in action!')
+        self.actions.set_block(False, self.indeficator, self.blockmode, self.blocks)
+        self.state &= ~ActionState.RUNNING
+        return result
+    
+    def __call_thread__(
+        self,
+        sender: Tag,
+        app_data: dict[str, Any] | str | None,
+        user_data: Any | None=None
+    ) -> None:
+        self.state |= ActionState.RUNNING
+        self.last_call = datetime.datetime.now()
+        self.actions.set_block(True, self.indeficator, self.blockmode, self.blocks)
+        try:
+            self.method(*_match_call_args(self.actions._app, self.method, sender, app_data, user_data))
+        except:
+            loguru.logger.exception('An error has occurred in action!')
+        self.actions.set_block(False, self.indeficator, self.blockmode, self.blocks)
+        self.state &= ~ActionState.RUNNING
+
+    def __call__(
+        self,
+        sender: Tag,
+        app_data: dict[str, Any] | str | None,
+        user_data: Any | None=None
+    ) -> Any | None:
+        loguru.logger.trace(f"[red]Call[/red]: {self!r}.__call__({sender!r}, {app_data!r}, {user_data!r})")
+        if not self.enabled:
+            return
+        if not self.__threaded:
+            if not self.can_call():
+                loguru.logger.trace(f"[yellow]Cancel[/yellow] action <{self.__indeficator}> because the call is not currently available.")
+                return
+            loguru.logger.trace(f"[green]Starting[/green] action <{self.__indeficator}> in [gray bold]simple mode[/gray bold].")
+            return self.__call_main__(sender, app_data, user_data)
+        else:
+            if not self.can_call():
+                loguru.logger.trace(f"[yellow]Cancel[/yellow] action <{self.__indeficator}> because the call is not currently available.")
+                return
+            if self.__thread is not None:
+                if self.__thread.is_alive():
+                    loguru.logger.trace(f"[yellow]Cancel[/yellow] action <{self.__indeficator}> because the previous call [gray bold]in the thread[/gray bold] has not yet ended.")
+                    return
+            loguru.logger.trace(f"[green]Starting[/green] action <{self.__indeficator}> in [gray bold]thread mode[/gray bold].")
+            self.__thread = threading.Thread(target=self.__call_thread__, args=(sender, app_data, user_data))
+            self.__thread.start()
+            return
+
+# ! Actioner Class
+
+class Actioner:
+    def __init__(self, app: object | None = None) -> None:
+        self._app = app
+        self.__set_block_semaphore = threading.Semaphore(1)
+        self.actions: dict[tuple[ActionName, ActionGroup], Action] = {}
+        self.blocks: list[
+            tuple[ActionBlockMode, tuple[ActionName, ActionGroup], list[ActionName | tuple[ActionName, ActionGroup]]]
+        ] = []
+    
+    def __str__(self) -> str:
+        return f'{self.__class__.__name__}({list(self.actions.values())})'
+    
+    def __repr__(self) -> str:
+        return self.__str__()
+    
+    def set_block(
+        self,
+        value: bool,
+        blocker_action: tuple[ActionName, ActionGroup],
+        blockmode: ActionBlockMode,
+        blocks: list[ActionName | tuple[ActionName, ActionGroup]],
+        /
+    ) -> None:
+        self.__set_block_semaphore.acquire()
+        if value:
+            self.blocks.append((blockmode, blocker_action, blocks))
+        else:
+            indexs_needed_remove = [index for index, block in enumerate(self.blocks) if (block[1] == blocker_action)]
+            for index_needed_remove in indexs_needed_remove:
+                self.blocks.pop(index_needed_remove)
+        self.__set_block_semaphore.release()
+    
+    def get(self, key: ActionIndeficator | ActionName, default: T=None) -> Action | T:
+        if isinstance(key, str):
+            for action_indeficator in self.actions.copy().keys():
+                if action_indeficator[0] == key:
+                    return self.actions[action_indeficator]
+        elif isinstance(key, tuple):
+            return self.actions[key]
+        return default
+    
+    def action(
+        self,
+        name: str,
+        group: str='main',
+        callmode: ActionCallModeLiteral | ActionCallMode = ActionCallMode.MANY,
+        blockmode: ActionBlockModeLiteral | ActionBlockMode = ActionBlockMode.NONE,
+        blocks: Iterable[ActionName | tuple[ActionName, ActionGroup]]=[],
+        threaded: bool=False,
+    ):
+        def wrapper(method: ActionMethod):
+            action = Action(self, name, method, group, callmode, blockmode, blocks, threaded)
+            self.actions[action.indeficator] = action
+            return action
+        return wrapper
+    
+    def add_action(
+        self,
+        method: ActionMethod,
+        name: str,
+        group: str='main',
+        callmode: ActionCallModeLiteral | ActionCallMode = ActionCallMode.MANY,
+        blockmode: ActionBlockModeLiteral | ActionBlockMode = ActionBlockMode.NONE,
+        blocks: Iterable[ActionName | tuple[ActionName, ActionGroup]]=[],
+        threaded: bool=False,
+    ) -> None:
+        action = Action(self, name, method, group, callmode, blockmode, blocks, threaded)
+        if action.indeficator in self.actions:
+            self.actions[action.indeficator].enabled = False
+        self.actions[action.indeficator] = action

dearfy-0.1.0a1/dearfy/app.py

@@ -0,0 +1,168 @@
+import loguru
+from enum import Enum
+import dearpygui.dearpygui as dpg
+# > Typing
+from typing_extensions import TypeAlias, Iterator
+# > Local Imports
+from dearfy.base import Item, DOMNode
+from dearfy.typing import Color, FilePath, Tag
+from dearfy.field import field
+from dearfy.action import Actioner, Action
+from dearfy.functions import formatting_kwargs, get_method_needed
+
+# ! Types
+
+ComposeResult: TypeAlias = Iterator[Item]
+
+# ! States
+
+class AppState(Enum):
+    NONE = 0
+    PREPARING = 1
+    PREINIT = 2
+    INIT = 3
+    POSTINIT = 4
+    RUNNING = 5
+
+# ! App Base Class
+
+class App(DOMNode):
+    _node_children: list[Item]
+    _actioner: Actioner = Actioner()
+
+    def __init__(
+        self,
+        title: str = 'Dearfy Viewport',
+        small_icon: FilePath | None = None,
+        large_icon: FilePath | None = None,
+        width: int = 1280,
+        height: int = 800,
+        x_pos: int = 100,
+        y_pos: int = 100,
+        min_width: int = 250,
+        max_width: int = 10000,
+        min_height: int = 250,
+        max_height: int = 10000,
+        resizable: bool = True,
+        vsync: bool = True,
+        always_on_top: bool = False,
+        decorated: bool = True,
+        clear_color: Color = (0, 0, 0, 255),
+        disable_close: bool = False,
+        minimized: bool = False,
+        maximized: bool = False
+    ) -> None:
+        super().__init__()
+        self._state: AppState = AppState.NONE
+        self._gkwagrs = {
+            'create_viewport': {
+                'title': title,
+                'small_icon': field(small_icon, '', nullable=False),
+                'large_icon': field(large_icon, '', nullable=False),
+                'width': width,
+                'height': height,
+                'x_pos': x_pos,
+                'y_pos': y_pos,
+                'min_width': min_width,
+                'max_width': max_width,
+                'min_height': min_height,
+                'max_height': max_height,
+                'resizable': resizable,
+                'vsync': vsync,
+                'always_on_top': always_on_top,
+                'decorated': decorated,
+                'clear_color': clear_color,
+                'disable_close': disable_close,
+            },
+            'show_viewport': {
+                'minimized': minimized,
+                'maximized': maximized,
+            }
+        }
+        self.__dearfy_compose__()
+        self.__dearfy_init_action_attributes__()
+        self._actioner._app = self
+        self._nodes.clear()
+    
+    def __str__(self) -> str:
+        kwargs = {}
+        for item_kwargs in self._gkwagrs.values():
+            kwargs.update(item_kwargs)
+        kwargs = get_method_needed(self.__init__, **kwargs)
+        return f'{self.__class__.__name__}({formatting_kwargs(**kwargs)})'
+    
+    def __dearfy_init_action_attributes__(self) -> None:
+        for attr_name in dir(self):
+            if attr_name.startswith('action_'):
+                attr = getattr(self, attr_name)
+                if isinstance(attr, Action):
+                    continue
+                elif callable(attr):
+                    self._actioner.add_action(attr, attr_name[7:])
+    
+    def __dearfy_compose__(self) -> None:
+        self._nodes.append(self)
+        for child in self.compose():
+            if self._current_node:
+                self._current_node._add_child(child)
+        self._nodes.clear()
+    
+    def __dearfy_preparing__(self) -> None:
+        for child in self._node_children:
+            child.__dearfy_preparing__(self)
+
+    def __dearfy_preinit__(self) -> None:
+        for child in self._node_children:
+            child.__dearfy_preinit__()
+    
+    def __dearfy_init__(self) -> None:
+        for child in self._node_children:
+            child.__dearfy_init__()
+    
+    def __dearfy_postinit__(self) -> None:
+        for child in self._node_children:
+            child.__dearfy_postinit__()
+    
+    def __dearfy_destroy__(self) -> None:
+        for child in self._node_children:
+            child.__dearfy_destroy__()
+    
+    def get_item(self, tag: Tag) -> Item:
+        try:
+            return self._node_main_parent._get_node_by_attr('tag', tag)
+        except AttributeError:
+            pass
+        raise RuntimeError(
+            "There is no Item with this tag. "
+            f"_node_main_parent={self._node_main_parent!r}"
+        )
+
+    def run(self) -> None:
+        self._state = AppState.PREPARING
+        self.__dearfy_preparing__()
+        loguru.logger.trace('[green]▬▬▬▬▬[/green] [yellow]AFTER PREPARING[/yellow] [green]▬▬▬▬▬[/green]')
+        loguru.logger.trace(self._to_rich_tree())
+        dpg.create_context()
+        dpg.create_viewport(**(self._gkwagrs['create_viewport']))
+        self._state = AppState.PREINIT
+        self.__dearfy_preinit__()
+        loguru.logger.trace('[green]▬▬▬▬▬[/green] [yellow]AFTER PREINIT[/yellow] [green]▬▬▬▬▬[/green]')
+        loguru.logger.trace(self._to_rich_tree())
+        self._state = AppState.INIT
+        self.__dearfy_init__()
+        loguru.logger.trace('[green]▬▬▬▬▬[/green] [yellow]AFTER INIT[/yellow] [green]▬▬▬▬▬[/green]')
+        loguru.logger.trace(self._to_rich_tree())
+        dpg.setup_dearpygui()
+        self._state = AppState.POSTINIT
+        self.__dearfy_postinit__()
+        loguru.logger.trace('[green]▬▬▬▬▬[/green] [yellow]AFTER POSTINIT[/yellow] [green]▬▬▬▬▬[/green]')
+        loguru.logger.trace(self._to_rich_tree())
+        self._state = AppState.RUNNING
+        dpg.show_viewport(**(self._gkwagrs['show_viewport']))
+        dpg.start_dearpygui()
+        dpg.destroy_context()
+        self._state = AppState.NONE
+        self.__dearfy_destroy__()
+        loguru.logger.trace(self._to_rich_tree())
+
+action = App._actioner.action

dearfy-0.1.0a1/dearfy/app.pyi

@@ -0,0 +1,94 @@
+
+# > Typing
+from typing_extensions import TypeAlias, Iterable, Iterator, ClassVar
+# > Local Imports
+from dearfy.base import Item, DOMNode
+from dearfy.typing import Color, FilePath, Tag
+from dearfy.action import (
+    Actioner, Action,
+    ActionBlockMode, ActionBlockModeLiteral, 
+    ActionCallMode, ActionCallModeLiteral,
+    ActionName, ActionGroup
+)
+
+# ! Types
+
+ComposeResult: TypeAlias = Iterator[Item]
+
+# ! App Base Class
+
+class App(DOMNode):
+    """Base class for describing an application."""
+
+    _actioner: ClassVar[Actioner]
+
+    _node_children: list[Item]
+
+    def __init__(
+        self,
+        title: str = 'Dearfy Viewport',
+        small_icon: FilePath | None = None,
+        large_icon: FilePath | None = None,
+        width: int = 1280,
+        height: int = 800,
+        x_pos: int = 100,
+        y_pos: int = 100,
+        min_width: int = 250,
+        max_width: int = 10000,
+        min_height: int = 250,
+        max_height: int = 10000,
+        resizable: bool = True,
+        vsync: bool = True,
+        always_on_top: bool = False,
+        decorated: bool = True,
+        clear_color: Color = (0, 0, 0, 255),
+        disable_close: bool = False,
+        minimized: bool = False,
+        maximized: bool = False
+    ) -> None:
+        """Base class for describing an application.
+
+        Args:
+            title (str, optional): Sets the title of the viewport. Defaults to 'Dearfy Viewport'.
+            small_icon (FilePath | None, optional): Sets the small icon that is found in the viewport's decorator bar. Must be \*.ico on Windows and either \*.ico or \*.png on Mac. Defaults to None.
+            large_icon (FilePath | None, optional): Sets the large icon that is found in the task bar while the app is running. Must be \*.ico on Windows and either \*.ico or \*.png on Mac. Defaults to None.
+            width (int, optional): Sets the width of the drawable space on the viewport. Defaults to 1280.
+            height (int, optional): Sets the height of the drawable space on the viewport. Defaults to 800.
+            x_pos (int, optional): Sets X position the viewport will be drawn in screen coordinates. Defaults to 100.
+            y_pos (int, optional): Sets Y position the viewport will be drawn in screen coordinates. Defaults to 100.
+            min_width (int, optional): Applies a minimuim limit to the width of the viewport. Defaults to 250.
+            max_width (int, optional): Applies a maximum limit to the width of the viewport. Defaults to 10000.
+            min_height (int, optional): Applies a minimuim limit to the height of the viewport. Defaults to 250.
+            max_height (int, optional): Applies a maximum limit to the height of the viewport. Defaults to 10000.
+            resizable (bool, optional): Enables and Disables user ability to resize the viewport. Defaults to True.
+            vsync (bool, optional): Enables and Disables the renderloop vsync limit. Vsync frame value is set by refresh rate of display. Defaults to True.
+            always_on_top (bool, optional): Forces the viewport to always be drawn ontop of all other viewports. Defaults to False.
+            decorated (bool, optional): Enabled and disabled the decorator bar at the top of the viewport. Defaults to True.
+            clear_color (Color, optional): Sets the color of the back of the viewport. Defaults to (0, 0, 0, 255).
+            disable_close (bool, optional): Disables the viewport close button. Can be used with set_exit_callback. Defaults to False.
+            minimized (bool, optional): Sets the state of the viewport to minimized. Defaults to False.
+            maximized (bool, optional): Sets the state of the viewport to maximized. Defaults to False.
+        """
+        ...
+    
+    def compose(self) -> ComposeResult: ...
+
+    def __dearfy_compose__(self) -> None: ...
+    def __dearfy_preparing__(self) -> None: ...
+    def __dearfy_preinit__(self) -> None: ...
+    def __dearfy_init__(self) -> None: ...
+    def __dearfy_postinit__(self) -> None: ...
+
+    def get_item(self, tag: Tag) -> Item: ...
+
+    def run(self) -> None: ...
+
+def action(
+    name: str,
+    group: str='main',
+    callmode: ActionCallModeLiteral | ActionCallMode = ActionCallMode.MANY,
+    blockmode: ActionBlockModeLiteral | ActionBlockMode = ActionBlockMode.NONE,
+    blocks: Iterable[ActionName | tuple[ActionName, ActionGroup]]=[],
+    threaded: bool=False,
+) -> Action:
+    ...