malevich-coretools 0.3.43__py3-none-any.whl → 0.3.44__py3-none-any.whl

malevich_coretools/abstract/abstract.py

@@ -628,3 +628,23 @@ class WSApp(BaseModel):
 
 class WSApps(BaseModel):
     data: List[WSApp]
+
+
+class MCPToolSimple(BaseModel):
+    name: Optional[str]     # can be None on updates
+    description: Optional[str] = None
+    inputSchema: Optional[Dict[str, Any]] = None
+
+
+class MCPTool(MCPToolSimple):
+    id: Optional[str] = None    # None if create, id otherwise
+    taskId: Optional[str] = None
+    pipelineId: Optional[str] = None
+    cfgId: Optional[str] = None
+    runSettings: Optional[RunSettings] = None
+    enableNotAuthorized: Optional[bool] = False
+
+
+class MCPToolCall(BaseModel):
+    name: str
+    arguments: Dict[str, Any]

malevich_coretools/batch/utils.py

@@ -80,7 +80,7 @@ class DefferOperationInternal(str):
         if self.__result_model is not None and self.__code < 400:   # ok
             try:
                 from malevich_coretools.secondary import model_from_json
-                self.__data = model_from_json(res, self.__result_model)
+                self.__data = model_from_json(res, self.__result_model, is_list=None)
             except BaseException:
                 Config.logger.error(f"parse {self.__alias} failed, model={self.__result_model.__name__}")
                 self.__data = res

malevich_coretools/funcs/funcs.py

@@ -1107,11 +1107,11 @@ async def post_admin_update_superuser_async(data: Superuser, *args, **kwargs) ->
 
 
 def delete_admin_runs(data: AdminStopOperation, *args, **kwargs) -> Alias.Json:
-    return send_to_core_modify(ADMIN_RUNS, data, is_post=False, *args, **kwargs)
+    return send_to_core_modify(ADMIN_RUNS, data, *args, **kwargs, is_post=False)
 
 
 async def delete_admin_runs_async(data: AdminStopOperation, *args, **kwargs) -> Alias.Json:
-    return await send_to_core_modify_async(ADMIN_RUNS, data, is_post=False, *args, **kwargs)
+    return await send_to_core_modify_async(ADMIN_RUNS, data, *args, **kwargs, is_post=False)
 
 # ManagerController
 
@@ -1473,19 +1473,85 @@ async def post_ws_apps_async(wait: bool, *args, **kwargs) -> WSApp:
 
 
 def delete_ws_apps_id(id: str, wait: bool, *args, **kwargs) -> Alias.Info:
-    return send_to_core_modify(WS_APPS_ID(id, wait), *args, **kwargs)
+    return send_to_core_modify(WS_APPS_ID(id, wait), *args, **kwargs, is_post=False)
 
 
 async def delete_ws_apps_id_async(id: str, wait: bool, *args, **kwargs) -> Alias.Info:
-    return await send_to_core_modify_async(WS_APPS_ID(id, wait), *args, **kwargs)
+    return await send_to_core_modify_async(WS_APPS_ID(id, wait), *args, **kwargs, is_post=False)
 
 
 def delete_ws_apps(only_not_active: bool, wait: bool, *args, **kwargs) -> Alias.Info:
-    return send_to_core_modify(WS_APPS_(only_not_active, wait), *args, **kwargs)
+    return send_to_core_modify(WS_APPS_(only_not_active, wait), *args, **kwargs, is_post=False)
 
 
 async def delete_ws_apps_async(only_not_active: bool, wait: bool, *args, **kwargs) -> Alias.Info:
