deva 1.3.1__tar.gz → 1.3.2__tar.gz

{deva-1.3.1 → deva-1.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: deva
-Version: 1.3.1
+Version: 1.3.2
 Summary: data eval in future
 Home-page: https://github.com/sostc/deva
 Author: spark

{deva-1.3.1 → deva-1.3.2}/deva/__init__.py

@@ -18,11 +18,7 @@ from .lambdas import _
 from .browser import browser,tab,tabs
 from .gpt import async_gpt,sync_gpt
 
-try:
-    # import panel as pn
-    from .dask import DaskStream, scatter
 
-except ImportError:
-    pass
 
-__version__ = '1.3.1'
+
+__version__ = '1.3.2'

{deva-1.3.1 → deva-1.3.2}/deva/admin.py

@@ -27,44 +27,36 @@ Deva 管理面板 - 基于 PyWebIO 和 Tornado 的 Web 应用程序
 # coding: utf-8
 
 # In[2]:
+import asyncio
 import os
 import traceback
+import json
+import time
 from urllib.parse import urljoin
-from deva import (
-    NW, NB, log, ls, Stream, first, sample, Deva, print, timer,NS,concat, Dtalk
-)
-from deva.browser import browser,tab,tabs
-from deva.bus import warn
-from deva.page import page #这里为了给流注入 webview 方法和sse 方法
-from pywebio.output import (
-    put_text, put_markdown, set_scope, put_table,use_scope, clear, toast, put_button, put_collapse, put_datatable,
-    put_buttons, put_row, put_html, put_link, popup,close_popup
-)
-
-from tornado.web import create_signed_value, decode_signed_value
 from typing import Callable, Union
-from pywebio.platform.tornado import webio_handler
-from pywebio_battery import put_logbox, logbox_append, set_localstorage, get_localstorage
-from pywebio.pin import pin, put_input
-from pywebio.session import set_env, run_async, run_js, run_asyncio_coroutine, get_session_implement
 
-from pywebio.input import input, input_group, PASSWORD, textarea, actions, TEXT
 import pandas as pd
-import json
-import time
-
 from openai import AsyncOpenAI
 from tornado.web import create_signed_value, decode_signed_value
-from typing import Callable, Union
+
+from deva import (
+    NW, NB, log, ls, Stream, first, sample, Deva, print, timer, NS, concat, Dtalk
+)
+from deva.browser import browser, tab, tabs
+from deva.bus import warn
+from deva.page import page  # 这里为了给流注入 webview 方法和sse 方法
+from deva.gpt import async_gpt, sync_gpt
+
+from pywebio.output import (
+    put_text, put_markdown, set_scope, put_table, use_scope, clear, toast, 
+    put_button, put_collapse, put_datatable, put_buttons, put_row, put_html, 
+    put_link, popup, close_popup, put_tabs
+)
 from pywebio.platform.tornado import webio_handler
 from pywebio_battery import put_logbox, logbox_append, set_localstorage, get_localstorage
 from pywebio.pin import pin, put_input
 from pywebio.session import set_env, run_async, run_js, run_asyncio_coroutine, get_session_implement
 from pywebio.input import input, input_group, PASSWORD, textarea, actions, TEXT
-import pandas as pd
-
-
-from deva.gpt import async_gpt,sync_gpt
 
 
 @timer(5,start=False)
@@ -345,7 +337,7 @@ log.start_cache(200, cache_max_age_seconds=60 * 60 * 24 * 30)
 log.map(lambda x: log.recent(10) >> concat('<br>'))\
     >> NS('访问日志', cache_max_len=1, cache_max_age_seconds=60 * 60 * 24 * 30)
 
-os.getpid() >> log
+
 
 streams = [NS('访问日志'), NS('实时新闻'), NS(
     '涨跌停'), NS('领涨领跌板块'), NS('1分钟板块异动'), NS('30秒板块异动')]
@@ -1099,6 +1091,7 @@ async def watch_topic(topic):
         )
     return result
 
+
 async def create_task():
     """创建定时任务"""
     
