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

bb_integrations_lib/provider/api/cargas/client.py

@@ -0,0 +1,43 @@
+import httpx
+
+from bb_integrations_lib.provider.api.cargas.model import CreateWholesaleTicketRequest, CreateWholesaleFeeLineRequest, \
+    CreateWholesaleLineRequest
+
+
+class CargasClient(httpx.AsyncClient):
+    def __init__(self,
+                 api_key: str,
+                 base_url: str = " https://cargase.aeroenergy.com/cargasenergy/API"):
+        super().__init__(base_url=base_url)
+        self.api_key = api_key
+
+    @property
+    def custom_headers(self) -> dict:
+        return {
+            'APIKey': self.api_key,
+            'Content-Type': 'application/json'
+        }
+
+    async def create_wholesale_ticket(self, data: CreateWholesaleTicketRequest) -> dict:
+        url = '/CreateWholesaleTicket'
+        res = await self.post(
+            url=url, headers=self.custom_headers, json=data.model_dump(exclude_none=True, mode="json")
+        )
+        res.raise_for_status()
+        return res.json()
+
+    async def create_wholesale_line(self, data: CreateWholesaleLineRequest) -> dict:
+        url = '/CreateWholesaleLine'
+        res = await self.post(
+            url=url, headers=self.custom_headers, json=data.model_dump(exclude_none=True, mode="json")
+        )
+        res.raise_for_status()
+        return res.json()
+
+    async def create_wholesale_fee_line(self, data: CreateWholesaleFeeLineRequest) -> dict:
+        url = '/CreateWholesaleFeeLine'
+        res = await self.post(
+            url=url, headers=self.custom_headers, json=data.model_dump(exclude_none=True, mode="json")
+        )
+        res.raise_for_status()
+        return res.json()

bb_integrations_lib/provider/api/cargas/model.py

@@ -0,0 +1,49 @@
+from datetime import datetime
+from typing import Optional
+
+from pydantic import BaseModel
+
+
+class CreateWholesaleFeeLineRequest(BaseModel):
+    DocumentID: str
+    ItemID: str
+    Quantity: Optional[float] = None
+    UnitPrice: Optional[float] = None
+    UserName: str
+
+
+class CreateWholesaleLineRequest(BaseModel):
+    DocumentID: int
+    ItemID: int
+    TankID: int
+    Quantity: float
+    QuantityGross: float
+    UnitPrice: Optional[float] = None
+    FreightRateID: Optional[float] = None
+    VendorLocationID: Optional[float] = None
+    FreightAmount: Optional[float] = None
+    SurchargeAmount: Optional[float] = None
+    UnitCostOverride: Optional[float] = None
+    CustomerPricingID: Optional[str] = None
+    UserName: str
+
+
+class CreateWholesaleTicketRequest(BaseModel):
+    CustomerID: int
+    DeliveryDate: datetime
+    CustomerPONumber: Optional[str] = None
+    DriverID: Optional[int] = None
+    WholesaleTruckID: Optional[int] = None
+    Message: Optional[str] = None
+    InvoiceNotes: Optional[str] = None
+    CostCenterID: Optional[int] = None
+    SubTypeID: Optional[int] = None
+    SalespersonID: Optional[int] = None
+    AdditionalNotes: Optional[str] = None
+    UserName: str
+
+
+class CreateWholesaleTicketRequestBundle(BaseModel):
+    ticket_request: CreateWholesaleTicketRequest
+    line_requests: list[CreateWholesaleLineRequest] = []
+    fee_line_requests: list[CreateWholesaleLineRequest] = []

bb_integrations_lib/provider/api/cargas/protocol.py

@@ -0,0 +1,23 @@
+from bb_integrations_lib.provider.api.cargas.model import CreateWholesaleTicketRequest, CreateWholesaleLineRequest, \
+    CreateWholesaleFeeLineRequest
+
+
+class CargasClient():
+    def __init__(self,
+                 api_key: str,
+                 base_url: str = " https://cargase.aeroenergy.com/cargasenergy/API"):
+        self.base_url = base_url
+        self.api_key = api_key
+
+    @property
+    def custom_headers(self) -> dict:
+        return {
+            'APIKey': self.api_key,
+            'Content-Type': 'application/json'
+        }
+
+    async def create_wholesale_ticket(self, data: CreateWholesaleTicketRequest): ...
+
+    async def create_wholesale_line(self, data: CreateWholesaleLineRequest): ...
+
+    async def create_wholesale_fee_line(self, data: CreateWholesaleFeeLineRequest): ...

