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

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

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

malevich_coretools-0.3.62/VERSION

@@ -0,0 +1 @@
+0.3.62

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

@@ -139,12 +139,8 @@ class ScaleInfo(BaseModel):
 
 
 class TaskComponent(BaseModel):
-    appControl: Optional[str] = None
-    control: Optional[str] = None
-    extra: Optional[str] = None
-    internal: Optional[str] = None
+    main: Optional[str] = None
     keyValue: Optional[str] = None
-    minimal: Optional[str] = None
     objectStorage: Optional[str] = None
 
 
@@ -504,6 +500,24 @@ class OperationOrNone(BaseModel):
     operationId: Optional[Alias.Id] = None
 
 
+class AdminRunInfoReq(OperationOrNone):
+    dmId: Optional[str] = None
+
+
+class AdminDMRegister(BaseModel):
+    id: int
+    url: Optional[str]
+    secret: Optional[str]
+    appSecret: Optional[str]
+    login: Optional[str]
+    actuaryDMId: Optional[int]
+
+
+class AdminDMUnregister(BaseModel):
+    id: str
+    actuaryDMId: Optional[int]
+
+
 class AdminStopOperation(BaseModel):
     operationId: Optional[Alias.Id] = None
     withLogs: bool

malevich_coretools-0.3.62/malevich_coretools/admin/utils.py

