cosmotech-acceleration-library 1.0.0__py3-none-any.whl

cosmotech/coal/cosmotech_api/workspace.py

@@ -0,0 +1,127 @@
+# 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/csm/__init__.py

@@ -0,0 +1,6 @@
+# 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.

cosmotech/coal/csm/engine/__init__.py

@@ -0,0 +1,47 @@
+# 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 csv
+import glob
+import json
+import os
+
+
+def apply_simple_csv_parameter_to_simulator(
+    simulator,
+    parameter_name: str,
+    target_attribute_name: str,
+    csv_id_column: str = "id",
+    csv_value_column: str = "value",
+):
+    """
+    Accelerator used to apply CSV parameters directly to a simulator
+    Will raise a ValueError if the parameter does not exist
+    If an entity is not found, will skip the row in the CSV
+    :param simulator: The simulator object to which the parameter will be applied
+    :param parameter_name: The name of the parameter fetched from the API
+    :param target_attribute_name: Target attribute of the entities listed in the CSV
+    :param csv_id_column: Column in the CSV file used for the entity ID
+    :param csv_value_column: Column in the CSV file used for the attribute value to change
+    :return: None
+    """
+    parameter_path = os.path.join(os.environ.get("CSM_PARAMETERS_ABSOLUTE_PATH"), parameter_name)
+    if os.path.exists(parameter_path):
+        csv_files = glob.glob(os.path.join(parameter_path, "*.csv"))
+        for csv_filename in csv_files:
+            model = simulator.GetModel()
+            with open(csv_filename, "r") as csv_file:
+                for row in csv.DictReader(csv_file):
+                    entity_name = row.get(csv_id_column)
+                    value = json.loads(row.get(csv_value_column))
+                    entity = model.FindEntityByName(entity_name)
+                    if entity:
+                        entity.SetAttributeAsString(target_attribute_name, json.dumps(value))
+    else:
+        raise ValueError(f"Parameter {parameter_name} does not exists.")
+
+
+__all__ = ["apply_simple_csv_parameter_to_simulator"]

cosmotech/coal/postgresql/__init__.py

@@ -0,0 +1,22 @@
+# 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.
+
+"""
+PostgreSQL integration module.
+
+This module provides functions for interacting with PostgreSQL databases.
+"""
+
+# Re-export functions from the runner module
+from cosmotech.coal.postgresql.runner import (
+    send_runner_metadata_to_postgresql,
+)
+
+# Re-export functions from the store module
+from cosmotech.coal.postgresql.store import (
+    dump_store_to_postgresql,
+)

cosmotech/coal/postgresql/runner.py