bb_integrations_lib/provider/api/dtn/client.py

@@ -0,0 +1,128 @@
+import asyncio
+from contextlib import contextmanager
+from typing import Dict, List
+import httpx
+import pandas as pd
+
+class DTNClient(httpx.AsyncClient):
+    def __init__(
+            self, username: str,
+            web_service_key: str,
+            api_key: str,
+            base_url: str,
+            timeout: float = 180.0,
+    ):
+        super().__init__(base_url=base_url)
+        self.username = username
+        self.web_service_key = web_service_key
+        self.api_key = api_key
+        self.base_url = base_url.rstrip("/")
+        self.client = httpx.AsyncClient(timeout=180)
+        self.timeout = httpx.Timeout(timeout, connect=60.0)
+
+    def __repr__(self):
+        return """DTN API Client designed for DTN Allocation Tracker"""
+
+    @property
+    def custom_headers(self) -> Dict[str, str]:
+        return {
+            'username': self.username,
+            'Accept': 'application/vnd.dtn.energy.v1+JSON',
+            'webservicekey': self.web_service_key,
+            'apikey': self.api_key,
+        }
+
+    async def get_allocations(self) -> List[Dict]:
+        url = '/allocations'
+        res = await self.get(url=url, headers=self.custom_headers, timeout=self.timeout)
+        return res.json()
+
+    async def get_data_in_group(self, url: str) -> List[Dict]:
+        if url.startswith(self.base_url):
+            url = url.removeprefix(self.base_url)
+        if not url.startswith('/'):
+            url = f'/{url}'
+        res = await self.get(
+            url=url,
+            headers=self.custom_headers,
+            timeout=self.timeout
+        )
+        return res.json()
+
+    async def get_terminal(self, href) -> Dict:
+        res = await self.get(url=href, headers=self.custom_headers, timeout=self.timeout)
+        return res.json()
+
+
+
+@contextmanager
+def init_dtn_api(username=None, web_service_key=None, api_key=None) -> DTNClient:
+    dtn_client = DTNClient(
+        username=username,
+        web_service_key=web_service_key,
+        api_key=api_key,
+        base_url='https://api.dtn.com/fuelsuite/allocationtracker/'
+    )
+    yield dtn_client
+
+
+def parse_allocation_data(allocation_data):
+    ret = []
+    for allocation in allocation_data['data']:
+        supplier = allocation.get('supplier', {})
+        location_data = allocation.get('location', {})
+        customer_data = allocation.get('customer', {})
+        consignee_group_data = customer_data.get('consigneeGroup', {})
+        product_group_data = allocation.get('productAllocationList', [])
+        terminal_data = location_data.get('terminal', {}) or {}
+        location_group_data = location_data.get('terminalGroup', {}) or {}
+        sold_to_data = consignee_group_data.get('soldTo', {}) or {}
+        supplier_name = supplier.get('name')
+        supplier_code = supplier.get('sellerNum')
+        terminal_name = location_group_data.get('name') or terminal_data.get('name') or None
+        terminal_code = location_group_data.get('id') or terminal_data.get('id') or None
+        terminal_hfref = location_group_data.get('terminalListLink', {}).get('href')
+        consignee_name = consignee_group_data.get('name')
+        consignee_id = consignee_group_data.get('id')
+        sold_to_id = sold_to_data.get('id')
+        sold_to_name = sold_to_data.get('name')
+        for group in product_group_data:
+            product_group_name = group.get('name')
+            uom = group.get('unitOfMeasure')
+            allocation_remaining_monthly = group.get('allocationRemainingAmountMonthly')
+            lifted_amount_monthly = group.get('liftedAmountMonthly')
+            refresh_amount_monthly = group.get('refreshAmountMonthly')
+            refresh_date_monthly = group.get('refreshDateMonthly')
+            scaled_start_amount_monthly = group.get('scaledStartAmountMonthly')
+            start_amount_monthly = group.get('startAmountMonthly')
+            row = {
+                'supplier_name': supplier_name,
+                'supplier_code': supplier_code,
+                'terminal_name': terminal_name,
+                'terminal_code': terminal_code,
+                'terminal_hfref': terminal_hfref,
+                'consignee_name': consignee_name,
+                'consignee_id': consignee_id,
+                'sold_to_name': sold_to_name,
+                'sold_to_id': sold_to_id,
+                'product_group_name': product_group_name,
+                'uom': uom,
+                'allocation_remaining_monthly': allocation_remaining_monthly,
+                'lifted_amount_monthly': lifted_amount_monthly,
+                'refresh_amount_monthly': refresh_amount_monthly,
+                'refresh_date_monthly': refresh_date_monthly,
+                'scaled_start_amount_monthly': scaled_start_amount_monthly,
+                'start_amount_monthly': start_amount_monthly,
+            }
+            ret.append(row)
+    return pd.DataFrame(ret)
+
+
+if __name__ == "__main__":
+    async def get_allocation_data():
+        with init_dtn_api(username="", web_service_key="", api_key="") as dtn_client:
+            allocations = await dtn_client.get_allocations()
+            print(allocations)
+
+
+    asyncio.run(get_allocation_data())

