malevich-coretools 0.3.54__tar.gz → 0.3.60__tar.gz

{malevich_coretools-0.3.54/malevich_coretools.egg-info → malevich_coretools-0.3.60}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: malevich-coretools
-Version: 0.3.54
+Version: 0.3.60
 Author: Andrew Pogrebnoj
 Author-email: andrew@onjulius.co
 License-File: LICENSE

malevich_coretools-0.3.60/VERSION

@@ -0,0 +1 @@
+0.3.60

{malevich_coretools-0.3.54 → malevich_coretools-0.3.60}/malevich_coretools/abstract/abstract.py

@@ -1,4 +1,4 @@
-from typing import Any, Dict, List, Optional, Tuple, Union
+from typing import Any, Dict, List, Optional, Set, Tuple, Union
 
 from pydantic import BaseModel
 
@@ -197,6 +197,7 @@ class MainTask(BaseModel):
     profileMode: Optional[str] = None
     withLogs: bool = False  # use only in prepare
     saveFails: bool = True
+    clearDagLogs: bool = True
     scaleCount: int = 1
     scaleInfo: List[ScaleInfo]
     component: TaskComponent
@@ -228,6 +229,7 @@ class MainPipeline(BaseModel):
     run: bool = True
     synthetic: bool = False
     saveFails: bool = True
+    clearDagLogs: bool = True
     scaleCount: int = 1
     tags: Optional[Dict[str, str]] = None
 
@@ -241,6 +243,7 @@ class RunTask(Operation):
     profileMode: Optional[str] = None
     withLogs: bool = False
     schedule: Optional[Schedule] = None
+    broadcast: bool = False
 
 
 class AppManage(Operation):
@@ -385,8 +388,8 @@ class CollectionMetadata(BaseModel):
 
 class LogsResult(BaseModel):
     data: str
-    logs: Dict[str, str]
-    userLogs: Dict[str, str] = {}
+    logs: Optional[Dict[str, str]] = {}
+    userLogs: Optional[Dict[str, str]] = {}
 
 
 class AppLog(BaseModel):
@@ -603,7 +606,7 @@ class UserLimits(BaseModel):
     defaultGpuDisk: int
 
 
-class BasePlatformSettings(BaseModel):
+class BasePlatformSettingsMain(BaseModel):
     memoryRequest: Optional[int] = None
     memoryLimit: Optional[int] = None
     cpuRequest: Optional[int] = None
@@ -613,7 +616,11 @@ class BasePlatformSettings(BaseModel):
     kubeconfig: Optional[str] = None
 
 
-class Limits(BasePlatformSettings):
+class BasePlatformSettings(BasePlatformSettingsMain):
+    allowKafka: bool = False
+
+
+class Limits(BasePlatformSettingsMain):
     gpuDisk: Optional[int] = None
 
 
@@ -675,3 +682,37 @@ class MCPToolCall(BaseModel):
 class RunsFilter(BaseModel):
     data: Optional[Dict[str, str]] = None
     withTags: bool = False
+
+
+class AppLocalScheme(BaseModel):
+    keys: List[str]
+    optionalKeys: Set[str]
+
+
+class AppErrorInfo(BaseModel):
+    operationId: str
+    runId: str
+    bindId: str
+    funId: str
+    iteration: int
+    isProcessor: bool = True
+    trace: str
+    errType: str
+    errArgs: List[str]
+    isMalevichErr: bool
+    cfg: Optional[Dict[str, Any]]
+    schemes: Optional[Dict[str, AppLocalScheme]] = None
+    args: List[List[Union[Union[str, List[str]], List[Union[str, List[str]]]]]] = None  # mb empty for send info structure
+    argsNames: List[str]
+
+
+class AppErrorInfos(BaseModel):
+    data: List[AppErrorInfo]
+
+
+class AppErrorInfoFilter(BaseModel):
+    operationId: str
+    runId: Optional[str] = None
+    bindId: Optional[str] = None
+    errType: Optional[str] = None
+    isMalevichErr: bool = False

{malevich_coretools-0.3.54 → malevich_coretools-0.3.60}/malevich_coretools/funcs/funcs.py

