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

bb_integrations_lib/pipelines/steps/exporting/keyvu_export_step.py

@@ -0,0 +1,356 @@
+from datetime import datetime, timedelta, UTC
+
+from bson import ObjectId
+from loguru import logger
+from pymongo import MongoClient, AsyncMongoClient
+from pymongo.asynchronous.database import AsyncDatabase
+from pymongo.synchronous.database import Database
+
+from bb_integrations_lib.gravitate.rita_api import GravitateRitaAPI
+from bb_integrations_lib.gravitate.sd_api import GravitateSDAPI
+from bb_integrations_lib.models.rita.config import GenericConfig
+from bb_integrations_lib.protocols.pipelines import Step
+from bb_integrations_lib.provider.api.keyvu.model import Delivery, StationDelivery, \
+    DeliveryStatus, KeyVuDeliveryPlan, default_serialization_options, StationDeliveryDetails, StationDeliveryBOL, \
+    GeoLocation
+from bb_integrations_lib.shared.model import RawData
+
+# See also v1 order trip status for better DeliveryStatus mapping
+delivery_status_map = {
+    "accepted": DeliveryStatus.planned,
+    "assigned": DeliveryStatus.planned,
+    "in progress": DeliveryStatus.unloading,
+    "complete": DeliveryStatus.delivered,
+    "canceled": DeliveryStatus.canceled
+}
+
+
+class KeyVuExportStep(Step):
+    def __init__(self, rita_client: GravitateRitaAPI, sd_client: GravitateSDAPI, mongo_database: AsyncDatabase,
+                 time_back: timedelta, only_mapped_sites: bool = True, by_counterparties: list[str] | None = None,
+                 order_nums: list[int] | None = None, *args, **kwargs):
+        """
+        Build a KeyVu delivery plan from recently modified orders in the S&D environment.
+
+        Automatically uses RITA mappings with a KeyVu source system.
+
+        :param rita_client: RITA client to retrieve mappings with.
+        :param sd_client: S&D client to retrieve orders from.
+        :param mongo_database: An initialized MongoDB database to retrieve order details from.
+        :param time_back: Gets orders with modification timestamp within the last timedelta duration.
+        :param only_mapped_sites: Whether to only include sites with extant Gravitate->KeyVu site ID mappings. If False
+          and no mapping is available for a site, the Gravitate location name will be used as the KeyVu site ID.
+        :param by_counterparties: Counterparties to include in the delivery plan. If empty, all counterparties are
+          included. Intended to be set by the RITA config, but a fallback can be set here.
+        """
+        super().__init__(*args, **kwargs)
+        self.time_back: timedelta = time_back
+        self.order_nums = order_nums
+
+        self.sd_client = sd_client
+        self.rita_client = rita_client
+        self.mongo_database = mongo_database
+
+        self.keyvu_site_mappings = None  # To be filled in by execute() (can't load it here since Rita client is async)
+
+        self.tcn_field_name = "source_system_id"
+        # This defaults to true to prevent leaking all sites to SWTO if we don't have mappings
+        self.only_mapped_sites = only_mapped_sites
+        self.by_counterparties = by_counterparties
+
+    def describe(self) -> str:
+        return "Export recent order updates to KeyVu"
+
+    async def execute(self, i: None = None) -> KeyVuDeliveryPlan:
+        logger.warning("Delivery dates and times are not fully implemented for all order scenarios.")
+
+        # Load additional configuration from Rita
+        try:
+            rita_config: GenericConfig = (await self.rita_client.get_config_by_name("/KeyVu", "KeyVu"))["KeyVu"]
+            self.tcn_field_name = rita_config.config.get("extra_data_tcn_field", self.tcn_field_name)
+            self.only_mapped_sites = rita_config.config.get("only_mapped_sites", self.only_mapped_sites)
+            self.by_counterparties = rita_config.config.get("by_counterparties", self.by_counterparties)
+        except Exception as e:
+            logger.warning(
+                f"Failed to load KeyVu config from RITA, using defaults"
+            )
+            logger.warning(f"Exception: {e}")
+
+        logger.info(
+            f"Configuration: extra_data_tcn_field: '{self.tcn_field_name}', "
+            f"only_mapped_sites: {self.only_mapped_sites}, "
+            f"by_counterparties: {self.by_counterparties}"
+        )
+
+        # Preload mappings
+        maps = await self.rita_client.get_mappings_by_source_system("KeyVu")
+        self.keyvu_site_mappings = {x.gravitate_id: x.source_id for x in maps}
+        if self.only_mapped_sites and not self.keyvu_site_mappings:
+            raise Exception("No KeyVu site mappings found, but only_mapped_sites is True")
+
+        end_date = datetime.now(UTC).replace(microsecond=0)
+        start_date = end_date - self.time_back
+        logger.info(f"Downloading orders newer than {start_date}")
+        if self.order_nums is not None:
+            orders_raw = []
+            for i, order_num in enumerate(self.order_nums):
+                logger.info(f"Downloading order {order_num} ({i + 1}/{len(self.order_nums)})")
+                order_resp = await self.sd_client.get_orders(order_number=order_num)
+                order_resp.raise_for_status()
+                orders_raw.extend(order_resp.json())
+        else:
+            order_resp = await self.sd_client.get_orders(last_change_date=start_date)
+            orders_raw = order_resp.json()
+
+        # Filter out orders supposedly changed in the future
+        orders = list(filter(
+            lambda o: datetime.fromisoformat(o.get("last_change_date")) < datetime.now() + timedelta(days=1),
+            orders_raw
+        ))
+
+        # Using non-v1 API here
+        logger.info("Getting BOL details")
+        bol_resp = await self.sd_client.token_post(url="order/bols_and_drops", json={
+            "order_ids": [order["order_id"] for order in orders]
+        })
+        bol_resp.raise_for_status()
+        bols_raw = bol_resp.json()
+        self.bol_lkp = {int(bol["order_number"]): bol for bol in bols_raw}
+
+        logger.info("Getting order details from database")
+        order_numbers = [order["order_number"] for order in orders]
+        order_docs = await self.mongo_database["order_v2"].find({
+            "number": {
+                "$in": order_numbers
+            }
+        }).to_list()
+        self.order_lkp = {o["number"]: o for o in order_docs}
+
+        logger.info("Getting location details from API")
+        loc_resp = await self.sd_client.all_locations()
+        loc_resp.raise_for_status()
+        locations_raw = loc_resp.json()
+        self.loc_lkp = {loc["id"]: loc for loc in locations_raw}
+
+        logger.info("Getting counterparty details from API")
+        cp_resp = await self.sd_client.all_counterparties()
+        cp_resp.raise_for_status()
+        cp_raw = cp_resp.json()
+        self.cp_lkp = {cp["id"]: cp for cp in cp_raw}
+
+        logger.info("Getting stores from API")
+        store_resp = await self.sd_client.all_stores(include_tanks=False)
+        store_resp.raise_for_status()
+        store_raw = store_resp.json()
+        self.store_lkp = {store["store_number"]: store for store in store_raw}
+
+        logger.info("Getting driver schedule details from database")
+        ds_ids = list(filter(lambda x: x is not None,
+                             [order.get("driver_schedule_id", None) for number, order in self.order_lkp.items()]))
+        ds_ids = [ObjectId(id) for id in ds_ids]
+        ds_docs = await self.mongo_database["driver_schedule"].find({
+            "_id": {
+                "$in": ds_ids
+            }
+        }).to_list()
+        self.driver_sched_lkp = {str(ds["_id"]): ds for ds in ds_docs}
+
+        logger.info("Building delivery plan models")
+        export_date = datetime.now(UTC).replace(microsecond=0)
+        deliveries = []
+        for o in orders:
+            try:
+                deliveries.append(self.order_to_keyvu_delivery(o))
+            except Exception as e:
+                logger.error(f"Failed to build a delivery item for {o['order_number']}: {e}")
+        dp = KeyVuDeliveryPlan(
+            start_date=start_date,
+            end_date=end_date,
+            export_date=export_date,
+            deliveries=deliveries
+        )
+        return dp
+
+    def determine_delivery_status(self, order: dict, order_doc: dict, drop_index: int) -> DeliveryStatus:
+        match order["order_state"]:
+            case "accepted" | "assigned" | "open":
+                return DeliveryStatus.planned
+            case "canceled" | "deleted":
+                return DeliveryStatus.canceled
+            case "in progress":
+                drop_doc: dict = order_doc["drops"][drop_index]
+                route_status = drop_doc.get('route_status')
+                # TODO: Implement better state tracking here - can we tell whether this particular delivery is being
+                #   loaded or not? Currently we'll just say it's planned.
+                if route_status == "driving to drop":
+                    return DeliveryStatus.on_route_loaded
+                elif route_status == "arrived at drop":
+                    return DeliveryStatus.unloading
+                return DeliveryStatus.planned
+            case "complete":
+                return DeliveryStatus.delivered
+            case _:
+                raise Exception(f"Could not determine delivery status from order state '{order['order_state']}'")
+
+    def get_delivery_date(self, order: dict, drop: dict, delivery_status: DeliveryStatus) -> datetime:
+        # TODO: Get the correct delivery date for all order scenarios.
+        delivery_date = None
+        if delivery_status == DeliveryStatus.planned or delivery_status == DeliveryStatus.unloading:
+            # Sometimes this is a str, sometimes it's a datetime
+            delivery_date = drop["eta"]
+        elif delivery_status == DeliveryStatus.canceled:
+            # Is this acceptable?
+            delivery_date = order.get("dispatch_window_end") or order.get("last_changed_date")
+        elif delivery_status == DeliveryStatus.delivered:
+            logger.debug("Delivered")
+            bols = self.bol_lkp.get(order["order_number"], {}).get("bols")
+            if not bols:
+                logger.warning("No BOL on order")
+            else:
+                delivery_date = max([datetime.fromisoformat(b["date"]) for b in bols])
+        if delivery_date is None:
+            logger.warning("Unable to determine a delivery date - using current datetime")
+            return datetime.now(UTC)
+
+        if type(delivery_date) is str:
+            delivery_date = datetime.fromisoformat(delivery_date)
+        return delivery_date.astimezone(UTC).replace(microsecond=0)
+
+    def drop_to_keyvu_station_delivery(self, order: dict, drop: dict, drop_index: int) -> StationDelivery | None:
+        # Confirm if the counterparty is included
+        if self.by_counterparties:
+            location = self.loc_lkp[drop["location_id"]]
+            store_cp_name = self.store_lkp[location["name"]][
+                "counterparty_name"]  # location name seems to = store_number
+            if store_cp_name not in self.by_counterparties:
+                logger.debug(
+                    f"Skipping order {order['order_number']} drop #{drop_index}, "
+                    f"{store_cp_name} not in counterparties list"
+                )
+                return None
+        delivery_status = self.determine_delivery_status(order, self.order_lkp[order["order_number"]], drop_index)
+
+        # Map the site IDs, if available
+        if self.keyvu_site_mappings:
+            site_id = self.keyvu_site_mappings.get(drop["location_name"])
+            # If the lookup fails...
+            if not site_id:
+                # ...and we are skipping unmapped sites, skip this one
+                if self.only_mapped_sites:
+                    logger.warning(
+                        f"Skipping {order['order_number']} drop #{drop_index}, could not find site_id in mappings")
+                    return None
+                # otherwise we can use the location name as a fallback
+                else:
+                    site_id = drop["location_name"]
+        # But if not, use location name directly
+        else:
+            site_id = drop["location_name"]
+
+        def bol_correlates(bol: dict, tanks: list[int]) -> bool:
+            return bol["location_id"] == drop["location_id"] and bol["store_tank"] in tanks
+
+        allocated_bols = self.order_lkp[order["order_number"]].get("allocated_bols", [])
+        # allocated_bols will have multiple entries - one per product - if a load is split.
+        # Since KeyVu doesn't have any product details, just supplier and terminal, this results in apparent duplicates
+        # when it gets converted to their format.
+        # Convert all BOLs, but only keep them if we haven't already generated an identical BOL entry.
+        converted_bols = []
+        for bol in allocated_bols:
+            converted = self.allocated_bol_to_keyvu_bol(bol)
+            drop_tanks = [x['tank_id'] for x in drop["details"]]
+            if converted not in converted_bols and bol_correlates(bol, drop_tanks):
+                converted_bols.append(converted)
+        return StationDelivery(
+            delivery_status=delivery_status,
+            site_id=site_id,
+            details=[StationDeliveryDetails.from_v1_order_dict(x) for x in drop["details"]],
+            delivery_date=self.get_delivery_date(order, drop, delivery_status),
+            bill_of_ladings=converted_bols
+        )
+
+    def allocated_bol_to_keyvu_bol(self, allocated_bol: dict) -> StationDeliveryBOL:
+        return StationDeliveryBOL(
+            supplier=allocated_bol["bol_supplier"],
+            terminal_name=allocated_bol["bol_terminal"],
+            bill_of_lading_number=allocated_bol["bol_number"],
+            terminal_control_number=self.loc_lkp.get(
+                allocated_bol["bol_terminal_id"], {}).get("extra_data", {}).get(self.tcn_field_name, ""),
+            consignee=""  # KeyVu says if we don't have a consignee ID ("usually some 5 digit number") to leave it empty
+        )
+
+    def all_drops_to_keyvu_station_deliveries(self, order: dict) -> list[StationDelivery]:
+        station_deliveries = [
+            self.drop_to_keyvu_station_delivery(order, drop, index)
+            for index, drop in enumerate(order["drops"])
+        ]
+        # Filter out failed conversions (typically failed site lookups)
+        return [d for d in station_deliveries if d is not None]
+
+    def order_to_keyvu_delivery(self, order: dict) -> Delivery:
+        updated_at: datetime = datetime.fromisoformat(max(filter(
+            lambda x: x is not None,
+            [order["last_change_date"], order.get("hauled_by_updated")])
+        ))
+        order_detail = self.order_lkp.get(order["order_number"], {})
+        unit = ""
+        if dsid := order_detail.get("driver_schedule_id"):
+            driver_log = self.driver_sched_lkp.get(dsid, {}).get("driver_log", {})
+            tractor = driver_log.get("tractor")
+            trailer = driver_log.get("trailer")
+            unit += tractor if tractor else ""
+            if unit and trailer:
+                unit += f"-{trailer}"
+            elif trailer:
+                unit = trailer
+
+        station_deliveries = self.all_drops_to_keyvu_station_deliveries(order)
+        if not station_deliveries:
+            raise Exception(f"No station deliveries built for order {order['order_number']}, skipping order")
+        return Delivery(
+            id=str(order["order_number"]),
+            carrier_name=order["supply_option"].get("carrier"),
+            # Grab the SCAC from the carrier counterparty, falling back to None (which becomes blank) if not found.
+            scac=self.cp_lkp.get(order_detail.get("carrier_id"), {}).get("scac"),
+            # GeoLocation must be included but we don't necessarily have any data to fill in (this would be driver
+            # breadcrumbs).
+            # This prevents geolocation from getting ignored entirely during serialization, because the schema expects
+            # it to be there, but doesn't add any sub-elements, which are optional.
+            geo_location=GeoLocation(longitude=None, latitude=None, heading=None, last_updated=None),
+            unit=unit,
+            last_updated=updated_at.astimezone(UTC).replace(microsecond=0),
+            station_deliveries=station_deliveries
+        )
+
+
+if __name__ == "__main__":
+    import asyncio
+
+
+    async def main():
+        s = KeyVuExportStep(
+            rita_client=GravitateRitaAPI(
+                base_url="",
+                username="",
+                password="",
+            ),
+            sd_client=GravitateSDAPI(
+                base_url="",
+                username="",
+                password="",
+            ),
+            mongo_database=AsyncMongoClient("mongo conn str")["mongo db name"],
+            time_back=timedelta(minutes=60),
+            order_nums=[]
+        )
+        plan = await s.execute()
+        dp_string = plan.to_xml(**default_serialization_options)
+        plan_file = RawData(
+            data=dp_string,
+            file_name=f"plan_file{datetime.now().isoformat()}.xml"
+        )
+        with open(plan_file.file_name, "wb") as f:
+            f.write(plan_file.data)
+
+
+    asyncio.run(main())

