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

bb_integrations_lib/pipelines/parsers/distribution_report/order_by_site_product_parser.py

@@ -0,0 +1,50 @@
+from io import StringIO
+import numpy as np
+import pandas as pd
+from bb_integrations_lib.protocols.pipelines import Parser
+from typing import override
+from pandas import DataFrame
+
+
+class OrderBySiteProductParser(Parser):
+    def __init__(self, tenant_name: str, source_system: str | None = None):
+        super().__init__(source_system, tenant_name)
+
+    def __repr__(self) -> str:
+        return "Order by site and product parser"
+
+    @override
+    async def parse(self, data: str, mapping_type: str | None = None) -> DataFrame:
+        orders = pd.read_csv(StringIO(data))
+        orders_columns = ['order_number', 'site', 'site_name', 'component_product', 'finished_product',
+                          'component_volume',
+                          'contract', 'market']
+        orders = orders[orders_columns]
+        orders['contract_type'] = np.where(orders['contract'].isna(), 'rack', 'contract')
+        grouped_sum = orders.groupby(['site', 'component_product', 'contract_type', 'market'])[
+            'component_volume'].sum().reset_index()
+
+        pivot_df = grouped_sum.pivot_table(
+            index=['site', 'component_product'],
+            values=['component_volume'],
+            columns=['contract_type'],
+            aggfunc='sum',
+            fill_value=0
+        )
+        pivot_df.columns = ['_'.join(col).strip() if isinstance(col, tuple) else col for col in pivot_df.columns]
+        pivot_df['component_volume_contract'] = pivot_df.get('component_volume_contract', 0)
+        pivot_df['component_volume_rack'] = pivot_df.get('component_volume_rack', 0)
+        pivot_df['total_product'] = pivot_df['component_volume_contract'] + pivot_df['component_volume_rack']
+        pivot_df['pct_contract'] = pivot_df['component_volume_contract'] / pivot_df['total_product']
+        pivot_df['pct_rack'] = pivot_df['component_volume_rack'] / pivot_df['total_product']
+        pivot_df = pivot_df.reset_index()
+        pivot_df['component_product'] = pivot_df['component_product'].apply(OrderBySiteProductParser.normalize_product)
+        pivot_df['site'] = pivot_df['site'].astype(str)
+        return pivot_df
+
+    @staticmethod
+    def normalize_product(val):
+        try:
+            return str(int(float(val)))
+        except (ValueError, TypeError):
+            return str(val).strip()

bb_integrations_lib/pipelines/parsers/distribution_report/tank_configs_parser.py

@@ -0,0 +1,47 @@
+import numpy as np
+import pandas as pd
+from bb_integrations_lib.protocols.pipelines import Parser
+from typing import override, Dict, List
+from pandas import DataFrame
+
+
+class TankConfigsParser(Parser):
+    def __init__(self, tenant_name: str, source_system: str | None = None):
+        super().__init__(source_system, tenant_name)
+
+    def __repr__(self) -> str:
+        return "Tank configs parser"
+
+    @override
+    async def parse(self, data: List[Dict], mapping_type: str | None = None) -> DataFrame:
+        tc_df = pd.DataFrame(data)
+        dos_columns = ['store_number', 'product', 'daily_lifting_estimate', 'measured_inventory']
+        tc_df = tc_df[dos_columns]
+
+        tc_df = tc_df.groupby(['store_number', 'product'])[
+            ['daily_lifting_estimate', 'measured_inventory']].sum().reset_index()
+        tc_df['dos'] = np.where(
+            (tc_df['measured_inventory'] == 0) | (tc_df['daily_lifting_estimate'] == 0),
+            'N/A',
+            tc_df['measured_inventory'] / tc_df['daily_lifting_estimate']
+        )
+        tc_df['dos'] = pd.to_numeric(tc_df['dos'], errors='coerce')
+        tc_df['dos_bucket'] = np.where(
+            tc_df['dos'] <= 2, '0-2',
+            np.where(tc_df['dos'] <= 4, '2-4',
+                     np.where(tc_df['dos'] <= 6, '4-6',
+                              np.where(tc_df['dos'] <= 8, '6-8',
+                                       np.where(tc_df['dos'] <= 10, '8-10',
+                                                np.where(tc_df['dos'].isna(), 'N/A', '10+')))))
+        )
+        tc_df['product'] = tc_df['product'].apply(TankConfigsParser.normalize_product)
+        tc_df['store_number'] = tc_df['store_number'].astype(str)
+
+        return tc_df
+
+    @staticmethod
+    def normalize_product(val):
+        try:
+            return str(int(float(val)))
+        except (ValueError, TypeError):
+            return str(val).strip()