@@ -1578,6 +1578,30 @@ 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)
 
 
+def get_app_error_info(data: AppErrorInfoFilter, *args, **kwargs) -> AppErrorInfos:
+    return model_from_json(send_to_core_modify(APP_ERROR_INFO(None), data, *args, **kwargs), AppErrorInfos)
+
+
+async def get_app_error_info_async(data: AppErrorInfoFilter, *args, **kwargs) -> AppErrorInfos:
+    return model_from_json(await send_to_core_modify_async(APP_ERROR_INFO(None), data, *args, **kwargs), AppErrorInfos)
+
+
+def delete_app_error_info(id: str, wait: bool, *args, **kwargs) -> Alias.Info:
+    return send_to_core_modify(APP_ERROR_INFO_ID(id, wait), *args, **kwargs, is_post=False)
+
+
+async def delete_app_error_info_async(id: str, wait: bool, *args, **kwargs) -> Alias.Info:
+    return await send_to_core_modify_async(APP_ERROR_INFO_ID(id, wait), *args, **kwargs, is_post=False)
+
+
+def delete_app_error_infos(wait: bool, *args, **kwargs) -> Alias.Info:
+    return send_to_core_modify(APP_ERROR_INFO(wait), *args, **kwargs, is_post=False)
+
+
+async def delete_app_error_infos_async(wait: bool, *args, **kwargs) -> Alias.Info:
+    return await send_to_core_modify_async(APP_ERROR_INFO(wait), *args, **kwargs, is_post=False)
+
+
 async def kafka_send(data: KafkaMsg, *args, **kwargs) -> Union[Alias.Info, KafkaMsg]:
     result = await send_to_core_post_async(KAFKA_SEND, data, *args, **kwargs)
     try:
