hospitality-expert

name	hospitality-expert
version	1.0.0
description	Expert-level hotel management, reservation systems, guest services, revenue management, and hospitality technology
category	domains
tags	["hospitality","hotel","reservation","pms","revenue-management"]
allowed-tools	["Read","Write","Edit"]

Hospitality Expert

Expert guidance for hotel management, reservation systems, property management systems (PMS), guest services, revenue management, and hospitality technology solutions.

Core Concepts

Hotel Management Systems

• Property Management System (PMS)
• Central Reservation System (CRS)
• Revenue Management System (RMS)
• Channel Manager
• Point of Sale (POS)
• Guest Relationship Management (GRM)
• Housekeeping management

Technologies

• Mobile check-in/check-out
• Digital key systems
• Guest messaging platforms
• IoT for room automation
• AI chatbots for customer service
• Contactless payments
• Energy management systems

Standards and Protocols

• HTNG (Hotel Technology Next Generation)
• OpenTravel Alliance standards
• PCI-DSS for payment security
• ADA compliance for accessibility
• Brand standards (if franchise)
• OTA integrations (Booking.com, Expedia)

Property Management System

from dataclasses import dataclass
from datetime import datetime, timedelta, date
from typing import List, Optional, Dict
from decimal import Decimal
from enum import Enum

class RoomType(Enum):
    STANDARD = "standard"
    DELUXE = "deluxe"
    SUITE = "suite"
    EXECUTIVE = "executive"

class RoomStatus(Enum):
    VACANT_CLEAN = "vacant_clean"
    VACANT_DIRTY = "vacant_dirty"
    OCCUPIED_CLEAN = "occupied_clean"
    OCCUPIED_DIRTY = "occupied_dirty"
    OUT_OF_ORDER = "out_of_order"
    OUT_OF_SERVICE = "out_of_service"

class ReservationStatus(Enum):
    CONFIRMED = "confirmed"
    CHECKED_IN = "checked_in"
    CHECKED_OUT = "checked_out"
    CANCELLED = "cancelled"
    NO_SHOW = "no_show"