bb_integrations_lib/pipelines/steps/exporting/pe_price_export_step.py

@@ -0,0 +1,238 @@
+import json
+from datetime import datetime, timedelta, UTC
+from functools import lru_cache
+from itertools import groupby
+from typing import Dict, Any, List, Tuple, Optional
+
+import pytz
+from dateutil.parser import parse
+from more_itertools.more import chunked
+
+from bb_integrations_lib.gravitate.pe_api import GravitatePEAPI
+from bb_integrations_lib.gravitate.rita_api import GravitateRitaAPI
+from bb_integrations_lib.mappers.prices.model import PricePublisher, PricingIntegrationConfig
+from bb_integrations_lib.models.pipeline_structs import StopPipeline
+from bb_integrations_lib.models.rita.config import GenericConfig
+from bb_integrations_lib.protocols.pipelines import Step, ParserBase
+from bb_integrations_lib.shared.model import PEPriceData
+
+
+class ImpossibleToParseDate(Exception):
+    pass
+
+
+class PEPriceExportStep(Step):
+    def __init__(self,
+                 rita_client: GravitateRitaAPI,
+                 pe_client: GravitatePEAPI,
+                 price_publishers: list[PricePublisher],
+                 parser: type[ParserBase] | None = None,
+                 parser_kwargs: dict | None = None,
+                 config_id: str | None = None,
+                 hours_back: int = 24,
+                 addl_endpoint_args: dict | None = None,
+                 last_sync_date: datetime | None = datetime.now(UTC),
+                 *args, **kwargs):
+        """This step requires:
+            - tenant_name: [REQUIRED] client name. (i.e Jacksons, TTE, Coleman)
+            - price_publishers:[REQUIRED] a list of price publisher names to be included in the price request
+            - config_id: [OPTIONAL] a RITA config to pull last sync date
+            - hours_back: [OPTIONAL] hours back from last sync date, defaults to 12
+            - mode: [OPTIONAL] can be 'production' or 'development', defaults to production
+        """
+        super().__init__(*args, **kwargs)
+        self.pe_client = pe_client
+        self.price_publishers = price_publishers
+        self.config_id = config_id
+        self.hours_back = hours_back
+        self.rita_client = rita_client
+        self.additional_endpoint_arguments = addl_endpoint_args or {}
+        self.last_sync_date = last_sync_date
+        if parser:
+            self.custom_parser = parser
+            self.custom_parser_kwargs = parser_kwargs or {}
+
+    def price_publisher_lkp(self) -> Dict[str, PricePublisher]:
+        lkp = {}
+        pp = self.price_publishers
+        for p in pp:
+            lkp[p.name] = p
+        return lkp
+
+    def get_publisher_extend_by(self, key: str) -> int | None:
+        lkp = self.price_publisher_lkp()
+        return lkp[key].extend_by_days
+
+    def get_publisher_price_type(self, key: str) -> str:
+        lkp = self.price_publisher_lkp()
+        return lkp[key].price_type
+
+    def price_type_rows(self, rows: List[PEPriceData]) -> List[PEPriceData]:
+        for row in rows:
+            price_type = self.get_publisher_price_type(row.PricePublisher)
+            row.PriceType = price_type
+        return rows
+
+    def describe(self) -> str:
+        return f"Export Pricing Engine Prices"
+
+    async def execute(self, _: Any = None) -> List[PEPriceData] | List[Dict]:
+        updated_prices = await self.get_updated_prices_for_publishers(last_sync_date=self.last_sync_date,
+                                                                      price_publishers=self.price_publishers)
+        if not updated_prices:
+            raise StopPipeline
+        updated_price_instrument_ids, min_updated_date = PEPriceExportStep.instrument_ids_and_min_date(updated_prices)
+        historic_prices_per_instrument_id = await self.get_updated_prices_for_instruments(
+            min_effective_date=min_updated_date,
+            price_publishers=self.price_publishers,
+            instrument_ids=updated_price_instrument_ids)
+        prices = self.update_historical_prices(historic_prices_per_instrument_id)
+        if not hasattr(self, "custom_parser"):
+            return prices
+        else:
+            parser = self.custom_parser(**self.custom_parser_kwargs)
+            parser_results = await parser.parse(prices)
+            return parser_results
+
+    def update_historical_prices(self, rows: List[PEPriceData]) -> List[PEPriceData]:
+        _sorted_id = sorted(rows, key=lambda r: (r.PriceInstrumentId, r.EffectiveFromDateTime), reverse=True)
+        for instrument_id, group in groupby(_sorted_id, key=lambda r: r.PriceInstrumentId):
+            group_list = PEPriceExportStep.rank_rows(list(group))
+            group_list_price_typed = self.price_type_rows(group_list)
+            max_row = max(group_list_price_typed, key=lambda r: r.EffectiveFromDateTime)
+            max_row.ExtendByDays = self.get_publisher_extend_by(max_row.PricePublisher)  # makes it more configurable
+            max_row.IsLatest = True
+        return _sorted_id
+
+
+    async def get_prices(
+            self,
+            query: Dict,
+            count: int = 1000,
+            include_source_data: bool = True
+    ) -> List[PEPriceData]:
+        records = []
+        payload = {
+            "Query": {**query,
+                      "COUNT": count
+                      },
+            "includeSourceData": include_source_data
+        }
+        resp = await self.pe_client.get_prices(payload)
+        while len(resp['Data']) > 0:
+            records.extend(resp['Data'])
+            max_sync = resp["MaxSyncResult"]
+            if max_sync is None:
+                break
+            payload["Query"]["MaxSync"] = max_sync
+            resp = await self.pe_client.get_prices(payload)
+        self.pipeline_context.included_files["Pricing Engine Export Prices Step"] = json.dumps(records)
+        return [PEPriceData.model_validate(price) for price in records]
+
+    async def get_updated_prices_for_publishers(self,
+                                                last_sync_date: datetime,
+                                                price_publishers: List[PricePublisher] = None) -> List[PEPriceData]:
+        last_sync_date = (last_sync_date - timedelta(hours=self.hours_back)).replace(tzinfo=pytz.UTC)
+        payload = {
+            "IsActiveFilterType": "ActiveOnly",
+            "PricePublisherNames": [p.name for p in (price_publishers or [])],
+            "MaxSync": {
+                "MaxSyncDateTime": last_sync_date.isoformat(),
+                "MaxSyncPkId": 0
+            },
+            **self.additional_endpoint_arguments,
+        }
+        rows = await self.get_prices(query=payload, include_source_data=True)
+        return rows
+
+    async def get_updated_prices_for_instruments(self,
+                                                 min_effective_date: datetime,
+                                                 instrument_ids: List[int],
+                                                 price_publishers: List[PricePublisher] = None) -> List[PEPriceData]:
+        res_rows = []
+        for idx, group in enumerate(chunked(instrument_ids, 50)):
+            payload = {
+                "IsActiveFilterType": "ActiveOnly",
+                "PricePublisherNames": [p.name for p in (price_publishers or [])],
+                "MinEffectiveDate": min_effective_date.isoformat(),
+                "PriceInstrumentIds": group
+            }
+            rows = await self.get_prices(query=payload, include_source_data=True)
+            res_rows.extend(rows)
+        return res_rows
+
+    @staticmethod
+    def instrument_ids_and_min_date(rows: List[PEPriceData]) -> Tuple[list, datetime]:
+        unique_price_instrument_ids = list(set([r.PriceInstrumentId for r in rows]))
+        min_date = min([PEPriceExportStep.try_to_parse_date(r.EffectiveFromDateTime) for r in rows])
+        return unique_price_instrument_ids, min_date
+
+    @staticmethod
+    def rank_rows(rows: List[PEPriceData]) -> List[PEPriceData]:
+        for idx, row in enumerate(rows):
+            row.Rank = idx + 1
+        return rows
+
+    @staticmethod
+    def try_to_parse_date(dt_string: str) -> datetime:
+        if isinstance(dt_string, str):
+            try:
+                parsed_datetime = parse(dt_string)
+                return parsed_datetime
+            except (ValueError, TypeError):
+                raise ImpossibleToParseDate(f"Could not parse date: {dt_string}")
+        elif isinstance(dt_string, datetime):
+            return dt_string
+        else:
+            raise ImpossibleToParseDate(f"Could not parse date: {dt_string} -> Format not supported")
+
+    @staticmethod
+    def check_if_date_bigger_equal_previous_weekday(date: str) -> bool:
+        parsed = parse(date).replace(tzinfo=pytz.UTC)
+        _weekday = PEPriceExportStep.previous_weekday()
+        return parsed >= _weekday
+
+    @staticmethod
+    @lru_cache(maxsize=1)
+    def previous_weekday(anchor: Optional[datetime] = None) -> datetime:
+        if anchor is None:
+            anchor = datetime.now(UTC)
+        anchor = anchor.replace(hour=0, minute=0, second=0, microsecond=0)
+        current_weekday = anchor.weekday()
+        if current_weekday == 0:  # Monday
+            days_back = 3  # Go back to Friday
+        elif current_weekday == 6:  # Sunday
+            days_back = 2  # Go back to Friday
+        else:  # Tuesday through Saturday
+            days_back = 1  # Go back one day
+        return anchor - timedelta(days=days_back)
+
+
+async def load_config(rita_client: GravitateRitaAPI, environment: str) -> Tuple[PricingIntegrationConfig, str]:
+    config_name = f"{environment} Pricing Engine Contract Integration"
+    configs = await rita_client.get_config_by_name(bucket_path="/Prices", config_name=config_name)
+    job_config: GenericConfig = configs[config_name]
+    pipeline_config: PricingIntegrationConfig = PricingIntegrationConfig.model_validate(job_config.config)
+    return pipeline_config, job_config.config_id
+
+
+if __name__ == "__main__":
+    async def main():
+        rita_client = GravitateRitaAPI(
+            base_url="",
+            client_id="",
+            client_secret=""
+        )
+        config, config_id = await load_config(environment="Loves", rita_client=rita_client)
+        s = PEPriceExportStep(
+            rita_client=rita_client,
+            pe_client=GravitatePEAPI(
+                base_url="",
+                username="",
+                password=""
+            ),
+            price_publishers=config.price_publishers,
+            config_id=config_id,
+            hours_back=24,
+        )
+        await s.execute()