bb_integrations_lib/pipelines/parsers/dtn/dtn_price_parser.py

@@ -0,0 +1,102 @@
+from typing import AsyncGenerator, Optional
+from typing import override
+
+from bb_integrations_lib.gravitate.sd_api import GravitateSDAPI
+from bb_integrations_lib.pipelines.parsers.dtn.model import DTNIntegrationConfig, DTNPriceRecord
+from bb_integrations_lib.shared.exceptions import MappingNotFoundException
+from loguru import logger
+
+from bb_integrations_lib.mappers.rita_mapper import RitaMapper, AsyncMappingProvider
+from bb_integrations_lib.models.rita.mapping import MappingType
+from bb_integrations_lib.protocols.pipelines import Parser
+from bb_integrations_lib.shared.model import MappingMode, SupplyPriceUpdateManyRequest
+from bb_integrations_lib.util.utils import lookup
+from pydantic import ValidationError
+
+
+class DTNPriceParser(Parser):
+    def __init__(
+            self,
+            source_system: str | None = None,
+            mapping_provider: Optional[AsyncMappingProvider] = None,
+            sd_client: GravitateSDAPI = None,
+            price_config: DTNIntegrationConfig = None,
+            **args
+    ):
+        super().__init__(source_system, mapping_provider)
+        self.mapper: Optional[RitaMapper] = None
+        self.sd_client = sd_client
+        self.price_config = price_config
+        self.supply_owner_configs_lkp_by_gravitate_id = lookup(self.price_config.supply_owners, lambda x: x.gravitate_id)
+
+    @override
+    async def parse(self, data: list[dict], mapping_type: MappingMode | None = None) -> AsyncGenerator[
+        SupplyPriceUpdateManyRequest, None]:
+        if mapping_type is None:
+            logger.warning("DTNPriceParser.parse mapping_type is None, defaulting to skip")
+            mapping_type = MappingMode.skip
+        self.mapper = await self.load_mapper()
+        preparsed_records = self.preparse(data, mapping_type)
+        for rec in preparsed_records:
+            with logger.catch(message=f"Skipped record {rec} due to error"):
+                supply_owner_config = self.supply_owner_configs_lkp_by_gravitate_id.get(rec.supply_owner)
+                extend_by_days = supply_owner_config.extend_by_days if supply_owner_config else 3
+                expire_in_hours = supply_owner_config.expire_in_hours if supply_owner_config else 24
+                yield SupplyPriceUpdateManyRequest(
+                    source_id=rec.source_id,
+                    source_system_id=rec.source_system,
+                    terminal_id=rec.terminal,
+                    product_id=rec.product,
+                    supplier_id=rec.supplier,
+                    effective_from=rec.effective_from_date,
+                    effective_to=rec.add_days(extend_by_days),
+                    price=rec.price,
+                    price_type=rec.price_type,
+                    timezone=None, # allways needs to be None
+                    contract=rec.contract,
+                    counterparty_id=rec.supply_owner,
+                    expire=rec.add_hours(expire_in_hours),
+                )
+
+    async def get_store_lkp(self):
+        stores = await self.sd_client.all_stores()
+        return lookup(stores.json(), lambda x: x.get("store_number"))
+
+    def try_to_map_composite_record(self, record: dict):
+        try:
+            ret = self.mapper.get_gravitate_id_by_composite(record, MappingType.composite)
+            return ret
+        except KeyError as e:
+            raise MappingNotFoundException(f"Unable to find matching record for record {record}") from e
+
+    def preparse(self, records: list[dict], mapping_type: MappingMode) -> list[DTNPriceRecord]:
+        parsed_records = []
+        mapping_failures = []
+        validation_failures = []
+        for translated in records:
+            try:
+                record = DTNPriceRecord(**translated)
+                mapped_record = self.try_to_map_composite_record(record.map_key)
+                mapped_record_key = {k.replace(" ", "_"): v for k, v in mapped_record.key.items()}
+                updated_mapped_record = record.model_copy(update=mapped_record_key)
+                parsed_records.append(updated_mapped_record)
+            except ValidationError as e:
+                validation_failures.append({
+                    "record": translated,
+                    "error": str(e),
+                })
+                logger.warning(f"Skipped invalid record {translated}: {e}")
+                continue
+            except MappingNotFoundException as mnfe:
+                mapping_failures.append({
+                    "record": translated,
+                    "error": str(mnfe),
+                })
+                logger.warning(f"Skipped record due to mapping not found {translated}: {mnfe}")
+                continue
+        self.logs = {
+            "validation_failures": validation_failures,
+            "mapping_failures": mapping_failures,
+            "successful_records": len(parsed_records),
+        }
+        return parsed_records

