cosmotech-acceleration-library 1.0.1__py3-none-any.whl → 2.0.0__py3-none-any.whl

cosmotech/coal/cosmotech_api/workspace.py

@@ -1,127 +0,0 @@
-# Copyright (C) - 2023 - 2025 - Cosmo Tech
-# This document and all information contained herein is the exclusive property -
-# including all intellectual property rights pertaining thereto - of Cosmo Tech.
-# Any use, reproduction, translation, broadcasting, transmission, distribution,
-# etc., to any person is prohibited unless it has been previously and
-# specifically authorized by written means by Cosmo Tech.
-import pathlib
-
-import cosmotech_api
-
-from cosmotech.coal.utils.logger import LOGGER
-from cosmotech.orchestrator.utils.translate import T
-
-
-def list_workspace_files(
-    api_client: cosmotech_api.api_client.ApiClient,
-    organization_id: str,
-    workspace_id: str,
-    file_prefix: str,
-) -> list[str]:
-    """
-    Helper function to list all workspace files using a pre-given file prefix
-    :param api_client: An api client used to connect to the Cosmo Tech API
-    :param organization_id: An ID of an Organization in the Cosmo Tech API
-    :param workspace_id: An ID of a Workspace in the Cosmo Tech API
-    :param file_prefix: The prefix of the files to find in the Workspace
-    :return: A list of existing files inside the workspace
-    """
-    target_list = []
-    api_ws = cosmotech_api.api.workspace_api.WorkspaceApi(api_client)
-    LOGGER.info(T("coal.cosmotech_api.workspace.target_is_folder"))
-    wsf = api_ws.find_all_workspace_files(organization_id, workspace_id)
-    for workspace_file in wsf:
-        if workspace_file.file_name.startswith(file_prefix):
-            target_list.append(workspace_file.file_name)
-
-    if not target_list:
-        LOGGER.error(
-            T("coal.common.errors.data_no_workspace_files").format(file_prefix=file_prefix, workspace_id=workspace_id)
-        )
-        raise ValueError(
-            T("coal.common.errors.data_no_workspace_files").format(file_prefix=file_prefix, workspace_id=workspace_id)
-        )
-
-    return target_list
-
-
-def download_workspace_file(
-    api_client: cosmotech_api.api_client.ApiClient,
-    organization_id: str,
-    workspace_id: str,
-    file_name: str,
-    target_dir: pathlib.Path,
-) -> pathlib.Path:
-    """
-    Downloads a given file from a workspace to a given directory
-    If the file is inside a directory in the workspace, sub-directories will be created.
-    :param api_client: An api client used to connect to the Cosmo Tech API
-    :param organization_id: An ID of an Organization in the Cosmo Tech API
-    :param workspace_id: An ID of a Workspace in the Cosmo Tech API
-    :param file_name: The file to download to the workspace
-    :param target_dir: The directory in which to write the file
-    :return: The path to the created file
-    """
-    if target_dir.is_file():
-        raise ValueError(T("coal.common.file_operations.not_directory").format(target_dir=target_dir))
-    api_ws = cosmotech_api.api.workspace_api.WorkspaceApi(api_client)
-
-    LOGGER.info(T("coal.cosmotech_api.workspace.loading_file").format(file_name=file_name))
-
-    _file_content = api_ws.download_workspace_file(organization_id, workspace_id, file_name)
-
-    local_target_file = target_dir / file_name
-    local_target_file.parent.mkdir(parents=True, exist_ok=True)
-
-    with open(local_target_file, "wb") as _file:
-        _file.write(_file_content)
-
-    LOGGER.info(T("coal.cosmotech_api.workspace.file_loaded").format(file=local_target_file))
-
-    return local_target_file
-
-
-def upload_workspace_file(
-    api_client: cosmotech_api.api_client.ApiClient,
-    organization_id: str,
-    workspace_id: str,
-    file_path: str,
-    workspace_path: str,
-    overwrite: bool = True,
-) -> str:
-    """
-    Upload a local file to a given workspace
-
-    If workspace_path ends with a "/" it will be considered as a folder inside the workspace
-    and the file will keep its current name
-
-    :param api_client: An api client used to connect to the Cosmo Tech API
-    :param organization_id: An ID of an Organization in the Cosmo Tech API
-    :param workspace_id: An ID of a Workspace in the Cosmo Tech API
-    :param file_path: Path to the file to upload in the workspace
-    :param workspace_path: The path inside the workspace to upload the file to
-    :param overwrite: Overwrite existing file in the workspace
-    :return: The final name of the file uploaded to the workspace
-    """
-    target_file = pathlib.Path(file_path)
-    if not target_file.exists():
-        LOGGER.error(T("coal.common.file_operations.not_exists").format(file_path=file_path))
-        raise ValueError(T("coal.common.file_operations.not_exists").format(file_path=file_path))
-    if not target_file.is_file():
-        LOGGER.error(T("coal.common.file_operations.not_single_file").format(file_path=file_path))
-        raise ValueError(T("coal.common.file_operations.not_single_file").format(file_path=file_path))
-
-    api_ws = cosmotech_api.api.workspace_api.WorkspaceApi(api_client)
-    destination = workspace_path + target_file.name if workspace_path.endswith("/") else workspace_path
-
-    LOGGER.info(T("coal.cosmotech_api.workspace.sending_to_api").format(destination=destination))
-    try:
-        _file = api_ws.upload_workspace_file(
-            organization_id, workspace_id, file_path, overwrite, destination=destination
-        )
-    except cosmotech_api.exceptions.ApiException as e:
-        LOGGER.error(T("coal.common.file_operations.already_exists").format(csv_path=destination))
-        raise e
-
-    LOGGER.info(T("coal.cosmotech_api.workspace.file_sent").format(file=_file.file_name))
-    return _file.file_name

