Merge pull request #76 from kense-lab/feat/upgrade-depends

Feat/upgrade versions of some libraries

Author: liuooo

app/api/v1/action.py

@@ -6,7 +6,7 @@
 
 from app.api.deps import get_async_session, get_token_id
 from app.libs.paginate import cursor_page, CommonPage
-from app.models.action import Action
+from app.models.action import Action, ActionRead
 from app.models.token_relation import RelationType
 from app.providers.auth_provider import auth_policy
 from app.schemas.common import DeleteResponse, BaseSuccessDataResponse
@@ -16,44 +16,50 @@
 router = APIRouter()
 
 
-@router.get("", response_model=CommonPage[Action])
+@router.get("", response_model=CommonPage[ActionRead])
 async def list_actions(*, session: AsyncSession = Depends(get_async_session), token_id=Depends(get_token_id)):
     """
     Returns a list of Actions.
     """
     statement = auth_policy.token_filter(
         select(Action), field=Action.id, relation_type=RelationType.Action, token_id=token_id
     )
-    return await cursor_page(statement, session)
+    page = await cursor_page(statement, session)
+    page.data = [ast.model_dump(by_alias=True) for ast in page.data]
+    return page.model_dump(by_alias=True)
 
 
-@router.post("", response_model=List[Action])
+@router.post("", response_model=List[ActionRead])
 async def create_actions(
     *, session: AsyncSession = Depends(get_async_session), body: ActionBulkCreateRequest, token_id=Depends(get_token_id)
-) -> List[Action]:
+):
     """
     Create an action with openapi schema.
     """
 
-    return await ActionService.create_actions(session=session, body=body, token_id=token_id)
+    actions = await ActionService.create_actions(session=session, body=body, token_id=token_id)
+    actions = [item.model_dump(by_alias=True) for item in actions]
+    return actions
 
 
-@router.get("/{action_id}", response_model=Action)
-async def get_action(*, session: AsyncSession = Depends(get_async_session), action_id: str) -> Action:
+@router.get("/{action_id}", response_model=ActionRead)
+async def get_action(*, session: AsyncSession = Depends(get_async_session), action_id: str):
     """
     Retrieves an action.
     """
-    return await ActionService.get_action(session=session, action_id=action_id)
+    action = await ActionService.get_action(session=session, action_id=action_id)
+    return action.model_dump(by_alias=True)
 
 
-@router.post("/{action_id}", response_model=Action)
+@router.post("/{action_id}", response_model=ActionRead)
 async def modify_action(
     *, session: AsyncSession = Depends(get_async_session), action_id: str, body: ActionUpdateRequest
-) -> Action:
+):
     """
     Modifies an action.
     """
-    return await ActionService.modify_action(session=session, action_id=action_id, body=body)
+    action = await ActionService.modify_action(session=session, action_id=action_id, body=body)
+    return action.model_dump(by_alias=True)
 
 
 @router.delete("/{action_id}", response_model=DeleteResponse)

app/api/v1/assistant.py

@@ -3,7 +3,7 @@
 from sqlmodel import select
 
 from app.api.deps import get_token_id, get_async_session
-from app.models.assistant import Assistant, AssistantUpdate, AssistantCreate
+from app.models.assistant import Assistant, AssistantUpdate, AssistantCreate, AssistantRead
 from app.libs.paginate import cursor_page, CommonPage
 from app.models.token_relation import RelationType
 from app.providers.auth_provider import auth_policy
@@ -13,7 +13,7 @@
 router = APIRouter()
 
 