@@ -0,0 +1,93 @@
+# 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.
+
+"""
+PostgreSQL runner operations module.
+
+This module provides functions for interacting with PostgreSQL databases
+for runner metadata operations.
+"""
+
+from adbc_driver_postgresql import dbapi
+
+from cosmotech.coal.cosmotech_api.connection import get_api_client
+from cosmotech.coal.cosmotech_api.runner.metadata import get_runner_metadata
+from cosmotech.coal.utils.logger import LOGGER
+from cosmotech.coal.utils.postgresql import generate_postgresql_full_uri
+from cosmotech.orchestrator.utils.translate import T
+
+
+def send_runner_metadata_to_postgresql(
+    organization_id: str,
+    workspace_id: str,
+    runner_id: str,
+    postgres_host: str,
+    postgres_port: int,
+    postgres_db: str,
+    postgres_schema: str,
+    postgres_user: str,
+    postgres_password: str,
+    table_prefix: str = "Cosmotech_",
+) -> None:
+    """
+    Send runner metadata to a PostgreSQL database.
+
+    Args:
+        organization_id: Organization ID
+        workspace_id: Workspace ID
+        runner_id: Runner ID
+        postgres_host: PostgreSQL host
+        postgres_port: PostgreSQL port
+        postgres_db: PostgreSQL database name
+        postgres_schema: PostgreSQL schema
+        postgres_user: PostgreSQL username
+        postgres_password: PostgreSQL password
+        table_prefix: Table prefix
+    """
+    # Get runner metadata
+    with get_api_client()[0] as api_client:
+        runner = get_runner_metadata(api_client, organization_id, workspace_id, runner_id)
+
+    # Generate PostgreSQL URI
+    postgresql_full_uri = generate_postgresql_full_uri(
+        postgres_host, str(postgres_port), postgres_db, postgres_user, postgres_password
+    )
+
+    # Connect to PostgreSQL and update runner metadata
+    with dbapi.connect(postgresql_full_uri, autocommit=True) as conn:
+        with conn.cursor() as curs:
+            schema_table = f"{postgres_schema}.{table_prefix}RunnerMetadata"
+            sql_create_table = f"""
+                CREATE TABLE IF NOT EXISTS {schema_table}  (
+                  id varchar(32) PRIMARY KEY,
+                  name varchar(256),
+                  last_run_id varchar(32),
+                  run_template_id varchar(32)
+                );
+            """
+            sql_upsert = f"""
+                INSERT INTO {schema_table} (id, name, last_run_id, run_template_id)
+                  VALUES(%s, %s, %s, %s)
+                  ON CONFLICT (id)
+                  DO
+                    UPDATE SET name = EXCLUDED.name, last_run_id = EXCLUDED.last_run_id;
+            """
+            LOGGER.info(T("coal.services.postgresql.creating_table").format(schema_table=schema_table))
+            curs.execute(sql_create_table)
+            conn.commit()
+            LOGGER.info(T("coal.services.postgresql.metadata"))
+            curs.execute(
+                sql_upsert,
+                (
+                    runner.get("id"),
+                    runner.get("name"),
+                    runner.get("lastRunId"),
+                    runner.get("runTemplateId"),
+                ),
+            )
+            conn.commit()
+            LOGGER.info(T("coal.services.postgresql.metadata_updated"))

cosmotech/coal/postgresql/store.py

@@ -0,0 +1,98 @@
+# 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.
+
+"""
+PostgreSQL store operations module.
+
+This module provides functions for interacting with PostgreSQL databases
+for store operations.
+"""
+
+from time import perf_counter
+import pyarrow
+
+from cosmotech.coal.store.store import Store
+from cosmotech.coal.utils.logger import LOGGER
+from cosmotech.coal.utils.postgresql import send_pyarrow_table_to_postgresql
+from cosmotech.orchestrator.utils.translate import T
+
+
+def dump_store_to_postgresql(
+    store_folder: str,
+    postgres_host: str,
+    postgres_port: int,
+    postgres_db: str,
+    postgres_schema: str,
+    postgres_user: str,
+    postgres_password: str,
+    table_prefix: str = "Cosmotech_",
+    replace: bool = True,
+) -> None:
+    """
+    Dump Store data to a PostgreSQL database.
+
+    Args:
+        store_folder: Folder containing the Store
+        postgres_host: PostgreSQL host
+        postgres_port: PostgreSQL port
+        postgres_db: PostgreSQL database name
+        postgres_schema: PostgreSQL schema
+        postgres_user: PostgreSQL username
+        postgres_password: PostgreSQL password
+        table_prefix: Table prefix
+        replace: Whether to replace existing tables
+    """
+    _s = Store(store_location=store_folder)
+
+    tables = list(_s.list_tables())
+    if len(tables):
+        LOGGER.info(T("coal.services.database.sending_data").format(table=f"{postgres_db}.{postgres_schema}"))
+        total_rows = 0
+        _process_start = perf_counter()
+        for table_name in tables:
+            _s_time = perf_counter()
+            target_table_name = f"{table_prefix}{table_name}"
+            LOGGER.info(T("coal.services.database.table_entry").format(table=target_table_name))
+            data = _s.get_table(table_name)
+            if not len(data):
+                LOGGER.info(T("coal.services.database.no_rows"))
+                continue
+            _dl_time = perf_counter()
+            rows = send_pyarrow_table_to_postgresql(
+                data,
+                target_table_name,
+                postgres_host,
+                postgres_port,
+                postgres_db,
+                postgres_schema,
+                postgres_user,
+                postgres_password,
+                replace,
+            )
+            total_rows += rows
+            _up_time = perf_counter()
+            LOGGER.info(T("coal.services.database.row_count").format(count=rows))
+            LOGGER.debug(
+                T("coal.common.timing.operation_completed").format(
+                    operation="Load from datastore", time=f"{_dl_time - _s_time:0.3}"
+                )
+            )
+            LOGGER.debug(
+                T("coal.common.timing.operation_completed").format(
+                    operation="Send to postgresql", time=f"{_up_time - _dl_time:0.3}"
+                )
+            )
+        _process_end = perf_counter()
+        LOGGER.info(
+            T("coal.services.database.rows_fetched").format(
+                table="all tables",
+                count=total_rows,
+                time=f"{_process_end - _process_start:0.3}",
+            )
+        )
+    else:
+        LOGGER.info(T("coal.services.database.store_empty"))

