review

AirbnbMapVisualiser.py

@@ -4,6 +4,7 @@ import folium
 from html import escape
 from transformers import AutoTokenizer
 import numpy as np
+from TrafficSpot import TrafficSpotManager
 
 
 class AirbnbMapVisualiser:
@@ -13,25 +14,103 @@ class AirbnbMapVisualiser:
             'password': '7033',
             'dsn': 'imz409.ust.hk:1521/imz409'
         }
-        # Initialize the tokenizer
         self.tokenizer = AutoTokenizer.from_pretrained('bert-base-uncased')
+        self.traffic_manager = TrafficSpotManager(self.connection_params)
+
         try:
-            self.all_listings = self.get_all_listings()
-            if self.all_listings:
-                self.neighborhoods = sorted(list(set(row[3] for row in self.all_listings if row[3])))
-            else:
-                self.neighborhoods = []
-                print("No listings found in database")
+            # Get all neighborhoods first (this is a small query)
+            self.neighborhoods = self.get_all_neighborhoods()
+            # Initialize with Sha Tin listings
+            self.cached_listings = {}
+            self.cached_listings["Sha Tin"] = self.get_neighborhood_listings("Sha Tin")
         except Exception as e:
             print(f"Initialization error: {str(e)}")
-            self.all_listings = []
             self.neighborhoods = []
+            self.cached_listings = {}
+
+    def get_all_neighborhoods(self):
+        try:
+            with oracledb.connect(**self.connection_params) as conn:
+                cursor = conn.cursor()
+                cursor.execute("""
+                    SELECT DISTINCT NEIGHBOURHOOD 
+                    FROM airbnb_master_data 
+                    WHERE NEIGHBOURHOOD IS NOT NULL 
+                    ORDER BY NEIGHBOURHOOD
+                """)
+                neighborhoods = [row[0] for row in cursor.fetchall()]
+                return neighborhoods
+        except Exception as e:
+            print(f"Database error getting neighborhoods: {str(e)}")
+            return []
+
+    def get_neighborhood_listings(self, neighborhood):
+        # Check if listings are already cached
+        if neighborhood in self.cached_listings:
+            return self.cached_listings[neighborhood]
+
+        try:
+            with oracledb.connect(**self.connection_params) as conn:
+                cursor = conn.cursor()
+                cursor.execute("""
+                   SELECT m.ID, m.NAME, m.HOST_NAME, m.NEIGHBOURHOOD,
+m.LATITUDE, m.LONGITUDE, m.ROOM_TYPE, m.PRICE,
+COUNT(r.LISTING_ID) as NUMBER_OF_REVIEWS, m.REVIEWS_PER_MONTH,
+m.MINIMUM_NIGHTS, m.AVAILABILITY_365
+FROM airbnb_master_data m
+LEFT JOIN airbnb_reviews_data r ON m.ID = r.LISTING_ID
+WHERE m.LATITUDE IS NOT NULL AND m.LONGITUDE IS NOT NULL AND NEIGHBOURHOOD = :neighborhood
+GROUP BY m.ID, m.NAME, m.HOST_NAME, m.NEIGHBOURHOOD,
+m.LATITUDE, m.LONGITUDE, m.ROOM_TYPE, m.PRICE,
+m.REVIEWS_PER_MONTH, m.MINIMUM_NIGHTS, m.AVAILABILITY_365
+                    
+                """, neighborhood=neighborhood)
+                listings = cursor.fetchall()
+                # Cache the results
+                self.cached_listings[neighborhood] = listings
+                return listings
+        except Exception as e:
+            print(f"Database error: {str(e)}")
+            return []
+
+    def get_listing_reviews(self, listing_id):
+        try:
+            with oracledb.connect(**self.connection_params) as conn:
+                cursor = conn.cursor()
+                cursor.execute("""
+                    SELECT REVIEW_DATE, REVIEWER_NAME, 
+                           CASE 
+                               WHEN LENGTH(COMMENTS) > 200 
+                               THEN SUBSTR(COMMENTS, 1, 200) || '...'
+                               ELSE COMMENTS 
+                           END as COMMENTS
+                    FROM AIRBNB_REVIEWS_DATA 
+                    WHERE LISTING_ID = :listing_id
+                    ORDER BY REVIEW_DATE DESC
+                """, listing_id=str(listing_id))
+                reviews = cursor.fetchall()
+
+                formatted_reviews = []
+                for review in reviews:
+                    review_date, reviewer_name, comments = review
+                    formatted_review = (
+                        str(review_date) if review_date else '',
+                        str(reviewer_name) if reviewer_name else '',
+                        str(comments) if comments else ''
+                    )
+                    formatted_reviews.append(formatted_review)
+
+                return formatted_reviews
+        except oracledb.DatabaseError as e:
+            print(f"Database error fetching reviews: {str(e)}")
+            return []
+        except Exception as e:
+            print(f"Error fetching reviews: {str(e)}")
+            return []
 
     def preprocess_text(self, text):
         if not isinstance(text, str):
             return ""