@@ -0,0 +1,374 @@
+from typing import Coroutine, Literal, Union, overload
+
+import malevich_coretools.funcs.funcs as f
+from malevich_coretools.abstract import *  # noqa: F403
+from malevich_coretools.batch import Batcher
+from malevich_coretools.secondary import Config
+
+
+@overload
+def admin_get_runs(
+    *,
+    auth: Optional[AUTH] = None,
+    conn_url: Optional[str] = None,
+    batcher: Optional[Batcher] = None,
+    is_async: Literal[False] = False,
+) -> AdminRunsInfo:
+    pass
+
+
+@overload
+def admin_get_runs(
+    *,
+    auth: Optional[AUTH] = None,
+    conn_url: Optional[str] = None,
+    batcher: Optional[Batcher] = None,
+    is_async: Literal[True],
+) -> Coroutine[Any, Any, AdminRunsInfo]:
+    pass
+
+
+def admin_get_runs(
+    *,
+    auth: Optional[AUTH] = None,
+    conn_url: Optional[str] = None,
+    batcher: Optional[Batcher] = None,
+    is_async: bool = False,
+) -> Union[AdminRunsInfo, Coroutine[Any, Any, AdminRunsInfo]]:
+    """return info about all runs"""
+    if batcher is None:
+        batcher = Config.BATCHER
+    if batcher is not None:
+        return batcher.add("getAllRuns", result_model=AdminRunsInfo)
+    if is_async:
+        return f.get_admin_runs_async(auth=auth, conn_url=conn_url)
+    return f.get_admin_runs(auth=auth, conn_url=conn_url)
+
+
+@overload
+def admin_get_run_info(
+    id: Alias.Id,
+    *,
+    dm_id: Optional[str] = None,
+    auth: Optional[AUTH] = None,
+    conn_url: Optional[str] = None,
+    batcher: Optional[Batcher] = None,
+    is_async: Literal[False] = False,
+) -> Alias.Json:
+    pass
+
+
+@overload
+def admin_get_run_info(
+    id: Alias.Id,
+    *,
+    dm_id: Optional[str] = None,
+    auth: Optional[AUTH] = None,
+    conn_url: Optional[str] = None,
+    batcher: Optional[Batcher] = None,
+    is_async: Literal[True],
+) -> Coroutine[Any, Any, Alias.Json]:
+    pass
+
+
+def admin_get_run_info(
+    id: Alias.Id,
+    *,
+    dm_id: Optional[str] = None,
+    auth: Optional[AUTH] = None,
+    conn_url: Optional[str] = None,
+    batcher: Optional[Batcher] = None,
+    is_async: bool = False,
+) -> Union[Alias.Json, Coroutine[Any, Any, Alias.Json]]:
+    """return run info by operation `id`"""
+    if batcher is None:
+        batcher = Config.BATCHER
+    data = AdminRunInfoReq(operationId=id, dmId=dm_id)
+    if batcher is not None:
+        return batcher.add("getRunInfo", data=data)
+    if is_async:
+        return f.get_admin_runs_info_async(data, auth=auth, conn_url=conn_url)
+    return f.get_admin_runs_info(data, auth=auth, conn_url=conn_url)
+
+
+@overload
+def admin_get_runs_info(
+    *,
+    dm_id: Optional[str] = None,
+    auth: Optional[AUTH] = None,
+    conn_url: Optional[str] = None,
+    batcher: Optional[Batcher] = None,
+    is_async: Literal[False] = False,
+) -> Alias.Json:
+    pass
+
+
+@overload
+def admin_get_runs_info(
+    *,
+    dm_id: Optional[str] = None,
+    auth: Optional[AUTH] = None,
+    conn_url: Optional[str] = None,
+    batcher: Optional[Batcher] = None,
+    is_async: Literal[True],
+) -> Coroutine[Any, Any, Alias.Json]:
+    pass
+
+
+def admin_get_runs_info(
+    *,
+    dm_id: Optional[str] = None,
+    auth: Optional[AUTH] = None,
+    conn_url: Optional[str] = None,
+    batcher: Optional[Batcher] = None,
+    is_async: bool = False,
+) -> Union[Alias.Json, Coroutine[Any, Any, Alias.Json]]:
+    """return json: dm id -> info about its runs"""
+    if batcher is None:
+        batcher = Config.BATCHER
+    data = AdminRunInfoReq(dmId=dm_id)
+    if batcher is not None:
+        return batcher.add("getRunInfo", data=data)
+    if is_async:
+        return f.get_admin_runs_info_async(data, auth=auth, conn_url=conn_url)
+    return f.get_admin_runs_info(data, auth=auth, conn_url=conn_url)
+
+
+@overload
+def admin_dm_register(
+    id: Optional[int] = None,
+    url: Optional[str] = None,
+    secret: Optional[str] = None,
+    app_secret: Optional[str] = None,
+    login: Optional[str] = None,
+    actuary_dm_id: Optional[int] = None,
+    *,
+    auth: Optional[AUTH] = None,
+    conn_url: Optional[str] = None,
+    batcher: Optional[Batcher] = None,
+    is_async: Literal[False] = False,
+) -> None:
+    pass
+
+
+@overload
+def admin_dm_register(
+    id: Optional[int] = None,
+    url: Optional[str] = None,
+    secret: Optional[str] = None,
+    app_secret: Optional[str] = None,
+    login: Optional[str] = None,
+    actuary_dm_id: Optional[int] = None,
+    *,
+    auth: Optional[AUTH] = None,
+    conn_url: Optional[str] = None,
+    batcher: Optional[Batcher] = None,
+    is_async: Literal[True],
+) -> Coroutine[Any, Any, None]:
+    pass
+
+
+def admin_dm_register(
+    id: Optional[int] = None,
+    url: Optional[str] = None,
+    secret: Optional[str] = None,
+    app_secret: Optional[str] = None,
+    login: Optional[str] = None,
+    actuary_dm_id: Optional[int] = None,
+    *,
+    auth: Optional[AUTH] = None,
+    conn_url: Optional[str] = None,
+    batcher: Optional[Batcher] = None,
+    is_async: bool = False,
+) -> Union[None, Coroutine[Any, Any, None]]:
+    assert id is not None or (url is not None and secret is not None and app_secret is not None and login is not None), "id or url & secret & app_secret & login should set"
+    if batcher is None:
+        batcher = Config.BATCHER
+    data = AdminDMRegister(id=id, url=url, secret=secret, appSecret=app_secret, login=login, actuaryDMId=actuary_dm_id)
+    if batcher is not None:
+        return batcher.add("postDMRegister", data=data)
+    if is_async:
+        return f.post_admin_dm_register_async(data, auth=auth, conn_url=conn_url)
+    return f.post_admin_dm_register(data, auth=auth, conn_url=conn_url)
+
+
+@overload
+def admin_dm_unregister(
+    id: Union[str, int] = 0,
+    actuary_dm_id: Optional[int] = None,
+    *,
+    auth: Optional[AUTH] = None,
+    conn_url: Optional[str] = None,
+    batcher: Optional[Batcher] = None,
+    is_async: Literal[False] = False,
+) -> None:
+    pass
+
+
+@overload
+def admin_dm_unregister(
+    id: Union[str, int] = 0,
+    actuary_dm_id: Optional[int] = None,
+    *,
+    auth: Optional[AUTH] = None,
+    conn_url: Optional[str] = None,
+    batcher: Optional[Batcher] = None,
+    is_async: Literal[True],
+) -> Coroutine[Any, Any, None]:
+    pass
+
+
+def admin_dm_unregister(
+    id: Union[str, int] = 0,    # id or login
+    actuary_dm_id: Optional[int] = None,
+    *,
+    auth: Optional[AUTH] = None,
+    conn_url: Optional[str] = None,
+    batcher: Optional[Batcher] = None,
+    is_async: bool = False,
+) -> Union[None, Coroutine[Any, Any, None]]:
+    if isinstance(id, int):
+        id = f'{id:05d}'
+    if batcher is None:
+        batcher = Config.BATCHER
+    data = AdminDMUnregister(id=id, actuaryDMId=actuary_dm_id)
+    if batcher is not None:
+        return batcher.add("deleteDMRegister", data=data)
+    if is_async:
+        return f.delete_admin_dm_register_async(data, auth=auth, conn_url=conn_url)
+    return f.delete_admin_dm_register(data, auth=auth, conn_url=conn_url)
+
+
+@overload
+def admin_update_superuser(
+    login: str,
+    is_superuser: 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 admin_update_superuser(
+    login: str,
+    is_superuser: 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 admin_update_superuser(
+    login: str,
+    is_superuser: 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]]:
+    """update user role by login"""
+    if batcher is None:
+        batcher = Config.BATCHER
+    data = Superuser(login=login, isSuperuser=is_superuser)
+    if batcher is not None:
+        return batcher.add("postUpdateSuperuser", data=data)
+    if is_async:
+        return f.post_admin_update_superuser_async(data, auth=auth, conn_url=conn_url)
+    return f.post_admin_update_superuser(data, auth=auth, conn_url=conn_url)
+
+
+@overload
+def admin_delete_run(
+    id: Alias.Id,
+    withLogs: bool = False,
+    *,
+    auth: Optional[AUTH] = None,
+    conn_url: Optional[str] = None,
+    batcher: Optional[Batcher] = None,
+    is_async: Literal[False] = False,
+) -> Alias.Json:
+    pass
+
+
+@overload
+def admin_delete_run(
+    id: Alias.Id,
+    withLogs: bool = False,
+    *,
+    auth: Optional[AUTH] = None,
+    conn_url: Optional[str] = None,
+    batcher: Optional[Batcher] = None,
+    is_async: Literal[True],
+) -> Coroutine[Any, Any, Alias.Json]:
+    pass
+
+
+def admin_delete_run(
+    id: Alias.Id,
+    withLogs: bool = False,
+    *,
+    auth: Optional[AUTH] = None,
+    conn_url: Optional[str] = None,
+    batcher: Optional[Batcher] = None,
+    is_async: bool = False,
+) -> Union[Alias.Json, Coroutine[Any, Any, Alias.Json]]:
+    """delete run by operation `id`"""
+    if batcher is None:
+        batcher = Config.BATCHER
+    data = AdminStopOperation(operationId=id, withLogs=withLogs)
+    if batcher is not None:
+        return batcher.add("deleteRuns", data=data)
+    if is_async:
+        return f.delete_admin_runs_async(data, auth=auth, conn_url=conn_url)
+    return f.delete_admin_runs(data, auth=auth, conn_url=conn_url)
+
+
+@overload
+def admin_delete_runs(
+    withLogs: bool = False,
+    *,
+    auth: Optional[AUTH] = None,
+    conn_url: Optional[str] = None,
+    batcher: Optional[Batcher] = None,
+    is_async: Literal[False] = False,
+) -> Alias.Json:
+    pass
+
+
+@overload
+def admin_delete_runs(
+    withLogs: bool = False,
+    *,
+    auth: Optional[AUTH] = None,
+    conn_url: Optional[str] = None,
+    batcher: Optional[Batcher] = None,
+    is_async: Literal[True],
+) -> Coroutine[Any, Any, Alias.Json]:
+    pass
+
+
+def admin_delete_runs(
+    withLogs: bool = False,
+    *,
+    auth: Optional[AUTH] = None,
+    conn_url: Optional[str] = None,
+    batcher: Optional[Batcher] = None,
+    is_async: bool = False,
+) -> Union[Alias.Json, Coroutine[Any, Any, Alias.Json]]:
+    """delete all runs"""
+    if batcher is None:
+        batcher = Config.BATCHER
+    data = AdminStopOperation(withLogs=withLogs)
+    if batcher is not None:
+        return batcher.add("deleteRuns", data=data)
+    if is_async:
+        return f.delete_admin_runs_async(data, auth=auth, conn_url=conn_url)
+    return f.delete_admin_runs(data, auth=auth, conn_url=conn_url)

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

@@ -1114,14 +1114,30 @@ async def get_admin_runs_async(*args, **kwargs) -> AdminRunsInfo:
     return model_from_json(await send_to_core_get_async(ADMIN_RUNS, *args, **kwargs), AdminRunsInfo)
 
 
-def get_admin_runs_info(data: OperationOrNone, *args, **kwargs) -> Alias.Json:
+def get_admin_runs_info(data: AdminRunInfoReq, *args, **kwargs) -> Alias.Json:
     return send_to_core_modify(ADMIN_RUNS_INFO, data, *args, **kwargs)
 
 
-async def get_admin_runs_info_async(data: OperationOrNone, *args, **kwargs) -> Alias.Json:
+async def get_admin_runs_info_async(data: AdminRunInfoReq, *args, **kwargs) -> Alias.Json:
     return await send_to_core_modify_async(ADMIN_RUNS_INFO, data, *args, **kwargs)
 
 
+def post_admin_dm_register(data: AdminDMRegister, *args, **kwargs) -> None:
+    return send_to_core_modify(ADMIN_DM_REGISTER, data, *args, **kwargs)
+
+
+async def post_admin_dm_register_async(data: AdminDMRegister, *args, **kwargs) -> None:
+    return await send_to_core_modify_async(ADMIN_DM_REGISTER, data, *args, **kwargs)
+
+
+def delete_admin_dm_register(data: AdminDMUnregister, *args, **kwargs) -> None:
+    return send_to_core_modify(ADMIN_DM_REGISTER, data, *args, **kwargs, is_post=False)
+
+
+async def delete_admin_dm_register_async(data: AdminDMUnregister, *args, **kwargs) -> None:
+    return await send_to_core_modify_async(ADMIN_DM_REGISTER, data, *args, **kwargs, is_post=False)
+
+
 def post_admin_update_superuser(data: Superuser, *args, **kwargs) -> Alias.Info:
     return send_to_core_modify(ADMIN_SUPERUSER, data, *args, **kwargs)
 
@@ -1222,14 +1238,22 @@ async def get_image_info_async(data: JsonImage, parse: bool, *args, **kwargs) ->
     return res
 
 
-def get_task_schedules(data: Operation, with_show: bool, *args, **kwargs) -> Schedules:
+def get_task_schedules(*args, **kwargs) -> ResultIds:
+    return model_from_json(send_to_core_get(MANAGER_TASK_SCHEDULES, *args, **kwargs), ResultIds)
+
+
+async def get_task_schedules_async(*args, **kwargs) -> ResultIds:
+    return model_from_json(await send_to_core_get_async(MANAGER_TASK_SCHEDULES, *args, **kwargs), ResultIds)
+
+
+def post_task_schedules(data: Operation, with_show: bool, *args, **kwargs) -> Schedules:
     res = model_from_json(send_to_core_modify(MANAGER_TASK_SCHEDULES, data, with_show=False, *args, **kwargs), Schedules)
     if with_show:
         Config.logger.info(res)
     return res
 
 
-async def get_task_schedules_async(data: Operation, with_show: bool, *args, **kwargs) -> Schedules:
+async def post_task_schedules_async(data: Operation, with_show: bool, *args, **kwargs) -> Schedules:
     res = model_from_json(await send_to_core_modify_async(MANAGER_TASK_SCHEDULES, data, with_show=False, *args, **kwargs), Schedules)
     if with_show:
         Config.logger.info(res)

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

@@ -287,21 +287,13 @@ def create_user_config(
 
 
 def create_task_component(
-    app_control: Optional[str] = None,
-    control: Optional[str] = None,
-    extra: Optional[str] = None,
-    internal: Optional[str] = None,
+    main: Optional[str] = None,
     key_value: Optional[str] = None,
-    minimal: Optional[str] = None,
     object_storage: Optional[str] = None,
 ) -> TaskComponent:
     return TaskComponent(
-        appControl=app_control,
-        control=control,
-        extra=extra,
-        internal=internal,
+        main=main,
         keyValue=key_value,
-        minimal=minimal,
         objectStorage=object_storage
     )
 

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

@@ -39,13 +39,13 @@ def with_key_values(url: str, key_values: Dict[str, Optional[str]]) -> str:
 
 ## DocsController
 DOCS_MAIN = f"{API_VERSION}/docs"
-DOCS = lambda wait: with_wait(f"{DOCS_MAIN}/", wait)
+DOCS = lambda wait: with_wait(DOCS_MAIN, wait)
 DOCS_ID = lambda id, wait: with_wait(f"{DOCS_MAIN}/{id}", wait)
 DOCS_NAME = lambda name, wait: with_wait(f"{DOCS_MAIN}/name/{name}", wait)
 
 ## CollectionsController
 COLLECTIONS_MAIN = f"{API_VERSION}/collections"
-COLLECTIONS = lambda wait: with_wait(f"{COLLECTIONS_MAIN}/", wait)
+COLLECTIONS = lambda wait: with_wait(COLLECTIONS_MAIN, wait)
 COLLECTIONS_IDS_NAME = lambda name, operation_id, run_id: with_key_values(f"{COLLECTIONS_MAIN}/ids/name/{urllib.parse.quote(str(name), safe='')}", {"operationId": operation_id, "runId": run_id})
 COLLECTIONS_NAME = lambda name, operation_id, run_id, offset, limit: with_key_values(f"{COLLECTIONS_MAIN}/name/{urllib.parse.quote(str(name), safe='')}", {"operationId": operation_id, "runId": run_id, "offset": offset, "limit": limit})
 COLLECTIONS_IDS_GROUP_NAME = lambda name, operation_id, run_id: with_key_values(f"{COLLECTIONS_MAIN}/ids/groupName/{urllib.parse.quote(str(name), safe='')}", {"operationId": operation_id, "runId": run_id})
@@ -67,7 +67,7 @@ COLLECTIONS_METADATA = lambda id, wait: with_wait(f"{COLLECTIONS_MAIN}/{urllib.p
 COLLECTION_OBJECTS_MAIN = f"{API_VERSION}/collectionObjects"
 COLLECTION_OBJECTS_ALL_GET = lambda path, recursive: with_key_values(f"{COLLECTION_OBJECTS_MAIN}/all", {"path": path, "recursive": recursive})
 COLLECTION_OBJECTS_ALL = lambda wait: with_wait(f"{COLLECTION_OBJECTS_MAIN}/all", wait)
-COLLECTION_OBJECTS_PATH = lambda path, wait, zip: with_key_values(f"{COLLECTION_OBJECTS_MAIN}/", {"path": path, "wait": None if wait is None else bool_to_str(wait), "zip": None if zip is None else bool_to_str(zip)})
+COLLECTION_OBJECTS_PATH = lambda path, wait, zip: with_key_values(COLLECTION_OBJECTS_MAIN, {"path": path, "wait": None if wait is None else bool_to_str(wait), "zip": None if zip is None else bool_to_str(zip)})
 COLLECTION_OBJECTS_PRESIGN_PUT = lambda path, callback_url, expires_in, wait: with_key_values(f"{COLLECTION_OBJECTS_MAIN}/presign/put", {"path": path, "callback_url": callback_url, "expiresIn": expires_in, "wait": bool_to_str(wait)})
 COLLECTION_OBJECTS_PRESIGN_GET = lambda path, callback_url, expires_in, wait: with_key_values(f"{COLLECTION_OBJECTS_MAIN}/presign/get", {"path": path, "callback_url": callback_url, "expiresIn": expires_in, "wait": bool_to_str(wait)})
 COLLECTION_OBJECTS_PRESIGN = lambda signature, zip: with_key_values(f"{COLLECTION_OBJECTS_MAIN}/presign", {"signature": signature, "zip": None if zip is None else bool_to_str(zip)})
@@ -84,7 +84,7 @@ ENDPOINTS_RESUME = lambda hash, wait: with_wait(f"{ENDPOINTS_MAIN}/resume/{urlli
 
 ## SchemeController
 SCHEMES_MAIN = f"{API_VERSION}/schemes"
-SCHEMES = lambda wait: with_wait(f"{SCHEMES_MAIN}/", wait)
+SCHEMES = lambda wait: with_wait(SCHEMES_MAIN, wait)
 SCHEMES_ID = lambda id, wait: with_wait(f"{SCHEMES_MAIN}/{urllib.parse.quote(str(id), safe='')}", wait)
 SCHEMES_ID_RAW = lambda id: f"{SCHEMES_MAIN}/{urllib.parse.quote(str(id), safe='')}/raw"
 SCHEMES_MAPPING = lambda wait: with_wait(f"{SCHEMES_MAIN}/mapping", wait)
@@ -100,7 +100,7 @@ PING = "ping"
 
 ## UserShareController
 SHARE_MAIN = f"{API_VERSION}/share"
-SHARE = lambda wait: with_wait(f"{SHARE_MAIN}/", wait)
+SHARE = lambda wait: with_wait(SHARE_MAIN, wait)
 SHARE_COLLECTION_ID = lambda id, wait: with_wait(f"{SHARE_MAIN}/collection/{urllib.parse.quote(str(id), safe='')}", wait)
 SHARE_SCHEME_ID = lambda id, wait: with_wait(f"{SHARE_MAIN}/scheme/{urllib.parse.quote(str(id), safe='')}", wait)
 SHARE_USER_APP_ID = lambda id, wait: with_wait(f"{SHARE_MAIN}/userApp/{urllib.parse.quote(str(id), safe='')}", wait)
@@ -109,13 +109,13 @@ SHARE_ALL = lambda wait: with_wait(f"{SHARE_MAIN}/all", wait)
 
 ## RegistrationController
 REGISTER_MAIN = f"{API_VERSION}/register"
-REGISTER = f"{REGISTER_MAIN}/"
+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"
 
 ## UserAppsController
 USER_APPS_MAIN = f"{API_VERSION}/userApps"
-USER_APPS = lambda wait: with_wait(f"{USER_APPS_MAIN}/", wait)
+USER_APPS = lambda wait: with_wait(USER_APPS_MAIN, wait)
 USER_APPS_REAL_IDS = f"{USER_APPS_MAIN}/realIds"
 USER_APPS_MAP_IDS = f"{USER_APPS_MAIN}/mapIds"
 USER_APPS_MAP_ID = lambda id: f"{USER_APPS_MAIN}/mapIds/{urllib.parse.quote(str(id), safe='')}"
@@ -124,7 +124,7 @@ USER_APPS_REAL_ID = lambda id: f"{USER_APPS_MAIN}/realIds/{urllib.parse.quote(st
 
 ## UserTasksController
 USER_TASKS_MAIN = f"{API_VERSION}/userTasks"
-USER_TASKS = lambda wait: with_wait(f"{USER_TASKS_MAIN}/", wait)
+USER_TASKS = lambda wait: with_wait(USER_TASKS_MAIN, wait)
 USER_TASKS_REAL_IDS = f"{USER_TASKS_MAIN}/realIds"
 USER_TASKS_MAP_IDS = f"{USER_TASKS_MAIN}/mapIds"
 USER_TASKS_MAP_ID = lambda id: f"{USER_TASKS_MAIN}/mapIds/{urllib.parse.quote(str(id), safe='')}"
@@ -133,7 +133,7 @@ USER_TASKS_REAL_ID = lambda id: f"{USER_TASKS_MAIN}/realIds/{urllib.parse.quote(
 
 ## UserPipelinesController
 USER_PIPELINES_MAIN = f"{API_VERSION}/userPipelines"
-USER_PIPELINES = lambda wait: with_wait(f"{USER_PIPELINES_MAIN}/", wait)
+USER_PIPELINES = lambda wait: with_wait(USER_PIPELINES_MAIN, wait)
 USER_PIPELINES_REAL_IDS = f"{USER_PIPELINES_MAIN}/realIds"
 USER_PIPELINES_MAP_IDS = f"{USER_PIPELINES_MAIN}/mapIds"
 USER_PIPELINES_MAP_ID = lambda id: f"{USER_PIPELINES_MAIN}/mapIds/{urllib.parse.quote(str(id), safe='')}"
@@ -144,7 +144,7 @@ USER_PIPELINES_TAG_REAL_IDS = lambda tag: f"{USER_PIPELINES_MAIN}/realIds/tagSea
 
 ## UserCfgsController
 USER_CFGS_MAIN = f"{API_VERSION}/userCfgs"
-USER_CFGS = lambda wait: with_wait(f"{USER_CFGS_MAIN}/", wait)
+USER_CFGS = lambda wait: with_wait(USER_CFGS_MAIN, wait)
 USER_CFGS_REAL_IDS = f"{USER_CFGS_MAIN}/realIds"
 USER_CFGS_MAP_IDS = f"{USER_CFGS_MAIN}/mapIds"
 USER_CFGS_MAP_ID = lambda id: f"{USER_CFGS_MAIN}/mapIds/{urllib.parse.quote(str(id), safe='')}"
@@ -153,7 +153,7 @@ USER_CFGS_REAL_ID = lambda id: f"{USER_CFGS_MAIN}/realIds/{urllib.parse.quote(st
 
 ## OperationResultsController
 OPERATION_RESULTS_MAIN = f"{API_VERSION}/operationResults"
-OPERATION_RESULTS = lambda wait: with_wait(f"{OPERATION_RESULTS_MAIN}/", wait)
+OPERATION_RESULTS = lambda wait: with_wait(OPERATION_RESULTS_MAIN, wait)
 OPERATION_RESULTS_ID = lambda id, wait: with_wait(f"{OPERATION_RESULTS_MAIN}/{urllib.parse.quote(str(id), safe='')}", wait)
 
 ## TempRunController
@@ -168,6 +168,7 @@ TEMP_RUN_OPERATIONS_IDS = lambda taskId, cfgId: f"{TEMP_RUN_MAIN}/operationsIds/
 ADMIN_MAIN = f"{API_VERSION}/admin"
 ADMIN_RUNS = f"{ADMIN_MAIN}/runs"
 ADMIN_RUNS_INFO = f"{ADMIN_MAIN}/runs/info"
+ADMIN_DM_REGISTER = f"{ADMIN_MAIN}/dm/register"
 ADMIN_SUPERUSER = f"{ADMIN_MAIN}/superuser"
 
 ## ManagerController
@@ -195,16 +196,16 @@ MANAGER_APP_PAUSE = lambda wait: with_wait(f"{MANAGER_MAIN}/app/pause", wait)
 
 ## LimitsController
 LIMITS_MAIN = f"{API_VERSION}/limits"
-LIMITS = lambda wait: with_wait(f"{LIMITS_MAIN}/", wait)
+LIMITS = lambda wait: with_wait(LIMITS_MAIN, wait)
 LIMITS_USER = lambda wait: with_wait(f"{LIMITS_MAIN}/user", wait)
 
 ## HandlerUrlController
 HANDLER_URL_MAIN = f"{API_VERSION}/handlerUrls"
-HANDLER_URL = lambda url, wait: with_key_values(f"{HANDLER_URL_MAIN}/", {"url": url, "wait": bool_to_str(wait)})
+HANDLER_URL = lambda url, wait: with_key_values(HANDLER_URL_MAIN, {"url": url, "wait": bool_to_str(wait)})
 
 ## AnalyticsController
 ANALYTICS_MAIN = f"{API_VERSION}/analytics"
-ANALYTICS = lambda wait: with_wait(f"{ANALYTICS_MAIN}/", wait)
+ANALYTICS = lambda wait: with_wait(ANALYTICS_MAIN, wait)
 ANALYTICS_MANY = lambda wait: with_wait(f"{ANALYTICS_MAIN}/many", wait)
 ANALYTICS_ID = lambda id, wait: with_wait(f"{ANALYTICS_MAIN}/{id}", wait)
 ANALYTICS_NAME = lambda name, wait: with_wait(f"{ANALYTICS_MAIN}/name/{name}", wait)
@@ -216,20 +217,20 @@ RUNS_INFO_LAST_FAILED = lambda count: with_key_values(f"{RUNS_INFO_MAIN}/lastFai
 
 ## WSAppsController
 WS_APPS_MAIN = f"{API_VERSION}/ws/apps"
-WS_APPS = lambda only_active, full: with_key_values(f"{WS_APPS_MAIN}/", {"onlyActive": only_active, "full": full})
-WS_APPS_ = lambda only_not_active, wait: with_key_values(f"{WS_APPS_MAIN}/", {"onlyNotActive": only_not_active, "wait": wait})
+WS_APPS = lambda only_active, full: with_key_values(WS_APPS_MAIN, {"onlyActive": only_active, "full": full})
+WS_APPS_ = lambda only_not_active, wait: with_key_values(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 = lambda id, name, wait: with_key_values(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"
 
 ## 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 = lambda wait: with_wait(APP_ERROR_INFO_MAIN, wait)
 APP_ERROR_INFO_ID = lambda operationId, wait: with_wait(f"{APP_ERROR_INFO_MAIN}/{operationId}", wait)
 
 ### Kafka
@@ -237,4 +238,4 @@ KAFKA_SEND = f"{MANAGER_MAIN}/kafkaMsg"
 
 ## BatchController
 BATCH_MAIN = f"{API_VERSION}/batch"
-BATCH = f"{BATCH_MAIN}/"
+BATCH = BATCH_MAIN

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

@@ -57,7 +57,7 @@ def bool_to_str(b: bool) -> str:
     return "true" if b else "false"
 
 
-def __show_logs_result(res: LogsResult, i: Optional[int]):  # noqa: ANN202
+def __show_logs_result(res: LogsResult, i: Optional[int] = None):  # noqa: ANN202
     if len(res.data) > 0:
         print(f"------- main ({i}):" if i is not None else "------- main:")
         print(res.data)

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

@@ -6735,7 +6735,7 @@ def get_task_schedules(
     conn_url: Optional[str] = None,
     batcher: Optional[Batcher] = None,
     is_async: Literal[False] = False,
-) -> Schedules:
+) -> Union[Schedules, ResultIds]:
     pass
 
 
@@ -6748,32 +6748,39 @@ def get_task_schedules(
     conn_url: Optional[str] = None,
     batcher: Optional[Batcher] = None,
     is_async: Literal[True],
-) -> Coroutine[Any, Any, Schedules]:
+) -> Coroutine[Any, Any, Union[Schedules, ResultIds]]:
     pass
 
 
 def get_task_schedules(
-    operation_id: str,
+    operation_id: Optional[str] = None,
     with_show: bool = True,
     *,
     auth: Optional[AUTH] = None,
     conn_url: Optional[str] = None,
     batcher: Optional[Batcher] = None,
     is_async: bool = False,
-) -> Union[Schedules, Coroutine[Any, Any, Schedules]]:
+) -> Union[ResultIds, Schedules, Coroutine[Any, Any, Schedules], Coroutine[Any, Any, ResultIds]]:
     """return schedule ids by `operation_id` """
     if batcher is None:
         batcher = Config.BATCHER
-    data = Operation(operationId=operation_id)
-    if batcher is not None:
-        return batcher.add("sendTaskSchedules", data=data, result_model=Schedules)
-    if is_async:
-        return f.get_task_schedules_async(
+    if operation_id is None:
+        if batcher is not None:
+            return batcher.add("getTaskSchedules", result_model=ResultIds)
+        if is_async:
+            return f.get_task_schedules_async(auth=auth, conn_url=conn_url)
+        return f.get_task_schedules(auth=auth, conn_url=conn_url)
+    else:
+        data = Operation(operationId=operation_id)
+        if batcher is not None:
+            return batcher.add("sendTaskSchedules", data=data, result_model=Schedules)
+        if is_async:
+            return f.post_task_schedules_async(
+                data, with_show=with_show, auth=auth, conn_url=conn_url
+            )
+        return f.post_task_schedules(
             data, with_show=with_show, auth=auth, conn_url=conn_url
         )
-    return f.get_task_schedules(
-        data, with_show=with_show, auth=auth, conn_url=conn_url
-    )
 
 
 @overload
@@ -6834,7 +6841,6 @@ def task_full(
     pass
 
 
-# FIXME check component
 def task_full(
     task_id: str,
     cfg_id: str,

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

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

malevich_coretools-0.3.60/VERSION

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

malevich_coretools-0.3.60/malevich_coretools/admin/utils.py

@@ -1,99 +0,0 @@
-import malevich_coretools.funcs.funcs as f
-from malevich_coretools.abstract import *  # noqa: F403
-from malevich_coretools.batch import Batcher
-from malevich_coretools.secondary import Config
-
-
-def admin_get_runs(
-    *,
-    auth: Optional[AUTH] = None,
-    conn_url: Optional[str] = None,
-    batcher: Optional[Batcher] = None,
-) -> AdminRunsInfo:
-    """return info about all runs"""
-    if batcher is None:
-        batcher = Config.BATCHER
-    if batcher is not None:
-        return batcher.add("getAllRuns", result_model=AdminRunsInfo)
-    return f.get_admin_runs(auth=auth, conn_url=conn_url)
-
-
-def admin_get_run_info(
-    id: Alias.Id,
-    *,
-    auth: Optional[AUTH] = None,
-    conn_url: Optional[str] = None,
-    batcher: Optional[Batcher] = None,
-) -> Alias.Json:
-    """return run info by operation `id`"""
-    if batcher is None:
-        batcher = Config.BATCHER
-    data = OperationOrNone(operationId=id)
-    if batcher is not None:
-        return batcher.add("getRunInfo", data=data)
-    return f.get_admin_runs_info(data, auth=auth, conn_url=conn_url)
-
-
-def admin_get_runs_info(
-    *,
-    auth: Optional[AUTH] = None,
-    conn_url: Optional[str] = None,
-    batcher: Optional[Batcher] = None,
-) -> Alias.Json:
-    """return json: dm id -> info about its runs"""
-    if batcher is None:
-        batcher = Config.BATCHER
-    data = OperationOrNone()
-    if batcher is not None:
-        return batcher.add("getRunInfo", data=data)
-    return f.get_admin_runs_info(data, auth=auth, conn_url=conn_url)
-
-
-def admin_update_superuser(
-    login: str,
-    is_superuser: bool = True,
-    *,
-    auth: Optional[AUTH] = None,
-    conn_url: Optional[str] = None,
-    batcher: Optional[Batcher] = None,
-) -> Alias.Info:
-    """update user role by login"""
-    if batcher is None:
-        batcher = Config.BATCHER
-    data = Superuser(login=login, isSuperuser=is_superuser)
-    if batcher is not None:
-        return batcher.add("postUpdateSuperuser", data=data)
-    return f.post_admin_update_superuser(data, auth=auth, conn_url=conn_url)
-
-
-def admin_delete_run(
-    id: Alias.Id,
-    withLogs: bool = False,
-    *,
-    auth: Optional[AUTH] = None,
-    conn_url: Optional[str] = None,
-    batcher: Optional[Batcher] = None,
-) -> Alias.Json:
-    """delete run by operation `id`"""
-    if batcher is None:
-        batcher = Config.BATCHER
-    data = AdminStopOperation(operationId=id, withLogs=withLogs)
-    if batcher is not None:
-        return batcher.add("deleteRuns", data=data)
-    return f.delete_admin_runs(data, auth=auth, conn_url=conn_url)
-
-
-def admin_delete_runs(
-    withLogs: bool = False,
-    *,
-    auth: Optional[AUTH] = None,
-    conn_url: Optional[str] = None,
-    batcher: Optional[Batcher] = None,
-) -> Alias.Json:
-    """delete all runs"""
-    if batcher is None:
-        batcher = Config.BATCHER
-    data = AdminStopOperation(withLogs=withLogs)
-    if batcher is not None:
-        return batcher.add("deleteRuns", data=data)
-    return f.delete_admin_runs(data, auth=auth, conn_url=conn_url)