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

cosmotech/coal/store/store.py

@@ -0,0 +1,79 @@
+# 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 os
+import pathlib
+
+import pyarrow
+from adbc_driver_sqlite import dbapi
+
+from cosmotech.coal.utils.logger import LOGGER
+from cosmotech.orchestrator.utils.translate import T
+
+
+class Store:
+    @staticmethod
+    def sanitize_column(column_name: str) -> str:
+        return column_name.replace(" ", "_")
+
+    def __init__(
+        self,
+        reset=False,
+        store_location: pathlib.Path = pathlib.Path(os.environ.get("CSM_PARAMETERS_ABSOLUTE_PATH", ".")),
+    ):
+        self.store_location = pathlib.Path(store_location) / ".coal/store"
+        self.store_location.mkdir(parents=True, exist_ok=True)
+        self._tables = dict()
+        self._database_path = self.store_location / "db.sqlite"
+        if reset:
+            self.reset()
+        self._database = str(self._database_path)
+
+    def reset(self):
+        if self._database_path.exists():
+            self._database_path.unlink()
+
+    def get_table(self, table_name: str) -> pyarrow.Table:
+        if not self.table_exists(table_name):
+            raise ValueError(T("coal.errors.data.no_table").format(table_name=table_name))
+        return self.execute_query(f"select * from {table_name}")
+
+    def table_exists(self, table_name) -> bool:
+        return table_name in self.list_tables()
+
+    def get_table_schema(self, table_name: str) -> pyarrow.Schema:
+        if not self.table_exists(table_name):
+            raise ValueError(T("coal.errors.data.no_table").format(table_name=table_name))
+        with dbapi.connect(self._database) as conn:
+            return conn.adbc_get_table_schema(table_name)
+
+    def add_table(self, table_name: str, data=pyarrow.Table, replace: bool = False):
+        with dbapi.connect(self._database, autocommit=True) as conn:
+            with conn.cursor() as curs:
+                rows = curs.adbc_ingest(table_name, data, "replace" if replace else "create_append")
+                LOGGER.debug(T("coal.common.data_transfer.rows_inserted").format(rows=rows, table_name=table_name))
+
+    def execute_query(self, sql_query: str) -> pyarrow.Table:
+        batch_size = 1024
+        batch_size_increment = 1024
+        while True:
+            try:
+                with dbapi.connect(self._database, autocommit=True) as conn:
+                    with conn.cursor() as curs:
+                        curs.adbc_statement.set_options(**{"adbc.sqlite.query.batch_rows": str(batch_size)})
+                        curs.execute(sql_query)
+                        return curs.fetch_arrow_table()
+            except OSError:
+                batch_size += batch_size_increment
+
+    def list_tables(self) -> list[str]:
+        with dbapi.connect(self._database) as conn:
+            objects = conn.adbc_get_objects(depth="all").read_all()
+            tables = objects["catalog_db_schemas"][0][0]["db_schema_tables"]
+        for table in tables:
+            table_name: pyarrow.StringScalar = table["table_name"]
+            yield table_name.as_py()

cosmotech/coal/utils/__init__.py

@@ -0,0 +1,18 @@
+# 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 import __version__
+
+WEB_DOCUMENTATION_ROOT = f"https://cosmo-tech.github.io/CosmoTech-Acceleration-Library/{__version__}/"
+
+
+def strtobool(string: str) -> bool:
+    if string.lower() in ["y", "yes", "t", "true", "on", "1"]:
+        return True
+    if string.lower() in ["n", "no", "f", "false", "off", "0"]:
+        return False
+    raise ValueError(f'"{string} is not a recognized truth value')

cosmotech/coal/utils/api.py

@@ -0,0 +1,68 @@
+# 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/logger.py

@@ -0,0 +1,10 @@
+# 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.orchestrator.utils.logger import get_logger
+
+LOGGER = get_logger("csm.data")

cosmotech/coal/utils/postgresql.py

@@ -0,0 +1,236 @@
+# 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/__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/csm_data/commands/__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/csm_data/commands/adx_send_data.py

@@ -0,0 +1,92 @@
+# 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.orchestrator.utils.translate import T
+
+from cosmotech.csm_data.utils.click import click
+from cosmotech.csm_data.utils.decorators import web_help, translate_help
+
+
+@click.command()
+@web_help("csm-data/adx-send-data")
+@translate_help("csm-data.commands.storage.adx_send_data.description")
+@click.option(
+    "--adx-uri",
+    envvar="AZURE_DATA_EXPLORER_RESOURCE_URI",
+    show_envvar=True,
+    required=True,
+    metavar="URI",
+    help=T("csm-data.commands.storage.adx_send_data.parameters.adx_uri"),
+)
+@click.option(
+    "--adx-ingest-uri",
+    envvar="AZURE_DATA_EXPLORER_RESOURCE_INGEST_URI",
+    show_envvar=True,
+    required=True,
+    metavar="URI",
+    help=T("csm-data.commands.storage.adx_send_data.parameters.adx_ingest_uri"),
+)
+@click.option(
+    "--database-name",
+    envvar="AZURE_DATA_EXPLORER_DATABASE_NAME",
+    show_envvar=True,
+    required=True,
+    metavar="NAME",
+    help=T("csm-data.commands.storage.adx_send_data.parameters.database_name"),
+)
+@click.option(
+    "--wait/--no-wait",
+    "wait",
+    envvar="CSM_DATA_ADX_WAIT_INGESTION",
+    show_envvar=True,
+    default=False,
+    show_default=True,
+    help=T("csm-data.commands.storage.adx_send_data.parameters.waiting_ingestion"),
+)
+@click.option(
+    "--tag",
+    envvar="CSM_DATA_ADX_TAG",
+    show_envvar=True,
+    default=None,
+    help=T("csm-data.commands.storage.adx_send_data.parameters.adx_tag"),
+)
+@click.option(
+    "--store-folder",
+    envvar="CSM_PARAMETERS_ABSOLUTE_PATH",
+    help=T("csm-data.commands.storage.adx_send_data.parameters.store_folder"),
+    metavar="PATH",
+    type=str,
+    show_envvar=True,
+    required=True,
+)
+def adx_send_data(
+    adx_uri: str,
+    adx_ingest_uri: str,
+    database_name: str,
+    wait: bool,
+    store_folder: str,
+    tag: str = None,
+):
+    """
+    Send data from the store to Azure Data Explorer.
+    """
+    from cosmotech.coal.azure.adx.store import send_store_to_adx
+
+    success = send_store_to_adx(
+        adx_uri=adx_uri,
+        adx_ingest_uri=adx_ingest_uri,
+        database_name=database_name,
+        wait=wait,
+        tag=tag,
+        store_location=store_folder,
+    )
+
+    if not success:
+        click.Abort()
+
+
+if __name__ == "__main__":
+    adx_send_data()

