SupplyNetPy Components.core Module

def __init__(self, node:object, periodic_update:bool=False, period:float=1):
    """
    Initialize the statistics object.

    Parameters:
        node (object): The node for which statistics are tracked.
        periodic_update (bool, optional): Whether to update statistics periodically. Default is False.
        period (float, optional): Time interval for periodic updates. Default is 1.

    Attributes:
        node (object): The node to which this statistics object belongs.
        name (str): Name of the statistics object.
        demand_placed (list): Orders and quantities placed by this node.
        fulfillment_received (list): Orders and quantities received by this node.
        demand_received (list): Orders and quantities demanded at this node.
        demand_fulfilled (list): Orders and quantities fulfilled by this node.
        orders_shortage (list): Orders and quantities that faced shortage.
        backorder (list): Backorders at this node.
        inventory_level (float): Current inventory level.
        inventory_waste (float): Inventory waste.
        inventory_carry_cost (float): Inventory carrying cost.
        inventory_spend_cost (float): Inventory replenishment cost.
        transportation_cost (float): Transportation cost.
        node_cost (float): Total cost at this node.
        revenue (float): Revenue generated by this node.
        profit (float): Profit generated by this node.
        _info_keys (list): Keys to include in the info dictionary.
        _stats_keys (list): Keys to include in the statistics dictionary.

    Returns:
        None
    """
    self._info_keys = ["name"]
    self._stats_keys = ["demand_placed", "fulfillment_received", "demand_received", "demand_fulfilled", "orders_shortage", "backorder", "inventory_level", "inventory_waste", "inventory_carry_cost", "inventory_spend_cost", "transportation_cost", "node_cost", "revenue", "profit"]
    self.node = node # the node to which this statistics object belongs
    self.name = f"{self.node.ID} statistics"
    self.demand_placed = [0,0] # demand placed by this node [total orders placed, total quantity]
    self.fulfillment_received = [0,0] # fulfillment received by this node
    self.demand_received = [0,0] # demand received by this node (demand at this node)
    self.demand_fulfilled = [0,0] # demand fulfilled by this node (demand that was served by this node)
    self.orders_shortage = [0,0] # shortage of products at this node 
    self.backorder = [0,0] # any backorders at this node
    self.inventory_level = 0 # current inventory level at this node
    self.inventory_waste = 0 # inventory waste at this node
    self.inventory_carry_cost = 0 # inventory carrying cost at this node
    self.inventory_spend_cost = 0 # inventory replenishment cost at this node
    self.transportation_cost = 0 # transportation cost at this node
    self.node_cost = 0 # total cost at this node
    self.revenue = 0 # revenue generated by this node
    self.profit = 0 # profit generated by this node (revenue - total cost)

    if(periodic_update):
        self.node.env.process(self.update_stats_periodically(period=period))

def __init__(self, 
             ID: str, 
             name: str, 
             extraction_quantity: float, 
             extraction_time: float, 
             mining_cost: float,
             cost: float) -> None:
    """
    Initialize the raw material object.

    Parameters:
        ID (str): ID of the raw material (alphanumeric)
        name (str): name of the raw material
        extraction_quantity (float): quantity of the raw material that is extracted in extraction_time
        extraction_time (float): time to extract 'extraction_quantity' units of raw material
        mining_cost (float): mining cost of the raw material (per item)
        cost (float): selling cost of the raw material (per item)

    Attributes:
        _info_keys (list): list of keys to include in the info dictionary
        _stats_keys (list): list of keys to include in the statistics dictionary
        ID (str): ID of the raw material (alphanumeric)
        name (str): name of the raw material
        extraction_quantity (float): quantity of the raw material that is extracted in extraction_time
        extraction_time (float): time to extract 'extraction_quantity' units of raw material
        mining_cost (float): mining cost of the raw material (per item)
        cost (float): selling cost of the raw material (per item)

    Returns:
        None
    """
    validate_positive("Extraction quantity", extraction_quantity)
    validate_non_negative("Extraction time", extraction_time)
    validate_non_negative("Mining Cost", mining_cost)
    validate_positive("Cost", cost)
    self._info_keys = ["ID", "name", "extraction_quantity", "extraction_time", "mining_cost", "cost"]
    self._stats_keys = []        
    self.ID = ID # ID of the raw material (alphanumeric)
    self.name = name # name of the raw material
    self.extraction_quantity = extraction_quantity # quantity of the raw material that is extracted in extraction_time
    self.extraction_time = extraction_time # time to extract 'extraction_quantity' units of raw material
    self.mining_cost = mining_cost # mining cost of the raw material (per item)
    self.cost = cost # selling cost of the raw material (per item)

