malevich-coretools 0.3.43__tar.gz → 0.3.45__tar.gz

{malevich_coretools-0.3.43/malevich_coretools.egg-info → malevich_coretools-0.3.45}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: malevich-coretools
-Version: 0.3.43
+Version: 0.3.45
 Author: Andrew Pogrebnoj
 Author-email: andrew@onjulius.co
 License-File: LICENSE
@@ -11,4 +11,5 @@ Requires-Dist: aiohttp
 Requires-Dist: kafka-python
 Dynamic: author
 Dynamic: author-email
+Dynamic: license-file
 Dynamic: requires-dist

malevich_coretools-0.3.45/VERSION

@@ -0,0 +1 @@
+0.3.45

{malevich_coretools-0.3.43 → malevich_coretools-0.3.45}/malevich_coretools/abstract/abstract.py

@@ -589,6 +589,7 @@ class BasePlatformSettings(BaseModel):
     cpuLimit: Optional[int] = None
     storageRequest: Optional[int] = None
     storageLimit: Optional[int] = None
+    kubeconfig: Optional[str] = None
 
 
 class Limits(BasePlatformSettings):
@@ -628,3 +629,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-0.3.43 → malevich_coretools-0.3.45}/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-0.3.43 → malevich_coretools-0.3.45}/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-0.3.43 → malevich_coretools-0.3.45}/malevich_coretools/funcs/helpers.py

@@ -332,6 +332,7 @@ def base_settings(
     cpu_limit: Optional[int] = None,
     storage_request: Optional[int] = None,
     storage_limit: Optional[int] = None,
+    kubeconfig: Optional[str] = None,
 ) -> str:
     return BasePlatformSettings(
         memoryRequest=memory_request,
@@ -340,4 +341,5 @@ def base_settings(
         cpuLimit=cpu_limit,
         storageRequest=storage_request,
         storageLimit=storage_limit,
+        kubeconfig=kubeconfig,
     ).model_dump_json()

{malevich_coretools-0.3.43 → malevich_coretools-0.3.45}/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-0.3.43 → malevich_coretools-0.3.45}/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-0.3.43 → malevich_coretools-0.3.45}/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 → malevich_coretools-0.3.45/malevich_coretools.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: malevich-coretools
-Version: 0.3.43
+Version: 0.3.45
 Author: Andrew Pogrebnoj
 Author-email: andrew@onjulius.co
 License-File: LICENSE
@@ -11,4 +11,5 @@ Requires-Dist: aiohttp
 Requires-Dist: kafka-python
 Dynamic: author
 Dynamic: author-email
+Dynamic: license-file
 Dynamic: requires-dist

malevich_coretools-0.3.43/VERSION

@@ -1 +0,0 @@
-0.3.43