malevich-coretools 0.3.68__tar.gz → 0.3.70__tar.gz

{malevich_coretools-0.3.68/malevich_coretools.egg-info → malevich_coretools-0.3.70}/PKG-INFO

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

malevich_coretools-0.3.70/VERSION

@@ -0,0 +1 @@
+0.3.70

{malevich_coretools-0.3.68 → malevich_coretools-0.3.70}/malevich_coretools/abstract/abstract.py

@@ -133,6 +133,14 @@ class KeysValues(Operation):
     data: Dict[str, str]
 
 
+class Keys(BaseModel):
+    data: Dict[str, str]
+
+
+class Statuses(BaseModel):
+    data: Dict[str, str]    # key - runId, value - one of: IN_PROGRESS, SUCCESS, FAILED
+
+
 class ScaleInfo(BaseModel):
     taskId: Optional[Alias.Id] = None
     appId: Alias.Id
@@ -254,6 +262,10 @@ class ResultIds(BaseModel):
     ids: List[Alias.Id]
 
 
+class ResultNames(BaseModel):
+    names: List[str]
+
+
 class FilesDirs(BaseModel):
     files: Dict[str, int]
     directories: List[str]

{malevich_coretools-0.3.68 → malevich_coretools-0.3.70}/malevich_coretools/abstract/pipeline.py

@@ -101,6 +101,8 @@ class AppEntity(BaseModel):
     image: JsonImage
     platform: str = "base"
     platformSettings: Optional[str] = None
+    requestedKeys: Optional[list[str]] = None   # user secret keys
+    optionalKeys: Optional[list[str]] = None    # user secret keys
 
     def internal(self) -> None:
         assert self.conditions is None or self.conditionsStructure is None, "should be set not more, than one of (conditions, conditionsStructure)"

{malevich_coretools-0.3.68 → malevich_coretools-0.3.70}/malevich_coretools/funcs/funcs.py

@@ -531,6 +531,39 @@ def get_ping(*args, **kwargs) -> Alias.Info:
 async def get_ping_async(*args, **kwargs) -> Alias.Info:
     return await send_to_core_get_async(PING, *args, **kwargs, is_text=True)
 
+
+def get_secret_keys(*args, **kwargs) -> ResultNames:
+    return model_from_json(send_to_core_get(SECRET_KEYS_MAIN, *args, **kwargs), ResultNames)
+
+
+async def get_secret_keys_async(*args, **kwargs) -> ResultNames:
+    return model_from_json(await send_to_core_get_async(SECRET_KEYS_MAIN, *args, **kwargs), ResultNames)
+
+
+def post_secret_keys_name(name: str, wait: bool, *args, **kwargs) -> Alias.Info:
+    return send_to_core_modify(SECRET_KEYS_NAME(name, wait), *args, **kwargs)
+
+
+async def post_secret_keys_name_async(name: str, wait: bool, *args, **kwargs) -> Alias.Info:
+    return await send_to_core_modify_async(SECRET_KEYS_NAME(name, wait), *args, **kwargs)
+
+
+def delete_secret_keys_name(name: str, wait: bool, *args, **kwargs) -> Alias.Info:
+    return send_to_core_modify(SECRET_KEYS_NAME(name, wait), *args, **kwargs, is_post=False)
+
+
+async def delete_secret_keys_name_async(name: str, wait: bool, *args, **kwargs) -> Alias.Info:
+    return await send_to_core_modify_async(SECRET_KEYS_NAME(name, wait), *args, **kwargs, is_post=False)
+
+
+def delete_secret_keys(wait: bool, *args, **kwargs) -> Alias.Info:
+    return send_to_core_modify(SECRET_KEYS_ALL(wait), *args, **kwargs, is_post=False)
+
+
+async def delete_secret_keys_async(wait: bool, *args, **kwargs) -> Alias.Info:
+    return await send_to_core_modify_async(SECRET_KEYS_ALL(wait), *args, **kwargs, is_post=False)
+
+
 # UserShareController
 
 