bb_integrations_lib/pipelines/parsers/dtn/model.py

@@ -0,0 +1,79 @@
+import math
+from datetime import datetime, timedelta
+
+from bb_integrations_lib.shared.model import ConfigMatchMode, ConfigMode, MappingMode
+from pydantic import BaseModel, field_validator, Field
+from dateutil.parser import parse
+from bb_integrations_lib.shared.shared_enums import PriceType
+
+
+class SupplyOwnerConfig(BaseModel):
+    gravitate_id: str
+    extend_by_days: int = 3
+    expire_in_hours: int = 24
+
+class DTNIntegrationConfig(BaseModel):
+    config_name: str
+    ftp_credentials: str
+    file_match_mode: ConfigMatchMode = ConfigMatchMode.Partial
+    config_match_mode: ConfigMode = ConfigMode.ByName
+    mapping_mode: MappingMode = MappingMode.full
+    supply_owners: list[SupplyOwnerConfig]
+
+class DTNPriceRecord(BaseModel):
+    supplier: str
+    terminal: str
+    product: str
+    price: float
+    source_system: str = "DTN"
+    effective_from_date: datetime
+    brand: str | None = None
+    supply_owner: str | None = Field(default=None, alias="supply owner")
+    price_type: PriceType | None = Field(default=PriceType.rack, alias="price type")
+    contract: str | None = None
+    model_config = {'extra': 'ignore', 'populate_by_name': True}
+
+    @field_validator('supplier', 'terminal', 'product', 'price', mode='before')
+    @classmethod
+    def reject_nan(cls, v, info):
+        if v is None:
+            raise ValueError(f'{info.field_name} cannot be None')
+        if isinstance(v, str) and v.lower() == 'nan':
+            raise ValueError(f'{info.field_name} cannot be NaN')
+        if isinstance(v, float) and math.isnan(v):
+            raise ValueError(f'{info.field_name} cannot be NaN')
+        return v
+
+    @field_validator('effective_from_date', mode='before')
+    @classmethod
+    def parse_date(cls, v, info):
+        if isinstance(v, str):
+            try:
+                return parse(v)
+            except (ValueError, TypeError):
+                raise ValueError(f'{info.field_name} must be a valid datetime string')
+        return v
+
+    @property
+    def source_id(self) -> str:
+        parts = [self.supplier, self.terminal, self.product, self.source_system, self.supply_owner]
+        if self.brand:
+            parts.append(self.brand)
+        return "|".join(parts)
+
+    @property
+    def map_key(self):
+        return {
+            "supplier": self.supplier,
+            "terminal": self.terminal,
+            "product": self.product,
+            "brand": self.brand,
+        }
+
+    def add_days(self, days: int) -> datetime:
+        """Return effective_from_date plus the specified days."""
+        return self.effective_from_date + timedelta(days=days)
+
+    def add_hours(self, hours: int) -> datetime:
+        """Return effective_from_date plus the specified hours."""
+        return self.effective_from_date + timedelta(hours=hours)