-    return await send_to_core_modify_async(WS_APPS_(only_not_active, wait), *args, **kwargs)
+    return await send_to_core_modify_async(WS_APPS_(only_not_active, wait), *args, **kwargs, is_post=False)
+
+
+def get_mcp_tools(*args, **kwargs) -> List[MCPTool]:
+    return model_from_json(send_to_core_get(MCP_TOOLS_ALL(None), *args, **kwargs), MCPTool, is_list=True)
+
+
+async def get_mcp_tools_async(*args, **kwargs) -> List[MCPTool]:
+    return model_from_json(await send_to_core_get_async(MCP_TOOLS_ALL(None), *args, **kwargs), MCPTool, is_list=True)
+
+
+def get_mcp_tools_list(*args, **kwargs) -> List[MCPToolSimple]:
+    return model_from_json(send_to_core_get(MCP_TOOLS_LIST, *args, **kwargs), MCPToolSimple, is_list=True)
+
+
+async def get_mcp_tools_list_async(*args, **kwargs) -> List[MCPToolSimple]:
+    return model_from_json(await send_to_core_get_async(MCP_TOOLS_LIST, *args, **kwargs), MCPToolSimple, is_list=True)
+
+
+def get_mcp_tool_id_name(id: Optional[str], name: Optional[str], *args, **kwargs) -> MCPTool:
+    return model_from_json(send_to_core_get(MCP_TOOLS(id, name, None), *args, **kwargs), MCPTool)
+
+
+async def get_mcp_tool_id_name_async(id: Optional[str], name: Optional[str], *args, **kwargs) -> MCPTool:
+    return model_from_json(await send_to_core_get_async(MCP_TOOLS(id, name, None), *args, **kwargs), MCPTool)
+
+
+def post_mcp_tool(data, wait: bool, *args, **kwargs) -> Alias.Id:
+    return send_to_core_modify(MCP_TOOLS(None, None, wait), data, *args, **kwargs)
+
+
+async def post_mcp_tool_async(data, wait: bool, *args, **kwargs) -> Alias.Id:
+    return await send_to_core_modify_async(MCP_TOOLS(None, None, wait), data, *args, **kwargs)
+
+
+def call_mcp_tool(data: MCPToolCall, with_show: bool, *args, **kwargs) -> Union[AppLogsWithResults, Any]:
+    res = send_to_core_modify(MCP_TOOLS_CALL, data, with_show=with_show, show_func=show_logs_func, *args, **kwargs)
+    try:
+        res = AppLogsWithResults.model_validate_json(res)
+    except BaseException:
+        pass
+    return res
+
+
+async def call_mcp_tool_async(data: MCPToolCall, with_show: bool, *args, **kwargs) -> Union[AppLogsWithResults, Any]:
+    res = await send_to_core_modify_async(MCP_TOOLS_CALL, data, with_show=with_show, show_func=show_logs_func, *args, **kwargs)
+    try:
+        res = AppLogsWithResults.model_validate_json(res)
+    except BaseException:
+        pass
+    return res
+
+
+def delete_mcp_tool_id_name(id: str, name: str, wait: bool, *args, **kwargs) -> Alias.Info:
+    return send_to_core_modify(MCP_TOOLS(id, name, wait), *args, **kwargs, is_post=False)
+
+
+async def delete_mcp_tool_id_name_async(id: str, name: str, wait: bool, *args, **kwargs) -> Alias.Info:
+    return await send_to_core_modify_async(MCP_TOOLS(id, name, wait), *args, **kwargs, is_post=False)
+
+
+def delete_mcp_tools(wait: bool, *args, **kwargs) -> Alias.Info:
+    return send_to_core_modify(MCP_TOOLS_ALL(wait), *args, **kwargs, is_post=False)
+
+
+async def delete_mcp_tools_async(wait: bool, *args, **kwargs) -> Alias.Info:
+    return await send_to_core_modify_async(MCP_TOOLS_ALL(wait), *args, **kwargs, is_post=False)
 
 
 async def kafka_send(data: KafkaMsg, *args, **kwargs) -> Union[Alias.Info, KafkaMsg]:

malevich_coretools/secondary/const.py

