bb-integrations-library 3.0.11__py3-none-any.whl

bb_integrations_lib/pipelines/steps/processing/mark_orders_exported_in_bbd_step.py

@@ -0,0 +1,185 @@
+from datetime import datetime, UTC
+from enum import StrEnum
+from time import monotonic
+from typing import Any
+
+import tenacity
+from loguru import logger
+from pymongo import UpdateOne
+from tenacity import retry, wait_exponential
+
+from bb_integrations_lib.gravitate.sd_api import GravitateSDAPI
+from bb_integrations_lib.models.pipeline_structs import BolExportResults
+from bb_integrations_lib.models.sd.orders import BackofficeERP, ERPStatus
+from bb_integrations_lib.protocols.pipelines import Step
+from bb_integrations_lib.util.utils import init_db
+
+
+class TooManyRequests(Exception):
+    pass
+
+
+class MarkOrdersExportedMethod(StrEnum):
+    API = "api"
+    BACKHAUL_API = "backhaul_api"
+    DB = "db"
+
+
+class MarkOrdersExportedInBBDStep(Step):
+    """
+    This step marks BolExportResult orders as exported in the order movements page.
+
+    It supports 2 different marking methods:
+      1. API method: Uses the S&D API, and runs an __always_succeed backoffice_erp function on every order. This is the
+         default, and very slow.
+      2. DB method: Directly modifies the S&D DB. Much faster, but subject to S&D schema changes.
+
+    Note that ``BolExportResults.errors`` must be a dict in the form ``{"order_number": int, "error": str}``.
+
+    **Limitations**:
+    If using the API method, the __always_succeed function must be set in the target S&D tenant. Error messages cannot
+    be set and will get discarded.
+    """
+
+    def __init__(self, order_number_key: str, export_method: MarkOrdersExportedMethod = MarkOrdersExportedMethod.API,
+                 export_function_name: str | None = None, sd_client: GravitateSDAPI | None = None,
+                 mongodb_conn_str: str | None = None, mongodb_db_name: str | None = None, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.export_method = export_method
+        self.function_name = export_function_name
+        self.order_number_key = order_number_key
+
+        self.sd_client = sd_client
+        self.mongodb_conn_str = mongodb_conn_str
+        self.mongodb_db_name = mongodb_db_name
+
+        match self.export_method:
+            case MarkOrdersExportedMethod.API | MarkOrdersExportedMethod.BACKHAUL_API:
+                logger.debug(f"Marking orders exported using {self.export_method} method")
+            case MarkOrdersExportedMethod.DB:
+                logger.debug("Marking orders exported using direct DB access method")
+
+    def describe(self) -> str:
+        return "Mark orders as exported in the order movements page"
+
+    async def execute(self, i: BolExportResults) -> BolExportResults:
+        unique_orders = list(set([int(order[self.order_number_key]) for order in i.orders]))
+        match self.export_method:
+            case MarkOrdersExportedMethod.API | MarkOrdersExportedMethod.BACKHAUL_API:
+                await self._mark_all_exported_api(unique_orders)
+            case MarkOrdersExportedMethod.DB:
+                await self._mark_exported_db(unique_orders, i.errors)
+
+        return i
+
+    async def _mark_all_exported_api(self, unique_orders: list[int]):
+        start_time = monotonic()
+        n_orders = len(unique_orders)
+        for index, number in enumerate(unique_orders):
+            try:
+                if self.export_method == MarkOrdersExportedMethod.API:
+                    await self._mark_exported_api(number)
+                else:
+                    await self._mark_exported_backhaul_api(number)
+                elapsed_time = monotonic() - start_time
+                logger.info(
+                    f"Marked order {number} done ({index + 1} of {n_orders}, {(index + 1) / n_orders:.0%}). "
+                    f"Total elapsed: {int(elapsed_time)}s")
+            except Exception as e:
+                logger.warning(f"Unable to mark order as exported. {e}")
+
+        logger.info(f"Finished processing {n_orders} orders in {int(monotonic() - start_time)}s")
+
+    @retry(
+        retry=tenacity.retry_if_exception_type(TooManyRequests),
+        wait=wait_exponential(multiplier=1, min=5, max=30),
+        stop=tenacity.stop_after_delay(60),
+    )
+    async def _mark_exported_api(self, number: int):
+        """
+        Use the S&D API to mark a single order as exported with an __always_succeed function.
+        Less reliable and much slower than the DB method, and requires the __always_succeed function to be set in the
+        target S&D tenant.
+        """
+        resp = await self.sd_client.export_single_order(number, self.function_name)
+        logger.debug(f"Order {number} response status code: {resp.status_code}")
+        if resp.status_code == 429:
+            raise TooManyRequests()
+        resp.raise_for_status()
+        resp_json = resp.json()
+        if len(resp_json) == 0:
+            raise Exception(resp_json)
+
+    @retry(
+        retry=tenacity.retry_if_exception_type(TooManyRequests),
+        wait=wait_exponential(multiplier=1, min=5, max=30),
+        stop=tenacity.stop_after_delay(60),
+    )
+    async def _mark_exported_backhaul_api(self, number: int):
+        """Use the S&D API to mark a single backhaul order as exported."""
+        resp = await self.sd_client.mark_backhaul_exported(number)
+        logger.debug(f"Order {number} response status code: {resp.status_code}")
+        if resp.status_code == 429:
+            raise TooManyRequests()
+        resp.raise_for_status()
+        resp_json = resp.json()
+        if len(resp_json) == 0:
+            raise Exception(resp_json)
+
+    async def _mark_exported_db(self, unique_orders: list[int], errors: list[dict[str, Any]]):
+        """
+        Mark multiple orders as exported by manually twiddling the S&D DB. This avoids the reliability and
+        performance issues of the API approach, and supports setting error text to be shown in the UI, but is at the
+        mercy of the DB schema changing underneath us.
+
+        :param unique_orders: List of order numbers to mark as exported / "sent"
+        :param errors: List of errors to mark as failed, each in the format ``{"order_number": int, "error": str}``
+        """
+        sent_erp_obj = BackofficeERP(status=ERPStatus.sent, time_sent=datetime.now(UTC), errors=[]).model_dump()
+        with init_db(self.mongodb_conn_str, self.mongodb_db_name) as db:
+            # Mark successful exports
+            if len(unique_orders) > 0:
+                mark_sent_result = db["order_v2"].update_many(filter={"number": {"$in": unique_orders}},
+                                           update={"$set": {"backoffice_erp": sent_erp_obj}})
+                logger.info(f"Marked {mark_sent_result.modified_count} orders as exported")
+            else:
+                logger.info("No successfully exported orders to mark")
+
+            # Mark failed exports with error messages
+            update_list = [UpdateOne(
+                    filter={"number": error["order_number"]},
+                    update={"$set": {
+                        "backoffice_erp": self._error_to_backoffice_erp_obj(error["error"]).model_dump()
+                    }})
+                for error in errors
+            ]
+            if len(update_list) > 0:
+                mark_failed_result = db["order_v2"].bulk_write(update_list)
+                logger.info(f"Marked {mark_failed_result.modified_count} orders as failed to export")
+            else:
+                logger.info("No export failures to mark")
+
+    @staticmethod
+    def _error_to_backoffice_erp_obj(error_message: str):
+        return BackofficeERP(status=ERPStatus.errors, time_sent=datetime.now(UTC), errors=[error_message])
+
+
+if __name__ == "__main__":
+    import asyncio
+
+    async def main():
+        order_nums = [10000]
+        orders = [{"OrderNumber":x} for x in order_nums]
+
+        s = MarkOrdersExportedInBBDStep(
+            order_number_key="OrderNumber",
+            export_function_name="__always_succeed",
+            export_method=MarkOrdersExportedMethod.API,
+            sd_client=GravitateSDAPI(
+                username="",
+                password="",
+                base_url="",
+            ))
+        await s.execute(BolExportResults(orders=orders, errors=[], file_name="oneoff", order_number_key="OrderNumber"))
+
+    asyncio.run(main())

bb_integrations_lib/pipelines/steps/processing/pe_price_rows_processing_step.py

@@ -0,0 +1,174 @@
+import copy
+from typing import Dict, List, Tuple
+
+from loguru import logger
+
+from bb_integrations_lib.mappers.prices.model import Groups, \
+    PricingIntegrationConfig
+from bb_integrations_lib.mappers.prices.price_mapper import PriceMapper
+from bb_integrations_lib.protocols.pipelines import Step
+from bb_integrations_lib.shared.exceptions import MappingNotFoundException
+from bb_integrations_lib.shared.model import PEPriceData, SupplyPriceUpdateManyRequest
+
+
+class PEParsePricesStep(Step):
+    def __init__(self, config: PricingIntegrationConfig, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+        self.config = config
+        self.pm = PriceMapper(
+            ttl=self.config.price_mapper_ttl,
+            debug_mode=self.config.price_mapper_debug_mode,
+            config=self.config
+        )
+
+    async def execute(self, rows: List[PEPriceData]) -> Tuple[
+        List[SupplyPriceUpdateManyRequest], Dict]:
+        return await self.process_rows(rows)
+
+    def get_price_request(self, rows: List[PEPriceData]) -> List[SupplyPriceUpdateManyRequest]:
+
+        res: List = []
+        for row in rows:
+            price = row.CurvePointPrices[0].Value
+            res.append(
+                SupplyPriceUpdateManyRequest
+                    (
+                    source_id=self.config.source_system_id,
+                    source_system_id=self.config.source_system,
+                    terminal_source_id=row.LocationSourceId if self.config.use_source_system_id else row.LocationSourceIdString,
+                    terminal_source_system_id=row.LocationSourceId,
+                    effective_from=row.EffectiveFromDateTime,
+                    effective_to=row.EffectiveToDateTime,
+                    expire=row.ExpirationDateTime,
+                    price=price,
+                    price_type="contract",
+                    product_source_id=row.ProductSourceId if self.config.use_source_system_id else row.ProductSourceIdString,
+                    product_source_system_id=row.ProductSourceId,
+                    supplier_source_id=row.SupplierSourceId if self.config.use_source_system_id else row.SupplierSourceIdString,
+                    supplier_source_system_id=row.SupplierSourceId,
+                    timezone="America/Chicago",
+                    curve_id=row.CurveId,
+                    contract=row.SourceContractId
+                )
+            )
+        return res
+
+    def get_factor(self, **kwargs):
+        result = 1
+        for value in kwargs.values():
+            result *= value
+        return result
+
+    async def process_rows(self, rows: List[PEPriceData]) -> Tuple[
+        List[SupplyPriceUpdateManyRequest], Dict]:
+        mappings = await self.get_mapping_groups()
+        new_rows = self.get_price_request(rows)
+        product_mappings = mappings.product_groups
+        location_mappings = mappings.location_groups
+        supplier_mappings = mappings.supplier_groups
+        processed_rows = []
+        error_dict = {}
+
+        for idx, row in enumerate(new_rows):
+            try:
+                terminals = location_mappings.get(row.terminal_source_id)
+                if terminals is None:
+                    raise MappingNotFoundException(f"Missing terminal mapping for source_id: {row.terminal_source_id}")
+
+                suppliers = supplier_mappings.get(row.supplier_source_id)
+                if suppliers is None:
+                    raise MappingNotFoundException(f"Missing supplier mapping for source_id: {row.supplier_source_id}")
+
+                products = product_mappings.get(row.product_source_id)
+                if products is None:
+                    raise MappingNotFoundException(f"Missing product mapping for source_id: {row.product_source_id}")
+
+                expected_combinations = self.get_factor(terminals_length=terminals.length,
+                                                        suppliers_length=suppliers.length,
+                                                        products_length=products.length)
+                row_combinations = []
+                for terminal_gravitate_id in terminals.ids:
+                    for supplier_gravitate_id in suppliers.ids:
+                        for product_gravitate_id in products.ids:
+                            new_row = copy.deepcopy(row)
+                            new_row.terminal_source_id = None
+                            new_row.supplier_source_id = None
+                            new_row.product_source_id = None
+                            new_row.terminal_id = terminal_gravitate_id
+                            new_row.supplier_id = supplier_gravitate_id
+                            new_row.product_id = product_gravitate_id
+                            row_combinations.append(new_row)
+                assert len(
+                    row_combinations) == expected_combinations, f"Expected {expected_combinations} combinations, got {len(row_combinations)}"
+                processed_rows.extend(row_combinations)
+            except MappingNotFoundException as mnfe:
+                error_message = f"Mapping error: {str(mnfe)}"
+                logger.error(f"Row {idx}: {error_message}")
+                error_dict[idx] = {
+                    "error_type": "MappingNotFoundException",
+                    "message": str(mnfe),
+                    "row_data": row.model_dump()
+                }
+                continue
+            except AssertionError as ae:
+                error_message = f"Combination count mismatch: {str(ae)}"
+                logger.error(f"Row {idx}: {error_message}")
+                error_dict[idx] = {
+                    "error_type": "AssertionError",
+                    "message": str(ae),
+                    "row_data": row.model_dump(),
+                    "expected_count": expected_combinations,
+                    "actual_count": len(row_combinations)
+                }
+                continue
+            except KeyError as ke:
+                error_message = f"KeyError: {str(ke)}"
+                logger.error(f"Row {idx}: {error_message}")
+                error_dict[idx] = {
+                    "error_type": "KeyError",
+                    "message": str(ke),
+                    "row_data": row.model_dump()
+                }
+                continue
+            except Exception as e:
+                error_message = f"Unexpected error: {str(e)}"
+                logger.error(f"Row {idx}: {error_message}")
+                error_dict[idx] = {
+                    "error_type": type(e).__name__,
+                    "message": str(e),
+                    "row_data": row.model_dump()
+                }
+                continue
+        return processed_rows, error_dict
+
+    async def get_mapping_groups(self) -> Groups:
+        mappings = await self.pm.get_mappings()
+        product_mappings = mappings.product_mappings
+        location_mappings = mappings.location_mappings
+        supplier_mappings = mappings.supplier_mappings
+        terminal_groups = self.pm.group_rows(
+            rows=location_mappings,
+            external_id_field=self.config.location_external_keys.external_id_field,
+            gravitate_id_field=self.config.location_external_keys.gravitate_id_field,
+            name_field=self.config.location_external_keys.name_field,
+        )
+        product_groups = self.pm.group_rows(
+            rows=product_mappings,
+            external_id_field=self.config.product_external_keys.external_id_field,
+            gravitate_id_field=self.config.product_external_keys.gravitate_id_field,
+            name_field=self.config.product_external_keys.name_field,
+        )
+        supplier_groups = self.pm.group_rows(
+            rows=supplier_mappings,
+            external_id_field=self.config.supplier_external_keys.external_id_field,
+            gravitate_id_field=self.config.supplier_external_keys.gravitate_id_field,
+            name_field=self.config.supplier_external_keys.name_field,
+        )
+        return Groups(
+            product_groups=product_groups,
+            location_groups=terminal_groups,
+            supplier_groups=supplier_groups,
+        )
+
+# TestPipeline deleted on May 20 2025. See previous commits for a copy.

bb_integrations_lib/pipelines/steps/processing/send_process_report_step.py

@@ -0,0 +1,47 @@
+from loguru import logger
+
+from bb_integrations_lib.gravitate.rita_api import GravitateRitaAPI
+from bb_integrations_lib.models.pipeline_structs import BBDUploadResult
+from bb_integrations_lib.models.rita.audit import ProcessReportV2Status, CreateReportV2, UploadProcessReportFile
+from bb_integrations_lib.protocols.pipelines import Step
+
+
+class SendProcessReportStep(Step):
+    def __init__(self, rita_client: GravitateRitaAPI, trigger: str, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.rita_client = rita_client
+        self.trigger = trigger
+
+    def describe(self) -> str:
+        if self.pipeline_context.file_config is not None:
+            return "Upload process report to file config " + self.pipeline_context.file_config.client_name
+        else:
+            raise RuntimeError("Attempting to use SendProcessReportStep without a previous step setting the file_config")
+
+    async def execute(self, i: BBDUploadResult) -> BBDUploadResult:
+        fc = self.pipeline_context.file_config
+        if fc is None or fc.config_id is None:
+            raise RuntimeError("Attempting to use SendProcessReportStep but the fileconfig is either not available from context, or does not have its config_id set.")
+        logger.info("Uploading process report to RITA...")
+        try:
+            await self.rita_client.create_process_report(CreateReportV2(
+                trigger=self.trigger,
+                # If we would be creating an error report, the exception is caught and reporting happens in finish_pipeline
+                status=ProcessReportV2Status.stop,
+                config_id=self.pipeline_context.file_config.config_id,
+                # Logs are one list item per line, newlines already included. Join into one string.
+                log=UploadProcessReportFile(file_base_name=f"log", content="".join(self.pipeline_context.logs)),
+                included_files = [
+                    UploadProcessReportFile(file_base_name=name, content=content)
+                    for name, content in self.pipeline_context.included_files.items()
+                ]
+            ))
+            logger.info("Uploaded.")
+        except Exception as e:
+            logger.warning("Failed to upload process report.")
+
+        # Reset logs for use by the next branch, if the pipeline has one.
+        self.pipeline_context.logs = []
+        self.pipeline_context.included_files = {}
+
+        return i

bb_integrations_lib/pipelines/steps/processing/sftp_renamer_step.py

@@ -0,0 +1,61 @@
+import os
+from asyncio import sleep
+from datetime import UTC, datetime
+
+import loguru
+
+from bb_integrations_lib.gravitate.rita_api import GravitateRitaAPI
+from bb_integrations_lib.models.pipeline_structs import StopPipeline
+from bb_integrations_lib.models.rita.config import Config
+from bb_integrations_lib.protocols.pipelines import Step
+from bb_integrations_lib.provider.ftp.client import FTPIntegrationClient
+
+
+class SFTPRenamerStep(Step):
+    def __init__(self, rita_client: GravitateRitaAPI, ftp_client: FTPIntegrationClient, config_id: str,
+                 halt_early: bool = False, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.rita_client = rita_client
+        self.ftp_client = ftp_client
+        self.config_id = config_id
+        self.halt_early = halt_early
+
+        self.config: Config | None = None
+        self.directory: str | None = None
+        self.file_name: str | None = None
+        self.output_name_base: str | None = None
+
+    async def load_config(self):
+        self.config = await self.rita_client.get_config_by_id(self.config_id)
+        self.directory = self.config.config.get("directory")
+
+        if not self.directory:
+            raise ValueError("The provided config is missing the `directory` field.")
+        self.file_name = self.config.config.get("file_name")
+        if not self.file_name:
+            raise ValueError("The provided config is missing the `file_name` field.")
+        self.output_name_base = self.config.config.get("output_name_base")
+        if not self.output_name_base:
+            raise ValueError("The provided config is missing the `output_name_base` field.")
+
+    def describe(self) -> str:
+        return "Rename files in FTP directory."
+
+    async def execute(self, i: None) -> None:
+        await self.load_config()
+
+        filenames = self.ftp_client.list_files(self.directory)
+        found_any = False
+        for filename in filenames:
+            if self.file_name in filename:
+                found_any = True
+                file_extension = os.path.splitext(filename)[1]
+                date = datetime.now(UTC).strftime("%Y%m%d%H%M%S")
+                new_filename = f"{self.output_name_base}{date}.{file_extension}"
+                old = os.path.join(self.directory, filename)
+                new = os.path.join(self.directory, new_filename)
+                self.ftp_client.rename_file(old, new)
+                loguru.logger.info(f"File renamed: {old} -> {new}")
+                await sleep(1)
+        if not found_any and self.halt_early:
+            raise StopPipeline("No files to rename.")

bb_integrations_lib/pipelines/steps/processing/tank_reading_touchup_steps.py

@@ -0,0 +1,75 @@
+from datetime import datetime, timedelta, UTC
+
+import pandas as pd
+from loguru import logger
+
+from bb_integrations_lib.gravitate.sd_api import GravitateSDAPI
+from bb_integrations_lib.protocols.pipelines import Step
+from bb_integrations_lib.shared.model import GetOrderBolsAndDropsRequest
+from bb_integrations_lib.util.config.manager import GlobalConfigManager
+
+
+class TRTouchUpStep(Step):
+    """Superclass for tank reading touchup steps"""
+    def __init__(self, step_configuration: dict) -> None:
+        super().__init__(step_configuration)
+        self.mode = step_configuration.get("mode", "production")
+
+class NouriaDayDropsTRTouchUpStep(TRTouchUpStep):
+    """
+    Touch up a standardized tank readings report to add a "Order Number + Drop Index" column, which Nouria uses to get
+    tank levels just before they dropped product.
+
+    Note that the tenant/environment is hard coded to Nouria.
+
+    """
+    def __init__(self, step_configuration: dict) -> None:
+        super().__init__(step_configuration)
+
+        self.tenant_name = "Nouria"
+        gcm = GlobalConfigManager().get_environment(self.tenant_name)
+        self.secrets = gcm.prod if self.mode == "production" else gcm.test
+        self.sd_client = GravitateSDAPI(
+            base_url=self.secrets.sd.base_url,
+            client_id=self.secrets.sd.client_id,
+            client_secret=self.secrets.sd.client_secret,
+        )
+
+    def describe(self) -> str:
+        return "Touchup Nouria tank readings for day drops report"
+
+    async def execute(self, i: pd.DataFrame) -> pd.DataFrame:
+        df = i.copy()
+        when = datetime.now(UTC)
+        recent_drops_resp = await self.sd_client.get_bols_and_drops(GetOrderBolsAndDropsRequest(
+            order_date_start=when - timedelta(days=1),
+            order_date_end=when
+        ))
+        recent_drops = recent_drops_resp.json()
+        dfg = df.groupby(["Store Number", "Tank Id"])
+        out_series = []
+        for bol in recent_drops:
+            for drop_idx, drop in enumerate(bol["drops"]):
+                site_no = str(drop["location"])
+                tank_id = str(drop["tank_id"])
+                try:
+                    # Gets the readings rows for this drop's specific site/tank
+                    group = dfg.get_group((site_no, tank_id))
+                    # Keep reads that are before the before_stick timestamp, then get the index of the reading
+                    # row that has the most recent (closest to before_stick_time) timestamp.
+                    idx = group[group["Read Time"] < drop["before_stick_time"]]["Read Time"].idxmax()
+                    # Copy it to avoid pandas grumbling
+                    row = df.iloc[idx].copy()
+                    row["Order Number + Drop Index"] = f"{bol['order_number']}-{drop_idx + 1}"
+                    out_series.append(row)
+                except KeyError:
+                    logger.warning(f"{site_no}, tank {tank_id} in drops but not tank readings, skipping record")
+                except ValueError as e:
+                    logger.warning(f"{site_no}, tank {tank_id} could not be processed: {e}")
+        # If there are no data rows, create a fake empty df with the same columns the actual data would have
+        # (since there are no series items to infer headers from, the whole file would be empty)
+        if len(out_series) == 0:
+            empty_df = pd.DataFrame(data=None, columns=df.columns + ["Order Number + Drop Index"])
+            return empty_df
+        # Otherwise reconstitute the relevant rows (with newly added order number/drop index column)
+        return pd.DataFrame.from_records(out_series).sort_values(["Store Number", "Tank Id"])

bb_integrations_lib/pipelines/steps/processing/upload_supplier_invoice_step.py

@@ -0,0 +1,16 @@
+from bb_integrations_lib.gravitate.sd_api import GravitateSDAPI
+from bb_integrations_lib.protocols.pipelines import Step
+from bb_integrations_lib.shared.model import SDSupplierInvoiceCreateRequest
+
+
+class UploadSupplierInvoiceStep(Step):
+    def __init__(self, sd_client: GravitateSDAPI, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.sd_client = sd_client
+
+    def describe(self) -> str:
+        return "Upload a supplier invoice to S&D"
+
+    async def execute(self, i: SDSupplierInvoiceCreateRequest) -> None:
+        res = await self.sd_client.upload_supplier_invoice(i)
+        res.raise_for_status()

bb_integrations_lib/pipelines/steps/send_attached_in_rita_email_step.py

@@ -0,0 +1,44 @@
+from io import BytesIO
+
+from bb_integrations_lib.gravitate.rita_api import GravitateRitaAPI
+from bb_integrations_lib.models.rita.email import EmailData, EmailAttachment
+from bb_integrations_lib.pipelines.steps.send_rita_email_step import SendRitaEmailStep
+from bb_integrations_lib.shared.model import RawData
+
+
+class SendAttachedInRitaEmailStep(SendRitaEmailStep):
+    def __init__(self, rita_client: GravitateRitaAPI, to: str | list[str], html_content: str, subject: str,
+                 timeout: float = 10.0, *args, **kwargs):
+        """
+        Send one or more RawData objects as an email attachment via RITA.
+
+        :param rita_client: Instantiated RITA API client using an API key with email.send scope.
+        :param to: Email address(es) to send the email to.
+        :param html_content: HTML content (body) of the email.
+        :param subject: Subject of the email.
+        :param timeout: The maximum amount of time allowed to send the email. Large emails may take longer to send than
+          the default.
+        """
+        super().__init__(rita_client=rita_client, timeout=timeout, *args, **kwargs)
+        self.to = to
+        self.html_content = html_content
+        self.subject = subject
+
+    def describe(self):
+        return "Send email via RITA with RawData(s) from step input attached"
+
+    async def execute(self, i: RawData | list[RawData]):
+        if isinstance(i, RawData):
+            i = [i]
+        ed = EmailData(
+            to=self.to,
+            html_content=self.html_content,
+            subject=self.subject,
+            attachments=[
+                EmailAttachment(
+                    file_name=rd.file_name,
+                    file_data=rd.data.getvalue() if type(rd.data) == BytesIO else rd.data,
+                ) for rd in i
+            ]
+        )
+        await super().execute(ed)

bb_integrations_lib/pipelines/steps/send_rita_email_step.py

@@ -0,0 +1,34 @@
+from bb_integrations_lib.gravitate.rita_api import GravitateRitaAPI
+from bb_integrations_lib.models.rita.email import EmailData
+from bb_integrations_lib.protocols.pipelines import Step
+
+
+class SendRitaEmailStep(Step):
+    def __init__(self, rita_client: GravitateRitaAPI, timeout: float = 10.0, raise_on_error: bool = True,
+                 email_data_override: EmailData | None = None, *args, **kwargs):
+        """
+        Instantiate a pipeline step that sends an email via RITA.
+
+        :param rita_client: Instantiated RITA API client using an API key with email.send scope.
+        :param timeout: The maximum amount of time allowed to send the email. Large emails may take longer to send than
+          the default.
+        :param raise_on_error: Whether to raise an exception if the email send HTTP response indicates an error.
+        :param email_data_override: Explicitly specified EmailData object to use instead of step input. This allows
+          specifying a static email for either testing or notifications.
+        """
+        super().__init__(*args, **kwargs)
+        self.rita_client = rita_client
+        self.timeout = timeout
+        self.raise_on_error = raise_on_error
+        self.ed_override = email_data_override
+
+    def describe(self) -> str:
+        return "Send email via RITA"
+
+    async def execute(self, i: EmailData):
+        if self.ed_override:
+            resp = await self.rita_client.send_email(self.ed_override, self.timeout)
+        else:
+            resp = await self.rita_client.send_email(i, self.timeout)
+        if self.raise_on_error:
+            resp.raise_for_status()

bb_integrations_lib/pipelines/steps/sleep_step.py

@@ -0,0 +1,24 @@
+import asyncio
+
+from loguru import logger
+
+from bb_integrations_lib.protocols.pipelines import Step
+
+
+class SleepStep(Step):
+    def __init__(self, duration: float, *args, **kwargs):
+        """
+        Equivalent to ``asyncio.sleep(duration)``.
+
+        :param duration: The number of seconds to sleep.
+        """
+        super().__init__(*args, **kwargs)
+
+        self.duration = duration
+
+    def describe(self) -> str:
+        return f"Wait a specified number of seconds"
+
+    async def execute(self, data: None) -> None:
+        logger.debug(f"Sleeping for {self.duration} seconds...")
+        await asyncio.sleep(self.duration)