@dataclass
class Room:
    """Hotel room information"""
    room_number: str
    room_type: RoomType
    floor: int
    status: RoomStatus
    base_rate: Decimal
    features: List[str]
    bed_type: str
    max_occupancy: 
    square_feet: 
    is_smoking: 


 :
    
    reservation_id: 
    guest_name: 
    guest_email: 
    guest_phone: 
    room_type: RoomType
    check_in_date: date
    check_out_date: date
    num_adults: 
    num_children: 
    status: ReservationStatus
    rate_per_night: Decimal
    total_amount: Decimal
    special_requests: 
    created_at: datetime
    booking_source:   
    assigned_room: []


 :
    
    folio_id: 
    reservation_id: 
    room_number: 
    guest_name: 
    charges: []
    total_charges: Decimal
    payments: []
    balance: Decimal

 :
    

     ():
        .rooms = {}
        .reservations = {}
        .folios = {}
        .guests = {}

     () -> Reservation:
        
        reservation_id = ._generate_reservation_id()

        
        check_in = reservation_data[]
        check_out = reservation_data[]
        num_nights = (check_out - check_in).days

        rate_per_night = Decimal((reservation_data[]))
        total_amount = rate_per_night * num_nights

        reservation = Reservation(
            reservation_id=reservation_id,
            guest_name=reservation_data[],
            guest_email=reservation_data[],
            guest_phone=reservation_data[],
            room_type=RoomType(reservation_data[]),
            check_in_date=check_in,
            check_out_date=check_out,
            num_adults=reservation_data[],
            num_children=reservation_data.get(, ),
            status=ReservationStatus.CONFIRMED,
            rate_per_night=rate_per_night,
            total_amount=total_amount,
            special_requests=reservation_data.get(, ),
            created_at=datetime.now(),
            booking_source=reservation_data.get(, ),
            assigned_room=
        )

        .reservations[reservation_id] = reservation

         reservation

     () -> :
        
        reservation = .reservations.get(reservation_id)
          reservation:
             {: }

        
        available_room = ._find_available_room(
            reservation.room_type,
            reservation.check_in_date,
            reservation.check_out_date
        )

          available_room:
             {: }

        
        reservation.assigned_room = available_room.room_number
        reservation.status = ReservationStatus.CHECKED_IN

        
        available_room.status = RoomStatus.OCCUPIED_CLEAN

        
        folio = ._create_folio(reservation, available_room)

         {
            : reservation_id,
            : available_room.room_number,
            : reservation.guest_name,
            : datetime.now().isoformat(),
            : reservation.check_out_date.isoformat(),
            : folio.folio_id
        }

     () -> :
        
        reservation = .reservations.get(reservation_id)
          reservation:
             {: }

        
        folio = (
            (f  f  .folios.values()  f.reservation_id == reservation_id),
            
        )

          folio:
             {: }

        
         folio.balance > :
             {
                : ,
                : (folio.balance)
            }

        
        reservation.status = ReservationStatus.CHECKED_OUT

        
         reservation.assigned_room:
            room = .rooms.get(reservation.assigned_room)
             room:
                room.status = RoomStatus.VACANT_DIRTY

         {
            : reservation_id,
            : reservation.guest_name,
            : datetime.now().isoformat(),
            : (folio.total_charges),
            : {
                : (folio.total_charges),
                : (folio.total_charges - folio.balance)
            }
        }

     () -> [Room]:
        
         room  .rooms.values():
             room.room_type != room_type:
                

             room.status   [RoomStatus.VACANT_CLEAN, RoomStatus.VACANT_DIRTY]:
                

            
             ._is_room_available(room.room_number, check_in, check_out):
                 room

         

     () -> :
        
         reservation  .reservations.values():
             reservation.assigned_room != room_number:
                

             reservation.status  [ReservationStatus.CANCELLED, ReservationStatus.NO_SHOW]:
                

            
              (check_out <= reservation.check_in_date  check_in >= reservation.check_out_date):
                 

         

     () -> Folio:
        
        folio_id = ._generate_folio_id()

        
        num_nights = (reservation.check_out_date - reservation.check_in_date).days
        room_charge = reservation.rate_per_night * num_nights

        charges = [{
            : datetime.now(),
            : ,
            : (room_charge)
        }]

        folio = Folio(
            folio_id=folio_id,
            reservation_id=reservation.reservation_id,
            room_number=room.room_number,
            guest_name=reservation.guest_name,
            charges=charges,
            total_charges=room_charge,
            payments=[],
            balance=room_charge
        )

        .folios[folio_id] = folio

         folio

     () -> :
        
        folio = .folios.get(folio_id)
          folio:
             {: }

        charge = {
            : datetime.now(),
            : charge_data[],
            : (Decimal((charge_data[])))
        }

        folio.charges.append(charge)
        folio.total_charges += Decimal((charge_data[]))
        folio.balance += Decimal((charge_data[]))

         {
            : folio_id,
            : charge,
            : (folio.balance)
        }

     () -> :
        
        folio = .folios.get(folio_id)
          folio:
             {: }

        payment_amount = Decimal((payment_data[]))

         payment_amount > folio.balance:
             {: }

        payment = {
            : datetime.now(),
            : payment_data[],
            : (payment_amount)
        }

        folio.payments.append(payment)
        folio.balance -= payment_amount

         {
            : folio_id,
            : payment,
            : (folio.balance)
        }

     () -> :
        
        availability = {}

         room_type  RoomType:
            available_count = 

             room  .rooms.values():
                 room.room_type == room_type:
                     ._is_room_available(room.room_number, check_in, check_out):
                        available_count += 

            availability[room_type.value] = available_count

         {
            : check_in.isoformat(),
            : check_out.isoformat(),
            : availability
        }

     () -> :
         uuid
         

     () -> :
         uuid
         

Revenue Management System

import numpy as np

class RevenueManagementSystem:
    """Hotel revenue management and dynamic pricing"""

    def __init__(self):
        self.pricing_rules = []
        self.demand_forecast = {}

    def calculate_dynamic_rate(self,
                              room_type: RoomType,
                              check_in_date: date,
                              days_until_arrival: int,
                              current_occupancy: float,
                              historical_data: dict) -> Decimal:
        """Calculate dynamic room rate"""
        # Base rate
        base_rates = {
            RoomType.STANDARD: Decimal('150'),
            RoomType.DELUXE: Decimal('200'),
            RoomType.SUITE: Decimal('350'),
            RoomType.EXECUTIVE: Decimal('450')
        }

        base_rate = base_rates.get(room_type, Decimal('150'))

        # Demand multiplier based on occupancy
        if current_occupancy > 0.85:
            demand_multiplier = Decimal('1.30')  # High demand
        elif current_occupancy > 0.70:
            demand_multiplier = Decimal('1.15')  # Moderate demand
        elif current_occupancy > 0.50:
            demand_multiplier = Decimal('1.00')  # Normal
        else:
            demand_multiplier = Decimal('0.85')  # Low demand

        
         days_until_arrival < :
            window_multiplier = Decimal()  
         days_until_arrival < :
            window_multiplier = Decimal()
         days_until_arrival > :
            window_multiplier = Decimal()  
        :
            window_multiplier = Decimal()

        
         check_in_date.weekday()  [, ]:  
            day_multiplier = Decimal()
         check_in_date.weekday() == :  
            day_multiplier = Decimal()
        :
            day_multiplier = Decimal()

        
        dynamic_rate = base_rate * demand_multiplier * window_multiplier * day_multiplier

        
        dynamic_rate = dynamic_rate.quantize(Decimal())

         dynamic_rate

     () -> :
        
        forecast = {}

         i  (days):
            forecast_date = start_date + timedelta(days=i)

            
            
            base_demand =   

            
             forecast_date.weekday()  [, ]:  
                day_factor = 
             forecast_date.weekday() == :
                day_factor = -
            :
                day_factor = 

            
            month = forecast_date.month
             month  [, , ]:  
                season_factor = 
             month  [, ]:  
                season_factor = 
            :
                season_factor = 

            forecasted_occupancy = base_demand + day_factor + season_factor
            forecasted_occupancy = (, (, forecasted_occupancy))

            forecast[forecast_date.isoformat()] = {
                : forecast_date.isoformat(),
                : forecasted_occupancy,
                :   i <     i <   
            }

         forecast

     () -> :
        
        
        

        allocation = {
            : (total_rooms * ),  
            : (total_rooms * ),     
            : (total_rooms * ),  
            : (total_rooms * )  
        }

         {
            : total_rooms,
            : allocation,
            : {
                : date_range[].isoformat(),
                : date_range[].isoformat()
            }
        }

     () -> Decimal:
        
         available_rooms == :
             Decimal()

        revpar = revenue / available_rooms
         revpar.quantize(Decimal())

     () -> Decimal:
        
         rooms_sold == :
             Decimal()

        adr = revenue / rooms_sold
         adr.quantize(Decimal())