cosmotech/coal/utils/api.py

@@ -1,68 +0,0 @@
-# Copyright (C) - 2023 - 2025 - Cosmo Tech
-# This document and all information contained herein is the exclusive property -
-# including all intellectual property rights pertaining thereto - of Cosmo Tech.
-# Any use, reproduction, translation, broadcasting, transmission, distribution,
-# etc., to any person is prohibited unless it has been previously and
-# specifically authorized by written means by Cosmo Tech.
-
-import json
-import pathlib
-from typing import Optional
-
-import cosmotech_api
-import yaml
-from cosmotech_api.api.solution_api import Solution
-from cosmotech_api.api.solution_api import SolutionApi
-from cosmotech_api.api.workspace_api import Workspace
-from cosmotech_api.api.workspace_api import WorkspaceApi
-from cosmotech_api.exceptions import ServiceException
-
-from cosmotech.coal.cosmotech_api.connection import get_api_client
-from cosmotech.coal.utils.logger import LOGGER
-from cosmotech.orchestrator.utils.translate import T
-
-
-def read_solution_file(solution_file) -> Optional[Solution]:
-    solution_path = pathlib.Path(solution_file)
-    if solution_path.suffix in [".yaml", ".yml"]:
-        open_function = yaml.safe_load
-    elif solution_path.suffix == ".json":
-        open_function = json.load
-    else:
-        LOGGER.error(T("coal.cosmotech_api.solution.invalid_file").format(file=solution_file))
-        return None
-    with solution_path.open() as _sf:
-        solution_content = open_function(_sf)
-    LOGGER.info(T("coal.cosmotech_api.solution.loaded").format(path=solution_path.absolute()))
-    _solution = Solution(
-        _configuration=cosmotech_api.Configuration(),
-        _spec_property_naming=True,
-        **solution_content,
-    )
-    LOGGER.debug(
-        T("coal.services.api.solution_debug").format(solution=json.dumps(_solution.to_dict(), indent=2, default=str))
-    )
-    return _solution
-
-
-def get_solution(organization_id, workspace_id) -> Optional[Solution]:
-    LOGGER.info(T("coal.cosmotech_api.solution.api_configured"))
-    with get_api_client()[0] as api_client:
-        api_w = WorkspaceApi(api_client)
-
-        LOGGER.info(T("coal.cosmotech_api.solution.loading_workspace"))
-        try:
-            r_data: Workspace = api_w.find_workspace_by_id(organization_id=organization_id, workspace_id=workspace_id)
-        except ServiceException as e:
-            LOGGER.error(
-                T("coal.cosmotech_api.workspace.not_found").format(
-                    workspace_id=workspace_id, organization_id=organization_id
-                )
-            )
-            LOGGER.debug(e)
-            return None
-        solution_id = r_data.solution.solution_id
-
-        api_sol = SolutionApi(api_client)
-        sol: Solution = api_sol.find_solution_by_id(organization_id=organization_id, solution_id=solution_id)
-    return sol

