pyouter 0.1.2__py3-none-any.whl

pyouter/__init__.py

@@ -0,0 +1,16 @@
+from .router import Router
+from .oh_my_zsh.install import install as omz
+from .fish.install import install as fish
+from .bash.install import install as bash
+from .app import App
+
+
+def runner():
+    app = App()
+    app.use(
+        router=Router(
+            install=Router(
+                ohmyzsh=omz,
+                fish=fish,
+                bash=bash)))
+    app.run()

pyouter/__main__.py

@@ -0,0 +1,5 @@
+#!/usr/bin/env python
+from pyouter import runner
+
+if __name__ == "__main__":
+    runner()

pyouter/app.py

@@ -0,0 +1,97 @@
+
+from typing import Any
+import asyncio
+
+from pyouter.default import create_parser
+from pyouter.errors import NotInit
+from pyouter.router import Router
+
+class App(object):
+    def __init__(self, config=None, parser=None):
+        opt_parser = parser if parser is not None else create_parser("tasks router runner")
+        
+        self.opt_parser = opt_parser
+        self.options = None
+        self.executor = None
+        
+        if config is None:
+            self.config = {}
+        elif type(config)==type(''):
+            import json
+            with open(config,'r') as f:
+                self.config = json.load(f)
+        elif type(config)==type({}):
+            self.config = config
+        else:
+            raise NotInit("config type unknonw")
+            
+        self.router: Router
+    
+    def use(self, router: Router):
+        self.router = router
+        return self
+    
+    def option(self, *args: Any, **kwds: Any):
+        self.opt_parser.add_argument(*args, **kwds)
+        return self
+
+    def web(self, host="127.0.0.1", port=8765, open_browser=True, focus=None):
+        """Start the local web ui for this app's router."""
+        if self.router is None:
+            raise NotInit("self.router in App")
+
+        if self.config is None:
+            raise NotInit("self.config in App")
+
+        if self.options is None:
+            self.options = self.opt_parser.parse_args()
+
+        self.router.context(self.config, self.options, self.executor)
+
+        from pyouter.web import serve
+        serve(
+            self,
+            host=host,
+            port=port,
+            open_browser=open_browser,
+            focus="" if focus is None else focus,
+        )
+        return self
+
+    def run(self):
+        if self.router is None:
+            raise NotInit("self.router in App")
+        
+        if self.config is None:
+            raise NotInit("self.config in App")
+        
+        if self.options is None:
+            self.options = self.opt_parser.parse_args()
+            
+        self.router.context(self.config, self.options, self.executor)
+
+        if getattr(self.options, 'web', False):
+            self.web(
+                host=getattr(self.options, "host", "127.0.0.1"),
+                port=getattr(self.options, "port", 8765),
+                open_browser=not getattr(self.options, "no_browser", False),
+                focus=self.options.actions,
+            )
+            return self
+
+        if getattr(self.options, 'tree', False):
+            if self.options.actions:
+                # 如果有actions参数，显示路径追踪和子树
+                self.router.print_tree(self.options.actions)
+            else:
+                # 如果没有actions参数，显示完整树
+                self.router.print_tree()
+            return self
+
+        if self.options.tasks:
+            for task in self.router.tasks():
+                print(task)
+        else:
+            asyncio.get_event_loop().run_until_complete(self.router.dispatch('', self.options.actions, 0))
+        
+        return self

pyouter/bash/install.py

@@ -0,0 +1,27 @@
+import string
+
+def install(config, options):
+    command = string.Template("""#!/usr/bin/env pyouter.bash
+# please save this script into your pyouter.bash completion dir and restart 
+# your base or source it use
+# . script_name
+# in MacOS with home brew, it is /usr/local/etc/bash_completion.d/
+
+_pipeline_router()
+{
+   COMPREPLY=($(compgen -W "$$(pyouter --tasks)" "$${COMP_WORDS[1]}"))
+}
+
+complete -F _pipeline_router pyouter
+
+# if you has used pyouter any old edition, maybe just use below source
+_completion_router()
+{
+   COMPREPLY=($(compgen -W "$$(python $script --tasks)" "$${COMP_WORDS[1]}"))
+}
+
+complete -F _completion_router $script
+""")
+    script_name = options.script if options.script else "__main__.py"
+    content = command.substitute(script=script_name)
+    print(content)