@@ -1136,7 +1129,7 @@ async def create_task():
     """
     # 调用GPT生成Python代码
     prompt = f"仅限于以下的功能和使用方法：{samplecode}，根据以下描述: {description}，生成一个Python异步函数,只生成函数主体就可以，不需要执行代码，所有 import 都放在函数内部,详细的代码注释"
-    result = sync_gpt(prompts=prompt)
+    result = await asyncio.create_task(async_gpt(prompts=prompt))
     def get_python_code_from_deepseek(content):
         # 假设返回的内容中 Python 代码被标记为 ```python ... ```
         import re
@@ -1251,9 +1244,9 @@ def manage_tasks():
                 row.append(put_row([
                     put_button("源码", onclick=lambda n=name: edit_code(n), color="primary"),
                     put_button("恢复", onclick=lambda n=name: recover_task(n), color="success"),
+                    put_button("彻底删除", onclick=lambda n=name: remove_task_forever(n), color="danger"),
                 ]))
                 deleted_table_data.append(row)
-
         if active_table_data:
             put_table(
                 active_table_data,
@@ -1327,6 +1320,19 @@ def recover_task(name):
     
     
     manage_tasks()
+
+def remove_task_forever(name):
+    """彻底删除任务，永久无法恢复"""
+    try:
+        scheduler.remove_job(name)>>log
+    except Exception as e:
+        e>>log
+    del tasks[name]
+    # 更新数据库中的任务状态为已删除
+    db = NB('tasks')
+    del db[name]
+    toast(f"任务 '{name}' 已删除！", color="success")
+    manage_tasks()
     
 async def taskadmin():
     await init_admin_ui('Deva任务管理')
@@ -1346,7 +1352,151 @@ async def streamadmin():
     put_markdown('### 数据流')
     put_buttons([s.name for s in streams],onclick=stream_click)
     
-
+async def inspect_object(obj):
+    """在Web界面上展示Python对象的所有相关信息
+    
+    参数:
+        obj: 要展示的Python对象
+    """
+    # 创建popup内容
+    content = []
+    
+    # 显示对象基本信息
+    content.append(put_markdown(f"### 对象信息"))
+    content.append(put_table([
+        ['类型', type(obj).__name__],
+        ['ID', id(obj)],
+        ['哈希值', hash(obj) if not isinstance(obj, dict) else 'N/A (字典不可哈希)'],
+        ['可调用', callable(obj)]
+    ]))
+    
+    # 显示对象文档
+    if obj.__doc__:
+        content.append(put_markdown("#### 文档说明"))
+        if obj.__doc__:
+            # 将文档内容按行分割
+            doc_lines = obj.__doc__.split('\n')
+            formatted_doc = []
+            in_code_block = False
+            
+            for line in doc_lines:
+                # 检测代码块开始
+                if line.strip().startswith('>>>') or line.strip().startswith('...'):
+                    if not in_code_block:
+                        formatted_doc.append('```python')
+                        in_code_block = True
+                    formatted_doc.append(line)
+                else:
+                    if in_code_block:
+                        formatted_doc.append('```')
+                        in_code_block = False
+                    formatted_doc.append(line)
+            
+            # 处理最后一个代码块
+            if in_code_block:
+                formatted_doc.append('```')
+            
+            # 将格式化后的文档内容添加到显示
+            content.append(put_markdown('\n'.join(formatted_doc)))
+    
+    # 显示对象属性
+    content.append(put_markdown("#### 属性"))
+    attrs = []
+    for attr in dir(obj):
+        if not attr.startswith('__'):
+            try:
+                value = getattr(obj, attr)
+                # 过滤掉方法，只显示非可调用属性
+                if not callable(value):
+                    attrs.append([attr, type(value).__name__, str(value)[:100]])
+            except Exception as e:
+                attrs.append([attr, '无法访问', str(e)])
+    content.append(put_table([['属性名', '类型', '值']] + attrs))
+    
+    # 显示对象方法
+    content.append(put_markdown("#### 方法"))
+    methods = []
+    for attr in dir(obj):
+        if not attr.startswith('__'):
+            try:
+                value = getattr(obj, attr)
+                if callable(value):
+                    doc = value.__doc__ or '无文档说明'
+                    methods.append([attr, doc[:200]])
+            except Exception as e:
+                methods.append([attr, f'无法访问: {str(e)}'])
+    content.append(put_table([['方法名', '文档说明']] + methods))
+    
+    # 在popup中显示内容
+    popup(title="对象详情", content=content, size='large')
+async def document():
+    await init_admin_ui("Deva管理面板")
+    # 获取deva下所有子模块
+    import deva
+    import pkgutil
+    import inspect
+    
+    # 遍历deva下的所有子模块
+    # 创建tab容器
+    tabs = []
+    
+    for module_info in pkgutil.iter_modules(deva.__path__):
+        module_name = module_info.name
+        try:
+            # 动态导入模块
+            module = __import__(f'deva.{module_name}', fromlist=['*'])
+            
+            # 创建模块内容
+            with use_scope(f'module_{module_name}', clear=True):
+                # 创建类和函数表格
+                module_table = [['名称', '类型', '文档说明']]
+                
+                # 获取模块中定义的成员，包括全局变量
+                members = inspect.getmembers(module)
+                
+                # 获取模块的全局变量
+                global_vars = {k: v for k, v in module.__dict__.items() 
+                             if not k.startswith('__') and not inspect.ismodule(v)}
+                
+                # 合并成员和全局变量
+                all_objects = {**dict(members), **global_vars}
+                
+                # 过滤出类和函数和全局对象
+                for name, obj in all_objects.items():
+                    # 检查是否为类、函数、被装饰的函数或全局对象
+                    if (inspect.isclass(obj) or inspect.isfunction(obj) or 
+                        hasattr(obj, '__wrapped__') or 
+                        (not inspect.ismodule(obj) and not name.startswith('_'))) :
+                        doc = obj.__doc__ or '无文档说明'
+                        if isinstance(doc, str):
+                            # 判断对象类型
+                            if inspect.isclass(obj):
+                                obj_type = '类'
+                            elif inspect.isfunction(obj) or hasattr(obj, '__wrapped__'):
+                                obj_type = '函数'
+                            else:
+                                obj_type = '全局对象'
+                            
+                            # 对于被装饰器修饰的函数，获取原始函数的文档
+                            if hasattr(obj, '__wrapped__'):
+                                doc = obj.__wrapped__.__doc__ or doc
+                            
+                            # 添加点击事件
+                            action_button = put_button(name, onclick=lambda o=obj: run_async(inspect_object(o)))
+                            module_table.append([action_button, obj_type, doc[:200]])
+                # 添加模块内容到tab
+                tabs.append({
+                    'title': module_name,
+                    'content': put_table(module_table)
+                })
+        except ImportError as e:
+            print(f"无法导入模块 {module_name}: {e}")
+            tabs.append({
+                'title': module_name,
+                'content': put_text(f"无法加载模块: {str(e)}")
+            })
+    # 显示所有模块的tab
+    put_tabs(tabs)
 async def main():
     # await my_timer()
     # 这个将会把会话协程卡在这里不动，采用 run_async则不会堵塞
@@ -1972,7 +2122,7 @@ def create_nav_menu():
             {name: '数据库', path: '/dbadmin', action: () => window.location.href = '/dbadmin'},
             {name: '实时流', path: '/streamadmin', action: () => window.location.href = '/streamadmin'},
             {name: '任务', path: '/taskadmin', action: () => window.location.href = '/taskadmin'},
-            {name: '关于', path: '#', action: () => alert('Deva管理面板 v1.0')}
+            {name: '文档', path: '/document', action: () => window.location.href = '/document'}
         ];
 
         menuItems.forEach(item => {
@@ -2039,11 +2189,13 @@ if __name__ == '__main__':
     # 创建一个名为'stream_webview'的Web服务器实例，监听所有网络接口(0.0.0.0)
     # 然后为该服务器添加路由处理器，将'/admin'路径映射到dbadmin处理函数
     # 使用PyWebIO的webio_handler进行封装，并指定CDN地址
+    cdn='https://fastly.jsdelivr.net/gh/wang0618/PyWebIO-assets@v1.8.3/'
     handlers = [
-        (r'/dbadmin', webio_handler(dbadmin, cdn='https://fastly.jsdelivr.net/gh/wang0618/PyWebIO-assets@v1.8.3/')),
-        (r'/streamadmin', webio_handler(streamadmin, cdn='https://fastly.jsdelivr.net/gh/wang0618/PyWebIO-assets@v1.8.3/')),
-        (r'/', webio_handler(main, cdn='https://fastly.jsdelivr.net/gh/wang0618/PyWebIO-assets@v1.8.3/')),
-        (r'/taskadmin', webio_handler(taskadmin, cdn='https://fastly.jsdelivr.net/gh/wang0618/PyWebIO-assets@v1.8.3/'))
+        (r'/dbadmin', webio_handler(dbadmin, cdn=cdn)),
+        (r'/streamadmin', webio_handler(streamadmin, cdn=cdn)),
+        (r'/', webio_handler(main, cdn=cdn)),
+        (r'/taskadmin', webio_handler(taskadmin, cdn=cdn)),
+        (r'/document', webio_handler(document, cdn=cdn))
     ]
     NW('stream_webview',host='0.0.0.0').application.add_handlers('.*$', handlers)
  

{deva-1.3.1 → deva-1.3.2}/deva/bus.py

@@ -72,7 +72,7 @@ warn = NS('warn')
 warn.sink(logging.warning)
 
 
-def log_print(x):
+def _log_print(x):
     try:
         # from termcolor import cprint
         # _log_print = (lambda x: cprint(x, 'red', 'on_cyan'))@P
@@ -86,7 +86,7 @@ def log_print(x):
 
 
 log = NS('log', cache_max_len=10, cache_max_age_seconds=60 * 60 * 24)
-log.sink(log_print)
+log.sink(_log_print)
 
 
 bus = NT('bus')

{deva-1.3.1 → deva-1.3.2}/deva/core.py

@@ -787,10 +787,6 @@ class Stream(object):
             upstream.downstreams.remove(self)
             self.upstreams.remove(upstream)
 
-    def scatter(self, **kwargs):
-        """分散流到dask"""
-        from .dask import scatter
-        return scatter(self, **kwargs)
 
     def remove(self, predicate):
         """只传递predicate返回False的元素"""
@@ -1038,9 +1034,11 @@ class Stream(object):
             for handler in self._subscribers[topic]:
                 handler(message)
 
-    def __call__(self,func):
-        return self.catch(func=func)
-
+    def __call__(self, obj):
+        if callable(obj):
+            return self.catch(func=obj)
+        else:
+            return self.emit(obj)
 
 
 class Sink(Stream):

{deva-1.3.1 → deva-1.3.2}/deva/gpt.py

@@ -5,27 +5,69 @@ from deva.namespace import NB
 from deva import warn
 
 
+
 class GPT:
+    """
+    GPT类封装了与大型语言模型（如DeepSeek、Sambanova）的交互功能。
+    提供同步和异步两种调用方式，支持普通文本和JSON格式的响应。
+    
+    主要功能：
+    - 同步查询：sync_query()
+    - 异步查询：async_query()
+    - 异步JSON查询：async_json_query()
+    - 自动模型切换：当某个模型失败时自动切换到备用模型
+    - 资源管理：支持上下文管理器自动关闭连接
+    
+    属性：
+    - model_type: 当前使用的模型类型（deepseek或sambanova）
+    - config: 模型配置信息
+    - api_key: API访问密钥
+    - base_url: API基础URL
+    - model: 模型名称
+    - last_used_model: 最后使用的模型类型
+    
+    示例用法：
+    1. 同步查询
+    >>> gpt = GPT()
+    >>> response = gpt.sync_query("你好")
+    >>> print(response)
+    
+    2. 异步查询
+    >>> async def main():
+    ...     gpt = GPT()
+    ...     response = await gpt.async_query("你好")
+    ...     print(response)
+    
+    3. 使用上下文管理器
+    >>> async def main():
+    ...     async with GPT() as gpt:
+    ...         response = await gpt.async_query("你好")
+    ...         print(response)
+    
+    4. JSON格式查询
+    >>> async def main():
+    ...     gpt = GPT()
+    ...     json_response = await gpt.async_json_query("返回JSON格式的天气数据")
+    ...     print(json_response)
+    """
     def __init__(self, model_type='deepseek'):
         """