bb_integrations_lib/provider/api/dtn/protocol.py

@@ -0,0 +1,9 @@
+from typing import Optional, Dict, Protocol, List
+
+
+class DTNClient(Protocol):
+    async def get_allocations(self) -> List[Dict]:
+        """Get all allocation data"""
+
+    async def get_data_in_group(self, url: str) -> List[Dict]:
+        """Get data in group href"""

bb_integrations_lib/provider/api/keyvu/client.py

@@ -0,0 +1,30 @@
+import httpx
+from httpx import Request, Response
+
+from bb_integrations_lib.provider.api.keyvu.model import KeyVuDeliveryPlan, default_serialization_options
+
+
+class KeyVuAuth(httpx.Auth):
+    def __init__(self, token):
+        self.token = token
+
+    def auth_flow(self, request: Request):
+        request.headers["Keyvu-Api-Key"] = self.token
+        yield request
+
+
+class KeyVuClient:
+    def __init__(self, api_key: str):
+        self.base_url = ""
+        self.api_key = api_key
+        self.client = httpx.AsyncClient(auth=KeyVuAuth(self.api_key))
+
+    def build_url(self, tail: str) -> str:
+        return f"{self.base_url}/{tail}"
+
+    async def upload_deliveryplan(self, data: KeyVuDeliveryPlan, override_filename: str | None = None) -> Response:
+        return await self.client.post(
+            url=self.build_url("upload/deliveryplan"),
+            content=data.to_xml(**default_serialization_options),
+            headers={"filename": override_filename} if override_filename else {}
+        )

bb_integrations_lib/provider/api/keyvu/model.py