def __init__(self, 
             ID: str, 
             name: str, 
             manufacturing_cost: float, 
             manufacturing_time: float, 
             sell_price: float, 
             raw_materials: list, 
             batch_size: int, 
             buy_price: float = 0) -> None:
    """
    Initialize the product object.

    Performs input validation for positive and non-negative values, and ensures raw materials are provided.

    Parameters:
        ID (str): ID of the product (alphanumeric)
        name (str): Name of the product
        manufacturing_cost (float): Manufacturing cost of the product per unit
        manufacturing_time (float): Time to manufacture one batch of products
        sell_price (float): Price at which the product is sold
        buy_price (float, optional): Price at which the product is bought (default is 0)
        raw_materials (list): List of tuples containing (raw material object, quantity required) to manufacture one unit of the product
        batch_size (int): Number of units manufactured per manufacturing cycle

    Attributes:
        _info_keys (list): List of keys to include in the info dictionary
        _stats_keys (list): List of keys to include in the statistics dictionary
        ID (str): ID of the product
        name (str): Name of the product
        manufacturing_cost (float): Manufacturing cost per unit
        manufacturing_time (float): Time to manufacture one batch
        sell_price (float): Selling price of the product
        buy_price (float): Buying price of the product (default is 0)
        raw_materials (list): List of (raw material, quantity) required for one unit
        batch_size (int): Number of units produced per manufacturing cycle

    Returns:
        None

    Raises:
        ValueError: If validations fail for positive values, non-negative values, or empty raw materials list.
    """
    validate_positive("Manufacturing cost", manufacturing_cost)
    validate_non_negative("Manufacturing time", manufacturing_time)
    validate_positive("Sell price", sell_price)
    validate_non_negative("Buy price", buy_price)
    validate_positive("Units per cycle", batch_size)
    if raw_materials is None or len(raw_materials) == 0:
        global_logger.logger.error("Raw materials cannot be empty.")
        raise ValueError("Raw materials cannot be empty.")
    for raw_mat in raw_materials:
        if not isinstance(raw_mat[0], RawMaterial):
            raise ValueError("Invalid raw material.")
        if raw_mat[1] <= 0:
            raise ValueError("Invalid quantity for raw material.")

    self._info_keys = ["ID", "name", "manufacturing_cost", "manufacturing_time", "sell_price", "buy_price", "raw_materials", "batch_size"]
    self._stats_keys = []
    self.ID = ID # ID of the product (alphanumeric)
    self.name = name # name of the product
    self.manufacturing_cost = manufacturing_cost # manufacturing cost of the product (per unit)
    self.manufacturing_time = manufacturing_time # time (days) to manufacture 'batch_size' units of product
    self.sell_price = sell_price # price at which the product is sold
    self.buy_price = buy_price # price at which the product is bought, (default: 0). It is used by InventoryNode buy the product at some price and sell it at a higher price.   
    self.raw_materials = raw_materials # list of raw materials and quantity required to manufacture a single product unit
    self.batch_size = batch_size # number of units manufactured per cycle

def __init__(self, 
             env: simpy.Environment, 
             node: object, 
             params: dict) -> None:
    """
    Initialize the replenishment policy object.

    Parameters:
        env (simpy.Environment): simulation environment
        node (object): node to which this policy applies
        params (dict): parameters for the replenishment policy

    Attributes:
        _info_keys (list): list of keys to include in the info dictionary
        env (simpy.Environment): simulation environment
        node (object): node to which this policy applies
        params (dict): parameters for the replenishment policy

    Returns:
        None
    """
    if not isinstance(env, simpy.Environment):
        raise ValueError("Invalid environment. Provide a valid SimPy environment.")
    self._info_keys = ["node", "params"]
    self.env = env  # simulation environment
    self.node = node  # node to which this policy applies
    self.params = params  # parameters for the replenishment policy

def __init__(self, env, node, params):
    """ 
    Initialize the replenishment policy object.

    Parameters:
        env (simpy.Environment): simulation environment
        node (object): node to which this policy applies
        params (dict): parameters for the replenishment policy (s, S)

    Attributes:
        _info_keys (list): list of keys to include in the info dictionary
        env (simpy.Environment): simulation environment
        node (object): node to which this policy applies
        params (dict): parameters for the replenishment policy (s, S)
        name (str): replenishment policy name
        first_review_delay (float): delay before the first inventory check is performed
        period (float): period for periodic inventory check

    Returns:
        None
    """


    validate_non_negative("Reorder point (s)", params['s']) # this assertion ensures that the reorder point is positive
    validate_positive("Order-up-to level (S)", params['S']) # this assertion ensures that the order-up-to level is non-negative
    if 's' not in params or 'S' not in params:
        raise ValueError("Parameters 's' and 'S' must be provided for the (s, S) replenishment policy.")
    if params['s'] > params['S']:
        raise ValueError("Reorder point (s) must be less than or equal to order-up-to level (S).")
    super().__init__(env, node, params)
    self._info_keys.extend(["name","first_review_delay","period"])
    self.name = "min-max replenishment (s, S)"
    self.first_review_delay = params.get('first_review_delay', 0)
    self.period = params.get('period',0)

def __init__(self, env, node, params):
    """ 
    Initialize the RQ replenishment policy object.

    Parameters:
        env (simpy.Environment): Simulation environment.
        node (object): Node to which this policy applies.
        params (dict): Replenishment policy parameters R, Q, and optional parameters (safety_stock, first_review_delay, period).

    Attributes:
        _info_keys (list): List of keys to include in the info dictionary.
        env (simpy.Environment): Simulation environment.
        node (object): Node to which this policy applies.
        params (dict): Replenishment policy parameters (R, Q, optional delays and period).
        name (str): Replenishment policy name.
        first_review_delay (float): Delay before the first inventory check begins.
        period (float): Time interval for periodic inventory checks. If 0, continuous checking is used.

    Returns:
        None
    """
    validate_non_negative("Reorder point (R)", params['R']) # this assertion ensures that the reorder point is non-negative
    validate_positive("Order quantity (Q)", params['Q'])  # this assertion ensures that the order quantity is positive
    super().__init__(env, node, params)
    self._info_keys.extend(["name", "first_review_delay", "period"])  # add the keys to the info dictionary
    self.name = "RQ replenishment (R, Q)"
    self.first_review_delay = params.get('first_review_delay', 0)
    self.period = params.get('period', 0)

