pro-craft 0.1.2__py3-none-any.whl → 0.1.4__py3-none-any.whl

pro_craft/server/__main__.py

@@ -1,131 +1,124 @@
-
-from fastapi import FastAPI, HTTPException, Header
+# server
+from fastapi import FastAPI, HTTPException
 from fastapi.middleware.cors import CORSMiddleware
-from fastapi import FastAPI, Depends
-from fastapi_users import FastAPIUsers
-from contextlib import asynccontextmanager
-from .utils import create_db_and_tables
-from .utils import get_user_manager, auth_backend
-from .models.models import User,UserCreate, UserRead,UserUpdate
-from .routers import admin_router,user_router
-from pydantic import BaseModel, Field, model_validator
+from prompt_writing_assistant.log import Log
+from dotenv import load_dotenv, find_dotenv
+from contextlib import asynccontextmanager, AsyncExitStack
+from fastapi import FastAPI, Request
+from fastapi.routing import APIRoute
 import argparse
 import uvicorn
-import uuid
-from umanager.log import Log
 
-# 应用程序生命周期事件
-@asynccontextmanager
-async def lifespan(app: FastAPI):
-    # 应用启动时创建数据库表
-    await create_db_and_tables()
-    yield
+from .mcp.math import mcp as fm_math
+from .mcp.weather import mcp as fm_weather
+
 
+default = 8007
 
-default=8008
+dotenv_path = find_dotenv()
+load_dotenv(dotenv_path, override=True)
+logger = Log.logger
+
+
+# Combine both lifespans
+@asynccontextmanager
+async def combined_lifespan(app: FastAPI):
+    # Run both lifespans
+    async with AsyncExitStack() as stack:
+        await stack.enter_async_context(fm_math.session_manager.run())
+        await stack.enter_async_context(fm_weather.session_manager.run())
+        yield
 
 app = FastAPI(
-    lifespan=lifespan,
     title="LLM Service",
     description="Provides an OpenAI-compatible API for custom large language models.",
     version="1.0.1",
+    # debug=True, 
+    # docs_url="/api-docs",
+    lifespan=combined_lifespan
 )
 
-fastapi_users = FastAPIUsers[User, uuid.UUID](
-    get_user_manager,
-    [auth_backend],
-)
-
-
 # --- Configure CORS ---
 origins = [
-    "*", # Allows all origins (convenient for development, insecure for production)
-    # Add the specific origin of your "别的调度" tool/frontend if known
-    # e.g., "http://localhost:5173" for a typical Vite frontend dev server
-    # e.g., "http://127.0.0.1:5173"
+    "*", 
 ]
 
 app.add_middleware(
     CORSMiddleware,
     allow_origins=origins,  # Specifies the allowed origins
-    allow_credentials=True, # Allows cookies/authorization headers
-    allow_methods=["*"],    # Allows all methods (GET, POST, OPTIONS, etc.)
-    allow_headers=["*"],    # Allows all headers (Content-Type, Authorization, etc.)
+    allow_credentials=True,  # Allows cookies/authorization headers
+    allow_methods=["*"],  # Allows all methods (GET, POST, OPTIONS, etc.)
+    allow_headers=["*"],  # Allows all headers (Content-Type, Authorization, etc.)
 )
 # --- End CORS Configuration ---
 
-# 注册认证和用户管理路由
-app.include_router(
-    fastapi_users.get_auth_router(auth_backend),
-    prefix="/auth/jwt",
-    tags=["auth"],
-)
-app.include_router(
-    fastapi_users.get_register_router(UserRead, UserCreate),
-    prefix="/auth",
-    tags=["auth"],
-)
-app.include_router(
-    fastapi_users.get_reset_password_router(),
-    prefix="/auth",
-    tags=["auth"],
-)
-app.include_router(
-    fastapi_users.get_verify_router(UserRead),
-    prefix="/auth",
-    tags=["auth"],
-)
-app.include_router(
-    fastapi_users.get_users_router(UserRead, UserUpdate),
-    prefix="/users",
-    tags=["users"],
-)
 
 
-# -------------------- 集成待办事项路由 --------------------
-# app.include_router(admin_router, prefix="/")
-# app.include_router(user_router, prefix="/")
 