-
-        # Tokenize and decode back to get normalized text
         tokens = self.tokenizer.tokenize(text)
         cleaned_text = " ".join(tokens)
         return cleaned_text
@@ -43,18 +122,14 @@ class AirbnbMapVisualiser:
     def compute_token_based_similarity(self, text1, text2):
         tokens1 = set(self.tokenizer.tokenize(text1.lower()))
         tokens2 = set(self.tokenizer.tokenize(text2.lower()))
-
         intersection = len(tokens1.intersection(tokens2))
-
         normalization_factor = min(len(tokens1), len(tokens2))
 
         if normalization_factor == 0:
             return 0
 
         base_similarity = intersection / normalization_factor
-
         boosted_score = 1 / (1 + np.exp(-6 * (base_similarity - 0.5)))
-
         return boosted_score
 
     def compute_search_scores(self, df, search_query):
@@ -68,21 +143,17 @@ class AirbnbMapVisualiser:
 
             token_sim = self.compute_token_based_similarity(processed_query, listing_desc)
 
-            # Enhanced exact match bonus
             exact_match_bonus = 0
             partial_match_bonus = 0
 
             for term in query_terms:
-                # Exact match bonus
                 if term in desc_terms:
-                    exact_match_bonus += 0.2  # 20% bonus for each exact term match
+                    exact_match_bonus += 0.2
 
-                # Partial match bonus
                 for desc_term in desc_terms:
                     if term in desc_term or desc_term in term:
-                        partial_match_bonus += 0.1  # 10% bonus for partial matches
+                        partial_match_bonus += 0.1
 