-        初始化GPT类，默认使用deepseek模型，可以选择sambanova
+        初始化GPT实例
         
         参数:
-            model_type: 模型类型，默认为'deepseek'
+            model_type (str): 模型类型，默认为'deepseek'，可选'sambanova'
+        
+        异常:
+            ValueError: 当缺少必要配置项时抛出
         """
         self.model_type = model_type
-        # 从对应类型的数据库获取配置
         self.config = NB(model_type)
         
-        # 验证必要的配置项
+        # 验证配置项
         required_configs = ['api_key', 'base_url', 'model']
-        missing_configs = []
-        for config in required_configs:
-            if config not in self.config:
-                missing_configs.append(config)
+        missing_configs = [c for c in required_configs if c not in self.config]
         
         if missing_configs:
-            # 生成配置示例代码
             example_code = "from deva.namespace import NB\n\n"
             example_code += "# 配置示例:\n"
             example_code += "NB('deepseek').update({\n"
@@ -41,40 +83,28 @@ class GPT:
             "请确保在其他地方正确设置这些配置项的值" >> warn
             example_code >> warn
             
-        # 设置默认值为None
         self.api_key = self.config.get('api_key')
         self.base_url = self.config.get('base_url')
         self.model = self.config.get('model')
-        self.last_used_model = model_type  # 记录最后使用的模型
+        self.last_used_model = model_type
         
-        # 初始化同步和异步客户端
+        # 初始化客户端
         self.sync_client = OpenAI(api_key=self.api_key, base_url=self.base_url)
         self.async_client = AsyncOpenAI(api_key=self.api_key, base_url=self.base_url)
+    
+    def sync_query(self, prompts):
         """
