python-tty 0.1.0__py3-none-any.whl

python_tty/console_factory.py

@@ -0,0 +1,100 @@
+import asyncio
+import threading
+
+from python_tty.config import Config
+from python_tty.consoles.loader import load_consoles
+from python_tty.consoles.manager import ConsoleManager
+from python_tty.consoles.registry import REGISTRY
+from python_tty.executor import CommandExecutor
+
+
+class ConsoleFactory:
+    """Bootstrap console system by loading modules and registering consoles.
+
+    Example:
+        # Pass your business core instance here to make it available
+        # to all console/commands classes via the manager service.
+        factory = ConsoleFactory(object())
+        factory.start()
+
+    Notes:
+        - To auto-load consoles, update DEFAULT_CONSOLE_MODULES in
+          python_tty.consoles.loader with the modules that define your console classes.
+        - Or call load_consoles(...) yourself before starting to register
+          consoles via their decorators.
+    """
+    def __init__(self, service=None, config: Config = None):
+        if config is None:
+            config = Config()
+        self.config = config
+        self.executor = CommandExecutor(config=config.executor)
+        self._executor_loop = None
+        self._executor_thread = None
+        self.manager = ConsoleManager(
+            service=service,
+            executor=self.executor,
+            on_shutdown=self.shutdown,
+            config=config.console_manager,
+        )
+        load_consoles()
+        REGISTRY.register_all(self.manager)
+
+    def start(self):
+        """Start the console loop with the registered root console."""
+        self._start_executor_if_needed()
+        self.manager.run()
+
+    def start_executor(self, loop=None):
+        """Start executor workers on the provided asyncio loop."""
+        self.executor.start(loop=loop)
+
+    def shutdown_executor(self, wait=True, timeout=None):
+        """Shutdown executor workers after RPC/TTY stop."""
+        loop = self._executor_loop
+        if loop is not None and loop.is_running():
+            self.executor.shutdown_threadsafe(wait=wait, timeout=timeout)
+            loop.call_soon_threadsafe(loop.stop)
+            if self._executor_thread is not None and wait:
+                self._executor_thread.join(timeout)
+            return None
+        return self.executor.shutdown_threadsafe(wait=wait, timeout=timeout)
+
+    def shutdown(self):
+        """Shutdown all resources owned by the factory."""
+        if self.config.console_factory.shutdown_executor:
+            self.shutdown_executor()
+
+    def _start_executor_if_needed(self):
+        if not self.config.console_factory.start_executor:
+            return
+        if self._executor_thread is not None and self._executor_thread.is_alive():
+            return
+        if self.config.console_factory.executor_in_thread:
+            self._start_executor_thread()
+        else:
+            self.start_executor()
+
+    def _start_executor_thread(self):
+        if self._executor_thread is not None and self._executor_thread.is_alive():
+            return
+        loop = asyncio.new_event_loop()
+        self._executor_loop = loop
+
+        def _run_loop():
+            asyncio.set_event_loop(loop)
+            self.start_executor(loop=loop)
+            loop.run_forever()
+            pending = asyncio.all_tasks(loop)
+            if pending:
+                for task in pending:
+                    task.cancel()
+                loop.run_until_complete(asyncio.gather(*pending, return_exceptions=True))
+            loop.close()
+
+        self._executor_thread = threading.Thread(
+            target=_run_loop,
+            name=self.config.console_factory.executor_thread_name,
+            daemon=True,
+        )
+        self._executor_thread.start()
+

python_tty/consoles/__init__.py

@@ -0,0 +1,16 @@
+from python_tty.consoles.core import BaseConsole, MainConsole, SubConsole
+from python_tty.consoles.decorators import root, sub, multi
+from python_tty.consoles.registry import REGISTRY
+from python_tty.consoles.loader import DEFAULT_CONSOLE_MODULES
+
+__all__ = [
+    "BaseConsole",
+    "MainConsole",
+    "SubConsole",
+    "DEFAULT_CONSOLE_MODULES",
+    "REGISTRY",
+    "root",
+    "sub",
+    "multi",
+]
+

python_tty/consoles/core.py

