aipyapp-qpython 0.1.24.20__py3-none-any.whl

aipyapp/aipy/qpython.py

@@ -0,0 +1,35 @@
+# -*- coding: utf8; -*-
+# qpy 环境相关函数
+import os
+import random
+import string
+
+def create_temp_py_file(code, dir):
+    # 生成一个随机的文件名
+    random_filename = ''.join(random.choices(string.ascii_letters + string.digits, k=10)) + '.py'
+    temp_file_path = os.path.join(dir, random_filename)
+    
+    # 写入代码到临时文件
+    with open(temp_file_path, 'w', encoding='utf-8') as temp_file:
+        temp_file.write(code)
+    
+    return temp_file_path
+
+def qpy_is_webapp(code):
+    # 读取前128个字节
+    header = code[:128]
+    
+    # 将字节转换为字符串并检查是否包含特定内容
+    if '#qpy:webapp' in header:
+        return True
+    else:
+        return False
+
+def qpy_exec(code, args):
+    try: # 在QPython环境跑的程序
+        import qpy, androidhelper
+        script = create_temp_py_file(code, qpy.tmp)
+        droid = androidhelper.Android()
+        droid.executeQPy(script)
+    except Exception as e: # 在非QPython环境跑的程序
+        exec(code, gs)

aipyapp/aipy/runner.py