-        初始化GPT类，默认使用deepseek模型，可以选择sambanova
+        同步查询大模型
         
         参数:
-            model_type: 模型类型，默认为'deepseek'
+            prompts (str|list): 提示词，可以是字符串或字符串列表
+            
+        返回:
+            str: 模型生成的文本
+            
+        异常:
+            Exception: 查询失败时抛出，并自动切换模型类型
         """
-        self.model_type = model_type
-        # 从对应类型的数据库获取配置
-        self.config = NB(model_type)
-        
-        # 验证必要的配置项
-        required_configs = ['api_key', 'base_url', 'model']
-        for config in required_configs:
-            if config not in self.config:
-                raise ValueError(f"缺少必要的配置项: {config}")
-        
-        self.api_key = self.config['api_key']
-        self.base_url = self.config['base_url']
-        self.model = self.config['model']
-        
-        # 初始化同步和异步客户端
-        self.sync_client = OpenAI(api_key=self.api_key, base_url=self.base_url)
-        self.async_client = AsyncOpenAI(api_key=self.api_key, base_url=self.base_url)
-    
-    def sync_query(self, prompts):
         try:
             if isinstance(prompts, str):
                 prompts = [prompts]
@@ -91,23 +121,23 @@ class GPT:
             return response.choices[0].message.content
         except Exception as e:
             print(f"同步查询失败: {traceback.format_exc()}")
-            # 尝试切换模型类型
-            if self.model_type == 'deepseek':
-                self.model_type = 'sambanova'
-            else:
-                self.model_type = 'deepseek'
-            self.config = NB(self.model_type)
-            self.api_key = self.config['api_key']
-            self.base_url = self.config['base_url']
-            self.model = self.config['model']
-            self.sync_client = OpenAI(api_key=self.api_key, base_url=self.base_url)
-            self.async_client = AsyncOpenAI(api_key=self.api_key, base_url=self.base_url)
-            self.last_used_model = self.model_type  # 更新最后使用的模型
+            self._switch_model()
             raise
 
     async def async_query(self, prompts):
+        """
+        异步查询大模型
+        
+        参数:
+            prompts (str|list): 提示词，可以是字符串或字符串列表
+            
+        返回:
+            str: 模型生成的文本
+            
+        异常:
+            Exception: 查询失败时抛出，并自动切换模型类型
+        """
         try:
-            # 异常处理
             if isinstance(prompts, str):
                 prompts = [prompts]
                 
@@ -123,30 +153,22 @@ class GPT:
             return completion.choices[0].message.content
         except Exception as e:
             print(f"异步查询失败: {traceback.format_exc()}")
-            # 尝试切换模型类型
-            if self.model_type == 'deepseek':
-                self.model_type = 'sambanova'
-            else:
-                self.model_type = 'deepseek'
-            self.config = NB(self.model_type)
-            self.api_key = self.config['api_key']
-            self.base_url = self.config['base_url']
-            self.model = self.config['model']
-            self.sync_client = OpenAI(api_key=self.api_key, base_url=self.base_url)
-            self.async_client = AsyncOpenAI(api_key=self.api_key, base_url=self.base_url)
-            self.last_used_model = self.model_type  # 更新最后使用的模型
+            self._switch_model()
             raise
             
-        
     async def async_json_query(self, prompts):
         """