@@ -0,0 +1,149 @@
+from datetime import datetime
+from enum import Enum
+from typing import Optional
+
+# from pydantic import BaseModel
+from pydantic_xml import BaseXmlModel, element
+
+default_serialization_options = {
+    "skip_empty": False, "exclude_none": False, "exclude_unset": True
+}
+"""To be passed to pydantic_xml.BaseXmlModel.to_xml when sending to the KeyVu API"""
+
+
+class DeliveryStatus(str, Enum):
+    planned = "Planned"
+    on_route_not_loaded = "OnRouteNotLoaded"
+    loading = "Loading"
+    on_route_loaded = "OnRouteLoaded"
+    unloading = "Unloading"
+    delivered = "Delivered"
+    confirmed = "Confirmed"
+    canceled = "Canceled"
+
+
+class UnitSystem(str, Enum):
+    metric = "Metric"
+    imperial = "Imperial"
+
+
+class KeyVuDeliveryPlan(BaseXmlModel, tag="Loads", nsmap={"": "http://keyvu.com/schemas/carrierloads/v6",
+                                                          "xsi": "http://www.w3.org/2001/XMLSchema-instance",
+                                                          "xsd": "http://www.w3.org/2001/XMLSchema"}):
+    start_date: datetime = element(tag="StartDate")
+    end_date: datetime = element(tag="EndDate")
+    export_date: datetime = element(tag="ExportDate")
+    deliveries: Optional[list["Delivery"]] = element(tag="Delivery", default=None, nillable=True)
+
+class GeoLocation(BaseXmlModel):
+    longitude: Optional[float] = element(tag="Longitude", nillable=True, default=None)
+    latitude: Optional[float] = element(tag="Latitude", nillable=True, default=None)
+    heading: Optional[float] = element(tag="Heading", nillable=True, default=None)
+    last_updated: Optional[datetime] = element(tag="LastUpdated", nillable=True, default=None)
+
+
+class Delivery(BaseXmlModel):
+    id: str = element(tag="Id")
+    carrier_name: Optional[str] = element(tag="CarrierName", default=None)
+    scac: Optional[str] = element(tag="Scac", default=None)
+    station_deliveries_array: "StationDeliveryArray" = element(tag="StationDeliveries", default=None)
+    trailer: Optional[str] = element(tag="Trailer", default=None)
+    last_updated: datetime = element(tag="LastUpdated")
+    geo_location: "GeoLocation" = element(tag="GeoLocation", default_factory=lambda: GeoLocation(longitude=None, latitude=None, heading=None, last_updated=None))
+    unit: str = element(tag="Unit")
+
+    def __init__(self, station_deliveries: list["StationDelivery"], **kwargs):
+        super().__init__(**kwargs)
+        self.station_deliveries = station_deliveries
+
+    @property
+    def station_deliveries(self) -> list["StationDelivery"] | None:
+        return self.station_deliveries_array.station_deliveries
+
+    @station_deliveries.setter
+    def station_deliveries(self, new_deliveries: list["StationDelivery"]) -> None:
+        self.station_deliveries_array = StationDeliveryArray(station_deliveries=new_deliveries)
+
+
+class StationDeliveryArray(BaseXmlModel):
+    station_deliveries: Optional[list["StationDelivery"]] = element(tag="StationDelivery", default=None)
+
+
+class StationDelivery(BaseXmlModel):
+    delivery_status: DeliveryStatus = element(tag="DeliveryStatus")
+    site_id: Optional[str] = element(tag="SiteId", default=None)
+    details_array: Optional["StationDeliveryDetailsArray"] = element(tag="Details", default=None)
+    bill_of_ladings_array: Optional["StationDeliveryBOLArray"] = element(tag="BillOfLadings", default=None)
+    tractor: Optional[str] = element(tag="Tractor", default=None)
+    delivery_date: datetime = element(tag="DeliveryDate")
+    carrier_delivery_status: Optional[str] = element(tag="CarrierDeliveryStatus", default=None)
+
+    def __init__(self, details: list["StationDeliveryDetails"] | None = None,
+                 bill_of_ladings: list["StationDeliveryBOL"] | None = None, **kwargs):
+        super().__init__(**kwargs)
+        self.details = details
+        self.bill_of_ladings = bill_of_ladings
+
+    @property
+    def details(self) -> list["StationDeliveryDetails"] | None:
+        if not self.details_array:
+            return None
+        return self.details_array.details
+
+    @details.setter
+    def details(self, new_details: list["StationDeliveryDetails"]) -> None:
+        self.details_array = StationDeliveryDetailsArray(details=new_details)
+
+    @property
+    def bill_of_ladings(self) -> list["StationDeliveryBOL"] | None:
+        if not self.bill_of_ladings_array:
+            return None
+        return self.bill_of_ladings_array.bill_of_ladings
+
+    @bill_of_ladings.setter
+    def bill_of_ladings(self, new_bols: list["StationDeliveryBOL"]) -> None:
+        self.bill_of_ladings_array = StationDeliveryBOLArray(bill_of_ladings=new_bols)
+
+
+class StationDeliveryDetailsArray(BaseXmlModel):
+    details: Optional[list["StationDeliveryDetails"]] = element(tag="StationDeliveryDetails", default=None)
+
+
+class StationDeliveryDetails(BaseXmlModel, tag="StationDeliveryDetails", skip_empty=True):
+    delivered_volume: Optional[float] = element(tag="DeliveredVolume", nillable=True)
+    volume_unit: UnitSystem = element(tag="VolumeUnit")
+    tank_sequence: Optional[int] = element(tag="TankSequence", default=None)
+    product_id: Optional[str] = element(tag="ProductId", default=None)
+    product: Optional[str] = element(tag="Product", default=None)
+    is_retained: bool = element(tag="IsRetained")
+
+    @staticmethod
+    def from_v1_order_dict(details: dict) -> "StationDeliveryDetails":
+        # Prefer using tank sequence, but fall back to product ID based matching. This is the behavior KeyVu prefers.
+        tank_sequence = details.get("tank_id")
+        product_id = None
+        product = None
+        if not tank_sequence:
+            product_id = details.get("product_source_id")
+            product = details.get("product_name")
+
+        return StationDeliveryDetails(
+            delivered_volume=details.get("quantity", 0.0),
+            volume_unit=UnitSystem.imperial,
+            tank_sequence=tank_sequence,
+            product_id=product_id,
+            product=product,
+            is_retained=False # TODO: Support retains
+        )
+
+
+class StationDeliveryBOLArray(BaseXmlModel):
+    bill_of_ladings: Optional[list["StationDeliveryBOL"]] = element(tag="StationDeliveryBillOfLadings")
+
+
+class StationDeliveryBOL(BaseXmlModel):
+    terminal_name: Optional[str] = element(tag="TerminalName", nillable=True)
+    terminal_control_number: str = element(tag="TerminalControlNumber")
+    bill_of_lading_number: str = element(tag="BillOfLadingNumber")
+    supplier: str = element(tag="Supplier")
+    consignee: str = element(tag="Consignee", default="")