cosmotech/coal/singlestore/__init__.py

@@ -0,0 +1,17 @@
+# 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.
+
+"""
+SingleStore integration module.
+
+This module provides functions for interacting with SingleStore databases.
+"""
+
+# Re-export functions from the store module
+from cosmotech.coal.singlestore.store import (
+    load_from_singlestore,
+)

cosmotech/coal/singlestore/store.py

@@ -0,0 +1,100 @@
+# 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.
+
+"""
+SingleStore store operations module.
+
+This module provides functions for interacting with SingleStore databases
+for store operations.
+"""
+
+import pathlib
+import time
+import csv
+import singlestoredb as s2
+
+from cosmotech.coal.store.csv import store_csv_file
+from cosmotech.coal.store.store import Store
+from cosmotech.coal.utils.logger import LOGGER
+from cosmotech.orchestrator.utils.translate import T
+
+
+def _get_data(table_name: str, output_directory: str, cursor) -> None:
+    """
+    Run a SQL query to fetch all data from a table and write them in csv files.
+
+    Args:
+        table_name: Table name
+        output_directory: Output directory
+        cursor: SingleStore cursor
+    """
+    start_time = time.perf_counter()
+    cursor.execute(f"SELECT * FROM {table_name}")
+    rows = cursor.fetchall()
+    end_time = time.perf_counter()
+    LOGGER.info(
+        T("coal.services.database.rows_fetched").format(
+            table=table_name, count=len(rows), time=round(end_time - start_time, 2)
+        )
+    )
+    with open(f"{output_directory}/{table_name}.csv", "w", newline="") as csv_stock:
+        w = csv.DictWriter(csv_stock, rows[0].keys())
+        w.writeheader()
+        w.writerows(rows)
+
+
+def load_from_singlestore(
+    single_store_host: str,
+    single_store_port: int,
+    single_store_db: str,
+    single_store_user: str,
+    single_store_password: str,
+    store_folder: str,
+    single_store_tables: str = "",
+) -> None:
+    """
+    Load data from SingleStore and store it in the Store.
+
+    Args:
+        single_store_host: SingleStore host
+        single_store_port: SingleStore port
+        single_store_db: SingleStore database name
+        single_store_user: SingleStore username
+        single_store_password: SingleStore password
+        store_folder: Store folder
+        single_store_tables: Comma-separated list of tables to load
+    """
+    single_store_working_dir = store_folder + "/singlestore"
+    if not pathlib.Path.exists(single_store_working_dir):
+        pathlib.Path.mkdir(single_store_working_dir)
+
+    start_full = time.perf_counter()
+
+    conn = s2.connect(
+        host=single_store_host,
+        port=single_store_port,
+        database=single_store_db,
+        user=single_store_user,
+        password=single_store_password,
+        results_type="dicts",
+    )
+    with conn:
+        with conn.cursor() as cur:
+            if single_store_tables == "":
+                cur.execute("SHOW TABLES")
+                table_names = cur.fetchall()
+            else:
+                table_names = single_store_tables.split(",")
+            LOGGER.info(T("coal.services.database.tables_to_fetch").format(tables=table_names))
+            for name in table_names:
+                _get_data(name, single_store_working_dir, cur)
+    end_full = time.perf_counter()
+    LOGGER.info(T("coal.services.database.full_dataset").format(time=round(end_full - start_full, 2)))
+
+    for csv_path in pathlib.Path(single_store_working_dir).glob("*.csv"):
+        LOGGER.info(T("coal.services.azure_storage.found_file").format(file=csv_path.name))
+        store_csv_file(csv_path.name[:-4], csv_path, store=Store(False, store_folder))