-        异步查询大模型
+        异步查询大模型并返回JSON格式结果
         
         参数:
-            prompts: 提示词列表或字符串
+            prompts (str|list): 提示词，可以是字符串或字符串列表
             
         返回:
-            大模型返回的结果
+            str: JSON格式的模型响应
+            
+        示例:
+        >>> response = await gpt.async_json_query("返回JSON格式的天气数据")
+        >>> print(response)  # 输出: {"weather": "sunny", "temperature": 25}
         """
         if isinstance(prompts, str):
             prompts = [prompts]
@@ -166,16 +188,28 @@ class GPT:
         return completion.choices[0].message.content
     
     async def close(self):
-        """关闭客户端连接"""
+        """关闭客户端连接，释放资源"""
         await self.async_client.close()
         self.sync_client.close()
     
     async def __aenter__(self):
+        """上下文管理器入口"""
         return self
     
     async def __aexit__(self, exc_type, exc_val, exc_tb):
+        """上下文管理器出口，自动关闭连接"""
         await self.close()
-
+    
+    def _switch_model(self):
+        """内部方法：在模型失败时切换模型类型"""
+        self.model_type = 'sambanova' if self.model_type == 'deepseek' else 'deepseek'
+        self.config = NB(self.model_type)
+        self.api_key = self.config['api_key']
+        self.base_url = self.config['base_url']
+        self.model = self.config['model']
+        self.sync_client = OpenAI(api_key=self.api_key, base_url=self.base_url)
+        self.async_client = AsyncOpenAI(api_key=self.api_key, base_url=self.base_url)
+        self.last_used_model = self.model_type
 _gpt = GPT()
 async_gpt = _gpt.async_query
 sync_gpt = _gpt.sync_query

{deva-1.3.1 → deva-1.3.2}/deva/page.py

@@ -322,7 +322,6 @@ class PageServer(object):
             page: Page实例,包含要添加的路由
         """
         self.application.add_handlers('.*$', page.get_routes())
-        page.get_routes() >> ls >> log
 
     def start(self,):
         """启动Web服务器并在浏览器中打开"""
@@ -516,7 +515,6 @@ def webview(s, url='/', server=None):
         './templates/streams.html', streams=server.streams[url]))
     server.add_page(page)
     print('start webview:', 'http://'+server.host+':'+str(server.port)+url)
-    print('with these streams:', server.streams[url])
     return server