pyouter/default.py

@@ -0,0 +1,73 @@
+import argparse
+
+
+def create_parser(description, tasks="tasks"):
+    opt_parser = argparse.ArgumentParser(description=description)
+
+    opt_parser.add_argument(
+        'actions',
+        metavar='A',
+        type=str,
+        nargs='?',
+        help='actions strings in tree')
+
+    opt_parser.add_argument(
+        f'--{tasks}',
+        const=True,
+        dest='tasks',
+        nargs='?',
+        help='completion the actions strings'
+    )
+
+    opt_parser.add_argument(
+        "-s", '--script-name',
+        dest="script",
+        nargs='?',
+        type=str,
+        help='completion the actions strings'
+    )
+
+    opt_parser.add_argument(
+        "-v", "--view",
+        dest="view",
+        help="view the router track",
+        action="store_true",
+    )
+    
+    opt_parser.add_argument(
+        "-t", "--tree",
+        dest="tree",
+        help="print all available router paths or inspect router tree structure",
+        action="store_true",
+    )
+
+    opt_parser.add_argument(
+        "-w", "--web",
+        dest="web",
+        help="start a local web ui to browse and run routers",
+        action="store_true",
+    )
+
+    opt_parser.add_argument(
+        "--host",
+        dest="host",
+        default="127.0.0.1",
+        help="host for the local web ui (default: 127.0.0.1)",
+    )
+
+    opt_parser.add_argument(
+        "--port",
+        dest="port",
+        default=8765,
+        type=int,
+        help="port for the local web ui (default: 8765)",
+    )
+
+    opt_parser.add_argument(
+        "--no-browser",
+        dest="no_browser",
+        help="do not open a browser when starting the web ui",
+        action="store_true",
+    )
+
+    return opt_parser

pyouter/errors.py

@@ -0,0 +1,10 @@
+class NotFound(Exception):
+    def __init__(self, route, token):
+        self.route = route
+        self.token = token
+        self.message = f"token [{token}] not found in {route}"
+
+
+class NotInit(Exception):
+    def __init__(self, info):
+        self.message = f"instance {info} not init"

pyouter/executor.py

@@ -0,0 +1,46 @@
+import asyncio
+import contextvars
+import inspect
+
+from concurrent.futures import Executor
+from functools import partial
+
+
+class LeafExecutor:
+    def __init__(self, config, options, executor, leaf):
+        self.config = config
+        self.options = options
+        self.executor = executor
+        self.leaf = leaf
+        
+    async def run(self):
+        
+        def is_continufunction(leaf):
+            if inspect.isfunction(leaf):
+                return inspect.iscoroutinefunction(leaf)
+            else:
+                return inspect.iscoroutinefunction(leaf.run)
+            
+        async def run_async(leaf, config, options):
+            if inspect.isfunction(leaf):
+                return await leaf(config, options)
+            else:
+                return await leaf.run(config, options)
+            
+        def run_sync(leaf, config, options):
+            if inspect.isfunction(leaf):
+                return leaf(config, options)
+            else:
+                return leaf.run(config, options)
+        
+        if is_continufunction(self.leaf):
+            await run_async(self.leaf, self.config, self.options)
+        else:
+            loop = asyncio.get_running_loop()
+            # Keep the caller's contextvars in the worker thread so a web run
+            # can attribute prints from synchronous actions to the right node.
+            ctx = contextvars.copy_context()
+            await loop.run_in_executor(
+                self.executor,
+                partial(ctx.run, partial(run_sync, self.leaf, self.config, self.options)),
+            )

pyouter/fish/install.py