-@router.get("", response_model=CommonPage[Assistant])
+@router.get("", response_model=CommonPage[AssistantRead])
 async def list_assistants(*, session: AsyncSession = Depends(get_async_session), token_id=Depends(get_token_id)):
     """
     Returns a list of assistants.
@@ -26,30 +26,30 @@ async def list_assistants(*, session: AsyncSession = Depends(get_async_session),
     return asts_page
 
 
-@router.post("", response_model=Assistant, response_model_exclude={"metadata"})
+@router.post("", response_model=AssistantRead)
 async def create_assistant(
     *, session: AsyncSession = Depends(get_async_session), body: AssistantCreate, token_id=Depends(get_token_id)
-) -> Assistant:
+):
     """
     Create an assistant with a model and instructions.
     """
     ast = await AssistantService.create_assistant(session=session, body=body, token_id=token_id)
     return ast.model_dump(by_alias=True)
 
 
-@router.get("/{assistant_id}", response_model=Assistant)
-async def get_assistant(*, session: AsyncSession = Depends(get_async_session), assistant_id: str) -> Assistant:
+@router.get("/{assistant_id}", response_model=AssistantRead)
+async def get_assistant(*, session: AsyncSession = Depends(get_async_session), assistant_id: str):
     """
     Retrieves an assistant.
     """
     ast = await AssistantService.get_assistant(session=session, assistant_id=assistant_id)
     return ast.model_dump(by_alias=True)
 
 
-@router.post("/{assistant_id}", response_model=Assistant)
+@router.post("/{assistant_id}", response_model=AssistantRead)
 async def modify_assistant(
     *, session: AsyncSession = Depends(get_async_session), assistant_id: str, body: AssistantUpdate
-) -> Assistant:
+):
     """
     Modifies an assistant.
     """

app/api/v1/message.py

@@ -6,7 +6,7 @@
 
 from app.api.deps import get_async_session
 from app.models import MessageFile
-from app.models.message import Message, MessageCreate, MessageUpdate
+from app.models.message import Message, MessageCreate, MessageUpdate, MessageRead
 from app.libs.paginate import cursor_page, CommonPage
 from app.services.message.message import MessageService
 
@@ -15,7 +15,7 @@
 
 @router.get(
     "/{thread_id}/messages",
-    response_model=CommonPage[Message],
+    response_model=CommonPage[MessageRead],
 )
 async def list_messages(
     *,
@@ -30,47 +30,53 @@ async def list_messages(
     if run_id:
         # 根据 run_id 进行过滤
         statement = statement.where(Message.run_id == run_id)
-    return await cursor_page(statement, session)
 
+    page = await cursor_page(statement, session)
+    page.data = [ast.model_dump(by_alias=True) for ast in page.data]
+    return page
 
-@router.post("/{thread_id}/messages", response_model=Message)
+
+@router.post("/{thread_id}/messages", response_model=MessageRead)
 async def create_message(
     *, session: AsyncSession = Depends(get_async_session), thread_id: str, body: MessageCreate
-) -> Message:
+):
     """
     Create a message.
     """
-    return await MessageService.create_message(session=session, thread_id=thread_id, body=body)
+    message = await MessageService.create_message(session=session, thread_id=thread_id, body=body)
+    return message.model_dump(by_alias=True)
 
 
 @router.get(
     "/{thread_id}/messages/{message_id}",
-    response_model=Message,
+    response_model=MessageRead,
 )
 async def get_message(
     *, session: AsyncSession = Depends(get_async_session), thread_id: str, message_id: str
-) -> Message:
+):
     """
     Retrieve a message.
     """
-    return await MessageService.get_message(session=session, thread_id=thread_id, message_id=message_id)
+    message = await MessageService.get_message(session=session, thread_id=thread_id, message_id=message_id)
+    return message.model_dump(by_alias=True)
 
 
 @router.post(
     "/{thread_id}/messages/{message_id}",
-    response_model=Message,
+    response_model=MessageRead,
 )
 async def modify_message(
     *,
     session: AsyncSession = Depends(get_async_session),
     thread_id: str,
     message_id: str = ...,
     body: MessageUpdate = ...,
-) -> Message:
+):
     """
     Modifies a message.
     """
-    return await MessageService.modify_message(session=session, thread_id=thread_id, message_id=message_id, body=body)
+    message = await MessageService.modify_message(session=session, thread_id=thread_id, message_id=message_id, body=body)
+    return message.model_dump(by_alias=True)
 
 
 @router.get(

app/api/v1/runs.py

@@ -6,8 +6,8 @@
 from app.api.deps import get_async_session
 from app.core.runner import pub_handler
 from app.libs.paginate import cursor_page, CommonPage
-from app.models import RunStep
 from app.models.run import RunCreate, RunRead, RunUpdate, Run
+from app.models.run_step import RunStep, RunStepRead
 from app.schemas.runs import SubmitToolOutputsRunRequest
 from app.schemas.threads import CreateThreadAndRun
 from app.services.run.run import RunService
@@ -19,7 +19,7 @@
 
 @router.get(
     "/{thread_id}/runs",
-    response_model=CommonPage[Run],
+    response_model=CommonPage[RunRead],
 )
 async def list_runs(
     *,
@@ -30,7 +30,9 @@ async def list_runs(
     Returns a list of runs belonging to a thread.
     """
     await ThreadService.get_thread(session=session, thread_id=thread_id)