bb_integrations_lib/pipelines/parsers/price_engine/parse_accessorials_prices_parser.py

@@ -0,0 +1,67 @@
+from datetime import datetime, timedelta
+from typing import  List, override
+
+import pytz
+from bb_integrations_lib.models.rita.mapping import MappingType
+from bb_integrations_lib.protocols.pipelines import Parser
+from bb_integrations_lib.shared.model import PEPriceData
+from loguru import logger
+
+
+class AccessorialPricesParser(Parser):
+    def __init__(self, tenant_name: str, source_system: str | None = None, timezone: str = "UTC"):
+        self.tz = timezone
+        super().__init__(tenant_name=tenant_name, source_system=source_system)
+
+    def __repr__(self) -> str:
+        return "Parse spot prices from rows to Sync Price Rows in Pricing Engine."
+
+    @override
+    async def parse(self, data: List[PEPriceData], mapping_type: MappingType | None = None) -> list[dict]:
+        mapper = await self.load_mapper()
+        mapping_failures = []
+        translation_failures = []
+        parsed_rows: List[dict] = []
+        processed_assessorial_ids = set()
+        latest_only = list(filter(lambda x: x.Rank == 1, data))
+        for translated_row in latest_only:
+            try:
+                local_tz = pytz.timezone(self.tz)
+                effective_from = datetime.now(local_tz).replace(
+                    hour=0, minute=0, second=0, microsecond=0
+                ) + timedelta(days=1)
+                price_instrument_id = translated_row.PriceInstrumentId
+                accessorial_id = mapper.get_gravitate_parent_id(str(price_instrument_id), MappingType.other)
+                price = translated_row.CurvePointPrices[0].Value
+                rate = mapper.get_gravitate_parent_id(str(accessorial_id), MappingType.other)
+                row = {
+                    "accessorial_id": accessorial_id,
+                    "effective_from_date": effective_from.isoformat(),
+                    "rate": str(AccessorialPricesParser.apply_rate(rate, price))
+                }
+                if accessorial_id not in processed_assessorial_ids:
+                    parsed_rows.append(row)
+                processed_assessorial_ids.add(accessorial_id)
+            except KeyError as e:
+                logger.warning(f"Failed to parse row {translated_row} due to mapping issue {e}")
+                mapping_failures.append(translated_row)
+                continue
+            except Exception as e:
+                logger.warning(f"Failed to parse row {translated_row} due to {e}")
+                translation_failures.append(translated_row)
+                continue
+        return parsed_rows
+
+    @staticmethod
+    def apply_rate(rate, value) -> float:
+        try:
+            float_value = float(value)
+        except (ValueError, TypeError):
+            raise ValueError(f"Invalid value: {value}")
+        match rate.lower():
+            case "positive":
+                return float_value
+            case "negative":
+                return float_value * -1
+            case _:
+                raise NotImplementedError(f"Unsupported rate: {rate}")

bb_integrations_lib/pipelines/parsers/price_engine/price_file_upload/price_merge_parser.py

