```python import re def parse_mall_location(address): level = None unit = None tower = None # Convert to lowercase for case-insensitive matching address_lower = address.lower() # 1. Extract Tower information # Pattern: "Tower 3", "Tower A" tower_match = re.search(r'(tower\s+\d+|tower\s+[a-z])', address_lower) if tower_match: tower = tower_match.group(1).title() # Capitalize "Tower" and the number/letter (e.g., "Tower 3", "Tower A") # 2. Extract Level number (explicit "Level X" pattern) # Pattern: "Level 2", "Level B1", "Level G" # Level indicators: B (Basement), L (Level), G (Ground), UG (Upper Ground), LG (Lower Ground), M (Mezzanine), P (Parking) level_explicit_match = re.search(r'level\s+([blgum]\d*|\d+)', address_lower) if level_explicit_match: extracted_level = level_explicit_match.group(1) if extracted_level.isdigit(): level = str(int(extracted_level)) # Normalize "02" to "2" else: level = extracted_level.upper() # Normalize "b1" to "B1", "g" to "G" # 3. Extract Unit number (complex format like #B1-16/16A or #02-42) # This pattern also implies a level, so we can derive it if not already found. # Pattern: #B1-16/16A, B1-16/16A, #02-42, 02-42, Unit #02-42 # The first group captures the full unit string (e.g., "B1-16/16A") unit_complex_match = re.search(r'(?:#|\bunit\s+#?)?(([blgum]\d*|\d+)-\d+[a-z]?(?:/\d+[a-z]?)?)', address_lower) if unit_complex_match: unit_str = unit_complex_match.group(1) # e.g., "b1-16/16a" unit = "#" + unit_str.upper() # Ensure B1, A, etc. are capitalized in unit string (e.g., #B1-16/16A) # Derive level from unit string if not already explicitly found if level is None: derived_level = unit_str.split('-')[0] if derived_level.isdigit(): level = str(int(derived_level)) else: level = derived_level.upper() # 4. Extract Unit number (simple format like #42) # Only if unit hasn't been found by the complex pattern if unit is None: # Pattern: #42, Unit #42, #123A unit_simple_match = re.search(r'(?:#|\bunit\s+#?)(\d+[a-z]?(?:/\d+[a-z]?)?)', address_lower) if unit_simple_match: unit = "#" + unit_simple_match.group(1).upper() # Capitalize any letters in unit (e.g., #123A) # Construct the output string based on available information parts = [] if level: parts.append(f"Level {level}") if unit: parts.append(f"Unit Number {unit}") result = "" if parts: result = ", ".join(parts) if tower: if result: result += f", {tower}" else: result = tower # If only tower is found if not result: return "Location Unknown" else: return result # Example usage with the provided address: address = "2 Orchard Turn, B1-16/16A, Singapore 238801" parsed_location = parse_mall_location(address) print(parsed_location) ``` View