@@ -0,0 +1,140 @@
+import uuid
+from abc import ABC
+
+from prompt_toolkit import PromptSession
+
+from python_tty.ui.events import UIEventListener, UIEventSpeaker
+from python_tty.executor import Invocation
+from python_tty.exceptions.console_exception import ConsoleExit, ConsoleInitException, SubConsoleExit
+from python_tty.ui.output import proxy_print
+from python_tty.utils import split_cmd
+
+
+class BaseConsole(ABC, UIEventListener):
+    forward_console = None
+
+    def __init__(self, console_message, console_style, parent=None, manager=None):
+        self.uid = str(uuid.uuid4())
+        self.parent = parent
+        self.manager = manager if manager is not None else getattr(parent, "manager", None)
+        if self.manager is not None:
+            self.service = self.manager.service
+        else:
+            self.service = getattr(parent, "service", None)
+        BaseConsole.forward_console = self
+        self.commands = self._build_commands()
+        self.session = PromptSession(console_message, style=console_style,
+                                     completer=self.commands.completer,
+                                     validator=self.commands.validator)
+        if isinstance(self.service, UIEventSpeaker):
+            self.service.add_event_listener(self)
+
+    def init_commands(self):
+        return None
+
+    def _build_commands(self):
+        from python_tty.commands import COMMAND_REGISTRY
+        commands_cls = getattr(self.__class__, "__commands_cls__", None)
+        if commands_cls is None:
+            commands = self.init_commands()
+            if commands is not None:
+                return commands
+            commands_cls = COMMAND_REGISTRY.get_commands_cls(self.__class__)
+        if commands_cls is None:
+            from python_tty.commands.mixins import DefaultCommands
+            commands_cls = DefaultCommands
+        return commands_cls(self)
+
+    def handler_event(self, event):
+        if BaseConsole.forward_console is not None and BaseConsole.forward_console == self:
+            proxy_print(event.msg, event.level)
+
+    def run(self, invocation: Invocation):
+        command_def = self.commands.get_command_def_by_id(invocation.command_id)
+        if command_def is None and invocation.command_name is not None:
+            command_def = self.commands.get_command_def(invocation.command_name)
+        if command_def is None:
+            raise ValueError(f"Command not found: {invocation.command_id}")
+        if len(invocation.argv) == 0:
+            return command_def.func(self.commands)
+        return command_def.func(self.commands, *invocation.argv)
+
+    def execute(self, cmd):
+        try:
+            invocation, token = self._build_invocation(cmd)
+            if invocation is None:
+                if token != "":
+                    self.cmd_invoke_miss(cmd)
+                return
+            executor = getattr(self.manager, "executor", None) if self.manager is not None else None
+            if executor is None:
+                self.run(invocation)
+                return
+            executor.submit_threadsafe(invocation, handler=self.run)
+        except ValueError:
+            return
+
+    def _build_invocation(self, cmd):
+        token, arg_text, _ = split_cmd(cmd)
+        if token == "":
+            return None, token
+        command_def = self.commands.get_command_def(token)
+        if command_def is None:
+            return None, token
+        param_list = self.commands.deserialize_args(command_def, arg_text)
+        command_id = self.commands.get_command_id(token)
+        invocation = Invocation(
+            run_id=str(uuid.uuid4()),
+            source="tty",
+            console_id=self.uid,
+            command_id=command_id,
+            command_name=token,
+            argv=param_list,
+            raw_cmd=cmd,
+        )
+        return invocation, token
+
+    def cmd_invoke_miss(self, cmd: str):
+        pass
+
+    def clean_console(self):
+        if isinstance(self.service, UIEventSpeaker):
+            self.service.remove_event_listener(self)
+        if BaseConsole.forward_console == self:
+            BaseConsole.forward_console = self.parent
+
+    def start(self):
+        if self.manager is not None:
+            self.manager.run_with(self)
+            return
+        while True:
+            try:
+                cmd = self.session.prompt()
+                self.execute(cmd)
+            except ConsoleExit:
+                if self.parent is None:
+                    break
+                else:
+                    raise ConsoleExit
+            except SubConsoleExit:
+                break
+            except (KeyboardInterrupt, ValueError):
+                # FIXME: Careful deal this!
+                # continue
+                break
+        self.clean_console()
+
+
+class MainConsole(BaseConsole):
+    def __init__(self, console_message, console_style, parent=None, manager=None):
+        if parent is not None:
+            raise ConsoleInitException("MainConsole parent must be None")
+        super().__init__(console_message, console_style, parent=None, manager=manager)
+
+
+class SubConsole(BaseConsole):
+    def __init__(self, console_message, console_style, parent=None, manager=None):
+        if parent is None:
+            raise ConsoleInitException("SubConsole parent is None")
+        super().__init__(console_message, console_style, parent=parent, manager=manager)
+

python_tty/consoles/decorators.py