@@ -0,0 +1,38 @@
+import string
+import os
+import os.path
+
+
+def install(config, options):
+    base = """!/usr/bin/env fish
+complete -c pyouter -f
+complete -c pyouter -a "(python pyouter --tasks)"
+    """
+    command = string.Template("""
+complete -c $script -f
+complete -c $script -a "(python $script --tasks)"
+""")
+    script_name = options.script if options.script else "main.py"
+    home = os.getenv("HOME")
+    plugin_dir = os.path.join(home, ".config/fish/completions")
+    plugin_path = os.path.join(plugin_dir, script_name + ".fish")
+
+    if not os.path.exists(plugin_dir):
+        os.mkdir(plugin_dir)
+
+    content = ""
+    if os.path.exists(plugin_path):
+        with open(plugin_path) as f:
+            content = f.read()
+
+    if not content.startswith(base):
+        content = base + content
+
+    plugin = command.substitute(script=script_name)
+    if plugin not in content:
+        content += plugin
+
+    with open(plugin_path, "w+") as f:
+        f.write(content)
+
+    print("success")

pyouter/oh_my_zsh/install.py

@@ -0,0 +1,72 @@
+import string
+import os
+import os.path
+import re
+
+
+def install(config, options):
+    base = """#compdef
+
+_pyouter() {
+    compls=$(pyouter --tasks)
+
+    completions=(${=compls})
+    compadd -- $completions
+}
+
+compdef _pyouter pyouter
+
+"""
+    command = string.Template("""
+_pipeline() {
+    compls=$$(python $script --tasks)
+
+    completions=($${=compls})
+    compadd -- $$completions
+}
+
+compdef _pipeline $script
+
+""")
+    script_name = options.script if options.script else "main.py"
+    home = os.getenv("HOME")
+    plugin_name = "pyouter"
+    plugin_dir = os.path.join(home, ".oh-my-zsh/plugins", plugin_name)
+    plugin_path = os.path.join(plugin_dir, plugin_name + ".plugin.zsh")
+    zshrc = os.path.join(home, ".zshrc")
+    regex = re.compile(r"\nplugins=\(.*?\)")
+
+    if not os.path.exists(plugin_dir):
+        os.mkdir(plugin_dir)
+
+    with open(zshrc, "r") as f:
+        zshrc_content = f.read()
+
+    m = regex.search(zshrc_content)
+    if m is None:
+        zshrc_content = zshrc_content + f"\nplugins=({plugin_name})\n"
+    else:
+        plugins_setting = m.group(0)
+        if plugin_name not in plugins_setting:
+            plugins_setting = plugins_setting[:-1] + f" {plugin_name}" + plugins_setting[-1]
+            prev, post = regex.split(zshrc_content)
+            zshrc_content = prev + plugins_setting + post
+
+    if os.path.exists(plugin_path):
+        with open(plugin_path) as f:
+            plugin_content = f.read()
+    else:
+        plugin_content = ""
+
+    if base not in plugin_content:
+        plugin_content = base + plugin_content
+    script = command.substitute(script=script_name)
+    if script not in plugin_content:
+        plugin_content += script
+
+    with open(plugin_path, "w+") as f:
+        f.write(plugin_content)
+
+    with open(zshrc, "w+") as f:
+        f.write(zshrc_content)
+    print("success")

pyouter/router.py