cosmotech/coal/utils/postgresql.py

@@ -1,236 +0,0 @@
-# Copyright (C) - 2023 - 2025 - Cosmo Tech
-# This document and all information contained herein is the exclusive property -
-# including all intellectual property rights pertaining thereto - of Cosmo Tech.
-# Any use, reproduction, translation, broadcasting, transmission, distribution,
-# etc., to any person is prohibited unless it has been previously and
-# specifically authorized by written means by Cosmo Tech.
-
-from typing import Optional
-from urllib.parse import quote
-
-import adbc_driver_manager
-import pyarrow as pa
-from adbc_driver_postgresql import dbapi
-from cosmotech.orchestrator.utils.translate import T
-from pyarrow import Table
-
-from cosmotech.coal.utils.logger import LOGGER
-
-
-def generate_postgresql_full_uri(
-    postgres_host: str,
-    postgres_port: str,
-    postgres_db: str,
-    postgres_user: str,
-    postgres_password: str,
-    force_encode: bool = False,
-) -> str:
-    # Check if password needs percent encoding (contains special characters)
-    # We don't log anything about the password for security
-    encoded_password = postgres_password
-    if force_encode:
-        encoded_password = quote(postgres_password, safe="")
-
-    return (
-        "postgresql://" + f"{postgres_user}"
-        f":{encoded_password}"
-        f"@{postgres_host}"
-        f":{postgres_port}"
-        f"/{postgres_db}"
-    )
-
-
-def get_postgresql_table_schema(
-    target_table_name: str,
-    postgres_host: str,
-    postgres_port: str,
-    postgres_db: str,
-    postgres_schema: str,
-    postgres_user: str,
-    postgres_password: str,
-    force_encode: bool = False,
-) -> Optional[pa.Schema]:
-    """
-    Get the schema of an existing PostgreSQL table using SQL queries.
-
-    Args:
-        target_table_name: Name of the table
-        postgres_host: PostgreSQL host
-        postgres_port: PostgreSQL port
-        postgres_db: PostgreSQL database name
-        postgres_schema: PostgreSQL schema name
-        postgres_user: PostgreSQL username
-        postgres_password: PostgreSQL password
-
-    Returns:
-        PyArrow Schema if table exists, None otherwise
-    """
-    LOGGER.debug(
-        T("coal.services.postgresql.getting_schema").format(
-            postgres_schema=postgres_schema, target_table_name=target_table_name
-        )
-    )
-
-    postgresql_full_uri = generate_postgresql_full_uri(
-        postgres_host,
-        postgres_port,
-        postgres_db,
-        postgres_user,
-        postgres_password,
-        force_encode,
-    )
-
-    with dbapi.connect(postgresql_full_uri) as conn:
-        try:
-            return conn.adbc_get_table_schema(
-                target_table_name,
-                db_schema_filter=postgres_schema,
-            )
-        except adbc_driver_manager.ProgrammingError:
-            LOGGER.warning(
-                T("coal.services.postgresql.table_not_found").format(
-                    postgres_schema=postgres_schema, target_table_name=target_table_name
-                )
-            )
-        return None
-
-
-def adapt_table_to_schema(data: pa.Table, target_schema: pa.Schema) -> pa.Table:
-    """
-    Adapt a PyArrow table to match a target schema with detailed logging.
-    """
-    LOGGER.debug(T("coal.services.postgresql.schema_adaptation_start").format(rows=len(data)))
-    LOGGER.debug(T("coal.services.postgresql.original_schema").format(schema=data.schema))
-    LOGGER.debug(T("coal.services.postgresql.target_schema").format(schema=target_schema))
-
-    target_fields = {field.name: field.type for field in target_schema}
-    new_columns = []
-
-    # Track adaptations for summary
-    added_columns = []
-    dropped_columns = []
-    type_conversions = []
-    failed_conversions = []
-
-    # Process each field in target schema
-    for field_name, target_type in target_fields.items():
-        if field_name in data.column_names:
-            # Column exists - try to cast to target type
-            col = data[field_name]
-            original_type = col.type
-
-            if original_type != target_type:
-                LOGGER.debug(
-                    T("coal.services.postgresql.casting_column").format(
-                        field_name=field_name,
-                        original_type=original_type,
-                        target_type=target_type,
-                    )
-                )
-                try:
-                    new_col = pa.compute.cast(col, target_type)
-                    new_columns.append(new_col)
-                    type_conversions.append(f"{field_name}: {original_type} -> {target_type}")
-                except pa.ArrowInvalid as e:
-                    LOGGER.warning(
-                        T("coal.services.postgresql.cast_failed").format(
-                            field_name=field_name,
-                            original_type=original_type,
-                            target_type=target_type,
-                            error=str(e),
-                        )
-                    )
-                    new_columns.append(pa.nulls(len(data), type=target_type))
-                    failed_conversions.append(f"{field_name}: {original_type} -> {target_type}")
-            else:
-                new_columns.append(col)
-        else:
-            # Column doesn't exist - add nulls
-            LOGGER.debug(T("coal.services.postgresql.adding_missing_column").format(field_name=field_name))
-            new_columns.append(pa.nulls(len(data), type=target_type))
-            added_columns.append(field_name)
-
-    # Log columns that will be dropped
-    dropped_columns = [name for name in data.column_names if name not in target_fields]
-    if dropped_columns:
-        LOGGER.debug(T("coal.services.postgresql.dropping_columns").format(columns=dropped_columns))
-
-    # Create new table
-    adapted_table = pa.Table.from_arrays(new_columns, schema=target_schema)
-
-    # Log summary of adaptations
-    LOGGER.debug(T("coal.services.postgresql.adaptation_summary"))
-    if added_columns:
-        LOGGER.debug(T("coal.services.postgresql.added_columns").format(columns=added_columns))
-    if dropped_columns:
-        LOGGER.debug(T("coal.services.postgresql.dropped_columns").format(columns=dropped_columns))
-    if type_conversions:
-        LOGGER.debug(T("coal.services.postgresql.successful_conversions").format(conversions=type_conversions))
-    if failed_conversions:
-        LOGGER.debug(T("coal.services.postgresql.failed_conversions").format(conversions=failed_conversions))
-
-    LOGGER.debug(T("coal.services.postgresql.final_schema").format(schema=adapted_table.schema))
-    return adapted_table
-
-
-def send_pyarrow_table_to_postgresql(
-    data: Table,
-    target_table_name: str,
-    postgres_host: str,
-    postgres_port: str,
-    postgres_db: str,
-    postgres_schema: str,
-    postgres_user: str,
-    postgres_password: str,
-    replace: bool,
-    force_encode: bool = False,
-) -> int:
-    LOGGER.debug(
-        T("coal.services.postgresql.preparing_send").format(
-            postgres_schema=postgres_schema, target_table_name=target_table_name
-        )
-    )
-    LOGGER.debug(T("coal.services.postgresql.input_rows").format(rows=len(data)))
-
-    # Get existing schema if table exists
-    existing_schema = get_postgresql_table_schema(
-        target_table_name,
-        postgres_host,
-        postgres_port,
-        postgres_db,
-        postgres_schema,
-        postgres_user,
-        postgres_password,
-        force_encode,
-    )
-
-    if existing_schema is not None:
-        LOGGER.debug(T("coal.services.postgresql.found_existing_table").format(schema=existing_schema))
-        if not replace:
-            LOGGER.debug(T("coal.services.postgresql.adapting_data"))
-            data = adapt_table_to_schema(data, existing_schema)
-        else:
-            LOGGER.debug(T("coal.services.postgresql.replace_mode"))
-    else:
-        LOGGER.debug(T("coal.services.postgresql.no_existing_table"))
-
-    # Proceed with ingestion
-    total = 0
-    postgresql_full_uri = generate_postgresql_full_uri(
-        postgres_host,
-        postgres_port,
-        postgres_db,
-        postgres_user,
-        postgres_password,
-        force_encode,
-    )
-
-    LOGGER.debug(T("coal.services.postgresql.connecting"))
-    with dbapi.connect(postgresql_full_uri, autocommit=True) as conn:
-        with conn.cursor() as curs:
-            mode = "replace" if replace else "create_append"
-            LOGGER.debug(T("coal.services.postgresql.ingesting_data").format(mode=mode))
-            total += curs.adbc_ingest(target_table_name, data, mode, db_schema_name=postgres_schema)
-
-    LOGGER.debug(T("coal.services.postgresql.ingestion_success").format(rows=total))
-    return total

