Source code for ecstask.oos_product_availability.osp_availability_interface

import logging
import traceback
import concurrent.futures
from typing import Dict, List, Any
from pymorri.exceptions import MoriException, MoriTimeoutException

logging.basicConfig(
    level=logging.INFO,
    format='[%(levelname)s] (%(threadName)s) %(message)s',
)
logger = logging.getLogger(__name__)
logger.setLevel(level=logging.DEBUG)


class OspAvailabilityInterface:
    def __init__(self, configuration: Dict, ssm_credentials: Dict, availability_override_obj: object):
        self.configuration = configuration
        self.ssm_credentials = ssm_credentials
        self.availability_override_obj = availability_override_obj

    def put_product_availability(self, min_id: int, store_id: int, list_override_json: list,
                                 time_out_seconds: int) -> Dict:

        response = None
        try:
            response = self.availability_override_obj.set_list_of_item_overrides_for_dates(
                min_id, store_id, list_override_json, timeout=time_out_seconds
            )  # Need to Discuss

        except MoriTimeoutException as morri_timeout_exc:
            logger.error(
                f" OSP_PRODUCT_AVAILABILITY_OOS_ALARM MoriTimeoutException {morri_timeout_exc}; "
                f"min_id: {min_id}, store_id: {store_id}")
        except Exception as ex:
            logger.error(
                f" OSP_PRODUCT_AVAILABILITY_OOS_ALARM Exception {ex} CAUGHT (TRACEBACK BELOW); min_id: {min_id}, "
                f"store_id: {store_id}")
            traceback.print_exc()

        return response

    def process(self, min_id: str, store_list: list, list_override_json: list):

        is_success = True
        with concurrent.futures.ThreadPoolExecutor(
                max_workers=self.configuration.get("OSP_API_CONCURRENT_THREADS")) as executor:
            item_futures = {
                executor.submit(self.put_product_availability, min_id, str(store_id).zfill(3), list_override_json,
                                self.configuration.get("OSP_TIMEOUT_SECONDS")): store_id for store_id in store_list}
            for future in concurrent.futures.as_completed(item_futures):
                store_id = item_futures[future]

                osp_api_response = future.result()

                logger.info(f"API RESPONSE: {osp_api_response}")
                if osp_api_response is None:
                    is_success = False
                elif osp_api_response['status'] == 200:
                    logger.info(
                        f"{osp_api_response['message']} for ProductId {min_id} and SiteId {str(store_id).zfill(3)} ")
                else:
                    logger.error(
                        f" OSP_PRODUCT_AVAILABILITY_OOS_ALARM ProductId {min_id}, SiteId {str(store_id).zfill(3)}"
                        f" {osp_api_response['message']}")
                    is_success = False

        return is_success