@@ -0,0 +1,42 @@
+from python_tty.consoles.registry import REGISTRY
+from python_tty.exceptions.console_exception import ConsoleInitException
+
+
+def root(console_cls):
+    """Mark a MainConsole subclass as the single root console."""
+    from python_tty.consoles import MainConsole
+    if not issubclass(console_cls, MainConsole):
+        raise ConsoleInitException("Root console must inherit MainConsole")
+    REGISTRY.set_root(console_cls)
+    return console_cls
+
+
+def sub(parent_name):
+    """Register a SubConsole subclass to a single parent console by name."""
+    if not isinstance(parent_name, str) or parent_name == "":
+        raise ConsoleInitException("Sub console parent name is empty")
+
+    def decorator(console_cls):
+        from python_tty.consoles import SubConsole
+        if not issubclass(console_cls, SubConsole):
+            raise ConsoleInitException("Sub console must inherit SubConsole")
+        REGISTRY.add_sub(console_cls, parent_name)
+        return console_cls
+
+    return decorator
+
+
+def multi(parent_map):
+    """Register a reusable SubConsole for multiple parents with instance names."""
+    if not isinstance(parent_map, dict) or len(parent_map) <= 0:
+        raise ConsoleInitException("Multi console mapping is empty")
+
+    def decorator(console_cls):
+        from python_tty.consoles import SubConsole
+        if not issubclass(console_cls, SubConsole):
+            raise ConsoleInitException("Multi console must inherit SubConsole")
+        REGISTRY.add_multi(console_cls, parent_map)
+        return console_cls
+
+    return decorator
+

python_tty/consoles/examples/__init__.py

@@ -0,0 +1,8 @@
+from python_tty.consoles.examples.root_console import RootConsole
+from python_tty.consoles.examples.sub_console import ModuleConsole
+
+__all__ = [
+    "RootConsole",
+    "ModuleConsole",
+]
+

python_tty/consoles/examples/root_console.py

@@ -0,0 +1,34 @@
+from prompt_toolkit.styles import Style
+
+from python_tty.commands.decorators import commands
+from python_tty.commands.examples.root_commands import RootCommands
+from python_tty.consoles import MainConsole, root
+
+message = [
+    ('class:host', 'vef1'),
+    ('class:prompt', ' '),
+    ('class:symbol', '>'),
+    ('class:prompt', ' ')
+]
+style = Style.from_dict({
+    # User input(default text)
+    '': '',
+    'host': '#00aa00 underline',
+    'symbol': '#00ffff'
+})
+
+
+@root
+@commands(RootCommands)
+class RootConsole(MainConsole):
+    console_name = "root"
+
+    def __init__(self, parent=None, manager=None):
+        super().__init__(message, style, parent=parent, manager=manager)
+
+    def cmd_invoke_miss(self, cmd: str):
+        print(f"Invoke os shell command [{cmd}]")
+
+    def clean_console(self):
+        super().clean_console()
+

python_tty/consoles/examples/sub_console.py

@@ -0,0 +1,34 @@
+from prompt_toolkit.styles import Style
+
+from python_tty.commands.decorators import commands
+from python_tty.commands.examples.sub_commands import SubCommands
+from python_tty.consoles import SubConsole, sub
+
+
+style = Style.from_dict({
+    # User input(default text)
+    '': '',
+    'host': '#00aaaa',
+    'symbol': '#00ffaa'
+})
+
+
+@sub("root")
+@commands(SubCommands)
+class ModuleConsole(SubConsole):
+    console_name = "module"
+
+    def __init__(self, module_name=None, parent=None, manager=None):
+        if module_name is None:
+            module_name = self.console_name
+        message = [
+            ('class:host', module_name),
+            ('class:prompt', ' '),
+            ('class:symbol', '>'),
+            ('class:prompt', ' ')
+        ]
+        super().__init__(message, style, parent=parent, manager=manager)
+
+    def clean_console(self):
+        super().clean_console()
+

python_tty/consoles/loader.py

@@ -0,0 +1,14 @@
+import importlib
+
+
+DEFAULT_CONSOLE_MODULES = ()
+
+
+def load_consoles(modules=None):
+    """Import console modules so class decorators can register themselves."""
+    if modules is None:
+        modules = DEFAULT_CONSOLE_MODULES
+    elif not isinstance(modules, (list, tuple)):
+        modules = [modules]
+    for module in modules:
+        importlib.import_module(module)

python_tty/consoles/manager.py