cosmotech/csm_data/commands/api/rds_load_csv.py

@@ -1,90 +0,0 @@
-# Copyright (C) - 2023 - 2025 - Cosmo Tech
-# This document and all information contained herein is the exclusive property -
-# including all intellectual property rights pertaining thereto - of Cosmo Tech.
-# Any use, reproduction, translation, broadcasting, transmission, distribution,
-# etc., to any person is prohibited unless it has been previously and
-# specifically authorized by written means by Cosmo Tech.
-
-from cosmotech.csm_data.utils.click import click
-from cosmotech.csm_data.utils.decorators import web_help, translate_help
-from cosmotech.orchestrator.utils.translate import T
-
-
-@click.command()
-@click.option(
-    "--target-folder",
-    envvar="CSM_DATASET_ABSOLUTE_PATH",
-    help=T("csm_data.commands.api.rds_load_csv.parameters.target_folder"),
-    metavar="PATH",
-    type=str,
-    show_envvar=True,
-    required=True,
-)
-@click.option(
-    "--organization-id",
-    envvar="CSM_ORGANIZATION_ID",
-    help=T("csm_data.commands.api.rds_load_csv.parameters.organization_id"),
-    metavar="o-XXXXXXXX",
-    type=str,
-    show_envvar=True,
-    required=True,
-)
-@click.option(
-    "--workspace-id",
-    envvar="CSM_WORKSPACE_ID",
-    help=T("csm_data.commands.api.rds_load_csv.parameters.workspace_id"),
-    metavar="w-XXXXXXXX",
-    type=str,
-    show_envvar=True,
-    required=True,
-)
-@click.option(
-    "--runner-id",
-    envvar="CSM_RUNNER_ID",
-    help=T("csm_data.commands.api.rds_load_csv.parameters.runner_id"),
-    metavar="r-XXXXXXXX",
-    type=str,
-    show_envvar=True,
-    required=True,
-)
-@click.option(
-    "--run-id",
-    envvar="CSM_RUN_ID",
-    help=T("csm_data.commands.api.rds_load_csv.parameters.run_id"),
-    metavar="run-XXXXXX",
-    type=str,
-    show_envvar=True,
-    required=True,
-)
-@click.option(
-    "--file-name",
-    help=T("csm_data.commands.api.rds_load_csv.parameters.file_name"),
-    metavar="NAME",
-    type=str,
-    default="results",
-    show_default=True,
-    required=True,
-)
-@click.option(
-    "--query",
-    help=T("csm_data.commands.api.rds_load_csv.parameters.query"),
-    metavar="SQL_QUERY",
-    type=str,
-    default="SELECT table_name FROM information_schema.tables WHERE table_schema='public'",
-    show_default=True,
-)
-@web_help("csm-data/api/rds-load-csv")
-@translate_help("csm_data.commands.api.rds_load_csv.description")
-def rds_load_csv(target_folder, organization_id, workspace_id, runner_id, run_id, file_name, query):
-    # Import the function at the start of the command
-    from cosmotech.coal.cosmotech_api import load_csv_from_run_data
-
-    load_csv_from_run_data(
-        target_folder=target_folder,
-        organization_id=organization_id,
-        workspace_id=workspace_id,
-        runner_id=runner_id,
-        run_id=run_id,
-        file_name=file_name,
-        query=query,
-    )