-app.include_router(admin_router,prefix="/admin")
-app.include_router(user_router,prefix="/users")
+app.mount("/math", fm_math.streamable_http_app()) # /math/mcp
+app.mount("/weather", fm_weather.streamable_http_app()) # /weather/mcp
+
+
+
 
 
 @app.get("/")
 async def root():
-    """ x """
+    """server run"""
     return {"message": "LLM Service is running."}
 
 
+@app.get("/api/status")
+def status():
+    return {"status": "ok"}
+
+@app.get("/api/list-routes/")
+async def list_fastapi_routes(request: Request):
+    routes_data = []
+    for route in request.app.routes:
+        if isinstance(route, APIRoute):
+            routes_data.append({
+                "path": route.path,
+                "name": route.name,
+                "methods": list(route.methods),
+                "endpoint": route.endpoint.__name__ # Get the name of the function
+            })
+    return {"routes": routes_data}
+
 
 
 if __name__ == "__main__":
+    # 这是一个标准的 Python 入口点惯用法
+    # 当脚本直接运行时 (__name__ == "__main__")，这里的代码会被执行
+    # 当通过 python -m YourPackageName 执行 __main__.py 时，__name__ 也是 "__main__"
+    # 27
     
     parser = argparse.ArgumentParser(
         description="Start a simple HTTP server similar to http.server."
     )
     parser.add_argument(
-        'port',
-        metavar='PORT',
+        "port",
+        metavar="PORT",
         type=int,
-        nargs='?', # 端口是可选的
+        nargs="?",  # 端口是可选的
         default=default,
-        help=f'Specify alternate port [default: {default}]'
+        help=f"Specify alternate port [default: {default}]",
     )
     # 创建一个互斥组用于环境选择
     group = parser.add_mutually_exclusive_group()
 
     # 添加 --dev 选项
     group.add_argument(
-        '--dev',
-        action='store_true', # 当存在 --dev 时，该值为 True
-        help='Run in development mode (default).'
+        "--dev",
+        action="store_true",  # 当存在 --dev 时，该值为 True
+        help="Run in development mode (default).",
     )
 
     # 添加 --prod 选项
     group.add_argument(
-        '--prod',
-        action='store_true', # 当存在 --prod 时，该值为 True
-        help='Run in production mode.'
+        "--prod",
+        action="store_true",  # 当存在 --prod 时，该值为 True
+        help="Run in production mode.",
     )
     args = parser.parse_args()
 
@@ -136,25 +129,26 @@ if __name__ == "__main__":
         env = "dev"
 
     port = args.port
+
     if env == "dev":
         port += 100
-        Log.reset_level('debug',env = env)
+        Log.reset_level("debug", env=env)
         reload = True
-        app_import_string = f"{__package__}.__main__:app" # <--- 关键修改：传递导入字符串
+        app_import_string = (
+            f"{__package__}.__main__:app"  # <--- 关键修改：传递导入字符串
+        )
     elif env == "prod":
-        Log.reset_level('info',env = env)# ['debug', 'info', 'warning', 'error', 'critical']
+        Log.reset_level(
+            "info", env=env
+        )  # ['debug', 'info', 'warning', 'error', 'critical']
         reload = False
         app_import_string = app
     else:
         reload = False
         app_import_string = app
-    
 
     # 使用 uvicorn.run() 来启动服务器
     # 参数对应于命令行选项
     uvicorn.run(
-        app_import_string,
-        host="0.0.0.0",
-        port=port,
-        reload=reload  # 启用热重载
+        app_import_string, host="0.0.0.0", port=port, reload=reload  # 启用热重载
     )

pro_craft/server/models.py

