@GitHK zipping -> data_export

Author: bisgaard-itis

packages/service-library/src/servicelib/rabbitmq/rpc_interfaces/storage/zipping.py renamed to packages/service-library/src/servicelib/rabbitmq/rpc_interfaces/storage/data_export.py

@@ -21,51 +21,51 @@
 _RPC_METHOD_NAME_ADAPTER = TypeAdapter(RPCMethodName)
 
 
-async def start_zipping(
+async def start_data_export(
     rabbitmq_rpc_client: RabbitMQRPCClient, *, paths: ZipTaskStartInput
 ) -> TaskRpcGet:
     result = await rabbitmq_rpc_client.request(
         STORAGE_RPC_NAMESPACE,
-        _RPC_METHOD_NAME_ADAPTER.validate_python("start_zipping"),
+        _RPC_METHOD_NAME_ADAPTER.validate_python("start_data_export"),
         paths=paths,
         timeout_s=_DEFAULT_TIMEOUT_S,
     )
     assert isinstance(result, TaskRpcGet)
     return result
 
 
-async def abort_zipping(
+async def abort_data_export(
     rabbitmq_rpc_client: RabbitMQRPCClient, *, task_id: TaskRpcId
 ) -> ZipTaskAbortOutput:
     result = await rabbitmq_rpc_client.request(
         STORAGE_RPC_NAMESPACE,
-        _RPC_METHOD_NAME_ADAPTER.validate_python("abort_zipping"),
+        _RPC_METHOD_NAME_ADAPTER.validate_python("abort_data_export"),
         task_id=task_id,
         timeout_s=_DEFAULT_TIMEOUT_S,
     )
     assert isinstance(result, ZipTaskAbortOutput)
     return result
 
 
-async def get_zipping_status(
+async def get_data_export_status(
     rabbitmq_rpc_client: RabbitMQRPCClient, *, task_id: TaskRpcId
 ) -> TaskRpcStatus:
     result = await rabbitmq_rpc_client.request(
         STORAGE_RPC_NAMESPACE,
-        _RPC_METHOD_NAME_ADAPTER.validate_python("get_zipping_status"),
+        _RPC_METHOD_NAME_ADAPTER.validate_python("get_data_export_status"),
         task_id=task_id,
         timeout_s=_DEFAULT_TIMEOUT_S,
     )
     assert isinstance(result, TaskRpcStatus)
     return result
 
 
-async def get_zipping_result(
+async def get_data_export_result(
     rabbitmq_rpc_client: RabbitMQRPCClient, *, task_id: TaskRpcId
 ) -> TaskRpcResult:
     result = await rabbitmq_rpc_client.request(
         STORAGE_RPC_NAMESPACE,
-        _RPC_METHOD_NAME_ADAPTER.validate_python("get_zipping_result"),
+        _RPC_METHOD_NAME_ADAPTER.validate_python("get_data_export_result"),
         task_id=task_id,
         timeout_s=_DEFAULT_TIMEOUT_S,
     )

services/storage/src/simcore_service_storage/api/rpc/_zipping.py renamed to services/storage/src/simcore_service_storage/api/rpc/_data_export.py

@@ -18,7 +18,7 @@
 
 
 @router.expose()
-async def start_zipping(app: FastAPI, paths: ZipTaskStartInput) -> TaskRpcGet:
+async def start_data_export(app: FastAPI, paths: ZipTaskStartInput) -> TaskRpcGet:
     assert app  # nosec
     return TaskRpcGet(
         task_id=uuid4(),
@@ -27,13 +27,13 @@ async def start_zipping(app: FastAPI, paths: ZipTaskStartInput) -> TaskRpcGet:
 
 
 @router.expose()
-async def abort_zipping(app: FastAPI, task_id: TaskRpcId) -> ZipTaskAbortOutput:
+async def abort_data_export(app: FastAPI, task_id: TaskRpcId) -> ZipTaskAbortOutput:
     assert app  # nosec
     return ZipTaskAbortOutput(result=True, task_id=task_id)
 
 
 @router.expose()
-async def get_zipping_status(app: FastAPI, task_id: TaskRpcId) -> TaskRpcStatus:
+async def get_data_export_status(app: FastAPI, task_id: TaskRpcId) -> TaskRpcStatus:
     assert app  # nosec
     return TaskRpcStatus(
         task_id=task_id,
@@ -45,7 +45,7 @@ async def get_zipping_status(app: FastAPI, task_id: TaskRpcId) -> TaskRpcStatus:
 
 
 @router.expose()
-async def get_zipping_result(app: FastAPI, task_id: TaskRpcId) -> TaskRpcResult:
+async def get_data_export_result(app: FastAPI, task_id: TaskRpcId) -> TaskRpcResult:
     assert app  # nosec
     assert task_id  # nosec
     return TaskRpcResult(result="Here's your result.", error=None)

services/storage/src/simcore_service_storage/api/rpc/routes.py

@@ -6,12 +6,12 @@
 from servicelib.rabbitmq import RPCRouter
 
 from ...modules.rabbitmq import get_rabbitmq_rpc_server
-from . import _zipping
+from . import _data_export
 
 _logger = logging.getLogger(__name__)
 
 
-ROUTERS: list[RPCRouter] = [_zipping.router]
+ROUTERS: list[RPCRouter] = [_data_export.router]
 
 
 def setup_rpc_api_routes(app: FastAPI) -> None:

services/storage/tests/unit/test_zipping.py renamed to services/storage/tests/unit/test_data_export.py

@@ -20,7 +20,7 @@
 from pytest_simcore.helpers.monkeypatch_envs import setenvs_from_dict
 from pytest_simcore.helpers.typing_env import EnvVarsDict
 from servicelib.rabbitmq import RabbitMQRPCClient
-from servicelib.rabbitmq.rpc_interfaces.storage import zipping
+from servicelib.rabbitmq.rpc_interfaces.storage import data_export
 from settings_library.rabbit import RabbitSettings
 from simcore_service_storage.core.settings import ApplicationSettings
 
@@ -73,28 +73,28 @@ async def rpc_client(
     return await rabbitmq_rpc_client("client")
 
 
-async def test_start_zipping(rpc_client: RabbitMQRPCClient, faker: Faker):
-    result = await zipping.start_zipping(
+async def test_start_data_export(rpc_client: RabbitMQRPCClient, faker: Faker):
+    result = await data_export.start_data_export(
         rpc_client, paths=ZipTaskStartInput(paths=[Path(faker.file_path())])
     )
     assert isinstance(result, TaskRpcGet)
 
 
-async def test_abort_zipping(rpc_client: RabbitMQRPCClient, faker: Faker):
+async def test_abort_data_export(rpc_client: RabbitMQRPCClient, faker: Faker):
     _task_id = TaskRpcId(faker.uuid4())
-    result = await zipping.abort_zipping(rpc_client, task_id=_task_id)
+    result = await data_export.abort_data_export(rpc_client, task_id=_task_id)
     assert isinstance(result, ZipTaskAbortOutput)
     assert result.task_id == _task_id
 
 
-async def test_get_zipping_status(rpc_client: RabbitMQRPCClient, faker: Faker):
+async def test_get_data_export_status(rpc_client: RabbitMQRPCClient, faker: Faker):
     _task_id = TaskRpcId(faker.uuid4())
-    result = await zipping.get_zipping_status(rpc_client, task_id=_task_id)
+    result = await data_export.get_data_export_status(rpc_client, task_id=_task_id)
     assert isinstance(result, TaskRpcStatus)
     assert result.task_id == _task_id
 
 
-async def test_get_zipping_result(rpc_client: RabbitMQRPCClient, faker: Faker):
+async def test_get_data_export_result(rpc_client: RabbitMQRPCClient, faker: Faker):
     _task_id = TaskRpcId(faker.uuid4())
-    result = await zipping.get_zipping_result(rpc_client, task_id=_task_id)
+    result = await data_export.get_data_export_result(rpc_client, task_id=_task_id)
     assert isinstance(result, TaskRpcResult)