cosmotech/csm_data/commands/adx_send_runnerdata.py

@@ -0,0 +1,119 @@
+# 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()
+@web_help("csm-data/adx-send-runner-data")
+@translate_help("csm-data.commands.storage.adx_send_runnerdata.description")
+@click.option(
+    "--dataset-absolute-path",
+    envvar="CSM_DATASET_ABSOLUTE_PATH",
+    show_envvar=True,
+    help=T("csm-data.commands.storage.adx_send_runnerdata.parameters.dataset_absolute_path"),
+    metavar="PATH",
+    required=True,
+)
+@click.option(
+    "--parameters-absolute-path",
+    envvar="CSM_PARAMETERS_ABSOLUTE_PATH",
+    metavar="PATH",
+    show_envvar=True,
+    help=T("csm-data.commands.storage.adx_send_runnerdata.parameters.parameters_absolute_path"),
+    required=True,
+)
+@click.option(
+    "--runner-id",
+    envvar="CSM_RUNNER_ID",
+    show_envvar=True,
+    required=True,
+    metavar="UUID",
+    help=T("csm-data.commands.storage.adx_send_runnerdata.parameters.runner_id"),
+)
+@click.option(
+    "--adx-uri",
+    envvar="AZURE_DATA_EXPLORER_RESOURCE_URI",
+    show_envvar=True,
+    required=True,
+    metavar="URI",
+    help=T("csm-data.commands.storage.adx_send_runnerdata.parameters.adx_uri"),
+)
+@click.option(
+    "--adx-ingest-uri",
+    envvar="AZURE_DATA_EXPLORER_RESOURCE_INGEST_URI",
+    show_envvar=True,
+    required=True,
+    metavar="URI",
+    help=T("csm-data.commands.storage.adx_send_runnerdata.parameters.adx_ingest_uri"),
+)
+@click.option(
+    "--database-name",
+    envvar="AZURE_DATA_EXPLORER_DATABASE_NAME",
+    show_envvar=True,
+    required=True,
+    metavar="NAME",
+    help=T("csm-data.commands.storage.adx_send_runnerdata.parameters.database_name"),
+)
+@click.option(
+    "--send-parameters/--no-send-parameters",
+    type=bool,
+    envvar="CSM_SEND_DATAWAREHOUSE_PARAMETERS",
+    show_envvar=True,
+    default=False,
+    show_default=True,
+    help=T("csm-data.commands.storage.adx_send_runnerdata.parameters.send_parameters"),
+)
+@click.option(
+    "--send-datasets/--no-send-datasets",
+    type=bool,
+    envvar="CSM_SEND_DATAWAREHOUSE_DATASETS",
+    show_envvar=True,
+    default=False,
+    show_default=True,
+    help=T("csm-data.commands.storage.adx_send_runnerdata.parameters.send_datasets"),
+)
+@click.option(
+    "--wait/--no-wait",
+    envvar="WAIT_FOR_INGESTION",
+    show_envvar=True,
+    default=False,
+    show_default=True,
+    help=T("csm-data.commands.storage.adx_send_runnerdata.parameters.wait"),
+)
+def adx_send_runnerdata(
+    send_parameters: bool,
+    send_datasets: bool,
+    dataset_absolute_path: str,
+    parameters_absolute_path: str,
+    runner_id: str,
+    adx_uri: str,
+    adx_ingest_uri: str,
+    database_name: str,
+    wait: bool,
+):
+    # Import the function at the start of the command
+    from cosmotech.coal.azure.adx.runner import send_runner_data
+
+    # Send runner data to ADX
+    send_runner_data(
+        dataset_absolute_path=dataset_absolute_path,
+        parameters_absolute_path=parameters_absolute_path,
+        runner_id=runner_id,
+        adx_uri=adx_uri,
+        adx_ingest_uri=adx_ingest_uri,
+        database_name=database_name,
+        send_parameters=send_parameters,
+        send_datasets=send_datasets,
+        wait=wait,
+    )
+
+
+if __name__ == "__main__":
+    adx_send_runnerdata()

cosmotech/csm_data/commands/api/__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.