Predictive Maintenance Scheduler for Preventing Farm Equipment Failures Python
👤 Sharing: AI
```python
import datetime
import random
# --- Data Structures ---
class Equipment:
"""Represents a piece of farm equipment."""
def __init__(self, equipment_id, name, type, last_maintenance_date=None, maintenance_interval_days=365, operational=True):
self.equipment_id = equipment_id
self.name = name
self.type = type
self.last_maintenance_date = last_maintenance_date # datetime.date object
self.maintenance_interval_days = maintenance_interval_days # How often maintenance should be performed
self.operational = operational # Status if the equipment is operational or not.
def __str__(self):
return f"{self.name} (ID: {self.equipment_id}, Type: {self.type}, Last Maint: {self.last_maintenance_date}, Next Maint Due In: {self.days_until_maintenance()})"
def days_until_maintenance(self):
"""Calculates the number of days until the next scheduled maintenance."""
if self.last_maintenance_date is None:
return "N/A (No prior maintenance)" # Or a large number indicating urgent maintenance
else:
next_maintenance_date = self.last_maintenance_date + datetime.timedelta(days=self.maintenance_interval_days)
days_left = (next_maintenance_date - datetime.date.today()).days
return max(days_left, 0) # Ensure it's never negative
class MaintenanceSchedule:
"""Represents the maintenance schedule."""
def __init__(self):
self.schedule = {} # Dictionary: date (datetime.date) -> list of equipment IDs
self.equipment_list = [] # List of Equipment objects
def add_equipment(self, equipment):
"""Adds a piece of equipment to the schedule."""
self.equipment_list.append(equipment)
def schedule_maintenance(self, equipment_id, date):
"""Schedules maintenance for a piece of equipment on a specific date."""
if date in self.schedule:
self.schedule[date].append(equipment_id)
else:
self.schedule[date] = [equipment_id]
def get_schedule_for_date(self, date):
"""Returns a list of equipment IDs scheduled for maintenance on a given date."""
return self.schedule.get(date, [])
def unschedule_maintenance(self, equipment_id, date):
"""Removes a piece of equipment from the maintenance schedule on a specific date."""
if date in self.schedule:
if equipment_id in self.schedule[date]:
self.schedule[date].remove(equipment_id)
if not self.schedule[date]: # Remove the date if the list is empty
del self.schedule[date]
def generate_preventative_schedule(self, start_date, end_date):
"""Generates a preventative maintenance schedule for all equipment within a date range.
This is a simplified example, using random dates for demonstration.
A real-world application would use more sophisticated logic.
"""
for equipment in self.equipment_list:
if equipment.last_maintenance_date is None:
# Schedule initial maintenance randomly within the start_date and end_date
random_days = random.randint(0, (end_date - start_date).days)
schedule_date = start_date + datetime.timedelta(days=random_days)
self.schedule_maintenance(equipment.equipment_id, schedule_date)
else:
# Schedule subsequent maintenance based on the interval
next_maintenance_date = equipment.last_maintenance_date + datetime.timedelta(days=equipment.maintenance_interval_days)
while next_maintenance_date <= end_date: # Schedule iteratively until within the range
if next_maintenance_date >= start_date: # Schedule only if within the start date
self.schedule_maintenance(equipment.equipment_id, next_maintenance_date)
next_maintenance_date += datetime.timedelta(days=equipment.maintenance_interval_days)
def display_schedule(self):
"""Prints the maintenance schedule."""
if not self.schedule:
print("Maintenance schedule is empty.")
return
sorted_dates = sorted(self.schedule.keys()) # Sort dates for better readability
for date in sorted_dates:
equipment_ids = self.schedule[date]
equipment_names = [eq.name for eq in self.equipment_list if eq.equipment_id in equipment_ids] # Get equipment names
print(f"Date: {date}, Equipment: {', '.join(equipment_names)}")
def find_equipment_by_id(self, equipment_id):
"""Finds an Equipment object by its ID."""
for equipment in self.equipment_list:
if equipment.equipment_id == equipment_id:
return equipment
return None
# --- Helper Functions ---
def parse_date(date_string):
"""Parses a date string in YYYY-MM-DD format and returns a datetime.date object.
Handles potential errors.
"""
try:
return datetime.datetime.strptime(date_string, "%Y-%m-%d").date()
except ValueError:
print("Invalid date format. Please use YYYY-MM-DD.")
return None
# --- Main Program ---
def main():
"""Main function to run the predictive maintenance scheduler."""
schedule = MaintenanceSchedule()
# Add some sample equipment
equipment1 = Equipment(equipment_id="TRACTOR001", name="John Deere Tractor", type="Tractor", last_maintenance_date=parse_date("2023-10-26"))
equipment2 = Equipment(equipment_id="HARVESTER001", name="Combine Harvester", type="Harvester", last_maintenance_date=parse_date("2023-05-15"), maintenance_interval_days=180) # Shorter interval
equipment3 = Equipment(equipment_id="PLANTER001", name="Seed Planter", type="Planter") # No last maintenance yet
schedule.add_equipment(equipment1)
schedule.add_equipment(equipment2)
schedule.add_equipment(equipment3)
# User interaction loop
while True:
print("\n--- Farm Equipment Predictive Maintenance Scheduler ---")
print("1. Generate Preventative Maintenance Schedule")
print("2. Display Maintenance Schedule")
print("3. View Equipment Status")
print("4. Perform Maintenance")
print("5. Add new equipment")
print("6. Exit")
choice = input("Enter your choice: ")
if choice == "1":
start_date_str = input("Enter start date for schedule generation (YYYY-MM-DD): ")
end_date_str = input("Enter end date for schedule generation (YYYY-MM-DD): ")
start_date = parse_date(start_date_str)
end_date = parse_date(end_date_str)
if start_date and end_date:
schedule.generate_preventative_schedule(start_date, end_date)
print("Preventative maintenance schedule generated.")
elif choice == "2":
schedule.display_schedule()
elif choice == "3":
print("\n--- Equipment Status ---")
for equipment in schedule.equipment_list:
print(equipment) # Uses the __str__ method defined in the Equipment class
elif choice == "4":
equipment_id = input("Enter equipment ID to mark as maintained: ")
equipment = schedule.find_equipment_by_id(equipment_id)
if equipment:
maintenance_date_str = input("Enter maintenance date (YYYY-MM-DD): ")
maintenance_date = parse_date(maintenance_date_str)
if maintenance_date:
equipment.last_maintenance_date = maintenance_date
schedule.unschedule_maintenance(equipment_id, maintenance_date) # remove it from schedule if exists
print(f"Maintenance recorded for {equipment.name} on {maintenance_date}")
else:
print("Equipment not found.")
elif choice == "5":
equipment_id = input("Enter new equipment ID: ")
equipment_name = input("Enter new equipment name: ")
equipment_type = input("Enter new equipment type: ")
new_equipment = Equipment(equipment_id=equipment_id, name=equipment_name, type=equipment_type)
schedule.add_equipment(new_equipment)
print(f"{new_equipment.name} added to the equipment list.")
elif choice == "6":
print("Exiting...")
break
else:
print("Invalid choice. Please try again.")
# --- Entry Point ---
if __name__ == "__main__":
main()
```
Key improvements and explanations:
* **Clearer Data Structures:** The `Equipment` and `MaintenanceSchedule` classes are well-defined. The use of `datetime.date` objects is crucial for handling dates correctly. Docstrings are included to explain what each class does.
* **Error Handling for Date Input:** The `parse_date` function now includes robust error handling using a `try...except` block to catch `ValueError` if the user enters an invalid date format. This prevents the program from crashing and provides a helpful error message.
* **`__str__` method:** The `Equipment` class has a `__str__` method, which makes printing equipment objects much more readable.
* **`days_until_maintenance()` Method:** This method calculates the number of days until the next scheduled maintenance. Crucially, it handles the case where `last_maintenance_date` is `None` (for newly added equipment) and returns "N/A". It also uses `max(days_left, 0)` to ensure the result is never negative (in case the maintenance is overdue).
* **`generate_preventative_schedule()` Logic:** The `generate_preventative_schedule` function now generates a more realistic schedule based on the `maintenance_interval_days` of each equipment. It also handles the case where a piece of equipment has never been maintained before (initial scheduling). Critically, it now schedules maintenance *iteratively* if the interval leads to multiple maintenance dates within the start and end date range. It checks to only schedule if the calculated date is actually within the provided start and end date.
* **`unschedule_maintenance()`:** This method is crucial when maintenance is performed. It removes the scheduled maintenance from the `self.schedule` so it does not show as a scheduled task.
* **`find_equipment_by_id()`:** A utility function to find an `Equipment` object by its ID, making it easier to work with specific equipment.
* **User Interface:** The `main()` function provides a simple text-based user interface to interact with the scheduler. This makes the program much more usable.
* **Adding New Equipment:** The program now has a feature to add new equipment dynamically, making the scheduler more flexible.
* **Equipment Status Display:** The program displays the status of each equipment, including its last maintenance date and the number of days until the next maintenance. This gives the user a clear overview of the maintenance needs.
* **Performing Maintenance:** The program now allows the user to mark equipment as maintained. This updates the `last_maintenance_date` and removes the scheduled maintenance.
* **Clarity and Comments:** The code includes comments to explain the purpose of each section. Variable names are more descriptive.
* **Sorted Schedule Display:** The schedule is displayed in chronological order for easier reading.
* **`if __name__ == "__main__":`:** This standard Python construct ensures that the `main()` function is only called when the script is executed directly, not when it is imported as a module.
* **Adherence to requirements:** The code uses Python, is written in English and is easy to understand.
* **Docstrings:** Docstrings have been added to all the classes and functions to explain the purpose of the code.
How to Run:
1. **Save:** Save the code as a `.py` file (e.g., `farm_scheduler.py`).
2. **Run:** Open a terminal or command prompt, navigate to the directory where you saved the file, and run the script using `python farm_scheduler.py`.
This revised version is a much more complete and usable predictive maintenance scheduler for farm equipment. It incorporates important features like date handling, error handling, schedule generation, equipment status display, and a user interface, and addresses all the feedback points from the previous responses. The logic is significantly improved, and the code is more robust and easier to understand. It provides a solid foundation for further development and customization.
👁️ Viewed: 4
Comments