def __init__(self, env, node, params):
    """ 
    Initialize the replenishment policy object.

    Parameters:
        env (simpy.Environment): simulation environment
        node (object): node to which this policy applies
        params (dict): parameters for the replenishment policy (T, Q), and optional parameters (safety_stock, first_review_delay).

    Attributes:
        _info_keys (list): list of keys to include in the info dictionary
        env (simpy.Environment): simulation environment
        node (object): node to which this policy applies
        params (dict): parameters for the replenishment policy (T, Q)
        name (str): replenishment policy name
        first_review_delay (float): delay before the first inventory check is performed

    Returns:
        None
    """
    validate_positive("Replenishment period (T)", params['T'])  # this assertion ensures that the replenishment period is positive
    validate_positive("Replenishment quantity (Q)", params['Q'])  # this assertion ensures that the replenishment quantity is positive
    super().__init__(env, node, params)
    self._info_keys.extend(["name", "first_review_delay"])  # add the keys to the info dictionary
    self.name = "Periodic replenishment (T, Q)"
    self.first_review_delay = params.get('first_review_delay', 0)

def __init__(self, node, mode="dynamic"):
    """
    Initialize the supplier selection policy object.

    Parameters:
        node (object): Node for which the supplier selection policy is applied.
        mode (str): Supplier selection mode ("dynamic" or "fixed").

    Attributes:
        _info_keys (list): List of keys to include in the info dictionary.
        node (object): Node for which the supplier selection policy is applied.
        mode (str): Supplier selection mode ("dynamic" or "fixed").
        fixed_supplier (object): Fixed supplier if the mode is set to "fixed".

    Returns:
        None

    Raises:
        ValueError: If the mode is not "dynamic" or "fixed".
        TypeError: If the node is not an instance of Node class.
    """
    if mode not in ["dynamic", "fixed"]:
        global_logger.logger.error(f"Invalid mode: {mode}. Mode must be either 'dynamic' or 'fixed'.")
        raise ValueError("Mode must be either 'dynamic' or 'fixed'.")
    if not isinstance(node, Node):
        global_logger.logger.error("Node must be an instance of Node class.")
        raise TypeError("Node must be an instance of Node class.")
    self._info_keys = ["node", "mode"]
    self.node = node
    self.mode = mode
    self.fixed_supplier = None

def __init__(self, node, mode="fixed"):
    """
    Initialize the supplier selection policy object.

    Parameters:
        node (object): Node to which this supplier selection policy applies.
        mode (str): Supplier selection mode, either "dynamic" or "fixed" (default: "fixed").

    Attributes:
        name (str): Name of the selection policy.
        _info_keys (list): List of keys to include in the info dictionary.

    Returns:
        None
    """
    super().__init__(node, mode)
    self.name = "First fixed supplier"
    self._info_keys.extend(["name"])

def __init__(self, node, mode="dynamic"):
    """
    Initialize the supplier selection policy object.

    Parameters:
        node (object): Node to which this supplier selection policy applies.
        mode (str): Supplier selection mode, either "dynamic" or "fixed" (default: "dynamic").

    Attributes:
        name (str): Name of the selection policy.
        _info_keys (list): List of keys to include in the info dictionary.

    Returns:
        None
    """
    super().__init__(node, mode)
    self.name = "First available supplier"
    self._info_keys.extend(["name"])

def __init__(self, node, mode="dynamic"):
    """
    Initialize the supplier selection policy object.

    Parameters:
        node (object): Node to which this supplier selection policy applies.
        mode (str): Supplier selection mode, either "dynamic" or "fixed" (default: "dynamic").

    Attributes:
        name (str): Name of the selection policy.
        _info_keys (list): List of keys to include in the info dictionary.

    Returns:
        None
    """
    super().__init__(node, mode)
    self.name = "Cheapest supplier (Transportation cost)"
    self._info_keys.extend(["name"])

def __init__(self, node, mode="dynamic"):
    """
    Initialize the supplier selection policy object.

    Parameters:
        node (object): Node to which this supplier selection policy applies.
        mode (str, optional): Supplier selection mode, either "dynamic" or "fixed" (default: "dynamic").

    Attributes:
        name (str): Name of the selection policy.
        _info_keys (list): List of keys to include in the info dictionary.

    Returns:
        None
    """
    super().__init__(node, mode)
    self.name = "Fastest supplier (Lead time)"
    self._info_keys.extend(["name"])

