Project: Object-Oriented Inventory System

from abc import ABC, abstractmethod
from dataclasses import dataclass, field
from datetime import datetime

class BaseInventoryItem(ABC):
    """Abstract Base Class establishing common interface contracts for all inventory items."""
    
    def __init__(self, item_id: str, title: str, price: float, quantity: int):
        self.item_id = item_id
        self.title = title
        self.price = price      # Invokes @price.setter
        self.quantity = quantity # Invokes @quantity.setter

    @property
    def price(self) -> float:
        return self._price

    @price.setter
    def price(self, value: float):
        if value < 0.0:
            raise ValueError("Price cannot be negative!")
        self._price = float(value)

    @property
    def quantity(self) -> int:
        return self._quantity

    @quantity.setter
    def quantity(self, value: int):
        if value < 0:
            raise ValueError("Quantity cannot be negative!")
        self._quantity = int(value)

    @abstractmethod
    def calculate_discounted_value(self) -> float:
        """Abstract method enforcing custom discount calculation in subclasses."""
        pass

    def __repr__(self):
        return f"{self.__class__.__name__}(id='{self.item_id}', title='{self.title}', price={self.price}, qty={self.quantity})"


@dataclass
class ElectronicsItem(BaseInventoryItem):
    """Concrete subclass representing electronic items with warranty metadata."""
    item_id: str
    title: str
    price: float
    quantity: int
    warranty_months: int = 12

    def __post_init__(self):
        # Initialize BaseInventoryItem properties after dataclass field binding
        super().__init__(self.item_id, self.title, self.price, self.quantity)

    def calculate_discounted_value(self) -> float:
        # Electronic items get 10% discount if quantity >= 10
        total = self.price * self.quantity
        return round(total * 0.90 if self.quantity >= 10 else total, 2)


@dataclass
class PerishableItem(BaseInventoryItem):
    """Concrete subclass representing perishable grocery items with expiration date."""
    item_id: str
    title: str
    price: float
    quantity: int
    days_to_expire: int = 7

    def __post_init__(self):
        super().__init__(self.item_id, self.title, self.price, self.quantity)

    def calculate_discounted_value(self) -> float:
        # Perishable items get 30% markdown if expiring in <= 3 days!
        total = self.price * self.quantity
        return round(total * 0.70 if self.days_to_expire <= 3 else total, 2)

# Testing Domain Model Instantiation and Polymorphism
e_item = ElectronicsItem("E101", "Gaming Monitor", 300.0, 12, warranty_months=24)
p_item = PerishableItem("P201", "Fresh Organic Milk", 4.50, 20, days_to_expire=2)

print("=== Domain Model Polymorphic Discount Valuation ===")
print(f"Item: {e_item.title:<20} | Discounted Value: ${e_item.calculate_discounted_value():,.2f}")
print(f"Item: {p_item.title:<20} | Discounted Value: ${p_item.calculate_discounted_value():,.2f}")

=== Domain Model Polymorphic Discount Valuation ===
Item: Gaming Monitor       | Discounted Value: $3,240.00
Item: Fresh Organic Milk   | Discounted Value: $63.00

import json
import csv
from abc import ABC, abstractmethod
from pathlib import Path

class BaseStorageRepository(ABC):
    """Abstract Base Class interface for storage persistence drivers."""
    
    @abstractmethod
    def save_data(self, file_path: Path, data: dict) -> bool:
        pass

    @abstractmethod
    def load_data(self, file_path: Path) -> dict:
        pass


class FileVaultLock:
    """Class-Based Context Manager ensuring safe resource handling during file operations."""
    def __init__(self, file_path: Path):
        self.file_path = file_path

    def __enter__(self):
        print(f"[VAULT LOCK] Securing access lock for: '{self.file_path.name}'")
        return self

    def __exit__(self, exc_type, exc_val, exc_tb):
        print(f"[VAULT UNLOCK] Releasing file lock for: '{self.file_path.name}'")
        if exc_type:
            print(f"[VAULT ALERT] Transaction aborted due to exception: {exc_val}")
        return False  # Propagate exception if present


class JSONStorageRepository(BaseStorageRepository):
    """Concrete JSON storage driver implementing BaseStorageRepository interface."""

    def save_data(self, file_path: Path, data: dict) -> bool:
        with FileVaultLock(file_path):
            with open(file_path, mode="w", encoding="utf-8") as f:
                json.dump(data, f, indent=4)
        return True

    def load_data(self, file_path: Path) -> dict:
        if not file_path.exists():
            return {}
        with FileVaultLock(file_path):
            with open(file_path, mode="r", encoding="utf-8") as f:
                return json.load(f)

print("Persistence Repository Driver Module Loaded Successfully.")

Persistence Repository Driver Module Loaded Successfully.

import sys
import logging
from pathlib import Path
from datetime import datetime

# ==========================================
# 1. LOGGING & CUSTOM EXCEPTIONS
# ==========================================
logging.basicConfig(
    level=logging.INFO,
    format="%(asctime)s [%(levelname)s] %(message)s",
    datefmt="%Y-%m-%d %H:%M:%S"
)
logger = logging.getLogger("InventoryOS")