@@ -0,0 +1,146 @@
+from prompt_toolkit.patch_stdout import patch_stdout
+
+from python_tty.config import ConsoleManagerConfig
+from python_tty.exceptions.console_exception import ConsoleExit, ConsoleInitException, SubConsoleExit
+from python_tty.ui.events import UIEventLevel, UIEventSpeaker
+from python_tty.ui.output import get_output_router, proxy_print
+
+
+class ConsoleEntry:
+    def __init__(self, console_cls, kwargs):
+        self.console_cls = console_cls
+        self.kwargs = kwargs
+
+
+class ConsoleManager:
+    def __init__(self, service=None, executor=None, on_shutdown=None, config: ConsoleManagerConfig = None):
+        self._registry = {}
+        self._stack = []
+        self._console_tree = None
+        self._root_name = None
+        self._service = service
+        self._executor = executor
+        self._on_shutdown = on_shutdown
+        self._shutdown_called = False
+        self._config = config if config is not None else ConsoleManagerConfig()
+        self._output_router = self._config.output_router or get_output_router()
+        self._use_patch_stdout = self._config.use_patch_stdout
+        self._warn_service_if_needed(service)
+
+    def register(self, name, console_cls, **kwargs):
+        self._registry[name] = ConsoleEntry(console_cls, kwargs)
+
+    def is_registered(self, name):
+        return name in self._registry
+
+    def set_root_name(self, root_name):
+        self._root_name = root_name
+
+    def set_console_tree(self, console_tree):
+        self._console_tree = console_tree
+
+    @property
+    def console_tree(self):
+        return self._console_tree
+
+    @property
+    def service(self):
+        return self._service
+
+    @property
+    def executor(self):
+        return self._executor
+
+    def clean(self):
+        if self._shutdown_called:
+            return
+        self._shutdown_called = True
+        if self._output_router is not None:
+            self._output_router.clear_session()
+        if callable(self._on_shutdown):
+            self._on_shutdown()
+
+    def _warn_service_if_needed(self, service):
+        if service is not None and not isinstance(service, UIEventSpeaker):
+            msg = f"The Service core[{service.__class__}] doesn't extend the [UIEventSpeaker],"\
+                  " which may affect the output of the Service core on the UI!"
+            proxy_print(msg, UIEventLevel.WARNING)
+
+    @property
+    def current(self):
+        return self._stack[-1] if self._stack else None
+
+    def push(self, name, **kwargs):
+        if name not in self._registry:
+            raise KeyError(f"Console [{name}] not registered")
+        entry = self._registry[name]
+        init_kwargs = dict(entry.kwargs)
+        init_kwargs.update(kwargs)
+        parent = self.current
+        console = entry.console_cls(parent=parent, manager=self, **init_kwargs)
+        console.console_name = name
+        self._stack.append(console)
+        self._bind_output_router()
+        return console
+
+    def pop(self):
+        if not self._stack:
+            return None
+        console = self._stack.pop()
+        console.clean_console()
+        self._bind_output_router()
+        return self.current
+
+    def run(self, root_name=None, **kwargs):
+        if root_name is None:
+            root_name = self._root_name
+        if root_name is None:
+            raise ConsoleInitException("Root console not registered")
+        self.push(root_name, **kwargs)
+        self._loop()
+
+    def run_with(self, root_console):
+        if root_console.parent is not None:
+            raise ConsoleInitException("Root console parent must be None")
+        root_console.manager = self
+        if getattr(root_console, "console_name", None) is None:
+            root_console.console_name = root_console.__class__.__name__.lower()
+        self._stack.append(root_console)
+        self._bind_output_router()
+        self._loop()
+
+    def _loop(self):
+        try:
+            while self._stack:
+                try:
+                    self._bind_output_router()
+                    cmd = self._prompt()
+                    self.current.execute(cmd)
+                except SubConsoleExit:
+                    self.pop()
+                except ConsoleExit:
+                    while self._stack:
+                        self.pop()
+                    break
+                except (KeyboardInterrupt, ValueError):
+                    while self._stack:
+                        self.pop()
+                    break
+        finally:
+            self.clean()
+
+    def _prompt(self):
+        if self._use_patch_stdout:
+            with patch_stdout():
+                return self.current.session.prompt()
+        return self.current.session.prompt()
+
+    def _bind_output_router(self):
+        if self._output_router is None:
+            return
+        current = self.current
+        if current is None:
+            self._output_router.clear_session()
+            return
+        self._output_router.bind_session(current.session)
+

python_tty/consoles/registry.py