@@ -0,0 +1,111 @@
+from typing import Dict, List, override, AsyncGenerator
+from dateutil.parser import parse
+from loguru import logger
+
+from bb_integrations_lib.models.rita.mapping import MappingType
+from bb_integrations_lib.pipelines.parsers.price_engine.price_file_upload.shared import PriceSyncParser
+from bb_integrations_lib.shared.model import MappingMode
+
+from bb_integrations_lib.protocols.flat_file import PELookup, \
+    PriceMergeIntegrationDTO, PriceMergeValue, PePriceMergeIntegration
+
+
+class PricesMergeParser(PriceSyncParser):
+    def __init__(self, tenant_name: str, source_system: str | None = None):
+        super().__init__(tenant_name, source_system)
+
+    def __repr__(self) -> str:
+        return "Parse prices from rows to Merge Price Rows in Pricing Engine."
+
+    @override
+    async def parse(self, data: List[Dict], mapping_type: MappingMode | None = None) -> AsyncGenerator[
+        PePriceMergeIntegration, None]:
+        mapper = await self.load_mapper()
+        mapping_failures = []
+        translation_failures = []
+        dtos: List[PriceMergeIntegrationDTO] = []
+        for translated_row in data:
+            try:
+                row_is_rvp = PricesMergeParser.is_rvp(
+                    translated_row.get('RVP', '0.0'))  # This will always be false if RVP does not exist
+                price_publisher_name = translated_row['price_publisher']
+                configuration = translated_row['configuration']
+                supplier_key = translated_row['supplier_key']
+                location_key = translated_row['location_key']
+                product_key = translated_row['product_key']
+                location_name = translated_row.get('location_name', None)
+                product_name = translated_row.get('product_name', None)
+                supplier_name = translated_row.get('supplier_name', None)
+                price_factor = translated_row.get('price_factor')
+                source_system_id = translated_row['source_system_id']
+                effective_from_str = translated_row['date']
+                effective_from_hrs_override = translated_row.get('effective_from_hrs_override', None)
+                effective_from_mins_override = translated_row.get('effective_from_mins_override', None)
+                effective_from = PricesMergeParser.get_effective_from_date(effective_from_str,
+                                                                           effective_from_hrs_override,
+                                                                           effective_from_mins_override)
+                effective_to_str = translated_row.get('effective_to',
+                                                      None)
+                effective_to_hrs_override = translated_row.get('effective_to_hrs_override', None)
+                effective_to_mins_override = translated_row.get('effective_to_mins_override', None)
+                effective_to = PricesMergeParser.get_effective_to_date(effective_to_str,
+                                                                       effective_to_hrs_override,
+                                                                       effective_to_mins_override)
+                price = translated_row['price']
+
+                if row_is_rvp and not "RVP" in product_key:
+                    product_key = PricesMergeParser.format_rvp_product(product_key, translated_row.get('RVP'))
+
+                if price_factor is not None:
+                    price = float(price) / int(price_factor)
+
+                if mapping_type == MappingMode.full:
+                    supplier_source_id = mapper.get_gravitate_child_id(source_parent_id=configuration,
+                                                                       source_child_id=supplier_key,
+                                                                       mapping_type=MappingType.counterparty)
+                    location_source_id = mapper.get_gravitate_child_id(source_parent_id=configuration,
+                                                                       source_child_id=location_key,
+                                                                       mapping_type=MappingType.terminal
+                                                                       )
+                    product_source_id = mapper.get_gravitate_child_id(source_parent_id=configuration,
+                                                                      source_child_id=product_key,
+                                                                      mapping_type=MappingType.product)
+                elif mapping_type == MappingMode.skip:
+                    supplier_source_id = supplier_key
+                    location_source_id = location_key
+                    product_source_id = product_key
+                else:
+                    raise ValueError(f"Unsupported mapping type: {mapping_type}")
+                if product_name is not None and location_name is not None and supplier_name is not None:
+                    price_instrument_name = f"{product_name} @ {location_name} - {supplier_name}"
+                else:
+                    price_instrument_name = f"{product_source_id} @ {location_source_id} - {supplier_source_id}"
+                price_instrument_source_string_id = f"{price_publisher_name} - {price_instrument_name}"
+                dtos.append(PriceMergeIntegrationDTO(
+                    PriceInstrumentLookup=PELookup(
+                        SourceIdString=price_instrument_source_string_id,
+                        SourceSystemId=int(source_system_id)
+                    ),
+                    EffectiveFromDateTime=effective_from,
+                    EffectiveToDateTime=effective_to,  # Effective to date is optional
+                    PriceValues=[
+                        PriceMergeValue(
+                            Value=float(price),
+                        )
+                    ]
+                ))
+            except (KeyError, ValueError) as e:
+                mapping_failures.append(translated_row)
+                logger.warning(f"Skipped record {translated_row} due to Key Error or Value Error: {e}")
+                continue
+            except Exception as uh:
+                translation_failures.append(translated_row)
+                logger.warning(f"Skipped record {translated_row} due to unhandled exception: {uh.args}")
+                continue
+            if dtos and price_publisher_name and source_system_id:
+                yield PePriceMergeIntegration(
+                    IntegrationDtos=dtos,
+                    SourceSystemId=int(source_system_id)
+                )
+            else:
+                logger.warning("No valid records were processed to create an integration")