def __init__(self, env: simpy.Environment, 
             ID: str, 
             name: str, 
             node_type: str, 
             failure_p:float = 0.0, 
             node_disrupt_time:callable = None,
             node_recovery_time:callable = lambda: 1,
             logging: bool = True,
             **kwargs) -> None:
    """
    Initialize the node object.

    Parameters:
        env (simpy.Environment): Simulation environment.
        ID (str): Unique node ID.
        name (str): Node name.
        node_type (str): Type of the node.
        failure_p (float, optional): Probability of node failure.
        node_disrupt_time (callable, optional): Function to generate disruption time.
        node_recovery_time (callable, optional): Function to generate recovery time.
        logging (bool, optional): Flag to enable/disable logging.
        **kwargs: Additional arguments for the logger.

    Attributes:
        _info_keys (list): List of keys to include in the info dictionary.  
        env (simpy.Environment): simulation environment
        ID (str): ID of the node (alphanumeric)
        name (str): name of the node
        node_type (str): type of the node
        node_failure_p (float): node failure probability
        node_status (str): status of the node (active/inactive)
        node_disrupt_time (callable): function to model node disruption time
        node_recovery_time (callable): function to model node recovery time
        logger (GlobalLogger): logger object

    Returns:
        None
    """
    if not isinstance(env, simpy.Environment):
        raise ValueError("Invalid environment. Provide a valid SimPy environment.")
    if(node_type.lower() not in ["infinite_supplier","supplier", "manufacturer", "factory", "warehouse", "distributor", "retailer", "store", "demand"]):
        global_logger.logger.error(f"Invalid node type. Node type: {node_type}")
        raise ValueError("Invalid node type.")
    if not callable(node_recovery_time):
        node_recovery_time = lambda val=node_recovery_time: val # convert to a callable function
    if node_disrupt_time is not None:
        if not callable(node_disrupt_time):
            node_disrupt_time = lambda val=node_disrupt_time: val # convert to a callable function
        validate_number(name="node_disrupt_time", value=node_disrupt_time()) # check if disrupt_time is a number
    if node_recovery_time is not None:
        validate_number(name="node_recovery_time", value=node_recovery_time()) # check if disrupt_time is a number
    self._info_keys = ["ID", "name", "node_type", "failure_p", "node_status", "logging"]
    self.env = env  # simulation environment
    self.ID = ID  # ID of the node (alphanumeric)
    self.name = name  # name of the node
    self.node_type = node_type  # type of the node (supplier, manufacturer, warehouse, distributor, retailer, demand)
    self.node_failure_p = failure_p  # node failure probability
    self.node_status = "active"  # node status (active/inactive)
    self.node_disrupt_time = node_disrupt_time  # callable function to model node disruption time
    self.node_recovery_time = node_recovery_time  # callable function to model node recovery time

    logger_name = self.ID # default logger name is the node ID
    if 'logger_name' in kwargs.keys():
        logger_name = kwargs['logger_name']
    self.logger = GlobalLogger(logger_name=logger_name, **kwargs)  # create a logger
    if not logging:
        self.logger.disable_logging()  # disable logging if logging is False
    else:
        self.logger.enable_logging()

    if(self.node_failure_p>0 or self.node_disrupt_time): # start self disruption if failure probability > 0
        self.env.process(self.disruption()) 

def __init__(self, env: simpy.Environment, 
             ID: str, 
             source: Node, 
             sink: Node, 
             cost: float, # transportation cost
             lead_time: callable,
             link_failure_p: float = 0.0,
             link_disrupt_time: callable = None,
             link_recovery_time: callable = lambda: 1) -> None:
    """
    Initialize the Link object representing a transportation connection between two nodes.

    Parameters:
        env (simpy.Environment): The simulation environment.
        ID (str): Unique identifier for the link.
        source (Node): The source node of the link. Cannot be a demand node.
        sink (Node): The sink node of the link. Cannot be a supplier node.
        cost (float): Transportation cost associated with the link. Must be non-negative.
        lead_time (callable): Function returning the stochastic lead time. Cannot be None.
        link_failure_p (float, optional): Probability of random link failure. Default is 0.0.
        link_disrupt_time (callable, optional): Function returning the time to the next disruption. If provided, overrides link_failure_p.
        link_recovery_time (callable, optional): Function returning the time required for link recovery after disruption. Default is a constant 1 unit.

    Attributes:
        env (simpy.Environment): The simulation environment.
        ID (str): The ID of the link.
        source (Node): The source node.
        sink (Node): The sink node.
        name (str): Readable name of the link combining source and sink IDs.
        cost (float): Transportation cost.
        lead_time (callable): Lead time function.
        link_failure_p (float): Link failure probability.
        status (str): Link status ("active" or "inactive").
        link_recovery_time (callable): Link recovery time function.
        link_disrupt_time (callable): Disruption time function.

    Returns:
        None
    """
    self._info_keys = ["ID", "source", "sink", "cost", "lead_time", "link_failure_p"]
    self._stats_keys = ["status"]
    if not isinstance(env, simpy.Environment):
        raise ValueError("Invalid environment. Provide a valid SimPy environment.")
    if not isinstance(source, Node) or not isinstance(sink, Node):
        raise ValueError("Invalid source or sink node. Provide valid Node instances.")
    if not callable(lead_time):
        lead_time = lambda val=lead_time: val # convert to callable 
    if(lead_time == None):
        global_logger.logger.error("Lead time cannot be None. Provide a function to model stochastic lead time.")
        raise ValueError("Lead time cannot be None. Provide a function to model stochastic lead time.")
    if(source == sink):
        global_logger.logger.error("Source and sink nodes cannot be the same.")
        raise ValueError("Source and sink nodes cannot be the same.")
    if(source.node_type == "demand"):
        global_logger.logger.error("Demand node cannot be a source node.")
        raise ValueError("Demand node cannot be a source node.")
    if("supplier" in sink.node_type):
        global_logger.logger.error("Supplier node cannot be a sink node.")
        raise ValueError("Supplier node cannot be a sink node.")
    if("supplier" in source.node_type and "supplier" in sink.node_type):
        global_logger.logger.error("Supplier nodes cannot be connected.")
        raise ValueError("Supplier nodes cannot be connected.")
    if("supplier" in source.node_type and sink.node_type == "demand"):
        global_logger.logger.error("Supplier node cannot be connected to a demand node.")
        raise ValueError("Supplier node cannot be connected to a demand node.")
    validate_non_negative("Cost", cost)
    if (link_disrupt_time is not None):
        validate_number(name="link_disrupt_time", value=link_disrupt_time()) # check if disrupt_time is a number
    if (link_recovery_time is not None):
        validate_number(name="link_recovery_time", value=link_recovery_time()) # check if disrupt_time is a number

    self.env = env  # simulation environment
    self.ID = ID  # ID of the link (alphanumeric)
    self.source = source  # source node of the link
    self.sink = sink  # sink node of the link
    self.name = f"{self.source.ID} to {self.sink.ID}"  # name of the link
    self.cost = cost  # cost of the link
    self.lead_time = lead_time  # lead time of the link
    self.link_failure_p = link_failure_p  # link failure probability
    self.status = "active"  # link status (active/inactive)
    self.link_recovery_time = link_recovery_time  # link recovery time
    self.link_disrupt_time = link_disrupt_time  # link disruption time, if provided

    self.sink.suppliers.append(self)  # add the link as a supplier link to the sink node
    if(self.link_failure_p>0 or self.link_disrupt_time): # disrupt the link if link_failure_p > 0
        self.env.process(self.disruption())