@@ -681,6 +714,47 @@ async def delete_register_login_async(login: str, wait: bool, *args, **kwargs) -
         Config.logger.info(info)
     return info
 
+
+def get_register_keys(*args, **kwargs) -> Keys:
+    return model_from_json(send_to_core_get(REGISTER_KEYS(None), *args, **kwargs), Keys)
+
+
+async def get_register_keys_async(*args, **kwargs) -> Keys:
+    return model_from_json(await send_to_core_get_async(REGISTER_KEYS(None), *args, **kwargs), Keys)
+
+
+def get_register_keys_name(name: str, *args, **kwargs) -> str:
+    return send_to_core_get(REGISTER_KEYS_NAME(name, None), *args, **kwargs, is_text=True)
+
+
+async def get_register_keys_name_async(name: str, *args, **kwargs) -> str:
+    return await send_to_core_get_async(REGISTER_KEYS_NAME(name, None), *args, **kwargs, is_text=True)
+
+
+def post_register_keys(data: Keys, wait: bool, *args, **kwargs) -> Alias.Info:
+    return send_to_core_modify(REGISTER_KEYS(wait), data, *args, **kwargs)
+
+
+async def post_register_keys_async(data: Keys, wait: bool, *args, **kwargs) -> Alias.Info:
+    return await send_to_core_modify_async(REGISTER_KEYS(wait), data, *args, **kwargs)
+
+
+def delete_register_keys_name(name: str, wait: bool, *args, **kwargs) -> Alias.Info:
+    return send_to_core_modify(REGISTER_KEYS_NAME(name, wait), *args, **kwargs, is_post=False)
+
+
+async def delete_register_keys_name_async(name: str, wait: bool, *args, **kwargs) -> Alias.Info:
+    return await send_to_core_modify_async(REGISTER_KEYS_NAME(name, wait), *args, **kwargs, is_post=False)
+
+
+def delete_register_keys(wait: bool, *args, **kwargs) -> Alias.Info:
+    return send_to_core_modify(REGISTER_KEYS(wait), *args, **kwargs, is_post=False)
+
+
+async def delete_register_keys_async(wait: bool, *args, **kwargs) -> Alias.Info:
+    return await send_to_core_modify_async(REGISTER_KEYS(wait), *args, **kwargs, is_post=False)
+
+
 # UserAppsController
 
 
@@ -1070,20 +1144,20 @@ async def get_run_condition_async(id: str, *args, **kwargs) -> Condition:
     return model_from_json(await send_to_core_get_async(TEMP_RUN_CONDITION(id), *args, **kwargs), Condition)
 
 
-def get_run_activeRuns(*args, **kwargs) -> ResultIds:
-    return model_from_json(send_to_core_get(TEMP_RUN_ACTIVE_RUNS, *args, **kwargs), ResultIds)
+def get_run_activeRuns(id: Optional[str], *args, **kwargs) -> ResultIds:
+    return model_from_json(send_to_core_get(TEMP_RUN_ACTIVE_RUNS(id), *args, **kwargs), ResultIds)
 
 
-async def get_run_activeRuns_async(*args, **kwargs) -> ResultIds:
-    return model_from_json(await send_to_core_get_async(TEMP_RUN_ACTIVE_RUNS, *args, **kwargs), ResultIds)
+async def get_run_activeRuns_async(id: Optional[str], *args, **kwargs) -> ResultIds:
+    return model_from_json(await send_to_core_get_async(TEMP_RUN_ACTIVE_RUNS(id), *args, **kwargs), ResultIds)
 
 
 def post_run_activeRuns(data: RunsFilter, *args, **kwargs) -> Union[ResultIds, ResultTags]:
-    return model_from_json(send_to_core_modify(TEMP_RUN_ACTIVE_RUNS, data, *args, **kwargs), ResultTags if data.withTags else ResultIds)
+    return model_from_json(send_to_core_modify(TEMP_RUN_ACTIVE_RUNS(None), data, *args, **kwargs), ResultTags if data.withTags else ResultIds)
 
 
 async def post_run_activeRuns_async(data: RunsFilter, *args, **kwargs) -> Union[ResultIds, ResultTags]:
-    return model_from_json(await send_to_core_modify_async(TEMP_RUN_ACTIVE_RUNS, data, *args, **kwargs), ResultTags if data.withTags else ResultIds)
+    return model_from_json(await send_to_core_modify_async(TEMP_RUN_ACTIVE_RUNS(None), data, *args, **kwargs), ResultTags if data.withTags else ResultIds)
 
 
 def get_run_mainTaskCfg(id: str, *args, **kwargs) -> MainTaskCfg:
@@ -1109,6 +1183,23 @@ def get_run_operationsIds(task_id: str, cfg_id: Optional[str]=None, *args, **kwa
 async def get_run_operationsIds_async(task_id: str, cfg_id: Optional[str]=None, *args, **kwargs) -> ResultIds:
     return model_from_json(await send_to_core_get_async(TEMP_RUN_OPERATIONS_IDS(task_id, cfg_id), *args, **kwargs), ResultIds)
 
+
+def get_run_statuses(id: str, *args, **kwargs) -> Statuses:
+    return model_from_json(send_to_core_get(TEMP_RUN_STATUSES(id), *args, **kwargs), Statuses)
+
+
+async def get_run_statuses_async(id: str, *args, **kwargs) -> Statuses:
+    return model_from_json(await send_to_core_get_async(TEMP_RUN_STATUSES(id), *args, **kwargs), Statuses)
+
+
+def get_run_status(id: str, run_id: str, *args, **kwargs) -> str:
+    return send_to_core_get(TEMP_RUN_STATUS(id, run_id), *args, **kwargs, is_text=True)
+
+
+async def get_run_status_async(id: str, run_id: str, *args, **kwargs) -> str:
+    return await send_to_core_get_async(TEMP_RUN_STATUS(id, run_id), *args, **kwargs, is_text=True)
+
+
 # AdminController
 
 

{malevich_coretools-0.3.68 → malevich_coretools-0.3.70}/malevich_coretools/secondary/const.py

@@ -97,6 +97,9 @@ PING = "ping"
 # MAPPING = lambda wait: with_wait(f"{COMMON_MAIN}/mapping", wait)
 # MAPPING_ID = lambda id, wait: with_wait(f"{COMMON_MAIN}/mapping/{urllib.parse.quote(str(id), safe='')}", wait)
 # COMMON_ALL = lambda wait: with_wait(f"{COMMON_MAIN}/all", wait)
+SECRET_KEYS_MAIN = f"{API_VERSION}/secretKeys"
+SECRET_KEYS_NAME = lambda name, wait: with_wait(f"{SECRET_KEYS_MAIN}/name/{urllib.parse.quote(str(name), safe='')}", wait)
+SECRET_KEYS_ALL = lambda wait: with_wait(f"{SECRET_KEYS_MAIN}/all", wait)
 
 ## UserShareController
 SHARE_MAIN = f"{API_VERSION}/share"
@@ -112,6 +115,8 @@ REGISTER_MAIN = f"{API_VERSION}/register"
 REGISTER = REGISTER_MAIN
 REGISTER_LOGIN = lambda login, wait: with_wait(f"{REGISTER_MAIN}/login/{urllib.parse.quote(str(login), safe='')}", wait)
 REGISTER_ALL = f"{REGISTER_MAIN}/all"
+REGISTER_KEYS = lambda wait: with_wait(f"{REGISTER_MAIN}/keys", wait)
+REGISTER_KEYS_NAME = lambda name, wait: with_wait(f"{REGISTER_MAIN}/keys/{urllib.parse.quote(str(name), safe='')}", wait)
 
 ## UserAppsController
 USER_APPS_MAIN = f"{API_VERSION}/userApps"
@@ -159,10 +164,12 @@ OPERATION_RESULTS_ID = lambda id, wait: with_wait(f"{OPERATION_RESULTS_MAIN}/{ur
 ## TempRunController
 TEMP_RUN_MAIN = f"{API_VERSION}/run"
 TEMP_RUN_CONDITION = lambda operationId: f"{TEMP_RUN_MAIN}/condition/{urllib.parse.quote(str(operationId), safe='')}"
-TEMP_RUN_ACTIVE_RUNS = f"{TEMP_RUN_MAIN}/activeRuns"
+TEMP_RUN_ACTIVE_RUNS = lambda operationId: with_key_values(f"{TEMP_RUN_MAIN}/activeRuns", {"operationId": operationId})
 TEMP_RUN_MAIN_TASK_CFG = lambda operationId: f"{TEMP_RUN_MAIN}/mainTaskCfg/{urllib.parse.quote(str(operationId), safe='')}"
 TEMP_RUN_MAIN_PIPELINE_CFG = lambda operationId: f"{TEMP_RUN_MAIN}/mainPipelineCfg/{urllib.parse.quote(str(operationId), safe='')}"
 TEMP_RUN_OPERATIONS_IDS = lambda taskId, cfgId: f"{TEMP_RUN_MAIN}/operationsIds/{urllib.parse.quote(str(taskId), safe='')}" if cfgId is None else f"{TEMP_RUN_MAIN}/operationsIds/{urllib.parse.quote(str(taskId), safe='')}/{urllib.parse.quote(str(cfgId), safe='')}"
+TEMP_RUN_STATUSES = lambda operationId: f"{TEMP_RUN_MAIN}/statuses/{urllib.parse.quote(str(operationId), safe='')}"
+TEMP_RUN_STATUS = lambda operationId, runId: f"{TEMP_RUN_MAIN}/statuses/{urllib.parse.quote(str(operationId), safe='')}/{urllib.parse.quote(str(runId), safe='')}"
 
 ## AdminController
 ADMIN_MAIN = f"{API_VERSION}/admin"

{malevich_coretools-0.3.68 → malevich_coretools-0.3.70}/malevich_coretools/utils.py

@@ -3133,6 +3133,202 @@ def ping(
         return f.get_ping_async(with_auth=False, conn_url=conn_url)
     return f.get_ping(with_auth=False, conn_url=conn_url)
 
+
+@overload
+def get_secret_keys(
+    *,
+    auth: Optional[AUTH] = None,
+    conn_url: Optional[str] = None,
+    batcher: Optional[Batcher] = None,
+    is_async: Literal[False] = False,
+) -> Coroutine[Any, Any, ResultNames]:
+    pass
+
+
+@overload
+def get_secret_keys(
+    *,
+    auth: Optional[AUTH] = None,
+    conn_url: Optional[str] = None,
+    batcher: Optional[Batcher] = None,
+    is_async: Literal[False] = False,
+) -> ResultNames:
+    pass
+
+
+def get_secret_keys(
+    *,
+    auth: Optional[AUTH] = None,
+    conn_url: Optional[str] = None,
+    batcher: Optional[Batcher] = None,
+    is_async: bool = False,
+) -> Union[ResultNames, Coroutine[Any, Any, ResultNames]]:
+    if batcher is None:
+        batcher = Config.BATCHER
+    if batcher is not None:
+        return batcher.add("getSecretKeys", result_model=ResultNames)
+    if is_async:
+        return f.get_secret_keys_async(auth=auth, conn_url=conn_url)
+    return f.get_secret_keys(auth=auth, conn_url=conn_url)
+
+
+@overload
+def create_secret_key(
+    name: 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 create_secret_key(
+    name: 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 create_secret_key(
+    name: 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]]:
+    if batcher is None:
+        batcher = Config.BATCHER
+    if batcher is not None:
+        return batcher.add("postSecretKeysByName", vars={"name": name})
+    if is_async:
+        return f.post_secret_keys_name_async(
+            name,
+            wait=wait,
+            auth=auth,
+            conn_url=conn_url,
+        )
+    return f.post_secret_keys_name(
+        name,
+        wait=wait,
+        auth=auth,
+        conn_url=conn_url,
+    )
+
+
+@overload
+def delete_secret_key(
+    name: 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_secret_key(
+    name: 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_secret_key(
+    name: 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]]:
+    if batcher is None:
+        batcher = Config.BATCHER
+    if batcher is not None:
+        return batcher.add("deleteSecretKeysByName", vars={"name": name})
+    if is_async:
+        return f.delete_secret_keys_name_async(
+            name,
+            wait=wait,
+            auth=auth,
+            conn_url=conn_url,
+        )
+    return f.delete_secret_keys_name(
+        name,
+        wait=wait,
+        auth=auth,
+        conn_url=conn_url,
+    )
+
+
+@overload
+def delete_secret_keys(
+    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_secret_keys(
+    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_secret_keys(
+    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]]:
+    if batcher is None:
+        batcher = Config.BATCHER
+    if batcher is not None:
+        return batcher.add("deleteSecretKeys")
+    if is_async:
+        return f.delete_secret_keys_async(
+            wait=wait,
+            auth=auth,
+            conn_url=conn_url,
+        )
+    return f.delete_secret_keys(
+        wait=wait,
+        auth=auth,
+        conn_url=conn_url,
+    )
+
+
 # UserShare
 
 
@@ -3891,6 +4087,243 @@ def delete_user(
     return f.delete_register(auth=auth, conn_url=conn_url)
 
 
+@overload
+def get_user_keys(
+    *,
+    auth: Optional[AUTH] = None,
+    conn_url: Optional[str] = None,
+    batcher: Optional[Batcher] = None,
+    is_async: Literal[False] = False,
+) -> Keys:
+    pass
+
+
+@overload
+def get_user_keys(
+    *,
+    auth: Optional[AUTH] = None,
+    conn_url: Optional[str] = None,
+    batcher: Optional[Batcher] = None,
+    is_async: Literal[True],
+) -> Coroutine[Any, Any, Keys]:
+    pass
+
+
+def get_user_keys(
+    *,
+    auth: Optional[AUTH] = None,
+    conn_url: Optional[str] = None,
+    batcher: Optional[Batcher] = None,
+    is_async: bool = False,
+) -> Union[Keys, Coroutine[Any, Any, Keys]]:
+    if batcher is None:
+        batcher = Config.BATCHER
+    if batcher is not None:
+        return batcher.add("getKeys", result_model=Keys)
+    if is_async:
+        return f.get_register_keys_async(auth=auth, conn_url=conn_url)
+    return f.get_register_keys(auth=auth, conn_url=conn_url)
+
+
+@overload
+def get_user_key(
+    name: str,
+    *,
+    auth: Optional[AUTH] = None,
+    conn_url: Optional[str] = None,
+    batcher: Optional[Batcher] = None,
+    is_async: Literal[False] = False,
+) -> str:
+    pass
+
+
+@overload
+def get_user_key(
+    name: str,
+    *,
+    auth: Optional[AUTH] = None,
+    conn_url: Optional[str] = None,
+    batcher: Optional[Batcher] = None,
+    is_async: Literal[True],
+) -> Coroutine[Any, Any, str]:
+    pass
+
+
+def get_user_key(
+    name: str,
+    *,
+    auth: Optional[AUTH] = None,
+    conn_url: Optional[str] = None,
+    batcher: Optional[Batcher] = None,
+    is_async: bool = False,
+) -> Union[str, Coroutine[Any, Any, str]]:
+    if batcher is None:
+        batcher = Config.BATCHER
+    if batcher is not None:
+        return batcher.add("getKeysByName", vars={"name": name})
+    if is_async:
+        return f.get_register_keys_name_async(name, auth=auth, conn_url=conn_url)
+    return f.get_register_keys_name(name, auth=auth, conn_url=conn_url)
+
+
+@overload
+def update_user_keys(
+    keys: Dict[str, 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 update_user_keys(
+    keys: Dict[str, 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 update_user_keys(
+    keys: Dict[str, 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]]:
+    if batcher is None:
+        batcher = Config.BATCHER
+    data = Keys(data=keys)
+    if batcher is not None:
+        return batcher.add("postKeys", data=data)
+    if is_async:
+        return f.post_register_keys_async(
+            data,
+            wait=wait,
+            auth=auth,
+            conn_url=conn_url,
+        )
+    return f.post_register_keys(
+        data,
+        wait=wait,
+        auth=auth,
+        conn_url=conn_url,
+    )
+
+
+@overload
+def delete_user_key(
+    name: 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_user_key(
+    name: 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_user_key(
+    name: 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]]:
+    if batcher is None:
+        batcher = Config.BATCHER
+    if batcher is not None:
+        return batcher.add("deleteKeysByName", vars={"name": name})
+    if is_async:
+        return f.delete_register_keys_name_async(
+            name,
+            wait=wait,
+            auth=auth,
+            conn_url=conn_url,
+        )
+    return f.delete_register_keys_name(
+        name,
+        wait=wait,
+        auth=auth,
+        conn_url=conn_url,
+    )
+
+
+@overload
+def delete_user_keys(
+    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_user_keys(
+    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_user_keys(
+    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]]:
+    if batcher is None:
+        batcher = Config.BATCHER
+    if batcher is not None:
+        return batcher.add("deleteKeys")
+    if is_async:
+        return f.delete_register_keys_async(
+            wait=wait,
+            auth=auth,
+            conn_url=conn_url,
+        )
+    return f.delete_register_keys(
+        wait=wait,
+        auth=auth,
+        conn_url=conn_url,
+    )
+
+
 # UserApps
 
 
@@ -6148,6 +6581,7 @@ def get_run_condition(
 def get_run_active_runs(
     tags: Optional[Dict[str, str]] = None,
     with_tags: bool = False,
+    id: Optional[str] = None,
     *,
     auth: Optional[AUTH] = None,
     conn_url: Optional[str] = None,
@@ -6161,6 +6595,7 @@ def get_run_active_runs(
 def get_run_active_runs(
     tags: Optional[Dict[str, str]] = None,
     with_tags: bool = False,
+    id: Optional[str] = None,
     *,
     auth: Optional[AUTH] = None,
     conn_url: Optional[str] = None,
@@ -6173,16 +6608,18 @@ def get_run_active_runs(
 def get_run_active_runs(
     tags: Optional[Dict[str, str]] = None,
     with_tags: bool = False,
+    id: Optional[str] = None,
     *,
     auth: Optional[AUTH] = None,
     conn_url: Optional[str] = None,
     batcher: Optional[Batcher] = None,
     is_async: bool = False,
 ) -> Union[ResultIds, ResultTags, Coroutine[Any, Any, ResultIds], Coroutine[Any, Any, ResultTags]]:
-    """return list running operationIds, filter by tags if set, return id -> tags if with_tags"""
+    """return list running operationIds, filter by tags if set, return id -> tags if with_tags; if operation `id` set - return runIds"""
     if batcher is None:
         batcher = Config.BATCHER
     if tags is not None or with_tags:
+        assert id is None, "id should be None in this case"
         data = RunsFilter(data=tags, withTags=with_tags)
         if batcher is not None:
             return batcher.add("postActiveRuns", data=data, result_model=ResultTags if with_tags else ResultIds)
@@ -6191,10 +6628,10 @@ def get_run_active_runs(
         return f.post_run_activeRuns(data, auth=auth, conn_url=conn_url)
     else:
         if batcher is not None:
-            return batcher.add("getActiveRuns", result_model=ResultIds)
+            return batcher.add("getActiveRuns", vars={"operationId": id}, result_model=ResultIds)
         if is_async:
-            return f.get_run_activeRuns_async(auth=auth, conn_url=conn_url)
-        return f.get_run_activeRuns(auth=auth, conn_url=conn_url)
+            return f.get_run_activeRuns_async(id, auth=auth, conn_url=conn_url)
+        return f.get_run_activeRuns(id, auth=auth, conn_url=conn_url)
 
 
 @overload
@@ -6329,6 +6766,93 @@ def get_task_runs(
     return f.get_run_operationsIds(task_id, cfg_id, auth=auth, conn_url=conn_url)
 
 
+@overload
+def get_run_statuses(
+    id: str,
+    *,
+    auth: Optional[AUTH] = None,
+    conn_url: Optional[str] = None,
+    batcher: Optional[Batcher] = None,
+    is_async: Literal[False] = False,
+) -> Statuses:
+    pass
+
+
+@overload
+def get_run_statuses(
+    id: str,
+    *,
+    auth: Optional[AUTH] = None,
+    conn_url: Optional[str] = None,
+    batcher: Optional[Batcher] = None,
+    is_async: Literal[True],
+) -> Coroutine[Any, Any, Statuses]:
+    pass
+
+
+def get_run_statuses(
+    id: str,
+    *,
+    auth: Optional[AUTH] = None,
+    conn_url: Optional[str] = None,
+    batcher: Optional[Batcher] = None,
+    is_async: bool = False,
+) -> Union[Statuses, Coroutine[Any, Any, Statuses]]:
+    """return runs statuses by operation `id`"""
+    if batcher is None:
+        batcher = Config.BATCHER
+    if batcher is not None:
+        return batcher.add("getStatuses", vars={"operationId": id}, result_model=Statuses)
+    if is_async:
+        return f.get_run_statuses_async(id, auth=auth, conn_url=conn_url)
+    return f.get_run_statuses(id, auth=auth, conn_url=conn_url)
+
+
+@overload
+def get_run_status(
+    id: str,
+    run_id: str,
+    *,
+    auth: Optional[AUTH] = None,
+    conn_url: Optional[str] = None,
+    batcher: Optional[Batcher] = None,
+    is_async: Literal[False] = False,
+) -> str:
+    pass
+
+
+@overload
+def get_run_status(
+    id: str,
+    run_id: str,
+    *,
+    auth: Optional[AUTH] = None,
+    conn_url: Optional[str] = None,
+    batcher: Optional[Batcher] = None,
+    is_async: Literal[True],
+) -> Coroutine[Any, Any, str]:
+    pass
+
+
+def get_run_status(
+    id: str,
+    run_id: str,
+    *,
+    auth: Optional[AUTH] = None,
+    conn_url: Optional[str] = None,
+    batcher: Optional[Batcher] = None,
+    is_async: bool = False,
+) -> Union[str, Coroutine[Any, Any, str]]:
+    """return run status by operation `id` and `run_id`: one of: IN_PROGRESS, SUCCESS, FAILED"""
+    if batcher is None:
+        batcher = Config.BATCHER
+    if batcher is not None:
+        return batcher.add("getStatusesOne", vars={"operationId": id, "runId": run_id})
+    if is_async:
+        return f.get_run_status_async(id, run_id, auth=auth, conn_url=conn_url)
+    return f.get_run_status(id, run_id, auth=auth, conn_url=conn_url)
+
+
 # Manager
 
 

{malevich_coretools-0.3.68 → malevich_coretools-0.3.70/malevich_coretools.egg-info}/PKG-INFO

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

malevich_coretools-0.3.68/VERSION

@@ -1 +0,0 @@
-0.3.68