@@ -30,6 +30,8 @@ def with_key_values(url: str, key_values: Dict[str, Optional[str]]) -> str:
                 value = urllib.parse.quote(str(value), safe='')
             elif isinstance(value, str):
                 value = urllib.parse.quote(value, safe='')
+            elif isinstance(value, bool):
+                value = bool_to_str(value)
             url = f"{url}{sep}{key}={value}"
             if sep == "?":
                 sep = "&"
@@ -216,6 +218,13 @@ WS_APPS = lambda only_active, full: with_key_values(f"{WS_APPS_MAIN}/", {"onlyAc
 WS_APPS_ = lambda only_not_active, wait: with_key_values(f"{WS_APPS_MAIN}/", {"onlyNotActive": only_not_active, "wait": wait})
 WS_APPS_ID = lambda id, wait: with_wait(f"{WS_APPS_MAIN}/{id}", wait)
 
+## McpToolController
+MCP_TOOLS_MAIN = f"{API_VERSION}/tools"
+MCP_TOOLS = lambda id, name, wait: with_key_values(f"{MCP_TOOLS_MAIN}/", {"id": id, "name": name, "wait": wait})
+MCP_TOOLS_ALL = lambda wait: with_wait(f"{MCP_TOOLS_MAIN}/all", wait)
+MCP_TOOLS_LIST = f"{MCP_TOOLS_MAIN}/list"
+MCP_TOOLS_CALL = f"{MCP_TOOLS_MAIN}/call"
+
 ### Kafka
 KAFKA_SEND = f"{MANAGER_MAIN}/kafkaMsg"
 

malevich_coretools/secondary/helpers.py

@@ -35,11 +35,17 @@ def to_json(data: Union[Dict[str, Any], Alias.Json], condition_and_msg: Tuple[Ca
     return res
 
 
-def model_from_json(data: Union[Dict[str, Any], Alias.Json], model: BaseModel):  # noqa: ANN201
+def model_from_json(data: Union[Dict[str, Any], Alias.Json], model: BaseModel, is_list: Optional[bool] = False):  # noqa: ANN201
     if isinstance(data, Alias.Json):
         data = json.loads(data)
-    assert isinstance(data, dict), data
-    return model.parse_obj(data)
+    if is_list is None:
+        is_list = isinstance(data, list)
+    if is_list:
+        assert isinstance(data, list), data
+        return [model.model_validate(item) for item in data]
+    else:
+        assert isinstance(data, dict), data
+        return model.model_validate(data)
 
 
 def rand_str(size: int = 10, chars=string.ascii_letters) -> str:

malevich_coretools/utils.py

@@ -4225,6 +4225,156 @@ def delete_ws_apps(
     return f.delete_ws_apps(only_not_active, wait=wait, auth=auth, conn_url=conn_url)
 
 
+# MCP Tools
+
+
+def get_mcp_tools(
+    *,
+    auth: Optional[AUTH] = None,
+    conn_url: Optional[str] = None,
+    batcher: Optional[Batcher] = None,
+    is_async: bool = False,
+) -> List[MCPTool]:
+    """return list of mcp tools"""
+    if batcher is None:
+        batcher = Config.BATCHER
+    if batcher is not None:
+        return batcher.add("getMcpTools", result_model=MCPTool) # list of it
+    if is_async:
+        return f.get_mcp_tools_async(auth=auth, conn_url=conn_url)
+    return f.get_mcp_tools(auth=auth, conn_url=conn_url)
+
+
+def get_mcp_tools_list(
+    *,
+    with_auth: bool = True,
+    auth: Optional[AUTH] = None,
+    conn_url: Optional[str] = None,
+    batcher: Optional[Batcher] = None,
+    is_async: bool = False,
+) -> List[MCPToolSimple]:
+    """return list of mcp tools (simple)"""
+    if batcher is None:
+        batcher = Config.BATCHER
+    if batcher is not None:
+        return batcher.add("getMcpToolsSimple", result_model=MCPToolSimple) # list of it
+    if is_async:
+        return f.get_mcp_tools_list_async(with_auth=with_auth, auth=auth, conn_url=conn_url)
+    return f.get_mcp_tools_list(with_auth=with_auth, auth=auth, conn_url=conn_url)
+
+
+def get_mcp_tool(
+    id: Optional[str] = None,
+    name: Optional[str] = None,
+    *,
+    with_auth: bool = True,
+    auth: Optional[AUTH] = None,
+    conn_url: Optional[str] = None,
+    batcher: Optional[Batcher] = None,
+    is_async: bool = False,
+) -> Union[MCPToolSimple, MCPTool]:
+    """return mcp tool struct by `id` or `name` """
+    assert id is not None or name is not None, "id or name should be set"
+    if batcher is None:
+        batcher = Config.BATCHER
+    if batcher is not None:
+        return batcher.add("getMcpToolByIdOrName", vars={"id": id, "name": name}, result_model=MCPTool)
+    if is_async:
+        return f.get_mcp_tool_id_name_async(id, name, with_auth=with_auth, auth=auth, conn_url=conn_url)
+    return f.get_mcp_tool_id_name(id, name, with_auth=with_auth, auth=auth, conn_url=conn_url)
+
+
+def post_mcp_tool(
+    name: str,
+    description: Optional[str] = None,
+    input_schema: Optional[Dict[str, Any]] = None,
+    task_id: Optional[str] = None,
+    pipeline_id: Optional[str] = None,
+    cfg_id: Optional[str] = None,
+    run_settings: Optional[RunSettings] = None,
+    enable_not_auth: Optional[str] = None,
+    id: Optional[str] = None,   # set it on update
+    wait: bool = True,
+    *,
+    auth: Optional[AUTH] = None,
+    conn_url: Optional[str] = None,
+    batcher: Optional[Batcher] = None,
+    is_async: bool = False,
+) -> Alias.Id:
+    """create mcp tool, return id"""
+    assert task_id is None or pipeline_id is None, "mcp tool should be defined in one way"
+    if batcher is None:
+        batcher = Config.BATCHER
+    data = MCPTool(name=name, description=description, inputSchema=input_schema, id=id, taskId=task_id,
+                   pipelineId=pipeline_id, cfgId=cfg_id, runSettings=run_settings, enableNotAuthorized=enable_not_auth)
+    if batcher is not None:
+        return batcher.add("postMcpTool", data=data)
+    if is_async:
+        return f.post_mcp_tool_async(data, wait=wait, auth=auth, conn_url=conn_url)
+    return f.post_mcp_tool(data, wait=wait, auth=auth, conn_url=conn_url)
+
+
+def call_mcp_tool(
+    name: str,
+    arguments: Dict[str, Any],
+    with_show: bool = True,
+    *,
+    with_auth: bool = True,
+    auth: Optional[AUTH] = None,
+    conn_url: Optional[str] = None,
+    batcher: Optional[Batcher] = None,
+    is_async: bool = False,
+) -> Union[AppLogsWithResults, Any]:
+    """run by mcp tool"""
+    if batcher is None:
+        batcher = Config.BATCHER
+    data = MCPToolCall(name=name, arguments=arguments)
+    if batcher is not None:
+        return batcher.add("postMcpToolCall", data=data, result_model=AppLogsWithResults)
+    if is_async:
+        return f.call_mcp_tool_async(data, with_show=with_show, with_auth=with_auth, auth=auth, conn_url=conn_url)
+    return f.call_mcp_tool(data, with_show=with_show, with_auth=with_auth, auth=auth, conn_url=conn_url)
+
+
+def delete_mcp_tool(
+    id: Optional[str] = None,
+    name: Optional[str] = None,
+    wait: bool = True,
+    *,
+    auth: Optional[AUTH] = None,
+    conn_url: Optional[str] = None,
+    batcher: Optional[Batcher] = None,
+    is_async: bool = False,
+) -> Alias.Info:
+    """delete mcp tool by `id` or `name` """
+    assert id is not None or name is not None, "id or name should be set"
+    if batcher is None:
+        batcher = Config.BATCHER
+    if batcher is not None:
+        return batcher.add("deleteMcpTool", vars={"id": id, "name": name})
+    if is_async:
+        return f.delete_mcp_tool_id_name_async(id, name, wait=wait, auth=auth, conn_url=conn_url)
+    return f.delete_mcp_tool_id_name(id, name, wait=wait, auth=auth, conn_url=conn_url)
+
+
+def delete_mcp_tools(
+    wait: bool = True,
+    *,
+    auth: Optional[AUTH] = None,
+    conn_url: Optional[str] = None,
+    batcher: Optional[Batcher] = None,
+    is_async: bool = False,
+) -> Alias.Info:
+    """delete all mcp tools"""
+    if batcher is None:
+        batcher = Config.BATCHER
+    if batcher is not None:
+        return batcher.add("deleteMcpTools")
+    if is_async:
+        return f.delete_mcp_tools_async(wait=wait, auth=auth, conn_url=conn_url)
+    return f.delete_mcp_tools(wait=wait, auth=auth, conn_url=conn_url)
+
+
 # kafka
 
 

{malevich_coretools-0.3.43.dist-info → malevich_coretools-0.3.44.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: malevich-coretools
-Version: 0.3.43
+Version: 0.3.44
 Author: Andrew Pogrebnoj
 Author-email: andrew@onjulius.co
 License-File: LICENSE

{malevich_coretools-0.3.43.dist-info → malevich_coretools-0.3.44.dist-info}/RECORD

@@ -1,28 +1,28 @@
 malevich_coretools/__init__.py,sha256=DJtPESxkCZD2SbTZTrR_x0TKDQ4MJpmBqGw5YpKYidM,134
-malevich_coretools/utils.py,sha256=gMq7KaB1cTdlMFDJIVyztvbv5_kkRmgtjQ7cNNdMA-I,144810
+malevich_coretools/utils.py,sha256=OlwY4ivtozu6JoXateYrnJ6bMX9JTEBdnNC8JXdsXEo,150106
 malevich_coretools/abstract/__init__.py,sha256=6vQ08c8HPYyT_pPkKlc-EwQKE8xG3HTEo2p_GiI5rik,142
-malevich_coretools/abstract/abstract.py,sha256=fQ1FNQjNdemDfp8BsiU6e6NnKiSREK-pBienY0KMLJY,15106
+malevich_coretools/abstract/abstract.py,sha256=JPv91Qkab4SQZ6a9lp2nA4591DyGWV_7kOGp9fxJ8QM,15647
 malevich_coretools/abstract/operations.py,sha256=cWlo2xzW-rzkTInzpDjBYeL68KfLYqSpZJRzCQ4OzjA,3070
 malevich_coretools/abstract/pipeline.py,sha256=HwhYp5G9yaZYaeDypChfpNd2W-kmJQfM9I54uek0B9k,7914
 malevich_coretools/abstract/statuses.py,sha256=9ISSw_evsylBshLXoU44TCoFOrZm4bXIxyAFFDqdUWc,333
 malevich_coretools/admin/__init__.py,sha256=zdIcHs3T_NZ8HYWts-O7OpBEWHIu779QDZMGF5HRCLg,35
 malevich_coretools/admin/utils.py,sha256=jmqy8qODvPOg1qcY1pBPJWJCdAVGiOFTAFn6Ltyhsms,3015
 malevich_coretools/batch/__init__.py,sha256=taxyZl8YOZd2EBd3leN6slzMkejUtjQ64Na31TcT3-I,165
-malevich_coretools/batch/utils.py,sha256=cqX34sfh85dCwLv7qprxatzhYxxj7LqZwjhlmk_3GXQ,7705
+malevich_coretools/batch/utils.py,sha256=FRmCYU-zr-RjgT1Mo3CUNcB2mW1t_gKCJazcMx6aIW4,7719
 malevich_coretools/funcs/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 malevich_coretools/funcs/checks.py,sha256=Q5pRtRevQrGv_-SMbn2GgYnulhclDLBXdRtbw2QOYKU,223
-malevich_coretools/funcs/funcs.py,sha256=9swDsy_9T9d4EUqaplY32LS0UK5WFJPXgLn0qrM41u0,79306
+malevich_coretools/funcs/funcs.py,sha256=Ht9WChcF8vQaKU0FeQFdX0VjdYTEnau7zYTK2pJnMzM,82252
 malevich_coretools/funcs/helpers.py,sha256=-i3TGN9UzlvtXPIjO4fM9z6cfzRfrg-ZIo4n8bQS3Lo,11342
 malevich_coretools/secondary/__init__.py,sha256=048HqvG36_1WdDVZK_RuECmaf14Iq2fviUysG1inlaE,78
 malevich_coretools/secondary/config.py,sha256=hRlSJuPQnhKyt1wmOAJX_XmcliaO0fPGbW94AE_Mazs,463
-malevich_coretools/secondary/const.py,sha256=dhXn4PcxP1okKNSazjnilrrnhj0bonnYJl9ZeUaUY8s,14540
-malevich_coretools/secondary/helpers.py,sha256=t-W9g9t0O1EaAX8UOb1wxXFAMawbtDotDH47t0GdjG4,6142
+malevich_coretools/secondary/const.py,sha256=uRnKYTHjY-n71gt98QCCOCTQ0py7cMK5ye08n-NDwds,14954
+malevich_coretools/secondary/helpers.py,sha256=lbLgHJeDQvn38DnKuXMaaNUD6PCxjzCusZO8DcLXqDk,6384
 malevich_coretools/secondary/kafka_utils.py,sha256=SIUnBFyfwsquN6MAUrEkKCw-1l7979Znl7OTQSX2UKo,989
 malevich_coretools/tools/__init__.py,sha256=jDxlCa5Dr6Y43qlI7JwsRAlBkKmFeTHTEnjNUvu-0iw,46
 malevich_coretools/tools/abstract.py,sha256=B1RW1FeNHrQ6r1k-cQZ4k4noCRXkIGt-JUwVoXEDkAg,4466
 malevich_coretools/tools/vast.py,sha256=63tvy70qQV9vnK0eWytlgjBGSnfA7l3kSIDgACBbMMs,12893
-malevich_coretools-0.3.43.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-malevich_coretools-0.3.43.dist-info/METADATA,sha256=lrVRYlJYP2hYdIgG07Hg3pi-1KWclY0Yjm-pkes83Bc,325
-malevich_coretools-0.3.43.dist-info/WHEEL,sha256=jB7zZ3N9hIM9adW7qlTAyycLYW9npaWKLRzaoVcLKcM,91
-malevich_coretools-0.3.43.dist-info/top_level.txt,sha256=wDX3s1Tso0otBPNrFRfXqyNpm48W4Bp5v6JfbITO2Z8,19
-malevich_coretools-0.3.43.dist-info/RECORD,,
+malevich_coretools-0.3.44.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+malevich_coretools-0.3.44.dist-info/METADATA,sha256=anOZSzqsZ_x005ycTFGJRUjCsUEbjY34yPBiaLBgKz0,325
+malevich_coretools-0.3.44.dist-info/WHEEL,sha256=52BFRY2Up02UkjOa29eZOS2VxUrpPORXg1pkohGGUS8,91
+malevich_coretools-0.3.44.dist-info/top_level.txt,sha256=wDX3s1Tso0otBPNrFRfXqyNpm48W4Bp5v6JfbITO2Z8,19
+malevich_coretools-0.3.44.dist-info/RECORD,,

{malevich_coretools-0.3.43.dist-info → malevich_coretools-0.3.44.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.8.2)
+Generator: setuptools (76.0.0)
 Root-Is-Purelib: true
 Tag: py3-none-any