-    return await cursor_page(select(Run).where(Run.thread_id == thread_id), session)
+    page = await cursor_page(select(Run).where(Run.thread_id == thread_id), session)
+    page.data = [ast.model_dump(by_alias=True) for ast in page.data]
+    return page.model_dump(by_alias=True)
 
 
 @router.post(
@@ -52,7 +54,7 @@ async def create_run(
     if body.stream:
         return pub_handler.sub_stream(db_run.id, request)
     else:
-        return db_run
+        return db_run.model_dump(by_alias=True)
 
 
 @router.get(
@@ -63,7 +65,8 @@ async def get_run(*, session: AsyncSession = Depends(get_async_session), thread_
     """
     Retrieves a run.
     """
-    return await RunService.get_run(session=session, run_id=run_id, thread_id=thread_id)
+    run = await RunService.get_run(session=session, run_id=run_id, thread_id=thread_id)
+    return run.model_dump(by_alias=True)
 
 
 @router.post(
@@ -80,7 +83,8 @@ async def modify_run(
     """
     Modifies a run.
     """
-    return await RunService.modify_run(session=session, thread_id=thread_id, run_id=run_id, body=body)
+    run = await RunService.modify_run(session=session, thread_id=thread_id, run_id=run_id, body=body)
+    return run.model_dump(by_alias=True)
 
 
 @router.post(
@@ -93,12 +97,13 @@ async def cancel_run(
     """
     Cancels a run that is `in_progress`.
     """
-    return await RunService.cancel_run(session=session, thread_id=thread_id, run_id=run_id)
+    run = await RunService.cancel_run(session=session, thread_id=thread_id, run_id=run_id)
+    return run.model_dump(by_alias=True)
 
 
 @router.get(
     "/{thread_id}/runs/{run_id}/steps",
-    response_model=CommonPage[RunStep],
+    response_model=CommonPage[RunStepRead],
 )
 async def list_run_steps(
     *,
@@ -109,14 +114,17 @@ async def list_run_steps(
     """
     Returns a list of run steps belonging to a run.
     """
-    return await cursor_page(
+    page = await cursor_page(
         select(RunStep).where(RunStep.thread_id == thread_id).where(RunStep.run_id == run_id), session
     )
+    page.data = [ast.model_dump(by_alias=True) for ast in page.data]
+    return page.model_dump(by_alias=True)
+
 
 
 @router.get(
     "/{thread_id}/runs/{run_id}/steps/{step_id}",
-    response_model=RunStep,
+    response_model=RunStepRead,
 )
 async def get_run_step(
     *,
@@ -128,7 +136,8 @@ async def get_run_step(
     """
     Retrieves a run step.
     """
-    return await RunService.get_run_step(thread_id=thread_id, run_id=run_id, step_id=step_id, session=session)
+    run_step = await RunService.get_run_step(thread_id=thread_id, run_id=run_id, step_id=step_id, session=session)
+    return run_step.model_dump(by_alias=True)
 
 
 @router.post(
@@ -156,7 +165,7 @@ async def submit_tool_outputs_to_run(
     if body.stream:
         return pub_handler.sub_stream(db_run.id, request)
     else:
-        return db_run
+        return db_run.model_dump(by_alias=True)
 
 
 @router.post("/runs", response_model=RunRead)
@@ -170,4 +179,4 @@ async def create_thread_and_run(
     if body.stream:
         return pub_handler.sub_stream(run.id, request)
     else:
-        return run
+        return run.model_dump(by_alias=True)

app/core/runner/thread_runner.py

@@ -6,6 +6,7 @@
 
 from sqlalchemy.orm import Session
 
+from app.models.token_relation import RelationType
 from config.config import settings
 from config.llm import llm_settings, tool_settings
 
@@ -247,7 +248,7 @@ def __init_llm_backend(self, assistant_id):
         if settings.AUTH_ENABLE:
             # init llm backend with token id
             token_id = TokenRelationService.get_token_id_by_relation(
-                session=self.session, relation_type="assistant", relation_id=assistant_id
+                session=self.session, relation_type=RelationType.Assistant, relation_id=assistant_id
             )
             token = TokenService.get_token_by_id(self.session, token_id)
             return LLMBackend(base_url=token.llm_base_url, api_key=token.llm_api_key)

app/libs/paginate.py

@@ -17,9 +17,9 @@
 
 class CursorParams(BaseModel, AbstractParams):
     limit: int = Query(20, ge=1, le=100, description="Page offset")
-    order: str = "desc"
-    after: Optional[str] = None
-    before: Optional[str] = None
+    order: str = Query(default="desc", description="Sort order")
+    after: Optional[str] = Query(None, description="Page after")
+    before: Optional[str] = Query(None, description="Page before")
 
     def to_raw_params(self) -> CursorRawParams:
         return CursorRawParams(cursor=None, size=self.limit, include_total=True)

app/libs/types.py

@@ -1,11 +1 @@
-from datetime import datetime
-
-from app.libs.util import datetime2timestamp
-
 from app.libs.bson.objectid import ObjectId as ObjectId  # noqa
-
-
-class Timestamp(datetime):
-    @classmethod
-    def __get_validators__(cls):
-        yield datetime2timestamp

app/libs/util.py

@@ -8,5 +8,21 @@ def datetime2timestamp(value: datetime):
     return value.timestamp()
 
 
+def str2datetime(value: str):
+    if not value:
+        return None
+    return datetime.fromisoformat(value)
+
+
+def is_valid_datetime(date_str, format="%Y-%m-%d %H:%M:%S"):
+    if not date_str or not isinstance(date_str, str):
+        return False
+    try:
+        datetime.strptime(date_str, format)
+        return True
+    except ValueError:
+        return False
+
+
 def random_uuid() -> str:
     return "ml-" + str(uuid.uuid4()).replace("-", "")