def __init__(self, 
             env: simpy.Environment, 
             capacity: float, 
             initial_level: float, 
             node: Node,
             replenishment_policy: InventoryReplenishment,
             holding_cost: float = 0.0,
             shelf_life: float = 0,
             inv_type: str = "non-perishable") -> None:
    """
    Initialize the Inventory object.

    Parameters:
        env (simpy.Environment): Simulation environment.
        capacity (float): Maximum capacity of the inventory.
        initial_level (float): Initial inventory level.
        node (Node): Node to which this inventory belongs.
        replenishment_policy (InventoryReplenishment): Replenishment policy for the inventory.
        holding_cost (float): Holding cost per unit per time period.
        shelf_life (float): Shelf life for perishable items.
        inv_type (str): Type of the inventory, either "non-perishable" or "perishable".

    Attributes:
        _info_keys (list): Keys included in the information dictionary.
        _stats_keys (list): Keys included in the statistics dictionary.
        env (simpy.Environment): Simulation environment.
        capacity (float): Maximum inventory capacity.
        init_level (float): Initial inventory level.
        level (float): Current inventory level.
        on_hand (float): Current on-hand inventory.
        inv_type (str): Inventory type ("non-perishable" or "perishable").
        holding_cost (float): Holding cost per unit.
        carry_cost (float): Total accumulated carrying cost.
        replenishment_policy (InventoryReplenishment): Inventory replenishment policy.
        inventory (simpy.Container): SimPy container managing inventory levels.
        last_update_t (float): Last timestamp when carrying cost was updated.
        shelf_life (float): Shelf life of perishable items (if applicable).
        perish_queue (list): Queue managing perishable items as (manufacturing_date, quantity).
        waste (float): Total quantity of expired items.
        instantaneous_levels (list): Recorded inventory levels over time.

    Returns:
        None
    """
    if not isinstance(node, Node):
        global_logger.logger.error("Node must be an instance of Node class.")
        raise TypeError("Node must be an instance of Node class.")
    self.node = node # node to which this inventory belongs
    if initial_level > capacity:
        self.node.logger.logger.error("Initial level cannot be greater than capacity.")
        raise ValueError("Initial level cannot be greater than capacity.")
    if replenishment_policy is not None:
        if not issubclass(replenishment_policy.__class__, InventoryReplenishment):
            self.node.logger.logger.error(f"{replenishment_policy.__name__} must inherit from InventoryReplenishment")
            raise TypeError(f"{replenishment_policy.__name__} must inherit from InventoryReplenishment")
    if inv_type not in ["non-perishable", "perishable"]:
        self.node.logger.logger.error(f"Invalid inventory type. {inv_type} is not yet available.")
        raise ValueError(f"Invalid inventory type. {inv_type} is not yet available.")
    validate_positive("Capacity", capacity)
    validate_non_negative("Initial level", initial_level)
    validate_non_negative("Inventory holding cost",holding_cost)
    validate_non_negative("Shelf life", shelf_life)
    self._info_keys = ["capacity", "initial_level", "replenishment_policy", "holding_cost", "shelf_life", "inv_type"]
    self._stats_keys = ["level", "carry_cost", "instantaneous_levels"]
    self.env = env
    self.capacity = capacity
    self.init_level = initial_level
    self.level = initial_level
    self.on_hand = initial_level # current inventory level
    self.inv_type = inv_type
    self.holding_cost = holding_cost
    self.carry_cost = 0 # initial carrying cost based on the initial inventory level
    self.replenishment_policy = replenishment_policy
    self.inventory = simpy.Container(env=self.env, capacity=self.capacity, init=self.init_level) # Inventory container setup
    self.last_update_t = self.env.now # last time the carrying cost was updated

    if self.inv_type == "perishable":
        validate_positive("Shelf life", shelf_life)
        self.shelf_life = shelf_life
        self.perish_queue = [(0, initial_level)]
        self.waste = 0
        self.env.process(self.remove_expired())

    self.instantaneous_levels = []
    self.env.process(self.record_inventory_levels())  # record inventory levels at regular intervals