@@ -1687,7 +1711,7 @@ async def send_to_core_get_async(path: str, with_auth=True, show_func: Optional[
         auth = (Config.CORE_USERNAME, Config.CORE_PASSWORD) if with_auth else None
     if auth is not None:
         auth = aiohttp.BasicAuth(login=auth[0], password=auth[1], encoding='utf-8')
-    async with async_session or aiohttp.ClientSession(auth=auth, connector=aiohttp.TCPConnector(verify_ssl=False)) as session:
+    async with async_session or aiohttp.ClientSession(auth=auth, connector=aiohttp.TCPConnector(verify_ssl=False), timeout=aiohttp.ClientTimeout(total=None)) as session:
         async with session.get(f"{host}{path}", headers=HEADERS) as response:
             await __async_check_response(response, show_func, f"{host}{path}")
             if response.status == HTTPStatus.NO_CONTENT:
@@ -1738,7 +1762,7 @@ async def send_to_core_modify_async(path: str, operation: Optional[Any] = None,
     if operation is not None:
         operation = json.dumps(operation.model_dump())
 
-    async with async_session or aiohttp.ClientSession(auth=auth if with_auth else None, connector=aiohttp.TCPConnector(verify_ssl=False)) as session:
+    async with async_session or aiohttp.ClientSession(auth=auth if with_auth else None, connector=aiohttp.TCPConnector(verify_ssl=False), timeout=aiohttp.ClientTimeout(total=None)) as session:
         if is_post:
             response_cm = session.post(f"{host}{path}", data=operation, headers=HEADERS)
         else:
@@ -1792,7 +1816,7 @@ async def send_to_core_modify_raw_async(path: str, data: bytes, with_auth: bool=
         auth = (Config.CORE_USERNAME, Config.CORE_PASSWORD)
     auth = aiohttp.BasicAuth(login=auth[0], password=auth[1], encoding='utf-8')
 
-    async with async_session or aiohttp.ClientSession(auth=auth if with_auth else None, connector=aiohttp.TCPConnector(verify_ssl=False)) as session:
+    async with async_session or aiohttp.ClientSession(auth=auth if with_auth else None, connector=aiohttp.TCPConnector(verify_ssl=False), timeout=aiohttp.ClientTimeout(total=None)) as session:
         if is_post:
             response_cm = session.post(f"{host}{path}", data=data, headers=HEADERS_RAW)
         else:

{malevich_coretools-0.3.54 → malevich_coretools-0.3.60}/malevich_coretools/funcs/helpers.py

@@ -439,6 +439,7 @@ def base_settings(
     storage_request: Optional[int] = None,
     storage_limit: Optional[int] = None,
     kubeconfig: Optional[str] = None,
+    allow_kafka: bool = False,
 ) -> str:
     return BasePlatformSettings(
         memoryRequest=memory_request,
@@ -448,4 +449,5 @@ def base_settings(
         storageRequest=storage_request,
         storageLimit=storage_limit,
         kubeconfig=kubeconfig,
+        allowKafka=allow_kafka,
     ).model_dump_json()

{malevich_coretools-0.3.54 → malevich_coretools-0.3.60}/malevich_coretools/secondary/const.py

@@ -227,6 +227,11 @@ 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"
 
+## AppErrorInfoController
+APP_ERROR_INFO_MAIN = f"{API_VERSION}/errors"
+APP_ERROR_INFO = lambda wait: with_wait(f"{APP_ERROR_INFO_MAIN}/", wait)
+APP_ERROR_INFO_ID = lambda operationId, wait: with_wait(f"{APP_ERROR_INFO_MAIN}/{operationId}", wait)
+
 ### Kafka
 KAFKA_SEND = f"{MANAGER_MAIN}/kafkaMsg"
 

{malevich_coretools-0.3.54 → malevich_coretools-0.3.60}/malevich_coretools/secondary/helpers.py

@@ -7,6 +7,7 @@ from pydantic import BaseModel
 
 from malevich_coretools.abstract.abstract import (
     Alias,
+    AppLog,
     AppLogs,
     FlattenAppLogsWithResults,
     LogsResult,
@@ -56,17 +57,36 @@ def bool_to_str(b: bool) -> str:
     return "true" if b else "false"
 
 
-def __show_logs_result(res: LogsResult):  # noqa: ANN202
+def __show_logs_result(res: LogsResult, i: Optional[int]):  # noqa: ANN202
     if len(res.data) > 0:
-        print("------- main:")
+        print(f"------- main ({i}):" if i is not None else "------- main:")
         print(res.data)
+    if res.logs is None:
+        res.logs = {}
+    if res.userLogs is None:
+        res.userLogs = {}
     for run_id, logs in res.logs.items():
-        print(f"------- {run_id}:")
         userLogs = res.userLogs.get(run_id, "")
-        if len(userLogs) > 0:
+        print(f"------- {run_id} ({i}):" if i is not None else f"------- {run_id}:")
+        if len(logs) == 0:
             print(userLogs)
-            print("-------")
-        print(logs)
+        else:
+            if len(userLogs) > 0:
+                print(userLogs)
+                print("-------")
+            print(logs)
+    for run_id, logs in res.userLogs.items():
+        if run_id not in res.logs:
+            print(f"------- {run_id} ({i}):" if i is not None else f"------- {run_id}:")
+            print(logs)
+
+
+def __logs_parts(app_log: AppLog) -> Dict[int, LogsResult]:
+    parts = {}
+    for i, log_res in enumerate(app_log.data):
+        if len(log_res.data) > 0 or (log_res.logs is not None and len(log_res.logs) > 0) or (log_res.userLogs is not None and len(log_res.userLogs) > 0):
+            parts[i] = log_res
+    return parts
 
 
 def show_logs(app_logs: AppLogs, err: bool = False) -> None:  # noqa: ANN202
@@ -75,59 +95,81 @@ def show_logs(app_logs: AppLogs, err: bool = False) -> None:  # noqa: ANN202
     if app_logs.error is not None:
         show(f"error: {app_logs.error}")
         print(__delimiter)
-    print("------- dag logs -------")
-    print(app_logs.dagLogs)
+    if len(app_logs.dagLogs) > 0:
+        print("------- dm logs -------")
+        print(app_logs.dagLogs)
     for app_name, app_log in app_logs.data.items():
+        parts = __logs_parts(app_log)
+        if len(parts) == 0:
+            continue
         print(f"------- {app_name} -------")
         if len(app_log.data) == 1:
             __show_logs_result(app_log.data[0])
         else:
-            for i, log_res in enumerate(app_log.data):
-                print(f"------- {i}:")
-                __show_logs_result(log_res)
-                print(__mini__delimiter)
+            c = len(parts)
+            for i, log_res in parts.items():
+                __show_logs_result(log_res, i)
+                c -= 1
+                if c != 0:
+                    print(__mini__delimiter)
         print(__delimiter)
 
 
 def show_logs_colored(app_logs: AppLogs, colors_dict: Optional[Dict[str, str]] = None) -> None:
     """colors_dict - should be unique for all app_logs by operation_id"""
-    def format(log, color: Optional[str]) -> None:
+    def format(log, color: Optional[str] = None) -> None:
         if color is None:
             Config.logger.warning(log)
         else:
             Config.logger.warning(color + log + __color_reset)
 
     def get_color(name: str) -> str:
-        if colors_dict is None:
-            return None
         color = colors_dict.get(name, None)
         if color is None:
             color = __colors[len(colors_dict) % len(__colors)]
             colors_dict[name] = color
         return color
 
+    if colors_dict is None:
+        colors_dict = {}
+
+    format(f"operation_id = {app_logs.operationId}")
     if app_logs.error is not None:
-        format(f"error: {app_logs.error}", get_color("error"))
+        color = get_color("error")
+        format(f"error: {app_logs.error}", color)
+        format(__delimiter, color)
     if len(app_logs.dagLogs) > 0:
-        color = get_color("dagLogs")
+        color = get_color("dm")
+        format("------- dm logs -------", color)
         for line in app_logs.dagLogs.splitlines():
-            format(f"dag: {line}", color)
+            format(f"dm: {line}", color)
     for app_name, app_log in app_logs.data.items():
-        color = get_color(f"${app_name}")
-        for i, logs_result in enumerate(app_log.data):
-            app_name_prefix = f"{app_name}${i}" if i != 0 else app_name
+        parts = __logs_parts(app_log)
+        if len(parts) == 0:
+            continue
+
+        color = get_color(app_name)
+        for i, logs_result in parts.items():
+            app_name_prefix = f"{app_name}${i}" if i != 0 or len(parts) > 1 else app_name
             if len(logs_result.data) > 0:
                 for line in logs_result.data.splitlines():
                     format(f"{app_name_prefix}$main: {line}", color)
-            if len(logs_result.logs) > 0:
-                for run_id, logs in logs_result.logs.items():
-                    user_logs = logs_result.userLogs.get(run_id, "")
-                    if len(user_logs) > 0:
-                        for line in user_logs.splitlines():
-                            format(f"{app_name_prefix}${run_id}: {line}", color)
-                    if len(logs) > 0:
-                        for line in logs.splitlines():
-                            format(f"{app_name_prefix}${run_id}: {line}", color)
+            if logs_result.logs is None:
+                logs_result.logs = {}
+            if logs_result.userLogs is None:
+                logs_result.userLogs = {}
+            for run_id, logs in logs_result.logs.items():
+                user_logs = logs_result.userLogs.get(run_id, "")
+                if len(user_logs) > 0:
+                    for line in user_logs.splitlines():
+                        format(f"{app_name_prefix}${run_id}$user: {line}", color)
+                if len(logs) > 0:
+                    for line in logs.splitlines():
+                        format(f"{app_name_prefix}${run_id}: {line}", color)
+            for run_id, user_logs in logs_result.userLogs.items():
+                if run_id not in logs_result.logs:
+                    for line in user_logs.splitlines():
+                        format(f"{app_name_prefix}${run_id}$user: {line}", color)
 
 
 def show_logs_func(data: str, err: bool = False):  # noqa: ANN201

{malevich_coretools-0.3.54 → malevich_coretools-0.3.60}/malevich_coretools/utils.py

@@ -6844,6 +6844,7 @@ def task_full(
     single_request: bool = False,
     profile_mode: Optional[str] = None,
     save_fails: bool = True,
+    clear_dag_logs: bool = True,
     with_show: bool = True,
     long: bool = False,
     long_timeout: Optional[int] = WAIT_RESULT_TIMEOUT,
@@ -6906,6 +6907,7 @@ def task_full(
         profileMode=profile_mode,
         withLogs=True,
         saveFails=save_fails,
+        clearDagLogs=clear_dag_logs,
         scaleInfo=scaleInfo,
         component=component,
         policy=policy,
@@ -7019,6 +7021,7 @@ def task_prepare(
     with_logs: bool = False,
     profile_mode: Optional[str] = None,
     save_fails: bool = True,
+    clear_dag_logs: bool = True,
     with_show: bool = None,
     long: bool = False,
     long_timeout: int = WAIT_RESULT_TIMEOUT,
@@ -7091,6 +7094,7 @@ def task_prepare(
         waitRuns=wait_runs,
         withLogs=with_logs,
         saveFails=save_fails,
+        clearDagLogs=clear_dag_logs,
         profileMode=profile_mode,
         scaleInfo=scaleInfo,
         component=component,
@@ -7135,6 +7139,7 @@ def task_run(
     long_timeout: int = WAIT_RESULT_TIMEOUT,
     with_logs: bool = False,
     schedule: Optional[Schedule] = None,
+    broadcast: bool = False,
     wait: bool = True,
     *,
     auth: Optional[AUTH] = None,
@@ -7159,6 +7164,7 @@ def task_run(
     long_timeout: int = WAIT_RESULT_TIMEOUT,
     with_logs: bool = False,
     schedule: Optional[Schedule] = None,
+    broadcast: bool = False,
     wait: bool = True,
     *,
     auth: Optional[AUTH] = None,
@@ -7182,6 +7188,7 @@ def task_run(
     long_timeout: int = WAIT_RESULT_TIMEOUT,
     with_logs: bool = False,
     schedule: Optional[Schedule] = None,
+    broadcast: bool = False,
     wait: bool = True,
     *,
     auth: Optional[AUTH] = None,
@@ -7204,6 +7211,7 @@ def task_run(
         long_timeout (Optional[int]): default timeout for long run (hour by default). If 'long=False' ignored. If None, then there is no limit. Doesn't stop the task, just stops trying to get the run result
         with_logs (bool): return run logs if True after end
         schedule: (Optional[Schedule]): schedule task runs settings - return scheduleId instead of operationId
+        broadcast: run scale pipeline (for new scale)
         wait (bool): is it worth waiting for the result or immediately return `operation_id`
         auth (Optional[AUTH]): redefined auth if not None"""
     if schedule is not None:
@@ -7224,6 +7232,7 @@ def task_run(
         profileMode=profile_mode,
         withLogs=with_logs,
         schedule=schedule,
+        broadcast=broadcast,
     )
     if batcher is not None:
         return batcher.add("sendTaskRun", data=data, result_model=AppLogs if with_logs or schedule is not None else None)
@@ -7322,6 +7331,7 @@ def pipeline_full(
     restrictions: Optional[Restrictions] = None,
     scaleInfo: List[ScaleInfo] = None,
     save_fails: bool = True,
+    clear_dag_logs: bool = True,
     tags: Optional[Dict[str, str]] = None,
     with_show: bool = True,
     long: bool = False,
@@ -7367,6 +7377,7 @@ def pipeline_full(
         kafkaModeUrl=None,
         run=True,
         saveFails=save_fails,
+        clearDagLogs=clear_dag_logs,
         scaleCount=1,
         tags=tags,
     )
@@ -7489,6 +7500,7 @@ def pipeline_prepare(
     kafka_mode_url_response: Optional[str] = None,
     synthetic: bool = False,
     save_fails: bool = True,
+    clear_dag_logs: bool = True,
     scale_count: int = 1,
     tags: Optional[Dict[str, str]] = None,
     with_show: bool = True,
@@ -7533,6 +7545,7 @@ def pipeline_prepare(
         run=False,
         synthetic=synthetic,
         saveFails=save_fails,
+        clearDagLogs=clear_dag_logs,
         scaleCount=scale_count,
         tags=tags,
     )
@@ -9263,6 +9276,156 @@ def delete_mcp_tools(
     return f.delete_mcp_tools(wait=wait, auth=auth, conn_url=conn_url)
 
 
+# app error info
+
+
+@overload
+def get_app_error_info(
+    operation_id: str,
+    run_id: Optional[str] = None,
+    bind_id: Optional[str] = None,
+    err_type: Optional[str] = None,
+    is_malevich_err: bool = False,
+    *,
+    with_auth: bool = True,
+    auth: Optional[AUTH] = None,
+    conn_url: Optional[str] = None,
+    batcher: Optional[Batcher] = None,
+    is_async: Literal[False] = False,
+) -> AppErrorInfos:
+    pass
+
+
+@overload
+def get_app_error_info(
+    operation_id: str,
+    run_id: Optional[str] = None,
+    bind_id: Optional[str] = None,
+    err_type: Optional[str] = None,
+    is_malevich_err: bool = False,
+    *,
+    with_auth: bool = True,
+    auth: Optional[AUTH] = None,
+    conn_url: Optional[str] = None,
+    batcher: Optional[Batcher] = None,
+    is_async: Literal[True],
+) -> Coroutine[Any, Any, AppErrorInfos]:
+    pass
+
+
+def get_app_error_info(
+    operation_id: str,
+    run_id: Optional[str] = None,
+    bind_id: Optional[str] = None,
+    err_type: Optional[str] = None,
+    is_malevich_err: bool = False,
+    *,
+    with_auth: bool = True,
+    auth: Optional[AUTH] = None,
+    conn_url: Optional[str] = None,
+    batcher: Optional[Batcher] = None,
+    is_async: bool = False,
+) -> Union[AppErrorInfos, Coroutine[Any, Any, AppErrorInfos]]:
+    """return mcp tool struct by `id` or `name` """
+    assert id is not None or name is not None, "id or name should be set"
+    data = AppErrorInfoFilter(operationId=operation_id, runId=run_id, bindId=bind_id, errType=err_type, isMalevichErr=is_malevich_err)
+    if batcher is None:
+        batcher = Config.BATCHER
+    if batcher is not None:
+        return batcher.add("getAppErrorInfo", data=data, result_model=AppErrorInfos)
+    if is_async:
+        return f.get_app_error_info_async(data, with_auth=with_auth, auth=auth, conn_url=conn_url)
+    return f.get_app_error_info(data, with_auth=with_auth, auth=auth, conn_url=conn_url)
+
+
+@overload
+def delete_app_error_info(
+    operation_id: str,
+    wait: bool = True,
+    *,
+    auth: Optional[AUTH] = None,
+    conn_url: Optional[str] = None,
+    batcher: Optional[Batcher] = None,
+    is_async: Literal[False] = False,
+) -> Alias.Info:
+    pass
+
+
+@overload
+def delete_app_error_info(
+    operation_id: str,
+    wait: bool = True,
+    *,
+    auth: Optional[AUTH] = None,
+    conn_url: Optional[str] = None,
+    batcher: Optional[Batcher] = None,
+    is_async: Literal[True],
+) -> Coroutine[Any, Any, Alias.Info]:
+    pass
+
+
+def delete_app_error_info(
+    operation_id: str,
+    wait: bool = True,
+    *,
+    auth: Optional[AUTH] = None,
+    conn_url: Optional[str] = None,
+    batcher: Optional[Batcher] = None,
+    is_async: bool = False,
+) -> Union[Alias.Info, Coroutine[Any, Any, Alias.Info]]:
+    """delete app error info by `operationId` """
+    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("deleteAppErrorInfoByOperationId", vars={"operationId": operation_id})
+    if is_async:
+        return f.delete_app_error_info_async(operation_id, wait=wait, auth=auth, conn_url=conn_url)
+    return f.delete_app_error_info(operation_id, wait=wait, auth=auth, conn_url=conn_url)
+
+
+@overload
+def delete_app_error_infos(
+    wait: bool = True,
+    *,
+    auth: Optional[AUTH] = None,
+    conn_url: Optional[str] = None,
+    batcher: Optional[Batcher] = None,
+    is_async: Literal[False] = False,
+) -> Alias.Info:
+    pass
+
+
+@overload
+def delete_app_error_infos(
+    wait: bool = True,
+    *,
+    auth: Optional[AUTH] = None,
+    conn_url: Optional[str] = None,
+    batcher: Optional[Batcher] = None,
+    is_async: Literal[True],
+) -> Coroutine[Any, Any, Alias.Info]:
+    pass
+
+
+def delete_app_error_infos(
+    wait: bool = True,
+    *,
+    auth: Optional[AUTH] = None,
+    conn_url: Optional[str] = None,
+    batcher: Optional[Batcher] = None,
+    is_async: bool = False,
+) -> Union[Alias.Info, Coroutine[Any, Any, Alias.Info]]:
+    """delete all app error infos"""
+    if batcher is None:
+        batcher = Config.BATCHER
+    if batcher is not None:
+        return batcher.add("deleteAppErrorInfos")
+    if is_async:
+        return f.delete_app_error_infos_async(wait=wait, auth=auth, conn_url=conn_url)
+    return f.delete_app_error_infos(wait=wait, auth=auth, conn_url=conn_url)
+
+
 # kafka
 
 

{malevich_coretools-0.3.54 → malevich_coretools-0.3.60/malevich_coretools.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: malevich-coretools
-Version: 0.3.54
+Version: 0.3.60
 Author: Andrew Pogrebnoj
 Author-email: andrew@onjulius.co
 License-File: LICENSE

malevich_coretools-0.3.54/VERSION

@@ -1 +0,0 @@
-0.3.54