Guest Services Management

@dataclass
class GuestRequest:
    """Guest service request"""
    request_id: str
    reservation_id: str
    room_number: str
    guest_name: str
    request_type: str  # 'housekeeping', 'maintenance', 'concierge', 'amenity'
    description: str
    priority: str  # 'low', 'medium', 'high'
    status: str  # 'open', 'in_progress', 'completed'
    created_at: datetime
    assigned_to: Optional[str]
    completed_at: Optional[datetime]

class GuestServicesSystem:
    """Guest services and experience management"""

    def __init__(self):
        self.requests = []
        self.guest_preferences = {}
        self.loyalty_members = {}

    def submit_guest_request(self, request_data: dict) -> GuestRequest:
        """Submit guest service request"""
        request = GuestRequest(
            request_id=self._generate_request_id(),
            reservation_id=request_data['reservation_id'],
            room_number=request_data['room_number'],
            guest_name=request_data['guest_name'],
            request_type=request_data['request_type'],
            description=request_data['description'],
            priority=request_data.get('priority', 'medium'),
            status=,
            created_at=datetime.now(),
            assigned_to=,
            completed_at=
        )

        .requests.append(request)

        
        ._auto_assign_request(request)

         request

     ():
        
        .guest_preferences[guest_id] = {
            : {
                : preferences.get(),
                : preferences.get(),
                : preferences.get()
            },
            : preferences.get(, []),
            : preferences.get(, []),
            : preferences.get(, {}),
            : preferences.get(, )
        }

     () -> :
        
        
        

        metrics = {
            : ,  
            : ,
            : ,
            : ,
            : ,
            : ,
            :   
        }

         {
            : reservation_id,
            : metrics,
            :   metrics[] >=  
                            metrics[] >=  
                          
        }

     ():
        
        
        assignments = {
            : ,
            : ,
            : ,
            : 
        }

        request.assigned_to = assignments.get(request.request_type, )

     () -> :
         uuid
         

Best Practices

Reservations Management

• Implement real-time availability
• Use channel manager for distribution
• Enable mobile booking
• Implement flexible cancellation policies
• Send automated confirmations
• Track booking sources
• Enable group bookings

Revenue Management

• Implement dynamic pricing
• Monitor competitor rates
• Forecast demand accurately
• Optimize inventory allocation
• Track RevPAR and ADR
• Use yield management strategies
• Analyze booking patterns

Guest Experience

• Personalize guest interactions
• Enable mobile check-in/out
• Provide digital concierge services
• Track guest preferences
• Respond promptly to requests
• Implement loyalty programs
• Gather feedback systematically

Operations

• Maintain housekeeping efficiency
• Implement preventive maintenance
• Use automated messaging
• Monitor room status in real-time
• Optimize staff scheduling
• Track operational metrics
• Ensure PCI-DSS compliance

Anti-Patterns

❌ Manual reservation management ❌ Static pricing year-round ❌ No guest preference tracking ❌ Poor channel management ❌ Slow response to guest requests ❌ No mobile capabilities ❌ Inadequate staff training ❌ Poor data security ❌ No revenue analytics

Resources

• HTNG (Hotel Technology Next Generation): https://htng.org/
• HSMAI (Hospitality Sales and Marketing Association): https://www.hsmai.org/
• AHLA (American Hotel & Lodging Association): https://www.ahla.com/
• STR (Hotel data and analytics): https://str.com/
• OpenTravel Alliance: https://opentravel.org/
• Hospitality Technology: https://www.hospitalitytech.com/
• Revenue Management Best Practices: https://www.revparguru.com/