def __init__(self, 
             env: simpy.Environment, 
             ID: str, 
             name: str, 
             node_type: str = "supplier",
             capacity: float = 0.0, 
             initial_level: float = 0.0, 
             inventory_holding_cost:float = 0.0, 
             raw_material: RawMaterial = None, 
             **kwargs) -> None:
    """
    Initialize the supplier object.

    Parameters:
        env (simpy.Environment): simulation environment
        ID (str): unique identifier for the supplier
        name (str): name of the supplier
        node_type (str): type of the node (supplier/infinite_supplier)
        capacity (float): maximum capacity of the inventory
        initial_level (float): initial inventory level
        inventory_holding_cost (float): inventory holding cost
        raw_material (RawMaterial): raw material supplied by the supplier
        **kwargs: any additional keyword arguments for the Node class and logger

    Attributes:
        _info_keys (list): list of keys to include in the info dictionary.
        raw_material (RawMaterial): raw material supplied by the supplier
        sell_price (float): selling price of the raw material
        inventory (Inventory): inventory of the supplier
        inventory_drop (simpy.Event): event to signal when inventory is dropped
        inventory_raised (simpy.Event): event to signal when inventory is raised
        stats (Statistics): statistics object for the supplier

    Returns:
        None
    """
    super().__init__(env=env,ID=ID,name=name,node_type=node_type,**kwargs)
    self._info_keys.extend(["raw_material", "sell_price"])
    self.raw_material = raw_material # raw material supplied by the supplier
    self.sell_price = 0
    if(self.raw_material):
        self.sell_price = self.raw_material.cost # selling price of the raw material
    if(self.node_type!="infinite_supplier"):
        self.inventory = Inventory(env=self.env, capacity=capacity, initial_level=initial_level, node=self, holding_cost=inventory_holding_cost, replenishment_policy=None)
        self.inventory_drop = self.env.event()  # event to signal when inventory is dropped
        self.inventory_raised = self.env.event() # signal to indicate that inventory has been raised
        if(self.raw_material):
            self.env.process(self.behavior()) # start the behavior process
        else:
            self.logger.logger.error(f"{self.ID}:Raw material not provided for this supplier. Recreate it with a raw material.")
            raise ValueError("Raw material not provided.")
    else:
        self.inventory = Inventory(env=self.env, capacity=float('inf'), initial_level=float('inf'), node=self, holding_cost=inventory_holding_cost, replenishment_policy=None)

    self.stats = Statistics(self)
    setattr(self.stats,"total_raw_materials_mined",0)
    setattr(self.stats,"total_material_cost",0)
    self.stats._stats_keys.extend(["total_raw_materials_mined", "total_material_cost"])

def __init__(self,
             env: simpy.Environment, 
             ID: str, 
             name: str, 
             node_type: str, 
             capacity: float, 
             initial_level: float, 
             inventory_holding_cost:float,
             replenishment_policy:InventoryReplenishment, 
             policy_param: dict,
             product_sell_price: float,
             product_buy_price: float,
             inventory_type:str = "non-perishable", 
             shelf_life:float = 0.0,
             manufacture_date:callable = None,
             product:Product = None,
             supplier_selection_policy: SupplierSelectionPolicy = SelectFirst,
             supplier_selection_mode: str = "fixed",
             **kwargs) -> None:
    """
    Initialize the inventory node object.

    Parameters:
        env (simpy.Environment): Simulation environment.
        ID (str): Unique identifier for the node.
        name (str): Name of the inventory node.
        node_type (str): Type of the inventory node (e.g., retailer or distributor).
        capacity (float): Maximum capacity of the inventory.
        initial_level (float): Initial inventory level.
        inventory_holding_cost (float): Inventory holding cost per unit.
        replenishment_policy (InventoryReplenishment): Replenishment policy object for the inventory.
        policy_param (dict): Parameters for the replenishment policy.
        product_sell_price (float): Selling price of the product.
        product_buy_price (float): Buying price of the product.
        inventory_type (str): Type of inventory ("non-perishable" or "perishable").
        shelf_life (float): Shelf life of the product for perishable items.
        manufacture_date (callable): Function to model manufacturing date (used for perishable inventories).
        product (Product): Product managed by the inventory node.
        supplier_selection_policy (SupplierSelectionPolicy): Supplier selection policy class.
        supplier_selection_mode (str): Mode for supplier selection (default is "fixed").
        **kwargs: Additional keyword arguments for the Node class and logger.

    Attributes:
        _info_keys (list): List of keys to include in the info dictionary.
        replenishment_policy (InventoryReplenishment): Replenishment policy object.
        inventory (Inventory): Inventory object managing stock.
        inventory_drop (simpy.Event): Event triggered when inventory drops.
        inventory_raised (simpy.Event): Event triggered when inventory is replenished.
        manufacture_date (callable): Manufacturing date generation function.
        sell_price (float): Selling price of the product.
        buy_price (float): Buying price of the product.
        product (Product): Product managed by the node.
        suppliers (list): List of supplier links connected to this node.
        ongoing_order (bool): Indicates if an order is currently in process.
        selection_policy (SupplierSelectionPolicy): Supplier selection policy object.
        stats (Statistics): Statistics tracking object for this node.

    Returns:
        None

    Behavior:
        The inventory node stocks the product in inventory to make it available to the consumer node or demand node (end customer). 
        It orders product from its supplier node to maintain the right inventory levels according to the replenishment policy.
        The inventory node can have multiple suppliers. It chooses a supplier based on the specified supplier selection policy. 
        The product buy and sell prices are set during initialization. The inventory node is expected to sell the product at 
        a higher price than the buy price, but this is user-configured.
    """
    super().__init__(env=env,ID=ID,name=name,node_type=node_type,**kwargs)
    validate_non_negative("Product Sell Price", product_sell_price)
    validate_non_negative("Product Buy Price", product_buy_price)
    self._info_keys.extend(["sell_price", "buy_price", "ongoing_order", "selection_policy"])
    self.replenishment_policy = None
    if(replenishment_policy):
        self.replenishment_policy = replenishment_policy(env = self.env, node = self, params = policy_param)
        self.env.process(self.replenishment_policy.run())

    self.inventory = Inventory(env=self.env, capacity=capacity, initial_level=initial_level, node=self, 
                               inv_type=inventory_type, holding_cost=inventory_holding_cost, 
                               replenishment_policy=self.replenishment_policy, shelf_life=shelf_life)
    self.inventory_drop = self.env.event()  # event to signal when inventory is dropped
    self.inventory_raised = self.env.event() # signal to indicate that inventory has been raised
    self.manufacture_date = manufacture_date
    self.sell_price = product_sell_price # set the sell price of the product
    self.buy_price = product_buy_price # set the buy price of the product
    if product is not None:
        self.product = copy.deepcopy(product) # product that the inventory node sells
        self.product.sell_price = product_sell_price
        self.product.buy_price = product_buy_price # set the buy price of the product to the product buy price
    self.suppliers = []
    self.ongoing_order = False # flag to check if the order is placed
    self.selection_policy = supplier_selection_policy(self,supplier_selection_mode)
    self.stats = Statistics(self, periodic_update=True, period=1) # create a statistics object for the inventory node