-            # Calculate category match bonus
             category_keywords = {
                 'location': ['near', 'close', 'located', 'area', 'district'],
                 'amenities': ['wifi', 'kitchen', 'bathroom', 'furnished'],
@@ -94,18 +165,16 @@ class AirbnbMapVisualiser:
             for category, keywords in category_keywords.items():
                 if any(keyword in processed_query.lower() for keyword in keywords):
                     if any(keyword in listing_desc.lower() for keyword in keywords):
-                        category_bonus += 0.15  # 15% bonus for matching categories
+                        category_bonus += 0.15
 
-            # Combine all scores with adjusted weights
             final_score = min(1.0, (
-                    token_sim * 0.4 +  # Base similarity
-                    exact_match_bonus * 0.3 +  # Exact matches
-                    partial_match_bonus * 0.2 +  # Partial matches
-                    category_bonus * 0.1  # Category matches
+                    token_sim * 0.4 +
+                    exact_match_bonus * 0.3 +
+                    partial_match_bonus * 0.2 +
+                    category_bonus * 0.1
             ))
 
-            # Apply exponential boost to higher scores
-            boosted_score = np.power(final_score, 0.7)  # This will boost higher scores more
+            boosted_score = np.power(final_score, 0.7)
             scores.append(boosted_score)
 
         return np.array(scores)
@@ -114,33 +183,26 @@ class AirbnbMapVisualiser:
         if not search_query:
             return df
 
-        # Get similarity scores
         scores = self.compute_search_scores(df, search_query)
-
-        # Add scores to dataframe
         df['relevance_score'] = scores
-
-        # Convert to percentage (0-100) with adjusted scaling
         df['relevance_percentage'] = df['relevance_score'] * 100
 
-        # Adjust threshold levels for relevance descriptions
         def get_relevance_description(score):
-            if score >= 70:  # Lowered from 85
+            if score >= 70:
                 return "Perfect match"
-            elif score >= 55:  # Lowered from 70
+            elif score >= 55:
                 return "Very relevant"
-            elif score >= 40:  # Lowered from 55
+            elif score >= 40:
                 return "Relevant"
-            elif score >= 25:  # Lowered from 40
+            elif score >= 25:
                 return "Somewhat relevant"
-            elif score >= 15:  # Lowered from 25
+            elif score >= 15:
                 return "Slightly relevant"
             else:
                 return "Less relevant"
 
         df['relevance_features'] = df['relevance_percentage'].apply(get_relevance_description)
 
-        # Enhanced matching features description
         def get_matching_features(row):
             query_tokens = set(self.tokenizer.tokenize(search_query.lower()))
             desc_tokens = set(self.tokenizer.tokenize(self.create_listing_description(row).lower()))
@@ -149,7 +211,6 @@ class AirbnbMapVisualiser:
             if not matching_tokens:
                 return "No direct matches"
 
-            # Group similar matches
             grouped_matches = []
             processed_tokens = set()
 
@@ -166,89 +227,48 @@ class AirbnbMapVisualiser:
             return ", ".join(grouped_matches)
 
         df['matching_features'] = df.apply(get_matching_features, axis=1)
-
-        # Sort by relevance score (descending)
         return df.sort_values('relevance_score', ascending=False)
 
-
-    def get_all_listings(self):
-        try:
-            with oracledb.connect(**self.connection_params) as conn:
-                cursor = conn.cursor()
-                cursor.execute("""
-                    SELECT ID, NAME, HOST_NAME, NEIGHBOURHOOD, 
-                           LATITUDE, LONGITUDE, ROOM_TYPE, PRICE,
-                           NUMBER_OF_REVIEWS, REVIEWS_PER_MONTH,
-                           MINIMUM_NIGHTS, AVAILABILITY_365
-                    FROM airbnb_master_data 
-                    WHERE LATITUDE IS NOT NULL 
-                    AND LONGITUDE IS NOT NULL
-                """)
-                return cursor.fetchall()
-        except Exception as e:
-            print(f"Database error: {str(e)}")
-            return []
-
-    def get_traffic_spots(self):
-        try:
-            with oracledb.connect(**self.connection_params) as conn:
-                cursor = conn.cursor()
-                cursor.execute("""
-                    SELECT KEY, LATITUDE, LONGITUDE 
-                    FROM TD_TRAFFIC_CAMERA_LOCATION 
-                    WHERE LATITUDE IS NOT NULL 
-                    AND LONGITUDE IS NOT NULL
-                """)
-                return cursor.fetchall()
-        except Exception as e:
-            print(f"Database error: {str(e)}")
-            return []
-
     def create_map_and_data(self, neighborhood="Sha Tin", show_traffic=True, center_lat=None, center_lng=None,
                             selected_id=None, search_query=None):
-        if not self.all_listings:
+        listings = self.get_neighborhood_listings(neighborhood)
+
+        if not listings:
             return None, None
 
-        df = pd.DataFrame(self.all_listings, columns=[
+        df = pd.DataFrame(listings, columns=[
             'id', 'name', 'host_name', 'neighbourhood',
             'latitude', 'longitude', 'room_type', 'price',
             'number_of_reviews', 'reviews_per_month',
             'minimum_nights', 'availability_365'
         ])
 
-        # Filter by neighborhood
-        df = df[df['neighbourhood'] == neighborhood].copy()
-
-        # Convert numeric columns
         numeric_cols = ['latitude', 'longitude', 'price', 'number_of_reviews',
                         'minimum_nights', 'availability_365', 'reviews_per_month']
         for col in numeric_cols:
             df[col] = pd.to_numeric(df[col], errors='coerce')
 
-        # Apply search-based sorting if query exists
         if search_query:
             df = self.sort_by_relevance(df, search_query)
 
         if df.empty:
             return None, None
 
-        # Calculate map center
         if center_lat is None or center_lng is None:
             center_lat = df['latitude'].mean()
             center_lng = df['longitude'].mean()
 
-        # Create map
         m = folium.Map(
             location=[center_lat, center_lng],
             zoom_start=16 if (center_lat is not None and center_lng is not None) else 14,
             tiles='OpenStreetMap'
         )
 
-        # Add markers for listings
         for idx, row in df.iterrows():
             marker_id = f"marker_{row['id']}"
+            reviews = self.get_listing_reviews(row['id'])
+            review_button_key = f"review_btn_{row['id']}"
 
-            # Add relevance information to popup if search was performed
             relevance_info = ""
             if search_query and 'relevance_percentage' in row:
                 relevance_info = f"""
@@ -267,6 +287,11 @@ class AirbnbMapVisualiser:
                     <p style='margin: 5px 0;'><strong>Price:</strong> ${row['price']:.0f}</p>
                     <p style='margin: 5px 0;'><strong>Reviews:</strong> {row['number_of_reviews']:.0f}</p>
                     {relevance_info}
+                    <button onclick="streamlit_click('{review_button_key}')" 
+                        style="background-color: #4CAF50; color: white; padding: 8px 15px; border: none; 
+                        border-radius: 4px; cursor: pointer; margin-top: 10px;">
+                        View Reviews ({len(reviews)})
+                    </button>
                 </div>
             """
 
@@ -282,31 +307,7 @@ class AirbnbMapVisualiser:
 
             if selected_id is not None and row['id'] == selected_id:
                 marker._name = marker_id
-                m.get_root().html.add_child(folium.Element(f"""
-                    <script>
-                        document.addEventListener('DOMContentLoaded', function() {{
-                            setTimeout(function() {{
-                                document.querySelector('#{marker_id}').click();
-                            }}, 1000);
-                        }});
-                    </script>
-                """))
-
-        # Add traffic cameras if requested
-        if show_traffic:
-            traffic_spots = self.get_traffic_spots()
-            for spot in traffic_spots:
-                if spot[1] and spot[2]:
-                    popup_content = f"""
-                        <div style='min-width: 150px; padding: 10px;'>
-                            <p style='margin: 5px 0;'><strong>Traffic Camera ID:</strong> {escape(str(spot[0]))}</p>
-                        </div>
-                    """
-
-                    folium.Marker(
-                        location=[float(spot[1]), float(spot[2])],
-                        popup=popup_content,
-                        icon=folium.Icon(color='blue', icon='camera'),
-                    ).add_to(m)
 
+        if show_traffic:
+            self.traffic_manager.add_spots_to_map(m)
         return m, df

TrafficSpot.py

@@ -0,0 +1,57 @@
+import oracledb
+from html import escape
+import folium
+
+class TrafficSpot:
+    def __init__(self, key, latitude, longitude):
+        self.key = key
+        self.latitude = float(latitude) if latitude is not None else None
+        self.longitude = float(longitude) if longitude is not None else None
+
+    def is_valid(self):
+        return self.latitude is not None and self.longitude is not None
+
+    def create_popup_content(self):
+        return f"""
+            <div style='min-width: 150px; padding: 10px;'>
+                <p style='margin: 5px 0;'><strong>Traffic Camera ID:</strong> {escape(str(self.key))}</p>
+            </div>
+        """
+
+    def add_to_map(self, folium_map):
+        if self.is_valid():
+            folium.Marker(
+                location=[self.latitude, self.longitude],
+                popup=self.create_popup_content(),
+                icon=folium.Icon(color='blue', icon='camera'),
+            ).add_to(folium_map)
+
+
+class TrafficSpotManager:
+    def __init__(self, connection_params):
+        self.connection_params = connection_params
+        self.traffic_spots = []
+        self.load_traffic_spots()
+
+    def load_traffic_spots(self):
+        try:
+            with oracledb.connect(**self.connection_params) as conn:
+                cursor = conn.cursor()
+                cursor.execute("""
+                    SELECT KEY, LATITUDE, LONGITUDE 
+                    FROM TD_TRAFFIC_CAMERA_LOCATION 
+                    WHERE LATITUDE IS NOT NULL 
+                    AND LONGITUDE IS NOT NULL
+                """)
+                spots = cursor.fetchall()
+                self.traffic_spots = [
+                    TrafficSpot(spot[0], spot[1], spot[2])
+                    for spot in spots
+                ]
+        except Exception as e:
+            print(f"Database error loading traffic spots: {str(e)}")
+            self.traffic_spots = []
+
+    def add_spots_to_map(self, folium_map):
+        for spot in self.traffic_spots:
+            spot.add_to_map(folium_map)

app.py

@@ -4,14 +4,40 @@ from streamlit_folium import st_folium, folium_static
 import math
 from AirbnbMapVisualiser import AirbnbMapVisualiser
 
+
 def load_css(css_file):
     with open(css_file) as f:
         st.markdown(f'<style>{f.read()}</style>', unsafe_allow_html=True)
 
+
+def render_review_dialog():
+        # Display reviews
+        with st.container():
+            col_title = st.columns([5, 1])
+            with col_title[0]:
+                st.markdown(f"### Reviews for {st.session_state.current_review_listing_name}")
+            reviews = st.session_state.visualizer.get_listing_reviews(st.session_state.current_review_listing)
+            if reviews:
+                for review in reviews:
+                    try:
+                        review_date, reviewer_name, comments = review
+                        st.markdown(f"""
+                                   <div class="review-card">
+                                     <div class="review-header">
+                                       {escape(str(reviewer_name))} - {escape(str(review_date))}
+                                     </div>
+                                     <div class="review-content">
+                                       {escape(str(comments))}
+                                     </div>
+                                   </div>""", unsafe_allow_html=True)
+                    except Exception as e:
+                        st.error(f"Error displaying review: {str(e)}")
+            else:
+                st.info("No reviews available for this listing.")
 def main():
     st.set_page_config(
         layout="wide",
-        page_title="HK Airbnb & Traffic Camera Explorer",
+        page_title="HKUST AirBNB+",
         initial_sidebar_state="expanded"
     )
     load_css('style.css')
@@ -33,19 +59,31 @@ def main():
         st.session_state.search_query = ""
     if 'tokenizer_loaded' not in st.session_state:
         st.session_state.tokenizer_loaded = False
+    if 'show_review_dialog' not in st.session_state:
+        st.session_state.show_review_dialog = False
+    if 'current_review_listing' not in st.session_state:
+        st.session_state.current_review_listing = None
+    if 'current_review_listing_name' not in st.session_state:
+        st.session_state.current_review_listing_name = None
 
     # Initialize visualizer with loading message for tokenizer
-    if not st.session_state.tokenizer_loaded:
+    if 'visualizer' not in st.session_state:
         with st.spinner('Loading BERT tokenizer...'):
-            visualizer = AirbnbMapVisualiser()
+            st.session_state.visualizer = AirbnbMapVisualiser()
             st.session_state.tokenizer_loaded = True
-    else:
-        visualizer = AirbnbMapVisualiser()
+
+    visualizer = st.session_state.visualizer
+
+    # Check if visualizer is properly initialized
+    if visualizer is None or not hasattr(visualizer, 'neighborhoods'):
+        st.error("Error initializing the application. Please refresh the page.")
+        return
 
     with st.sidebar:
-        st.markdown('<p class="sidebar-header">HKUST AirBNB+ (External Hall Scheme for Non Local PG Students) <BR/></p>', unsafe_allow_html=True)
+        st.markdown(
+            '<p class="sidebar-header">HKUST AirBNB+ (External Hall Scheme for Non Local PG Students) <BR/></p>',
+            unsafe_allow_html=True)
 
-        # Enhanced search bar with placeholder
         search_query = st.text_input(
             "🔍 Search listings",
             value=st.session_state.search_query,
@@ -55,9 +93,9 @@ def main():
         if search_query != st.session_state.search_query:
             st.session_state.search_query = search_query
             st.session_state.current_page = 1
+            st.session_state.show_review_dialog = False
 
-        st.markdown('<hr style="margin: 20px 0; border: none; border-top: 1px solid #e0e0e0;">',
-                   unsafe_allow_html=True)
+        st.markdown('<hr style="margin: 20px 0; border: none; border-top: 1px solid #e0e0e0;">', unsafe_allow_html=True)
 
         neighborhood = st.selectbox(
             "Select Neighborhood",
@@ -72,6 +110,7 @@ def main():
             st.session_state.selected_id = None
             st.session_state.current_page = 1
             st.session_state.search_query = ""
+            st.session_state.show_review_dialog = False
             st.rerun()
 
     # Create map and get data
@@ -92,6 +131,7 @@ def main():
             st.session_state.center_lat = df.iloc[0]['latitude']
             st.session_state.center_lng = df.iloc[0]['longitude']
         st.session_state.previous_neighborhood = neighborhood
+        st.session_state.show_review_dialog = False
         st.rerun()
 
     if m is None:
@@ -114,16 +154,13 @@ def main():
 
         st.markdown('<div class="scrollable-container">', unsafe_allow_html=True)
 
-        # Enhanced listing display with matching features
         for idx in range(start_idx, end_idx):
             row = df.iloc[idx]
             background_color = "#E3F2FD" if st.session_state.selected_id == row['id'] else "white"
 
-            # Enhanced relevance info with matching features
             relevance_info = ""
             if st.session_state.search_query and 'relevance_percentage' in row:
-                relevance_info = f"""<p class="listing-info"> 🎯 Relevance: {row['relevance_percentage']:.0f}% </p>
-                """
+                relevance_info = f"""<p class="listing-info"> 🎯 Relevance: {row['relevance_percentage']:.0f}% </p>"""
                 if 'matching_features' in row:
                     matching_features = row['matching_features']
                     if matching_features and matching_features != "No direct matches":
@@ -138,11 +175,23 @@ def main():
                     {relevance_info}</div>
             """, unsafe_allow_html=True)
 
-            if st.button("View Details", key=f"btn_{row['id']}"):
-                st.session_state.selected_id = row['id']
-                st.session_state.center_lat = row['latitude']
-                st.session_state.center_lng = row['longitude']
-                st.rerun()
+            col_details, col_reviews = st.columns(2)
+
+            with col_details:
+                if st.button("View Details", key=f"btn_{row['id']}"):
+                    st.session_state.selected_id = row['id']
+                    st.session_state.center_lat = row['latitude']
+                    st.session_state.center_lng = row['longitude']
+                    st.rerun()
+
+            with col_reviews:
+                if st.button("View Reviews", key=f"review_btn_{row['id']}"):
+                    st.session_state.show_review_dialog = True
+                    st.session_state.current_review_listing = row['id']
+                    st.session_state.current_review_listing_name = row['name']
+                    st.session_state.scroll_to_review = True
+                    st.rerun()
+
 
         st.markdown('</div>', unsafe_allow_html=True)
 
@@ -166,6 +215,7 @@ def main():
                     st.session_state.selected_id = df.iloc[new_start_idx]['id']
                     st.session_state.center_lat = df.iloc[new_start_idx]['latitude']
                     st.session_state.center_lng = df.iloc[new_start_idx]['longitude']
+                st.session_state.show_review_dialog = False
                 st.rerun()
 
         with col_prev:
@@ -176,6 +226,7 @@ def main():
                     st.session_state.selected_id = df.iloc[new_start_idx]['id']
                     st.session_state.center_lat = df.iloc[new_start_idx]['latitude']
                     st.session_state.center_lng = df.iloc[new_start_idx]['longitude']
+                st.session_state.show_review_dialog = False
                 st.rerun()
 
         with col_next:
@@ -186,7 +237,13 @@ def main():
                     st.session_state.selected_id = df.iloc[new_start_idx]['id']
                     st.session_state.center_lat = df.iloc[new_start_idx]['latitude']
                     st.session_state.center_lng = df.iloc[new_start_idx]['longitude']
+                st.session_state.show_review_dialog = False
                 st.rerun()
 
+    # Show review dialog if active
+    if st.session_state.show_review_dialog:
+        render_review_dialog()
+
+
 if __name__ == "__main__":
     main()

style.css

@@ -227,4 +227,187 @@
     margin: 16px 0;
     border-radius: 4px;
     color: #C62828;
-}
+}
+
+.review-card {
+    background: white;
+    border: 1px solid #e0e0e0;
+    border-radius: 8px;
+    padding: 16px;
+    margin-bottom: 16px;
+    box-shadow: 0 2px 4px rgba(0,0,0,0.05);
+}
+
+.review-header {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    margin-bottom: 12px;
+}
+
+.reviewer-name {
+    font-weight: bold;
+    color: #1a73e8;
+}
+
+.review-date {
+    color: #666;
+    font-size: 0.9em;
+}
+
+.review-content {
+    line-height: 1.6;
+    color: #333;
+}
+
+.relevance-indicator {
+    font-size: 0.9em;
+    font-weight: 500;
+    padding: 4px 8px;
+    border-radius: 4px;
+    background: rgba(0,0,0,0.05);
+    display: inline-block;
+}
+
+.review-search-container {
+    margin-bottom: 20px;
+}
+
+.review-filters {
+    display: flex;
+    gap: 16px;
+    margin-bottom: 16px;
+}
+
+.scrollable-reviews {
+    max-height: 600px;
+    overflow-y: auto;
+    padding-right: 16px;
+}
+
+.listing-card {
+    padding: 15px;
+    margin-bottom: 15px;
+    border-radius: 8px;
+    box-shadow: 0 2px 4px rgba(0,0,0,0.1);
+}
+
+.listing-title {
+    margin: 0 0 10px 0;
+    font-size: 1.1em;
+    font-weight: bold;
+}
+
+.listing-info {
+    margin: 5px 0;
+    font-size: 0.9em;
+}
+
+.sidebar-header {
+    font-size: 1.2em;
+    font-weight: bold;
+    margin-bottom: 20px;
+}
+
+.map-container {
+    border-radius: 10px;
+    overflow: hidden;
+    box-shadow: 0 2px 5px rgba(0,0,0,0.1);
+}
+
+.scrollable-container {
+    max-height: calc(100vh - 100px);
+    overflow-y: auto;
+    padding-right: 10px;
+}
+
+.listing-card {
+    padding: 15px;
+    margin-bottom: 15px;
+    border-radius: 8px;
+    box-shadow: 0 2px 4px rgba(0,0,0,0.1);
+    transition: background-color 0.3s ease;
+}
+
+.listing-title {
+    margin: 0 0 10px 0;
+    font-size: 1.1em;
+    font-weight: bold;
+    color: #2c3e50;
+}
+
+.listing-info {
+    margin: 5px 0;
+    font-size: 0.9em;
+    color: #34495e;
+}
+
+/* Dialog styling */
+.dialog-content {
+    background-color: white;
+    padding: 20px;
+    border-radius: 10px;
+    box-shadow: 0 4px 20px rgba(0,0,0,0.15);
+    margin: 20px 0;
+    max-height: 80vh;
+    overflow-y: auto;
+}
+
+.review-card {
+    background-color: #f8f9fa;
+    border-left: 4px solid #4CAF50;
+    padding: 15px;
+    margin: 10px 0;
+    border-radius: 4px;
+}
+
+.review-header {
+    font-weight: bold;
+    color: #2c3e50;
+    margin-bottom: 8px;
+}
+
+.review-content {
+    color: #34495e;
+    line-height: 1.6;
+    font-size: 0.95em;
+}
+
+/* Button styling */
+.stButton button {
+    width: 100%;
+    border-radius: 4px;
+    transition: all 0.3s ease;
+}
+
+.stButton button:hover {
+    transform: translateY(-1px);
+    box-shadow: 0 2px 5px rgba(0,0,0,0.1);
+}
+
+/* Pagination styling */
+.pagination {
+    display: flex;
+    justify-content: center;
+    align-items: center;
+    margin-top: 20px;
+}
+
+/* Custom scrollbar */
+::-webkit-scrollbar {
+    width: 8px;
+}
+
+::-webkit-scrollbar-track {
+    background: #f1f1f1;
+    border-radius: 4px;
+}
+
+::-webkit-scrollbar-thumb {
+    background: #888;
+    border-radius: 4px;
+}
+
+::-webkit-scrollbar-thumb:hover {
+    background: #555;
+}