bb_integrations_lib/provider/api/macropoint/client.py

@@ -0,0 +1,28 @@
+import base64
+from functools import lru_cache
+import httpx
+from httpx import Response
+from bb_integrations_lib.provider.api.macropoint.model import LocationUpdateRequest
+
+
+class MacropointClient(httpx.AsyncClient):
+    def __init__(self, username, password):
+        super().__init__()
+        self.username = username
+        self.password = password
+        self._headers = {}
+
+    @lru_cache(maxsize=1)
+    async def _get_token(self):
+        encoded = base64.standard_b64encode(f"{self.username}:{self.password}".encode()).decode()
+        return f"Basic {encoded}"
+
+    async def update_location(self, req: LocationUpdateRequest) -> Response:
+        return await self.post(
+            url="https://macropoint-lite.com/api/1.0/tms/data/location",
+            headers={
+                "Content-Type": "application/xml",
+                "Authorization": await self._get_token(),
+            },
+            data=req.to_xml()
+        )

bb_integrations_lib/provider/api/macropoint/model.py

@@ -0,0 +1,40 @@
+from pydantic_xml import BaseXmlModel, element
+
+
+class Sender(
+    BaseXmlModel,
+):
+    load_id: str = element("LoadID")
+
+class Requestor(
+    BaseXmlModel,
+):
+    mpid: str = element("MPID")
+    load_id: str = element("LoadID")
+
+class AllowAccessFrom(
+    BaseXmlModel,
+):
+    mpid: str = element("MPID")
+
+class Coordinates(
+    BaseXmlModel,
+):
+    latitude: float = element("Latitude")
+    longitude: float = element("Longitude")
+
+class Location(
+    BaseXmlModel,
+):
+    coordinates: Coordinates = element("Coordinates")
+    created_date_time: str = element("CreatedDateTime")
+
+class LocationUpdateRequest(
+    BaseXmlModel,
+    tag="TMSLocationData",
+    nsmap={"": 'http://macropoint-lite.com/xml/1.0'}
+):
+    sender: Sender = element("Sender")
+    requestor: Requestor = element("Requestor")
+    allow_access_from: AllowAccessFrom = element("AllowAccessFrom")
+    location: Location = element("Location")

bb_integrations_lib/provider/api/pc_miler/client.py