bb_integrations_lib/pipelines/parsers/price_engine/price_file_upload/price_sync_parser.py

@@ -0,0 +1,107 @@
+from typing import  Dict, List, override, AsyncGenerator
+
+from loguru import logger
+
+from bb_integrations_lib.models.rita.mapping import MappingType
+from bb_integrations_lib.pipelines.parsers.price_engine.price_file_upload.shared import PriceSyncParser
+from bb_integrations_lib.shared.model import MappingMode
+from bb_integrations_lib.protocols.flat_file import PriceInstrumentDTO, PELookup, PeBulkSyncIntegration, \
+    BulkSyncIntegrationDTO, PriceTypeDTO
+
+
+class PricesSyncParser(PriceSyncParser):
+    def __init__(self, tenant_name: str, source_system: str | None = None):
+        super().__init__(tenant_name=tenant_name, source_system=source_system)
+
+    def __repr__(self) -> str:
+        return "Parse prices from rows to Sync Price Rows in Pricing Engine."
+
+    @override
+    async def parse(self, data: List[Dict], mapping_type: MappingMode | None = None) -> AsyncGenerator[
+        PeBulkSyncIntegration, None]:
+        mapper = await self.load_mapper()
+        mapping_failures = []
+        translation_failures = []
+        dtos: List[PriceInstrumentDTO] = []
+        for translated_row in data:
+            try:
+                row_is_rvp = PricesSyncParser.is_rvp(translated_row.get('RVP', '0.0'))
+                price_publisher_name = translated_row['price_publisher']
+                configuration = translated_row['configuration']
+                supplier_key = translated_row['supplier_key']
+                location_key = translated_row['location_key']
+                product_key = translated_row['product_key']
+                posting_type = translated_row.get('posting_type', "Posting")
+                location_name = translated_row.get('location_name', None)
+                product_name = translated_row.get('product_name', None)
+                supplier_name = translated_row.get('supplier_name', None)
+                if row_is_rvp and not "RVP" in product_key:
+                    product_key = PricesSyncParser.format_rvp_product(product_key, translated_row['RVP'])
+                source_system_id = translated_row['source_system_id']
+
+                if mapping_type == MappingMode.full:
+                    supplier_source_id = mapper.get_gravitate_child_id(source_parent_id=configuration,
+                                                                       source_child_id=supplier_key,
+                                                                       mapping_type=MappingType.counterparty)
+                    location_source_id = mapper.get_gravitate_child_id(source_parent_id=configuration,
+                                                                       source_child_id=location_key,
+                                                                       mapping_type=MappingType.terminal
+                                                                       )
+                    product_source_id = mapper.get_gravitate_child_id(source_parent_id=configuration,
+                                                                      source_child_id=product_key,
+                                                                      mapping_type=MappingType.product)
+                elif mapping_type == MappingMode.skip:
+                    supplier_source_id = supplier_key
+                    location_source_id = location_key
+                    product_source_id = product_key
+                else:
+                    raise ValueError(f"Unsupported mapping type: {mapping_type}")
+                if product_name is not None and location_name is not None and supplier_name is not None:
+                    price_instrument_name = f"{product_name} @ {location_name} - {supplier_name}"
+                else:
+                    price_instrument_name = f"{product_source_id} @ {location_source_id} - {supplier_source_id}"
+                price_instrument_source_string_id = f"{price_publisher_name} - {price_instrument_name}"
+                dtos.append(PriceInstrumentDTO(
+                    Name=price_instrument_name,
+                    Abbreviation=price_instrument_name,
+                    SourceIdString=price_instrument_source_string_id,
+                    ProductLookup=PELookup(
+                        SourceIdString=product_source_id,
+                        SourceSystemId=int(source_system_id)
+                    ),
+                    LocationLookup=PELookup(
+                        SourceIdString=location_source_id,
+                        SourceSystemId=int(source_system_id)
+                    ),
+                    CounterPartyLookup=PELookup(
+                        SourceIdString=supplier_source_id,
+                        SourceSystemId=int(source_system_id)
+                    )
+                ))
+            except (KeyError, ValueError) as e:
+                mapping_failures.append(translated_row)
+                logger.warning(f"Skipped record {translated_row} due to Key Error or Value Error: {e}")
+                continue
+            except Exception as uh:
+                translation_failures.append(translated_row)
+                logger.warning(f"Skipped record {translated_row} due to unhandled exception: {uh.args}")
+                continue
+            if dtos and price_publisher_name and source_system_id:
+                yield PeBulkSyncIntegration(
+                    IntegrationDtos=[
+                        BulkSyncIntegrationDTO(
+                            Name=price_publisher_name,
+                            Abbreviation=price_publisher_name,
+                            SourceIdString=price_publisher_name,
+                            PriceInstrumentDTOs=dtos,
+                            PriceTypeDTOs=[
+                                PriceTypeDTO(
+                                    PriceTypeMeaning=posting_type
+                                )
+                            ]
+                        )
+                    ],
+                    SourceSystemId=int(source_system_id)
+                )
+            else:
+                logger.warning("No valid records were processed to create an integration")