@@ -0,0 +1,182 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+import sys
+import json
+import traceback
+from io import StringIO
+from importlib.util import find_spec
+
+from term_image.image import from_file, from_url
+
+from . import utils
+from .qpython import qpy_is_webapp, qpy_exec
+from .i18n import T
+from .plugin import event_bus
+from .interface import Runtime
+
+INIT_IMPORTS = """
+import os
+import re
+import sys
+import json
+import time
+import random
+import traceback
+"""
+
+import signal
+
+# 定义处理 Ctrl+C 的函数
+def signal_handler(sig, frame):
+    raise KeyboardInterrupt
+
+# 注册信号处理器
+signal.signal(signal.SIGINT, signal_handler)
+
+
+def is_json_serializable(obj):
+    try:
+        json.dumps(obj)  # 尝试序列化对象
+        return True
+    except (TypeError, OverflowError):
+        return False
+
+def diff_dicts(dict1, dict2):
+    diff = {}
+    for key, value in dict1.items():
+        if key not in dict2 or dict2[key] != value:
+            diff[key] = value
+    return diff
+
+class Runner(Runtime):
+    def __init__(self, settings, console, *, envs=None):
+        self._console = console
+        self._settings = settings
+        self.env = envs or {}
+        self._auto_install = settings.get('auto_install')
+        self._auto_getenv = settings.get('auto_getenv')
+        self.clear()
+
+    def clear(self):
+        self.history = [{'env': self.env}]
+        self._globals = {'runtime': self, '__session__': {}, '__name__': '__main__', 'input': self.input, '__history__': self.history}
+        exec(INIT_IMPORTS, self._globals)
+
+    def __repr__(self):
+        return f"<Runner history={len(self.history)}, env={len(self.env)}>"
+    
+    @property
+    def globals(self):
+        return self._globals
+    
+    def __call__(self, code_str, blocks):
+        old_stdout, old_stderr = sys.stdout, sys.stderr
+        captured_stdout = StringIO()
+        captured_stderr = StringIO()
+        sys.stdout, sys.stderr = captured_stdout, captured_stderr
+        result = {}
+        env = self.env.copy()
+        session = self._globals['__session__'].copy()
+        gs = self._globals.copy()
+        gs['__result__'] = {}
+        gs['__code_blocks__'] = blocks
+        try:
+            if qpy_is_webapp(code_str): #如果是QPY的WEB APP
+                qpy_exec(code_str, gs)
+            else: # 否则正常运行
+                exec(code_str, gs)
+
+            if not gs['__result__']:
+                result['message'] = T("The operation completed successfully")
+        except (SystemExit, Exception) as e:
+            result['errstr'] = str(e)
+            result['traceback'] = traceback.format_exc()
+
+        except KeyboardInterrupt:
+            result['message'] = T("Execution was interrupted by the user")
+
+        finally:
+            sys.stdout = old_stdout
+            sys.stderr = old_stderr
+
+        s = captured_stdout.getvalue().strip()
+        if s: result['stdout'] = s if is_json_serializable(s) else '<filtered: cannot json-serialize>'
+        s = captured_stderr.getvalue().strip()
+        if s: result['stderr'] = s if is_json_serializable(s) else '<filtered: cannot json-serialize>'        
+
+        vars = gs.get('__result__')
+        if vars:
+            result['__result__'] = self.filter_result(vars)
+
+        history = {'code': code_str, 'result': result}
+
+        diff = diff_dicts(env, self.env)
+        if diff:
+            history['env'] = diff
+        diff = diff_dicts(gs['__session__'], session)
+        if diff:
+            history['session'] = diff
+
+        self.history.append(history)
+        return result
+    
+    @utils.restore_output
+    def install_packages(self, packages):
+        self._console.print(f"\n⚠️ LLM {T('ask_for_packages')}: {packages}")
+        need_install = []
+        for package in packages:
+            if not find_spec(package):
+                need_install.append(package)
+        if not need_install:
+            self._console.print(f"✅ {T('packages_exist')}")
+            return True
+        ok = utils.confirm(self._console, f"💬 {T('agree_packages')} 'y'> ", auto=self._auto_install)
+        if ok:
+            return utils.install_packages(self._console, need_install)
+        
+    @utils.restore_output
+    def getenv(self, name, default=None, *, desc=None):
+        self._console.print(f"\n⚠️ LLM {T('ask_for_env', name)}: {desc}")
+        try:
+            value = self.env[name][0]
+            self._console.print(f"✅ {T('env_exist', name)}")
+        except KeyError:
+            if self._auto_getenv:
+                self._console.print(f"✅ {T('auto_confirm')}")
+                value = None
+            else:
+                value = self._console.input(f"💬 {T('input_env', name)}: ")
+                value = value.strip()
+            if value:
+                self.setenv(name, value, desc)
+        return value or default
+    
+    @utils.restore_output
+    def display(self, path=None, url=None):
+        quiet = self._console.quiet
+        image = {'path': path, 'url': url}
+        event_bus.broadcast('display', image)
+        if not quiet:
+            image = from_file(path) if path else from_url(url)
+            image.draw()
+
+    @utils.restore_output
+    def input(self, prompt=''):
+        return self._console.input(prompt)
+      
+    def setenv(self, name, value, desc):
+        self.env[name] = (value, desc)
+
+    def filter_result(self, vars):
+        if isinstance(vars, dict):
+            for key in vars.keys():
+                if key in self.env:
+                    vars[key] = '<masked>'
+                else:
+                    vars[key] = self.filter_result(vars[key])
+        elif isinstance(vars, list):
+            vars = [self.filter_result(v) for v in vars]
+        else:
+            vars = vars if is_json_serializable(vars) else '<filtered>'
+        return vars

aipyapp/aipy/task.py