@@ -0,0 +1,6 @@
+
+# server
+from typing import Dict, Any, Optional, List
+from pydantic import BaseModel, Field, model_validator
+
+

pro_craft/server/router/recommended.py

@@ -0,0 +1,283 @@
+# server
+# 推荐算法
+
+from ..models import UpdateItem, DeleteResponse, DeleteRequest, QueryItem
+from fastapi import APIRouter, Depends, HTTPException, status
+from typing import Dict, Any
+from diglife.embedding_pool import EmbeddingPool
+from diglife.log import Log
+import os
+import httpx
+
+from dotenv import load_dotenv, find_dotenv
+
+dotenv_path = find_dotenv()
+load_dotenv(dotenv_path, override=True)
+
+
+
+router = APIRouter(tags=["recommended"])
+
+logger = Log.logger
+
+recommended_biographies_cache_max_leng = os.getenv("recommended_biographies_cache_max_leng",2) #config.get("recommended_biographies_cache_max_leng", 2)
+recommended_biographies_cache_max_leng = int(recommended_biographies_cache_max_leng)
+recommended_cache_max_leng = os.getenv("recommended_cache_max_leng",2) #config.get("recommended_cache_max_leng", 2)
+recommended_cache_max_leng = int(recommended_cache_max_leng)
+user_server_base_url = "http://182.92.107.224:7000"
+
+ep = EmbeddingPool()
+recommended_biographies_cache: Dict[str, Dict[str, Any]] = {}
+recommended_figure_cache: Dict[str, Dict[str, Any]] = {}
+
+@router.post(
+    "/update",  # 推荐使用POST请求进行数据更新
+    summary="更新或添加文本嵌入",
+    description="将给定的文本内容与一个ID关联并更新到Embedding池中。",
+    response_description="表示操作是否成功。",
+)
+def recommended_update(item: UpdateItem):
+    """记忆卡片是0  传记是1
+    记忆卡片是0
+    记忆卡片上传的是记忆卡片的内容 str
+    记忆卡片id
+    0
+
+    传记是1
+    上传的是传记简介  str
+    传记id
+    1
+
+    数字分身是2
+    上传数字分身简介和性格描述  str
+    数字分身id
+    2
+    """
+    # TODO 需要一个反馈状态
+    try:
+        if item.type in [0, 1, 2]:  # 上传的是卡片
+            ep.update(text=item.text, id=item.id, type=item.type)
+        else:
+            logger.error(f"Error updating EmbeddingPool for ID '{item.id}': {e}")
+            raise HTTPException(
+                status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+                detail=f"Failed to update embedding for ID '{item.id}': {e}",
+            )
+
+        return {"status": "success", "message": f"ID '{item.id}' updated successfully."}
+
+    except ValueError as e:  # 假设EmbeddingPool.update可能抛出ValueError
+        logger.warning(f"Validation error during update: {e}")
+        raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail=str(e))
+    except Exception as e:
+        logger.error(f"Error updating EmbeddingPool for ID '{item.id}': {e}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"Failed to update embedding for ID '{item.id}': {e}",
+        )
+
+
+@router.post("/delete", response_model=DeleteResponse, description="delete")
+async def delete_server(request: DeleteRequest):
+
+    logger.info("running delete_server")
+
+    # TODO 需要一个反馈状态
+    result = ep.delete(id=request.id)  # 包裹的内核函数
+
+    ########
+    return DeleteResponse(
+        status="success",
+    )
+
+
+
+
+# async def aget_content_by_id(url = ""):
+#     # url = url.format(user_profile_id = user_profile_id)
+#     async with httpx.AsyncClient() as client:
+#         try:
+#             response = await client.get(url)
+#             response.raise_for_status()  # 如果状态码是 4xx 或 5xx，会抛出 HTTPStatusError 异常
+            
+#             print(f"Status Code: {response.status_code}")
+#             print(f"Response Body: {response.json()}") # 假设返回的是 JSON
+#             return response.json()
+#         except httpx.HTTPStatusError as e:
+#             print(f"HTTP error occurred: {e.response.status_code} - {e.response.text}")
+#         except httpx.RequestError as e:
+#             print(f"An error occurred while requesting {e.request.url!r}: {e}")
+#         except Exception as e:
+#             print(f"An unexpected error occurred: {e}")
+#     return None
+
+async def aget_(url = ""):
+    async with httpx.AsyncClient() as client:
+        try:
+            response = await client.get(url)
+            response.raise_for_status()  # 如果状态码是 4xx 或 5xx，会抛出 HTTPStatusError 异常
+            
+            print(f"Status Code: {response.status_code}")
+            print(f"Response Body: {response.json()}") # 假设返回的是 JSON
+            return response.json()
+        except httpx.HTTPStatusError as e:
+            print(f"HTTP error occurred: {e.response.status_code} - {e.response.text}")
+        except httpx.RequestError as e:
+            print(f"An error occurred while requesting {e.request.url!r}: {e}")
+        except Exception as e:
+            print(f"An unexpected error occurred: {e}")
+    return None
+
+@router.post(
+    "/search_biographies_and_cards",
+    summary="搜索传记和记忆卡片",
+    description="搜索传记和记忆卡片",
+    response_description="搜索结果列表。",
+)
+async def recommended_biographies_and_cards(query_item: QueryItem):
+    """
+        # result = [
+        #     {
+        #         "id": "1916693308020916225",  # 传记ID
+        #         "type": 1,
+        #         "order": 0,
+        #     },
+        #     {
+        #         "id": "1962459564012359682",  # 卡片ID
+        #         "type": 0,
+        #         "order": 1,
+        #     },
+        #     {
+        #         "id": "1916389315373727745",  # 传记ID
+        #         "type": 1,
+        #         "order": 2,
+        #     },
+        # ]
+
+        {
+        "text":"这是一个传记001",
+        "id":"1916693308020916225",
+        "type":1
+    }
+    {
+        "text":"这是一个传记002",
+        "id":"1916389315373727745",
+        "type":1
+    }
+    {
+        "text":"这是一个卡片001",
+        "id":"1962459564012359682",
+        "type":0
+    }
+    """
+    try:
+        # TODO 需要一个通过id 获取对应内容的接口
+        # TODO 调用id 获得对应的用户简介 query_item.user_id
+
+
+        user_profile_id_to_fetch = query_item.user_id
+        # memory_info = await aget_content_by_id(user_profile_id_to_fetch,url = user_server_base_url + "/api/inner/getMemoryCards?userProfileId={user_profile_id}")
+        memory_info = await aget_(url = user_server_base_url + f"/api/inner/getMemoryCards?userProfileId={user_profile_id_to_fetch}")
+        # memory_info = await get_memorycards_by_id(user_profile_id_to_fetch)
+        user_brief = '\n'.join([i.get('content') for i in memory_info['data']["memoryCards"][:4]])
+
+
+        result = ep.search_bac(query=user_brief)
+
+        if recommended_biographies_cache.get(query_item.user_id):
+            clear_result = [
+                i
+                for i in result
+                if i.get("id")
+                not in recommended_biographies_cache.get(query_item.user_id)
+            ]
+        else:
+            recommended_biographies_cache[query_item.user_id] = []
+            clear_result = result
+
+        recommended_biographies_cache[query_item.user_id] += [
+            i.get("id") for i in result
+        ]
+        recommended_biographies_cache[query_item.user_id] = list(
+            set(recommended_biographies_cache[query_item.user_id])
+        )
+        if (
+            len(recommended_biographies_cache[query_item.user_id])
+            > recommended_biographies_cache_max_leng
+        ):
+            recommended_biographies_cache[query_item.user_id] = []
+
+        return {
+            "status": "success",
+            "result": clear_result,
+            "query": query_item.user_id,
+        }
+
+    except Exception as e:
+        logger.error(
+            f"Error searching EmbeddingPool for query '{query_item.user_id}': {e}"
+        )
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"Failed to perform search: {e}",
+        )
+
+
+
+@router.post(
+    "/search_figure_person",
+    description="搜索数字分身的",
+)
+async def recommended_figure_person(query_item: QueryItem):
+    """
+
+    """
+    try:
+
+        user_profile_id_to_fetch = query_item.user_id
+        # avatar_info = await aget_avatar_desc_by_id(user_profile_id_to_fetch)
+        # avatar_info = await aget_content_by_id(user_profile_id_to_fetch,url = user_server_base_url + "/api/inner/getAvatarDesc?userProfileId={user_profile_id}")
+        avatar_info = await aget_(url = user_server_base_url + f"/api/inner/getAvatarDesc?userProfileId={user_profile_id_to_fetch}")
+        print(avatar_info,'avatar_info')
+        if avatar_info["code"] == 200:
+            user_brief = avatar_info["data"].get("avatarDesc")
+        else:
+            user_brief = "这是一个简单的人"
+
+        result = ep.search_figure_person(query=user_brief)  # 100+
+
+        if recommended_figure_cache.get(query_item.user_id):
+            # 不需要创建
+            clear_result = [
+                i
+                for i in result
+                if i.get("id") not in recommended_figure_cache.get(query_item.user_id)
+            ]
+        else:
+            recommended_figure_cache[query_item.user_id] = []
+            clear_result = result
+
+        recommended_figure_cache[query_item.user_id] += [i.get("id") for i in result]
+        recommended_figure_cache[query_item.user_id] = list(
+            set(recommended_figure_cache[query_item.user_id])
+        )
+        if (
+            len(recommended_figure_cache[query_item.user_id])
+            > recommended_cache_max_leng
+        ):
+            recommended_figure_cache[query_item.user_id] = []
+        return {
+            "status": "success",
+            "result": clear_result,
+            "query": query_item.user_id,
+        }
+
+    except Exception as e:
+        logger.error(
+            f"Error searching EmbeddingPool for query '{query_item.user_id}': {e}"
+        )
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"Failed to perform search: {e}",
+        )
+

