Implement a Composable Event Recommendation Engine

Problem Statement

Design an event recommendation engine for a ticketing platform that calculates a final 'relevance score' for events. The system must support composable ranking rules that can be enabled, disabled, or reordered dynamically.

Each recommendation request may include different constraints (e.g., location, budget, or event category). Implement a system that allows chaining these rules together and supports a 'fallback' mechanism: if the primary rules yield too few events, the system should execute secondary rules to backfill the results.

Requirements

1. Define a RecommendationRule interface with a method apply(user_id, event_list) -> scored_events.
2. Implement a RecommendationEngine class that manages a collection of rules and fallback logic.
3. Implement at least two concrete rules:
   • PopularityRule: Scores events based on global ticket sales.
   • ProximityRule: Scores events based on distance from the user's current location.

Interface

class Event:
    def __init__(self, id, category, price, popularity, lat, lon):
        self.id = id
        # ... other attributes

class RecommendationEngine:
    def __init__(self):
        # Initialize rules and fallback strategies
        pass

    def add_rule(self, rule, priority):
        pass

    def get_recommendations(self, user_id, events, count):
        # Return top N events based on prioritized rules
        pass

Example

• Input: A list of 10 events, a user located at (40.7, -74.0), and a count of 3.
• Logic: Apply ProximityRule (weight 0.7) and PopularityRule (weight 0.3).
• Output: A list of 3 Event objects sorted by the weighted sum of scores.

Constraints

• The engine must handle thousands of events per request.
• Rules must be independent and interchangeable.
• If a specific rule fails (e.g., service timeout), the system should continue to the next available rule.