@@ -0,0 +1,264 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+import os
+import re
+import json
+import uuid
+import platform
+from pathlib import Path
+from datetime import date
+from enum import Enum, auto
+
+import requests
+from rich.panel import Panel
+from rich.align import Align
+from rich.table import Table
+from rich.syntax import Syntax
+from rich.markdown import Markdown
+
+from .i18n import T
+from .plugin import event_bus
+from .templates import CONSOLE_HTML_FORMAT
+from .utils import get_safe_filename
+
+CERT_PATH = Path('/tmp/aipy_client.crt')
+
+class MsgType(Enum):
+    CODE = auto()
+    TEXT = auto()
+
+class Task:
+    MAX_ROUNDS = 16
+
+    def __init__(self, instruction, *, system_prompt=None, max_rounds=None):
+        self.task_id = uuid.uuid4().hex
+        self.instruction = instruction
+        self.console = None
+        self.llm = None
+        self.runner = None
+        self.max_rounds = max_rounds
+        self.system_prompt = system_prompt
+        self.pattern = re.compile(
+            r"^(`{3,4})(\w+)\s+([\w\-\.]+)\n(.*?)^\1\s*$",
+            re.DOTALL | re.MULTILINE
+        )
+
+    def save(self, path):
+       self._console.save_html(path, clear=False, code_format=CONSOLE_HTML_FORMAT)
+
+    def save_html(self, path, task):
+        # 获取当前代码所在目录下的template.html作为模版文件
+        # 读取模版文件
+        # 将模版文件中的{{code}}替换为task转换为json
+        # 保存为新的html文件
+        template_path = Path(__file__).resolve().parent / 'template.html'
+        try:
+            with open(template_path, 'r') as f:
+                template_content = f.read()
+        except FileNotFoundError:
+            self.console.print(f"[red]Error: template.html not found at {template_path}[/red]")
+            return
+        except Exception as e:
+            self.console.print_exception()
+            return
+
+        if 'llm' in task and isinstance(task['llm'], list) and len(task['llm']) > 0:
+            if task['llm'][0]['role'] == 'system':
+                task['llm'].pop(0)
+
+        task_json = json.dumps(task, ensure_ascii=False)
+        html_content = template_content.replace('{{code}}', task_json)
+
+        try:
+            with open(path, 'w', encoding='utf-8') as f:
+                f.write(html_content)
+                self.console.print(f"[green]Task saved to {path}[/green]")
+        except Exception as e:
+            self.console.print_exception()
+            return
+
+    def done(self):
+        #import pdb;pdb.set_trace()
+        instruction = self.instruction
+        task = {'instruction': instruction}
+        task['llm'] = self.llm.history.json()
+        task['runner'] = self.runner.history
+        filename = get_safe_filename(instruction, extension='.json') or f"{self.task_id}.json"
+        try:
+            json.dump(task, open(filename, 'w'), ensure_ascii=False, indent=4)
+        except Exception as e:
+            self.console.print_exception()
+
+        filename = get_safe_filename(instruction) or f"{self.task_id}.html"
+        if hasattr(self.console, 'gui'):
+            # Only save new html in gui mode for now.
+            self.save_html(filename, task)
+        else:
+            self.console.save_html(filename, clear=True, code_format=CONSOLE_HTML_FORMAT)
+
+        self.llm.clear()
+        self.runner.clear()
+        self.task_id = None
+        self.instruction = None
+
+    def parse_reply(self, markdown):
+        """
+        从LLM回复中匹配出需要执行的代码
+        """
+        code_blocks = {}
+        for match in self.pattern.finditer(markdown):
+            _, _, name, content = match.groups()
+            code_blocks[name] = content.rstrip('\n')
+
+        return code_blocks
+
+    def process_code_reply(self, blocks, llm=None):
+        """
+        执行从LLM回复中匹配出的代码
+        """
+
+        event_bus('exec', blocks)
+        code_block = blocks['main']
+        self.box(f"[white] 🚀 {T('start_execute')} ", code_block, lang='python')
+        result = self.runner(code_block, blocks)
+        event_bus('result', result)
+        result = json.dumps(result, ensure_ascii=False, indent=4)
+        self.box(f"[green] ✅ {T('execute_result')} ", result, lang="json")
+        status = self.console.status(f"[dim white]{T('start_feedback')}...")
+        self.console.print(status)
+        feed_back = f"# {T('Initial mission')}\n{self.instruction}\n\n# {T('Code execution result feedback')}\n{result}"
+        feedback_response = self.llm(feed_back, name=llm)
+        return feedback_response
+
+    def box(self, title, content, align=None, lang=None):
+        if hasattr(self.console, 'gui'):
+            # Using Mocked console. Dont use Panel
+
+            if lang == 'json':
+                # Only print execute result.
+                self.console.print(f"\n{title}")
+                self.console.print(content)
+            return
+
+        if lang:
+            content = Syntax(content, lang, line_numbers=True, word_wrap=True)
+        if align:
+            content = Align(content, align=align)
+        
+        self.console.print(Panel(content, title=title))
+
+    def print_summary(self):
+        history = self.llm.history
+        """
+        table = Table(title=T("Task Summary"), show_lines=True)
+
+        table.add_column(T("Round"), justify="center", style="bold cyan", no_wrap=True)
+        table.add_column(T("Time(s)"), justify="right")
+        table.add_column(T("In Tokens"), justify="right")
+        table.add_column(T("Out Tokens"), justify="right")
+        table.add_column(T("Total Tokens"), justify="right", style="bold magenta")
+
+        round = 1
+        for row in history.get_usage():
+            table.add_row(
+                str(round),
+                str(row["time"]),
+                str(row["input_tokens"]),
+                str(row["output_tokens"]),
+                str(row["total_tokens"]),
+            )
+            round += 1
+        self._console.print("\n")
+        self._console.print(table)
+        """
+        summary = history.get_summary()
+        if 'time' in summary:
+            summary = "| {rounds} | {time:.3f}s | Tokens: {input_tokens}/{output_tokens}/{total_tokens}".format(**summary)
+        else:
+            summary = ''
+        event_bus.broadcast('summary', summary)
+        self.console.print(f"\n⏹ [cyan]{T('end_instruction')} {summary}")
+
+    def build_user_prompt(self):
+        prompt = {'task': self.instruction}
+        prompt['python_version'] = platform.python_version()
+        prompt['platform'] = platform.platform()
+        prompt['today'] = date.today().isoformat()
+        prompt['work_dir'] = '工作目录为qpy.tmp，默认在qpy.tmp下创建文件'
+        if self.console.quiet:
+            prompt['matplotlib'] = "我现在用的是 matplotlib 的 Agg 后端，请默认用 plt.savefig() 保存图片后用 runtime.display() 显示，禁止使用 plt.show()"
+            prompt['wxPython'] = "你回复的Markdown 消息中，可以用 ![图片](图片路径) 的格式引用之前创建的图片，会显示在 wx.html2 的 WebView 中"
+        else:
+            prompt['TERM'] = os.environ.get('TERM')
+            prompt['LC_TERMINAL'] = os.environ.get('LC_TERMINAL')
+        return prompt
+
+    def run(self, instruction=None, *, llm=None, max_rounds=None):
+        """
+        执行自动处理循环，直到 LLM 不再返回代码消息
+        """
+        self.box(f"[yellow] 💁 {T('start_instruction')} ", f'[red]{instruction or self.instruction}', align="center")
+        if not instruction:
+            prompt = self.build_user_prompt()
+            event_bus('task_start', prompt)
+            instruction = json.dumps(prompt, ensure_ascii=False)
+            system_prompt = self.system_prompt
+        else:
+            system_prompt = None
+        rounds = 1
+        max_rounds = max_rounds or self.max_rounds
+        if not max_rounds or max_rounds < 1:
+            max_rounds = self.MAX_ROUNDS
+        response = self.llm(instruction, system_prompt=system_prompt, name=llm)
+        while response and rounds <= max_rounds:
+            blocks = self.parse_reply(response)
+            if 'main' not in blocks:
+                break
+            rounds += 1
+            response = self.process_code_reply(blocks, llm)
+            if event_bus.is_stopped():
+                break
+        self.print_summary()
+        os.write(1, b'\a\a\a')
+
+    def chat(self, prompt):
+        system_prompt = None if self.llm.history else self.system_prompt
+        response, ok = self.llm(prompt, system_prompt=system_prompt)
+        self.console.print(Markdown(response))
+
+    def step(self):
+        response = self.llm.get_last_message()
+        if not response:
+            self.console.print(f"❌ {T('no_context')}")
+            return
+        self.process_reply(response)
+
+    def publish(self, title=None, author=None, verbose=True):
+        url = self.settings.get('publish.url')
+        cert = self.settings.get('publish.cert')
+        if not (url and cert) or self.settings.get('publish.disable'):
+            if verbose: self.console.print(f"[red]{T('publish_disabled')}")
+            return False
+        title = title or self.instruction
+        author = author or os.getlogin()
+        meta = {'author': author}
+        files = {'content': self.console.export_html(clear=False)}
+        data = {'title': title, 'metadata': json.dumps(meta)}
+
+        if not (CERT_PATH.exists() and CERT_PATH.stat().st_size  > 0):
+            CERT_PATH.write_text(cert)
+
+        try:
+            response = requests.post(url, files=files, data=data, cert=str(CERT_PATH), verify=True)
+        except Exception as e:
+            self.console.print_exception(e)
+            return
+        
+        status_code = response.status_code
+        if status_code in (200, 201):
+            if verbose: self.console.print(f"[green]{T('upload_success')}:", response.json())
+            return response.json()
+        else:
+            if verbose: self.console.print(f"[red]{T('upload_failed', status_code)}:", response.text)
+            return False