pro_craft/utils.py

@@ -1 +1,161 @@
-from utils_tool import *
+'''
+Author: 823042332@qq.com 823042332@qq.com
+Date: 2025-08-28 09:07:54
+LastEditors: 823042332@qq.com 823042332@qq.com
+LastEditTime: 2025-08-28 09:30:32
+FilePath: /pro_craft/src/pro_craft/unit.py
+Description: 这是默认设置,请设置`customMade`, 打开koroFileHeader查看配置 进行设置: https://github.com/OBKoro1/koro1FileHeader/wiki/%E9%85%8D%E7%BD%AE
+'''
+import re
+import inspect
+import importlib
+import yaml
+import zlib
+from volcenginesdkarkruntime import Ark
+import os
+
+
+def extract_(text: str, pattern_key = r"json",multi = False):
+    pattern = r"```"+ pattern_key + r"([\s\S]*?)```"
+    matches = re.findall(pattern, text)
+    if multi:
+        [match.strip() for match in matches]
+        if matches:
+            return [match.strip() for match in matches]    
+        else:
+            return ""  # 返回空字符串或抛出异常，此处返回空字符串
+    else:
+        if matches:
+            return matches[0].strip()  # 添加strip()去除首尾空白符
+        else:
+            return ""  # 返回空字符串或抛出异常，此处返回空字符串
+
+
+def extract_from_loaded_objects(obj_list):
+    results = []
+    for obj in obj_list:
+        if inspect.isclass(obj):
+            class_info = {
+                "type": "class",
+                "name": obj.__name__,
+                "docstring": inspect.getdoc(obj),
+                "signature": f"class {obj.__name__}{inspect.getclasstree([obj], unique=True)[0][0].__bases__}:" if inspect.getclasstree([obj], unique=True)[0][0].__bases__ != (object,) else f"class {obj.__name__}:", # 尝试获取基类
+                "methods": []
+            }
+            # 遍历类的方法
+            for name, member in inspect.getmembers(obj, predicate=inspect.isfunction):
+                if name.startswith('__') and name != '__init__': # 过滤掉大多数魔术方法，但保留 __init__
+                    continue
+                
+                # inspect.signature 可以获取更精确的签名
+                sig = inspect.signature(member)
+                is_async = inspect.iscoroutinefunction(member)
+
+                method_info = {
+                    "type": "method",
+                    "name": name,
+                    "docstring": inspect.getdoc(member),
+                    "signature": f"{'async ' if is_async else ''}def {name}{sig}:",
+                    "is_async": is_async
+                }
+                class_info["methods"].append(method_info)
+            results.append(class_info)
+        elif inspect.isfunction(obj) or inspect.iscoroutinefunction(obj):
+            is_async = inspect.iscoroutinefunction(obj)
+            sig = inspect.signature(obj)
+            results.append({
+                "type": "function",
+                "name": obj.__name__,
+                "docstring": inspect.getdoc(obj),
+                "signature": f"{'async ' if is_async else ''}def {obj.__name__}{sig}:",
+                "is_async": is_async
+            })
+    return results
+
+
+def get_adler32_hash(s):
+    return zlib.adler32(s.encode('utf-8'))
+
+def embedding_inputs(inputs:list[str],model_name = None):
+    model_name = model_name or os.getenv("Ark_model_name")
+    ark_client = Ark(api_key=os.getenv("Ark_api_key"))
+
+    resp = ark_client.embeddings.create(
+                model=model_name,
+                input=inputs,
+                encoding_format="float",
+            )
+    return [i.embedding for i in resp.data]
+
+def load_inpackage_file(package_name:str, file_name:str,file_type = 'yaml'):
+    """ load config """
+    with importlib.resources.open_text(package_name, file_name) as f:
+        if file_type == 'yaml':
+            return yaml.safe_load(f)
+        else:
+            return f.read()
+
+
+def super_print(s,target:str):
+    print()
+    print()
+    print("=="*21 + target + "=="*21)
+    print()
+    print("=="*50)
+    print(type(s))
+    print("=="*50)
+    print(s)
+    print("=="*50)
+    print()
+
+
+from sqlalchemy.orm import sessionmaker
+
+from contextlib import contextmanager
+@contextmanager
+def create_session(engine):
+    # 5. 创建会话 (Session)
+    # Session 是与数据库交互的主要接口，它管理着你的对象和数据库之间的持久化操作
+    Session = sessionmaker(bind=engine)
+    session = Session()
+    try:
+        yield session
+
+    except Exception as e:
+        print(f"An error occurred: {e}")
+        session.rollback() # 发生错误时回滚事务
+    finally:
+        session.close() # 关闭会话，释放资源
+
+from contextlib import contextmanager
+from sqlalchemy import create_engine, Column, Integer, String, UniqueConstraint
+from sqlalchemy.orm import declarative_base, sessionmaker
+from sqlalchemy.ext.asyncio import AsyncSession, create_async_engine # 异步核心
+import asyncio
+
+from contextlib import contextmanager
+
+from contextlib import asynccontextmanager # 注意这里是 asynccontextmanager
+import asyncio
+
+
+@asynccontextmanager
+async def create_async_session(async_engine):
+    # 5. 创建会话 (Session)
+    # Session 是与数据库交互的主要接口，它管理着你的对象和数据库之间的持久化操作
+    Session = sessionmaker(bind=async_engine,
+                           expire_on_commit=False, 
+                           class_=AsyncSession
+                           )
+    session = Session()
+    try:
+        yield session
+        await session.commit() # 在成功的情况下自动提交事务
+
+    except Exception as e:
+        print(f"An error occurred: {e}")
+        await session.rollback() # 发生错误时回滚事务
+        raise # 重新抛出异常，让调用者知道操作失败
+    finally:
+        await session.close() # 关闭会话，释放资源
+