cosmotech/csm_data/commands/api/rds_send_csv.py

@@ -1,74 +0,0 @@
-# Copyright (C) - 2023 - 2025 - Cosmo Tech
-# This document and all information contained herein is the exclusive property -
-# including all intellectual property rights pertaining thereto - of Cosmo Tech.
-# Any use, reproduction, translation, broadcasting, transmission, distribution,
-# etc., to any person is prohibited unless it has been previously and
-# specifically authorized by written means by Cosmo Tech.
-
-from cosmotech.csm_data.utils.click import click
-from cosmotech.csm_data.utils.decorators import web_help, translate_help
-from cosmotech.orchestrator.utils.translate import T
-
-
-@click.command()
-@click.option(
-    "--source-folder",
-    envvar="CSM_DATASET_ABSOLUTE_PATH",
-    help=T("csm_data.commands.api.rds_send_csv.parameters.source_folder"),
-    metavar="PATH",
-    type=str,
-    show_envvar=True,
-    required=True,
-)
-@click.option(
-    "--organization-id",
-    envvar="CSM_ORGANIZATION_ID",
-    help=T("csm_data.commands.api.rds_send_csv.parameters.organization_id"),
-    metavar="o-XXXXXXXX",
-    type=str,
-    show_envvar=True,
-    required=True,
-)
-@click.option(
-    "--workspace-id",
-    envvar="CSM_WORKSPACE_ID",
-    help=T("csm_data.commands.api.rds_send_csv.parameters.workspace_id"),
-    metavar="w-XXXXXXXX",
-    type=str,
-    show_envvar=True,
-    required=True,
-)
-@click.option(
-    "--runner-id",
-    envvar="CSM_RUNNER_ID",
-    help=T("csm_data.commands.api.rds_send_csv.parameters.runner_id"),
-    metavar="r-XXXXXXXX",
-    type=str,
-    show_envvar=True,
-    required=True,
-)
-@click.option(
-    "--run-id",
-    envvar="CSM_RUN_ID",
-    help=T("csm_data.commands.api.rds_send_csv.parameters.run_id"),
-    metavar="run-XXXXXX",
-    type=str,
-    show_envvar=True,
-    required=True,
-)
-@web_help("csm-data/api/rds-send-csv")
-@translate_help("csm_data.commands.api.rds_send_csv.description")
-def rds_send_csv(source_folder, organization_id, workspace_id, runner_id, run_id):
-    # Import the function at the start of the command
-    from cosmotech.coal.cosmotech_api import send_csv_to_run_data
-
-    try:
-        send_csv_to_run_data(
-            source_folder=source_folder,
-            organization_id=organization_id,
-            workspace_id=workspace_id,
-            runner_id=runner_id,
-            run_id=run_id,
-        )
-    except FileNotFoundError:
-        return 1