@@ -0,0 +1,130 @@
+import asyncio
+
+import httpx
+from loguru import logger
+from pydantic import ValidationError
+from bb_integrations_lib.provider.api.pc_miler.model import TokenData
+
+route_reports_eagle_standard_params = {
+    "ReportRoutes": [
+        {
+            "ReportingOptions": {
+                "UseTollData": True,
+                "TollDiscount": "All",
+                "IncludeFerryDistance": True,
+                "EstimatedTimeOptions": {
+                    "ETAETD": 1,
+                    "DateOption": 2,
+                    "DateAndTime": {
+                        "DayOfWeek": 4,
+                        "TimeOfDay": "10:00 AM",
+                        "TimeZone": 0
+                    }
+                },
+                "UseTraffic": True
+            },
+            "ReportTypes": [
+                {
+                    "__type": "StateReportType:http://pcmiler.alk.com/APIs/v1.0",
+                    "SortByRoute": False
+                },
+                {
+                    "__type": "GeoTunnelReportType:http://pcmiler.alk.com/APIs/v1.0",
+                    "CiteInterval": 5.0
+                }
+            ],
+            "Stops": [
+                {
+                    "Coords": {
+                        "Lat": "38.36440700",
+                        "Lon": "-82.60173800"
+                    }
+                },
+                {
+                    "Coords": {
+                        "Lat": "38.08867300",
+                        "Lon": "-81.83779700"
+                    }
+                }
+            ],
+            "Options": {
+                "VehicleType": 0,
+                "RoutingType": 0,
+                "HighwayOnly": False,
+                "DistanceUnits": 0,
+                "TollRoads": 3,
+                "BordersOpen": True,
+                "OverrideRestrict": False,
+                "HazMatType": 4,
+                "RouteOptimization": 0,
+                "hubRouting": False,
+                "SideOfStreetAdherence": 0,
+                "ferryDiscourage": True,
+                "AFSetIDs": [-1],
+                "UseSites": True
+            }
+        }
+    ]
+}
+
+
+class PCMilerClient(httpx.AsyncClient):
+    def __init__(
+            self,
+            base_url: str,
+            username: str,
+            password: str,
+            api_key: str,
+            timeout: float = 180.0,
+    ):
+        super().__init__(base_url=base_url)
+        self.username = username
+        self.password = password
+        self.api_key = api_key
+        self.apis = PCMilerAPIWrapper(client=self)
+        self.timeout = httpx.Timeout(timeout, connect=60.0)
+
+    def __repr__(self):
+        return """PC Miler Client designed for PC Miler Web Service"""
+
+    async def get_token(self, url: str) -> TokenData:
+        try:
+            json_data = {'apiKey': self.api_key}
+            response = await self.post(url, json=json_data)
+            response.raise_for_status()
+            response_data = response.json()
+            return TokenData.model_validate(response_data)
+
+        except httpx.ReadTimeout as e:
+            logger.error(f"Request timed out while getting token: {e}")
+            raise
+
+        except httpx.HTTPStatusError as e:
+            status_code = e.response.status_code
+            logger.error(f"HTTP error {status_code} while getting token: {e.response.text}")
+            raise
+
+        except httpx.HTTPError as e:
+            logger.error(f"HTTP error occurred while getting token: {e}")
+            raise
+
+        except ValidationError as e:
+            logger.error(f"Invalid token data received: {e}")
+            raise
+
+        except Exception as e:
+            logger.error(f"Unexpected error while getting token: {e}")
+            raise
+
+
+class PCMilerAPIWrapper:
+    def __init__(self, client: PCMilerClient):
+        from bb_integrations_lib.provider.api.pc_miler.web_services_apis import RoutingAPI
+        from bb_integrations_lib.provider.api.pc_miler.web_services_apis import SingleSearchAPI
+        from bb_integrations_lib.provider.api.pc_miler.web_services_apis import PlacesAPI
+
+        self.routing = RoutingAPI(client=client)
+        self.single_search = SingleSearchAPI(client=client)
+        self.places = PlacesAPI(client=client)
+
+

bb_integrations_lib/provider/api/pc_miler/model.py

@@ -0,0 +1,6 @@
+from pydantic import BaseModel
+
+
+class TokenData(BaseModel):
+    token: str
+    expires: str