cosmotech/coal/store/__init__.py

@@ -0,0 +1,42 @@
+# 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.
+
+"""
+Store module.
+
+This module provides functions for working with the Store,
+including loading and converting data.
+"""
+
+# Re-export the Store class
+from cosmotech.coal.store.store import Store
+
+# Re-export functions from the csv module
+from cosmotech.coal.store.csv import (
+    store_csv_file,
+    convert_store_table_to_csv,
+)
+
+# Re-export functions from the native_python module
+from cosmotech.coal.store.native_python import (
+    store_pylist,
+    convert_table_as_pylist,
+)
+
+# Re-export functions from the pandas module (if available)
+
+from cosmotech.coal.store.pandas import (
+    store_dataframe,
+    convert_store_table_to_dataframe as convert_store_table_to_pandas_dataframe,
+)
+
+# Re-export functions from the pyarrow module (if available)
+
+from cosmotech.coal.store.pyarrow import (
+    store_table,
+    convert_store_table_to_dataframe as convert_store_table_to_pyarrow_table,
+)

cosmotech/coal/store/csv.py

@@ -0,0 +1,44 @@
+# 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 pyarrow.csv as pc
+
+from cosmotech.coal.store.store import Store
+
+
+def store_csv_file(
+    table_name: str,
+    csv_path: pathlib.Path,
+    replace_existsing_file: bool = False,
+    store=Store(),
+):
+    if not csv_path.exists():
+        raise FileNotFoundError(f"File {csv_path} does not exists")
+
+    data = pc.read_csv(csv_path)
+    _c = data.column_names
+    data = data.rename_columns([Store.sanitize_column(_column) for _column in _c])
+
+    store.add_table(table_name=table_name, data=data, replace=replace_existsing_file)
+
+
+def convert_store_table_to_csv(
+    table_name: str,
+    csv_path: pathlib.Path,
+    replace_existsing_file: bool = False,
+    store=Store(),
+):
+    if csv_path.name.endswith(".csv") and csv_path.exists() and not replace_existsing_file:
+        raise FileExistsError(f"File {csv_path} already exists")
+    if not csv_path.name.endswith(".csv"):
+        csv_path = csv_path / f"{table_name}.csv"
+    folder = csv_path.parent
+    folder.mkdir(parents=True, exist_ok=True)
+
+    pc.write_csv(store.get_table(table_name), csv_path)

cosmotech/coal/store/native_python.py

@@ -0,0 +1,25 @@
+# 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 pyarrow as pa
+
+from cosmotech.coal.store.store import Store
+
+
+def store_pylist(
+    table_name: str,
+    data: list[dict],
+    replace_existsing_file: bool = False,
+    store=Store(),
+):
+    data = pa.Table.from_pylist(data)
+
+    store.add_table(table_name=table_name, data=data, replace=replace_existsing_file)
+
+
+def convert_table_as_pylist(table_name: str, store=Store()):
+    return store.get_table(table_name).to_pylist()

cosmotech/coal/store/pandas.py

@@ -0,0 +1,26 @@
+# 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 pyarrow
+
+from cosmotech.coal.store.store import Store
+import pandas as pd
+
+
+def store_dataframe(
+    table_name: str,
+    dataframe: pd.DataFrame,
+    replace_existsing_file: bool = False,
+    store=Store(),
+):
+    data = pyarrow.Table.from_pandas(dataframe)
+
+    store.add_table(table_name=table_name, data=data, replace=replace_existsing_file)
+
+
+def convert_store_table_to_dataframe(table_name: str, store=Store()) -> pd.DataFrame:
+    return store.get_table(table_name).to_pandas()

cosmotech/coal/store/pyarrow.py

@@ -0,0 +1,23 @@
+# 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.coal.store.store import Store
+
+import pyarrow as pa
+
+
+def store_table(
+    table_name: str,
+    data: pa.Table,
+    replace_existsing_file: bool = False,
+    store=Store(),
+):
+    store.add_table(table_name=table_name, data=data, replace=replace_existsing_file)
+
+
+def convert_store_table_to_dataframe(table_name: str, store=Store()) -> pa.Table:
+    return store.get_table(table_name)