bb_integrations_lib/pipelines/parsers/price_engine/price_file_upload/shared.py

@@ -0,0 +1,81 @@
+from typing import List, Dict, Any
+
+from dateutil.parser import parse
+
+from bb_integrations_lib.protocols.pipelines import Parser
+from bb_integrations_lib.shared.model import MappingMode
+
+
+class PriceSyncParser(Parser):
+    def __init__(self, tenant_name: str, source_system: str | None = None):
+        super().__init__(tenant_name=tenant_name, source_system=source_system)
+
+    def __repr__(self) -> str:
+        return "Parse prices from rows to Sync Price Rows in Pricing Engine."
+
+    async def parse(self, data: List[Dict], mapping_type: MappingMode | None = None) -> Any:
+        pass
+
+    @staticmethod
+    def is_rvp(rvp: str) -> bool:
+        try:
+            return float(rvp) > 0.0
+        except (ValueError, TypeError):
+            return False
+
+    @staticmethod
+    def format_rvp_product(product_key: str, rvp: str | None) -> str:
+        if not rvp:
+            return product_key
+        rvp_str = str(rvp)
+        if product_key.endswith(rvp_str):
+            product_key = product_key[:-len(rvp_str)]
+        product_key = product_key.rstrip('.')
+        return f"{product_key}{float(rvp_str)}"
+
+    @staticmethod
+    def get_effective_to_date(effective_to_str: str | None,
+                              effective_to_hrs_override: str | None,
+                              effective_to_minutes_override: str | None) -> str | None:
+        return PriceSyncParser.get_date_override(effective_to_str, effective_to_hrs_override,
+                                                 effective_to_minutes_override)
+
+    @staticmethod
+    def get_effective_from_date(effective_from_str: str | None,
+                                effective_from_hrs_override: str | None,
+                                effective_from_minutes_override: str | None) -> str | None:
+        return PriceSyncParser.get_date_override(effective_from_str, effective_from_hrs_override,
+                                                 effective_from_minutes_override)
+
+    @staticmethod
+    def get_date_override(date_str: str | None,
+                          date_to_hrs_override: str | None,
+                          date_to_minutes_override: str | None) -> str | None:
+
+        if not date_str:
+            return date_str
+
+        parsed_date = parse(date_str)
+
+        if date_to_hrs_override and date_to_minutes_override:
+            return parsed_date.replace(
+                hour=int(date_to_hrs_override),
+                minute=int(date_to_minutes_override),
+                second=0
+            ).isoformat()
+
+        elif date_to_hrs_override:
+            return parsed_date.replace(
+                hour=int(date_to_hrs_override),
+                minute=0,
+                second=0
+            ).isoformat()
+
+        elif date_to_minutes_override:
+            return parsed_date.replace(
+                minute=int(date_to_minutes_override),
+                second=0
+            ).isoformat()
+
+        else:
+            return date_str