cosmotech/csm_data/commands/api/rds_send_store.py

@@ -1,74 +0,0 @@
-# Copyright (C) - 2023 - 2025 - Cosmo Tech
-# This document and all information contained herein is the exclusive property -
-# including all intellectual property rights pertaining thereto - of Cosmo Tech.
-# Any use, reproduction, translation, broadcasting, transmission, distribution,
-# etc., to any person is prohibited unless it has been previously and
-# specifically authorized by written means by Cosmo Tech.
-
-from cosmotech.csm_data.utils.click import click
-from cosmotech.csm_data.utils.decorators import web_help, translate_help
-from cosmotech.orchestrator.utils.translate import T
-
-
-@click.command()
-@click.option(
-    "--store-folder",
-    envvar="CSM_PARAMETERS_ABSOLUTE_PATH",
-    help=T("csm_data.commands.api.rds_send_store.parameters.store_folder"),
-    metavar="PATH",
-    type=str,
-    show_envvar=True,
-    required=True,
-)
-@click.option(
-    "--organization-id",
-    envvar="CSM_ORGANIZATION_ID",
-    help=T("csm_data.commands.api.rds_send_store.parameters.organization_id"),
-    metavar="o-XXXXXXXX",
-    type=str,
-    show_envvar=True,
-    required=True,
-)
-@click.option(
-    "--workspace-id",
-    envvar="CSM_WORKSPACE_ID",
-    help=T("csm_data.commands.api.rds_send_store.parameters.workspace_id"),
-    metavar="w-XXXXXXXX",
-    type=str,
-    show_envvar=True,
-    required=True,
-)
-@click.option(
-    "--runner-id",
-    envvar="CSM_RUNNER_ID",
-    help=T("csm_data.commands.api.rds_send_store.parameters.runner_id"),
-    metavar="r-XXXXXXXX",
-    type=str,
-    show_envvar=True,
-    required=True,
-)
-@click.option(
-    "--run-id",
-    envvar="CSM_RUN_ID",
-    help=T("csm_data.commands.api.rds_send_store.parameters.run_id"),
-    metavar="run-XXXXXX",
-    type=str,
-    show_envvar=True,
-    required=True,
-)
-@web_help("csm-data/api/rds-send-store")
-@translate_help("csm_data.commands.api.rds_send_store.description")
-def rds_send_store(store_folder, organization_id, workspace_id, runner_id, run_id):
-    # Import the function at the start of the command
-    from cosmotech.coal.cosmotech_api import send_store_to_run_data
-
-    try:
-        send_store_to_run_data(
-            store_folder=store_folder,
-            organization_id=organization_id,
-            workspace_id=workspace_id,
-            runner_id=runner_id,
-            run_id=run_id,
-        )
-    except FileNotFoundError:
-        return 1