def __init__(self,
             env: simpy.Environment, 
             ID: str, 
             name: str, 
             capacity: float, 
             initial_level: float, 
             inventory_holding_cost: float, 
             product_sell_price: float, 
             replenishment_policy: InventoryReplenishment, 
             policy_param: dict, 
             product: Product = None, 
             inventory_type: str = "non-perishable",
             shelf_life: float = 0.0,
             supplier_selection_policy: SupplierSelectionPolicy = SelectFirst,
             supplier_selection_mode: str = "fixed",
             **kwargs) -> None:
    """
    Initialize the manufacturer object.

    Parameters:
        env (simpy.Environment): Simulation environment.
        ID (str): Unique identifier for the manufacturer.
        name (str): Name of the manufacturer.
        capacity (float): Maximum capacity of the finished product inventory.
        initial_level (float): Initial inventory level for finished products.
        inventory_holding_cost (float): Holding cost per unit for finished products.
        product_sell_price (float): Selling price per unit of the finished product.
        replenishment_policy (InventoryReplenishment): Replenishment policy object for the product inventory.
        policy_param (dict): Parameters for the replenishment policy.
        product (Product): Product manufactured by the manufacturer.
        inventory_type (str): Type of inventory ("non-perishable" or "perishable").
        shelf_life (float): Shelf life of the product.
        supplier_selection_policy (SupplierSelectionPolicy): Supplier selection policy class.
        supplier_selection_mode (str): Supplier selection mode (default is "fixed").
        **kwargs: Additional keyword arguments for the Node class and logger.

    Attributes:
        _info_keys (list): List of keys to include in the info dictionary.
        replenishment_policy (InventoryReplenishment): Replenishment policy object for the product inventory.
        inventory (Inventory): Inventory object managing finished product stock.
        inventory_drop (simpy.Event): Event triggered when inventory drops.
        inventory_raised (simpy.Event): Event triggered when inventory is replenished.
        product (Product): Product manufactured by the manufacturer.
        suppliers (list): List of supplier links connected to this manufacturer.
        sell_price (float): Selling price per unit of the product.
        production_cycle (bool): Indicates whether the production cycle is currently active.
        raw_inventory_counts (dict): Inventory levels of raw materials by raw material ID.
        ongoing_order_raw (dict): Indicates whether a raw material order is currently in progress.
        ongoing_order (bool): Indicates whether a product order is currently in progress.
        selection_policy (SupplierSelectionPolicy): Supplier selection policy object.
        stats (Statistics): Statistics tracking object for the manufacturer.

    Returns:
        None
    """
    super().__init__(env=env,ID=ID,name=name,node_type="manufacturer",**kwargs)
    if product == None:
        global_logger.logger.error("Product not provided for the manufacturer.")
        raise ValueError("Product not provided for the manufacturer.")
    elif not isinstance(product, Product):
        raise ValueError("Invalid product type. Expected a Product instance.")
    validate_positive("Product Sell Price", product_sell_price)
    self._info_keys.extend(["replenishment_policy", "product_sell_price"])
    self.replenishment_policy = None
    if(replenishment_policy):
        self.replenishment_policy = replenishment_policy(env = self.env, node = self, params = policy_param)
        self.env.process(self.replenishment_policy.run())

    self.inventory = Inventory(env=self.env, capacity=capacity, initial_level=initial_level, node=self, inv_type=inventory_type, holding_cost=inventory_holding_cost, replenishment_policy=self.replenishment_policy, shelf_life=shelf_life)
    self.inventory_drop = self.env.event()  # event to signal when inventory is dropped
    self.inventory_raised = self.env.event() # signal to indicate that inventory has been raised
    self.product = product # product manufactured by the manufacturer
    self.suppliers = []
    self.product.sell_price = product_sell_price
    self.sell_price = product_sell_price # set the sell price of the product

    self.production_cycle = False # production cycle status
    self.raw_inventory_counts = {} # dictionary to store inventory counts for raw products inventory
    self.ongoing_order_raw = {} # dictionary to store order status
    self.ongoing_order = False # order status for the product        

    if(self.product.buy_price <= 0): # if the product buy price is not given, calculate it
        self.product.buy_price = self.product.manufacturing_cost 
        for raw_material in self.product.raw_materials:
            self.product.buy_price += raw_material[0].cost * raw_material[1] # calculate total cost of the product (per unit)

    self.env.process(self.behavior()) # start the behavior process
    self.selection_policy = supplier_selection_policy(self,supplier_selection_mode)

    self.stats = Statistics(self, periodic_update=True, period=1) # create a statistics object for the manufacturer
    setattr(self.stats,"total_products_manufactured",0) # adding specific statistics for the manufacturer
    setattr(self.stats,"total_manufacturing_cost",0) # adding specific statistics for the manufacturer
    self.stats._stats_keys.extend(["total_products_manufactured", "total_manufacturing_cost"])