@@ -0,0 +1,102 @@
+from python_tty.exceptions.console_exception import ConsoleInitException
+
+
+def _get_console_name(console_cls):
+    name = getattr(console_cls, "console_name", None)
+    if name:
+        return name
+    name = getattr(console_cls, "CONSOLE_NAME", None)
+    if name:
+        return name
+    return console_cls.__name__.lower()
+
+
+def _get_console_kwargs(console_cls):
+    kwargs = getattr(console_cls, "console_kwargs", None)
+    if kwargs is None:
+        return {}
+    if not isinstance(kwargs, dict):
+        raise ConsoleInitException("console_kwargs must be dict")
+    return kwargs
+
+
+class SubConsoleEntry:
+    def __init__(self, console_cls, parent_name, name):
+        self.console_cls = console_cls
+        self.parent_name = parent_name
+        self.name = name
+
+
+class ConsoleRegistry:
+    def __init__(self):
+        self._root_cls = None
+        self._root_name = None
+        self._subs = {}
+
+    def set_root(self, console_cls):
+        if self._root_cls is not None:
+            raise ConsoleInitException("Root console already set")
+        self._root_cls = console_cls
+        self._root_name = _get_console_name(console_cls)
+
+    def add_sub(self, console_cls, parent_name):
+        name = _get_console_name(console_cls)
+        if name == self._root_name or name in self._subs:
+            raise ConsoleInitException(f"Console name duplicate [{name}]")
+        self._subs[name] = SubConsoleEntry(console_cls, parent_name, name)
+
+    def add_multi(self, console_cls, parent_map):
+        if not isinstance(parent_map, dict) or len(parent_map) <= 0:
+            raise ConsoleInitException("Multi console mapping is empty")
+        for parent_name, instance_name in parent_map.items():
+            if not isinstance(parent_name, str) or parent_name == "":
+                raise ConsoleInitException("Multi console parent name is empty")
+            if not isinstance(instance_name, str) or instance_name == "":
+                raise ConsoleInitException("Multi console instance name is empty")
+            resolved_name = _resolve_instance_name(parent_name, instance_name)
+            if resolved_name == self._root_name or resolved_name in self._subs:
+                raise ConsoleInitException(f"Console name duplicate [{resolved_name}]")
+            self._subs[resolved_name] = SubConsoleEntry(console_cls, parent_name, resolved_name)
+
+    def register_all(self, manager):
+        if self._root_cls is None:
+            raise ConsoleInitException("Root console not set")
+        manager.set_root_name(self._root_name)
+        manager.register(self._root_name, self._root_cls, **_get_console_kwargs(self._root_cls))
+        for name, entry in self._subs.items():
+            manager.register(name, entry.console_cls, **_get_console_kwargs(entry.console_cls))
+        for name, entry in self._subs.items():
+            if not manager.is_registered(entry.parent_name):
+                raise ConsoleInitException(
+                    f"Parent console [{entry.parent_name}] for [{name}] not registered"
+                )
+        console_tree = _build_console_tree(self._root_name, self._subs)
+        manager.set_console_tree(console_tree)
+
+
+def _resolve_instance_name(parent_name, instance_name):
+    prefix = f"{parent_name}_"
+    if instance_name.startswith(prefix):
+        return instance_name
+    return f"{prefix}{instance_name}"
+
+
+def _build_console_tree(root_name, sub_entries):
+    children_map = {}
+    for name, entry in sub_entries.items():
+        children_map.setdefault(entry.parent_name, []).append(name)
+    for _, children in children_map.items():
+        children.sort()
+    all_names = [root_name]
+    all_names.extend(list(sub_entries.keys()))
+    for name in all_names:
+        if name not in children_map:
+            children_map[name] = []
+    return {
+        "root": root_name,
+        "children": children_map,
+    }
+
+
+REGISTRY = ConsoleRegistry()
+

python_tty/exceptions/__init__.py

@@ -0,0 +1,7 @@
+class UIBaseException(Exception):
+    def __init__(self, msg):
+        super().__init__()
+        self.msg = msg
+
+    def __str__(self):
+        return self.msg

python_tty/exceptions/console_exception.py

@@ -0,0 +1,12 @@
+class ConsoleInitException(Exception):
+    """ Console init exception """
+    def __init__(self, message: str):
+        super().__init__(message)
+
+
+class ConsoleExit(Exception):
+    pass
+
+
+class SubConsoleExit(Exception):
+    pass

python_tty/executor/__init__.py

@@ -0,0 +1,10 @@
+from python_tty.executor.executor import CommandExecutor
+from python_tty.executor.models import Invocation, RunState, RunStatus
+
+__all__ = [
+    "CommandExecutor",
+    "Invocation",
+    "RunState",
+    "RunStatus",
+]
+