@@ -0,0 +1,139 @@
+import asyncio
+
+from .errors import NotFound
+from .executor import LeafExecutor
+
+class Router(object):
+    def __init__(self, **args):
+        self.route = {}
+        for key in args:
+            self.route[key] = args[key]
+
+    def context(self, config, options, executor):
+        self.config = config
+        self.options = options
+        self.executor = executor
+        for key in self.route:
+            router = self.route[key]
+            if type(router) == type(self):
+                router.context(config, options, executor)
+
+    async def dispatch(self, pre:str|None, command: str, depth: int):
+        show_path = self.options.view or getattr(self.options, 'tree', False)
+        path_prefix = '  '*depth if getattr(self.options, 'tree', False) else ''
+        run_action = not getattr(self.options, 'tree', False)
+        
+        def full_path(pre, command):
+            if pre is not None and pre!='':
+                return f'{pre}.{command}'
+            else:
+                return command
+        
+        if "." in command:
+            crt, nxt = command.split('.', 1)
+            if crt not in self.route:
+                raise NotFound(self.route, crt)
+            
+            router_path = full_path(pre, crt)
+            if show_path:
+                print(f'[pyouter] {path_prefix}->router: {router_path}')
+            
+            return await self.route[crt].dispatch(router_path, nxt, depth+1)
+        else:
+            if command not in self.route.keys():
+                raise NotFound(self.route, command)
+
+            leaf = self.route[command]
+            if isinstance(leaf, Router):
+                # 只在第一次遇到Router时输出路径信息
+                router_path = full_path(pre, command)
+                if show_path:
+                    print(f'[pyouter] {path_prefix}->router2: {router_path}')
+                
+                tasks = []
+                for crt in leaf.route:
+                    task = asyncio.create_task(leaf.dispatch(router_path, crt, depth+1))
+                    tasks.append(task)
+                
+                await asyncio.gather(*tasks, return_exceptions=True)
+            else:
+                action_path = full_path(pre, command)
+                if show_path:
+                    print(f'[pyouter] {path_prefix}->action: {action_path}')
+                
+                if run_action:
+                    executor = LeafExecutor(self.config, self.options, self.executor, leaf)
+                    await executor.run()
+
+    def tasks(self, base=None):
+
+        for key in self.route:
+            current = f"{base}.{key}" if base else key
+            item = self.route[key]
+            if type(item) is Router:
+                for task in item.tasks(current):
+                    yield task
+            else:
+                yield current
+
+    def print_tree(self, path=None, prefix="", is_last=True):
+        """
+        打印树状结构，类似tree命令的输出格式
+        path: 要追踪的路径，如 "a.b.c"
+        prefix: 当前行的前缀（用于缩进）
+        is_last: 是否是当前层级的最后一个节点
+        """
+        if path:
+            # 解析路径，先追踪到目标节点
+            parts = path.split('.')
+            current_router = self
+            current_path = ""
+            
+            # 追踪路径
+            for i, part in enumerate(parts):
+                if part not in current_router.route:
+                    print(f"路径 '{path}' 不存在")
+                    return
+                
+                current_path = f"{current_path}.{part}" if current_path else part
+                current_router = current_router.route[part]
+                
+                # 如果不是Router，说明到达叶子节点
+                if not isinstance(current_router, Router):
+                    if i < len(parts) - 1:
+                        print(f"路径 '{path}' 在 '{current_path}' 处终止（不是Router节点）")
+                        return
+                    break
+            
+            # 打印路径追踪
+            print(f"路径追踪: {path}")
+            print("└── " + path)
+            
+            # 打印目标节点下的完整树
+            if isinstance(current_router, Router):
+                print(f"\n{current_path} 下的完整树:")
+                current_router._print_subtree("", True)
+            else:
+                print(f"叶子节点: {current_path}")
+        else:
+            # 打印完整树
+            self._print_subtree("", True)
+    
+    def _print_subtree(self, prefix="", is_last=True):
+        """
+        打印子树结构
+        """
+        items = list(self.route.items())
+        for i, (key, value) in enumerate(items):
+            is_last_item = i == len(items) - 1
+            connector = "└── " if is_last_item else "├── "
+            
+            if isinstance(value, Router):
+                print(f"{prefix}{connector}{key}/")
+                # 递归打印子树
+                next_prefix = prefix + ("    " if is_last_item else "│   ")
+                value._print_subtree(next_prefix, is_last_item)
+            else:
+                # 叶子节点
+                func_name = value.__name__ if hasattr(value, '__name__') else type(value).__name__
+                print(f"{prefix}{connector}{key} ({func_name})")