class InventoryError(Exception):
    """Base exception for inventory domain errors."""
    pass

class ItemNotFoundError(InventoryError):
    """Raised when requested item ID does not exist."""
    pass

class StockDepletedError(InventoryError):
    """Raised when withdrawal exceeds available stock."""
    pass

# ==========================================
# 2. COMPOSITE INVENTORY MANAGER SERVICE
# ==========================================
class InventoryManager:
    """
    Composite Service Class ("Has-A" Storage Repository).
    Manages in-memory object registry and delegates persistent operations.
    """
    def __init__(self, storage_repo: BaseStorageRepository, db_path: Path):
        self.storage_repo = storage_repo
        self.db_path = db_path
        self._registry: dict[str, BaseInventoryItem] = {}

    def add_item(self, item: BaseInventoryItem):
        self._registry[item.item_id] = item
        logger.info(f"Registered item #{item.item_id} ({item.title}) to inventory.")

    def get_item(self, item_id: str) -> BaseInventoryItem:
        if item_id not in self._registry:
            raise ItemNotFoundError(f"Inventory item ID #{item_id} not found!")
        return self._registry[item_id]

    def process_sale(self, item_id: str, qty_sold: int) -> float:
        item = self.get_item(item_id)
        if qty_sold > item.quantity:
            raise StockDepletedError(f"Cannot sell {qty_sold} units of '{item.title}'! Only {item.quantity} in stock.")
        
        item.quantity -= qty_sold
        sale_total = item.price * qty_sold
        logger.info(f"Processed sale: {qty_sold}x '{item.title}' -> Total: ${sale_total:,.2f}")
        return sale_total

    def persist_to_disk(self):
        # Convert objects to serializable dictionary maps using comprehensions
        serialized_data = {
            item_id: {
                "type": item.__class__.__name__,
                "title": item.title,
                "price": item.price,
                "quantity": item.quantity,
                "extra": getattr(item, "warranty_months", getattr(item, "days_to_expire", 0))
            }
            for item_id, item in self._registry.items()
        }
        self.storage_repo.save_data(self.db_path, serialized_data)
        logger.info(f"Persisted {len(serialized_data)} records to disk database.")

    def get_all_items(self) -> list[BaseInventoryItem]:
        return list(self._registry.values())

# ==========================================
# 3. MATCH-CASE CLI DISPATCHER
# ==========================================
def dispatch_cli_command(command_str: str, manager: InventoryManager) -> bool:
    """
    Parses CLI commands using Structural Pattern Matching.
    Returns False when exit command is received.
    """
    tokens = command_str.strip().split()
    
    match tokens:
        case ["ADD", "ELEC", item_id, title, price_str, qty_str, warranty_str]:
            try:
                item = ElectronicsItem(
                    item_id=item_id,
                    title=title,
                    price=float(price_str),
                    quantity=int(qty_str),
                    warranty_months=int(warranty_str)
                )
                manager.add_item(item)
                print(f"SUCCESS: Added Electronics Item '{title}' (#{item_id})")
            except ValueError as val_err:
                print(f"ERROR: Invalid numeric format -> {val_err}")

        case ["ADD", "PERISH", item_id, title, price_str, qty_str, expire_str]:
            try:
                item = PerishableItem(
                    item_id=item_id,
                    title=title,
                    price=float(price_str),
                    quantity=int(qty_str),
                    days_to_expire=int(expire_str)
                )
                manager.add_item(item)
                print(f"SUCCESS: Added Perishable Item '{title}' (#{item_id})")
            except ValueError as val_err:
                print(f"ERROR: Invalid numeric format -> {val_err}")

        case ["SELL", item_id, qty_str] if qty_str.isdigit():
            try:
                total = manager.process_sale(item_id, int(qty_str))
                print(f"SUCCESS: Sale completed! Total Charged: ${total:,.2f}")
            except InventoryError as inv_err:
                print(f"SALE_REJECTED: {inv_err}")

        case ["LIST"]:
            items = manager.get_all_items()
            print("\n" + "="*65)
            print(f"{'ID':<8} | {'Title':<20} | {'Price':<10} | {'Qty':<6} | {'Discounted Value':<12}")
            print("="*65)
            for item in sorted(items, key=lambda x: x.price, reverse=True):
                disc_val = item.calculate_discounted_value()
                print(f"{item.item_id:<8} | {item.title:<20} | ${item.price:<9.2f} | {item.quantity:<6} | ${disc_val:<11,.2f}")
            print("="*65 + "\n")

        case ["SAVE"]:
            manager.persist_to_disk()
            print("SUCCESS: Inventory database saved to persistent JSON store.")

        case ["EXIT" | "QUIT"]:
            manager.persist_to_disk()
            print("Shutting down Inventory OS. Session persisted safely.")
            return False

        case _:
            print(f"ERROR: Command '{command_str}' unrecognized.")
            print("Commands: ADD ELEC