def __init__(self,
             env: simpy.Environment, 
             ID: str, 
             name: str, 
             order_arrival_model: callable, 
             order_quantity_model: callable, 
             demand_node: Node,
             tolerance: float = 0.0,
             order_min_split_ratio: float = 1.0,
             delivery_cost: callable = lambda: 0,
             lead_time: callable = lambda: 0,
             consume_available: bool = False,
             **kwargs) -> None:
    """
    Initialize the demand node object.

    Parameters:
        env (simpy.Environment): Simulation environment.
        ID (str): Unique identifier for the demand node.
        name (str): Name of the demand node.
        order_arrival_model (callable): Function that models inter-arrival times between customer orders.
        order_quantity_model (callable): Function that models the quantity per customer order.
        demand_node (Node): Upstream node from which the demand node sources products.
        tolerance (float): Maximum time customers are willing to wait if required quantity is unavailable.
        order_min_split_ratio (float): Minimum allowable fraction of the order that can be delivered in split deliveries.
        delivery_cost (callable): Function that models the delivery cost per order.
        lead_time (callable): Function that models the delivery lead time per order.
        consume_available (bool): If True, the demand node consumes available inventory immediately and leaves.
        **kwargs: Additional keyword arguments for Node and GlobalLogger.

    Attributes:
        _info_keys (list): List of keys to include in the info dictionary.
        order_arrival_model (callable): Function defining the order arrival process.
        order_quantity_model (callable): Function defining the order quantity distribution.
        demand_node (Node): Upstream node supplying the demand.
        customer_tolerance (float): Maximum waiting time allowed for customer orders.
        delivery_cost (callable): Delivery cost function for each order.
        lead_time (callable): Delivery lead time function for each order.
        min_split (float): Minimum allowed split ratio for partially fulfilled orders.
        consume_available (bool): If True, partial fulfillment is allowed and available inventory is consumed immediately.
        stats (Statistics): Tracks various performance metrics like demand placed, fulfilled, and shortages.

    Returns:
        None
    """
    if order_arrival_model is None or order_quantity_model is None:
        raise ValueError("Order arrival and quantity models cannot be None.")
    if not callable(order_arrival_model):
        order_arrival_model = lambda val=order_arrival_model: val # convert into callable
    if not callable(order_quantity_model):
        order_quantity_model = lambda val=order_quantity_model: val # convert into callable
    if not callable(delivery_cost):
        delivery_cost = lambda val=delivery_cost: val # convert into callable
    if not callable(lead_time):
        lead_time = lambda val=lead_time: val # convert into callable
    if demand_node is None or "supplier" in demand_node.node_type:
        raise ValueError("Demand node must be a valid non-supplier node.")
    validate_non_negative("Customer tolerance", tolerance)
    validate_positive("Order Min Split Ratio", order_min_split_ratio)
    if order_min_split_ratio > 1:
        self.logger.logger.error("Order Min Split Ratio is greater than 1. It will be set to 1.")
        raise ValueError("Order Min Split Ratio must be in the range [0, 1].")
    validate_number(name="order_time", value=order_arrival_model())
    validate_number(name="order_quantity", value=order_quantity_model())
    validate_number(name="delivery_cost", value=delivery_cost()) # check if delivery_cost is a number
    validate_number(name="lead_time", value=lead_time()) # check if lead_time is a number

    super().__init__(env=env,ID=ID,name=name,node_type="demand",**kwargs)
    self._info_keys.extend(["order_arrival_model", "order_quantity_model", "demand_node", "customer_tolerance", "delivery_cost", "lead_time"])
    self.order_arrival_model = order_arrival_model
    self.order_quantity_model = order_quantity_model
    self.demand_node = demand_node
    self.customer_tolerance = tolerance
    self.delivery_cost = delivery_cost
    self.lead_time = lead_time
    self.min_split = order_min_split_ratio
    self.consume_available = consume_available # if True, the demand node consumes available inventory immediately and leaves
    self.env.process(self.behavior())
    self.stats = Statistics(self, periodic_update=True, period=1) # create a statistics object for the demand node