aipyapp/aipy/taskmgr.py

@@ -0,0 +1,108 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+import os
+from pathlib import Path
+
+from .i18n import T
+from .task import Task
+from .llm import LLM
+from .runner import Runner
+from .plugin import PluginManager
+
+lang = os.getenv('LANG')[:2] if os.getenv('LANG') else "en"
+if lang == "zh":
+    from .prompt import SYSTEM_PROMPT
+else:
+    from .prompt_en import SYSTEM_PROMPT
+
+class TaskManager:
+    def __init__(self, settings, console):
+        self.settings = settings
+        self.console = console
+        self.task = None
+        self.envs = {}
+        self.config_files = settings._loaded_files
+        self.system_prompt = f"{settings.system_prompt}\n{SYSTEM_PROMPT}"
+        plugin_dir = settings.get('plugin_dir') or Path.cwd() / 'plugins'
+        self.plugin_manager = PluginManager(plugin_dir)
+        self.plugin_manager.load_plugins()
+        if settings.workdir:
+            workdir = Path.cwd() / settings.workdir
+            workdir.mkdir(parents=True, exist_ok=True)
+            os.chdir(workdir)
+            self._cwd = workdir
+        else:
+            self._cwd = Path.cwd()
+        self._init_environ()
+        self._init_api()
+        self.runner = Runner(settings, console, envs=self.envs)
+        self.llm = LLM(settings, console, system_prompt=self.system_prompt)
+
+    @property
+    def workdir(self):
+        return str(self._cwd)
+
+    def use(self, name):
+        ret = self.llm.use(name)
+        self.console.print('[green]Ok[/green]' if ret else '[red]Error[/red]')
+        return ret
+
+    def done(self):
+        if self.task:
+            self.task.done()
+            self.task = None
+
+    def save(self, path):
+        if self.task:  
+            self.task.save(path)
+
+    def _init_environ(self):
+        envs = self.settings.get('environ', {})
+        for name, value in envs.items():
+            os.environ[name] = value
+
+    def _init_api(self):
+        api = self.settings.get('api')
+        if not api:
+            return
+        lines = [self.system_prompt]
+        for api_name, api_conf in api.items():
+            lines.append(f"## {api_name} API")
+            desc = api_conf.get('desc')
+            if desc: 
+                lines.append(f"### API {T('description')}\n{desc}")
+
+            envs = api_conf.get('env')
+            if not envs:
+                continue
+
+            lines.append(f"### {T('env_description')}")
+            for name, (value, desc) in envs.items():
+                value = value.strip()
+                if not value:
+                    continue
+                lines.append(f"- {name}: {desc}")
+                self.envs[name] = (value, desc)
+
+        self.system_prompt = "\n".join(lines)
+
+    def new_task(self, instruction, llm=None, max_rounds=None, system_prompt=None):
+        if llm and not self.llm.use(llm):
+            return None
+        
+        system_prompt = system_prompt or self.system_prompt
+        max_rounds = max_rounds or self.settings.get('max_rounds')
+        task = Task(instruction, system_prompt=system_prompt, max_rounds=max_rounds)
+        task.console = self.console
+        task.llm = self.llm
+        task.runner = self.runner
+        return task
+    
+    def __call__(self, instruction, llm=None, max_rounds=None, system_prompt=None):
+        if self.task:
+            self.task.run(instruction=instruction, llm=llm, max_rounds=max_rounds)
+        else:
+            task = self.new_task(instruction, llm=llm, max_rounds=max_rounds, system_prompt=system_prompt)
+            self.task = task
+            task.run()