spa-l2-cairo-shop-knn

Rerun

import geopandas as gpd

# Load the layers
gdf = gpd.read_file('/work/cairo_retail.gpkg', layer='shops')
anchors = gpd.read_file('/work/cairo_retail.gpkg', layer='anchors')

print("Shops columns:", gdf.columns.tolist())
print("Anchors columns:", anchors.columns.tolist())
print("Shops head:\n", gdf.head())
print("Anchors head:\n", anchors.head())
print("CRS Shops:", gdf.crs)
print("CRS Anchors:", anchors.crs)

import geopandas as gpd
import pandas as pd
import numpy as np
import json
from scipy.spatial import cKDTree

def normalize_name(name):
    if not isinstance(name, str):
        return ""
    # Basic normalization: uppercase, strip whitespace
    return name.strip().upper()

def main():
    # Load data
    gdf_shops = gpd.read_file('/work/cairo_retail.gpkg', layer='shops')
    gdf_anchors = gpd.read_file('/work/cairo_retail.gpkg', layer='anchors')

    # Normalize names
    gdf_shops['normalised_name'] = gdf_shops['raw_name'].apply(normalize_name)
    gdf_anchors['anchor_name_normalised'] = gdf_anchors['anchor_name'].apply(normalize_name)

    # Consistent naming requirement:
    # "the same shop_id always carries the same normalised_name, and all shops belonging to one chain share a single canonical spelling."
    # However, the input only has 'raw_name' and 'shop_id'. 
    # I'll interpret "all shops belonging to one chain" as: if two shops have "nearly" the same name (after basic normalization), they should share the same canonical name.
    # Looking at the prompt, it's a data cleaning task. Let's see if there are obvious duplicates.
    # In the absence of a "chain" column, I will group by the normalized name. 
    # But the prompt says "the same shop_id always carries the same normalised_name" which is trivial.
    # "all shops belonging to one chain share a single canonical spelling".
    # Since I don't have a 'chain' column, I'll assume for now that 'raw_name' is the key.
    # Actually, let's check if there are many variations of names.
    
    # For the purpose of this task, I will treat the normalized name (strip + upper) as the canonical name.
    # If the user wanted more complex fuzzy matching, they would usually provide it or it's a hint that I should do it.
    # Let's check for duplicates in normalized names.
    
    # Coordinate processing
    # CRS is EPSG:22992 (metres)
    shop_coords = np.array(list(zip(gdf_shops.geometry.x, gdf_shops.geometry.y)))
    anchor_coords = np.array(list(zip(gdf_anchors.geometry.x, gdf_anchors.geometry.y)))
    
    shop_tree = cKDTree(shop_coords)
    anchor_tree = cKDTree(anchor_coords)

    output = []

    for i, anchor in gdf_anchors.iterrows():
        a_id = anchor['anchor_id']
        a_name = anchor['anchor_name_normalised']
        a_pos = np.array([anchor.geometry.x, anchor.geometry.y])

        # 1. 5 nearest shops
        # k=5, but we must exclude the anchor if it were in the shops (not the case here)
        # distances: dists, indices: idxs
        dists_shops, idxs_shops = shop_tree.query(a_pos, k=5)
        
        # Handle cases where k < 5 (if there are fewer than 5 shops)
        if idxs_shops.ndim == 0: # k=1 case
             dists_shops = np.array([dists_shops])
             idxs_shops = np.array([idxs_shops])
        elif len(idxs_shops.shape) == 1:
             dists_shops = dists_shops.reshape(-1, 1)
             idxs_shops = idxs_shops.reshape(-1, 1)
        
        # Ensure we have exactly 5 (though usually there are more)
        # Actually cKDTree.query with k=5 returns (5,) if k=5.
        # If it's a single point, it returns a scalar.
        
        knn_list = []
        for d, idx in zip(dists_shops.flatten(), idxs_shops.flatten()):
            shop = gdf_shops.iloc[idx]
            knn_list.append({
                "shop_id": shop['shop_id'],
                "normalised_name": shop['normalised_name'],
                "distance_m": float(d),
                "within_1km": bool(d <= 1000.0)
            })
        
        # Sorting knn by ascending distance (already should be from cKDTree)
        knn_list.sort(key=lambda x: x['distance_m'])
        
        # 2. 5x3 distance matrix from these 5 shops to the anchor's 3 closest sibling anchors
        # "sibling anchors" = other anchors. 
        # We need the 3 closest anchors *excluding the current anchor itself*.
        # query k=4 to get the anchor itself and the 3 others.
        dists_anchors, idxs_anchors = anchor_tree.query(a_pos, k=4)
        
        # Filter out the current anchor
        sibling_indices = []
        for idx in idxs_anchors.flatten():
            if gdf_anchors.iloc[int(idx)]['anchor_id'] != a_id:
                sibling_indices.append(int(idx))
            if len(sibling_indices) == 3:
                break
        
        # If we didn't find 3 siblings (e.g. only 1 or 2 anchors total)
        # But the prompt implies we can find them.
        
        # Matrix: rows = knn shops, cols = sibling anchors
        # Columns correspond to sibling anchors in distance-ascending order.
        # We already have sibling_indices from anchor_tree.query which is distance-ascending.
        
        matrix = []
        for shop_entry in knn_list:
            row = []
            s_pos = np.array([gdf_shops.iloc[gdf_shops[gdf_shops['shop_id'] == shop_entry['shop_id']]['shop_id'].values[0]].geometry.x,
                              gdf_shops.iloc[gdf_shops[gdf_shops['shop_id'] == shop_entry['shop_id']]['shop_id'].values[0]].geometry.y])
            # Wait, the shop_id might not be unique if I'm not careful, but let's use the index from the knn search.
            # Better: use the index from the knn search.
            
        # Redoing the loop to be more efficient
        # The idxs_shops contains the indices of the shops in gdf_shops.
        
        # Correct way to build the matrix:
        # For each of the 5 shops in knn_list:
            # For each of the 3 sibling anchors:
                # dist = distance between shop and sibling anchor
        
        matrix = []
        for idx_s in [gdf_shops.index[gdf_shops['shop_id'] == item['shop_id']][0] for item in knn_list]: # This is slow but safe for small sets
            # Wait, I already have idxs_shops. Let's use that.
            pass
        
        # Let's rewrite the anchor loop correctly.
        
    # ... (see full implementation below)

if __name__ == "__main__":
    main()

import geopandas as gpd
import pandas as pd
import numpy as np
import json
from scipy.spatial import cKDTree

def normalize_name(name):
    if not isinstance(name, str):
        return ""
    # Basic normalization: uppercase, strip whitespace
    return name.strip().upper()

def main():
    # Load data
    gdf_shops = gpd.read_file('/work/cairo_retail.gpkg', layer='shops')
    gdf_anchors = gpd.read_file('/work/cairo_retail.gpkg', layer='anchors')

    # Normalize names
    gdf_shops['normalised_name'] = gdf_shops['raw_name'].apply(normalize_name)
    gdf_anchors['anchor_name_normalised'] = gdf_anchors['anchor_name'].apply(normalize_name)

    # Coordinate processing
    # CRS is EPSG:22992 (metres)
    shop_coords = np.array(list(zip(gdf_shops.geometry.x, gdf_shops.geometry.y)))
    anchor_coords = np.array(list(zip(gdf_anchors.geometry.x, gdf_anchors.geometry.y)))
    
    shop_tree = cKDTree(shop_coords)
    anchor_tree = cKDTree(anchor_coords)

    output = []

    for i, anchor in gdf_anchors.iterrows():
        a_id = anchor['anchor_id']
        a_name = anchor['anchor_name_normalised']
        a_pos = np.array([anchor.geometry.x, anchor.geometry.y])

        # 1. 5 nearest shops
        # k=5
        dists_shops, idxs_shops = shop_tree.query(a_pos, k=5)
        
        # In case k=1 or something else is returned (though k=5 is requested)
        if dists_shops.ndim == 0:
            dists_shops = np.array([dists_shops])
            idxs_shops = np.array([idxs_shops])
        if len(dists_shops.shape) == 1:
            dists_shops = dists_shops.reshape(-1, 1)
            idxs_shops = idxs_shops.reshape(-1, 1)

        knn_list = []
        # Note: idxs_shops contains indices into gdf_shops
        # Ensure we have exactly 5 (pad if necessary, but usually there are more)
        # The prompt says "exactly 5 entries". 
        # If there are fewer than 5 shops in the whole dataset, this will fail or need padding.
        # But we assume there are enough.
        
        for d, idx in zip(dists_shops.flatten(), idxs_shops.flatten()):
            shop = gdf_shops.iloc[idx]
            knn_list.append({
                "shop_id": str(shop['shop_id']),
                "normalised_name": str(shop['normalised_name']),
                "distance_m": float(d),
                "within_1km": bool(d <= 1000.0),
                "_internal_idx": int(idx) # for matrix calculation
            })
        
        # Sort knn by distance (already should be, but just in case)
        knn_list.sort(key=lambda x: x['distance_m'])
        
        # 2. 3 closest sibling anchors
        # k=4 to account for itself
        dists_anchors, idxs_anchors = anchor_tree.query(a_pos, k=4)
        
        if dists_anchors.ndim == 0:
            dists_anchors = np.array([dists_anchors])
            idxs_anchors = np.array([idxs_anchors])
        elif len(dists_anchors.shape) == 1:
            dists_anchors = dists_anchors.reshape(-1, 1)
            idxs_anchors = idxs_anchors.reshape(-1, 1)

        sibling_indices = []
        for idx in idxs_anchors.flatten():
            if gdf_anchors.iloc[int(idx)]['anchor_id'] != a_id:
                sibling_indices.append(int(idx))
            if len(sibling_indices) == 3:
                break
        
        # Build 5x3 matrix
        # Rows: knn shops (the 5 we found)
        # Columns: sibling anchors (the 3 we found)
        full_matrix = []
        for shop_entry in knn_list:
            row = []
            s_idx_in_gdf = shop_entry['_internal_idx']
            s_pos = shop_coords[s_idx_in_gdf]
            
            for sib_idx in sibling_indices:
                sib_pos = anchor_coords[sib_idx]
                # Calculate Euclidean distance (already in metres because CRS is metric)
                dist_m = np.sqrt(np.sum((s_pos - sib_pos)**2))
                row.append(float(dist_m))
            full_matrix.append(row)
            
        # Prepare final record
        # Remove the internal index from knn
        for entry in knn_list:
            del entry['_internal_idx']

        output.append({
            "anchor_id": str(a_id),
            "anchor_name_normalised": str(a_name),
            "knn": knn_list,
            "full_distance_matrix_m": full_matrix
        })

    # Write to JSON
    with open('/work/market_neighbourhoods.json', 'w') as f:
        json.dump(output, f, indent=2)

if __name__ == "__main__":
    main()

import geopandas as gpd
import pandas as pd
import numpy as np
import json

def normalize_name(name):
    if not isinstance(name, str):
        return ""
    return name.strip().upper()

def main():
    # Load data
    gdf_shops = gpd.read_file('/work/cairo_retail.gpkg', layer='shops')
    gdf_anchors = gpd.read_file('/work/cairo_retail.gpkg', layer='anchors')

    # Normalize names and handle the "consistent spelling" requirement
    # The prompt says: "the same shop_id always carries the same normalised_name, 
    # and all shops belonging to one chain share a single canonical spelling."
    # We will create a mapping of raw names to a canonical name.
    # A common approach is to group by a normalized version and take the most frequent or first.
    
    gdf_shops['temp_norm'] = gdf_shops['raw_name'].apply(normalize_name)
    
    # To handle "all shops belonging to one chain share a single canonical spelling"
    # we'll use the most common normalized name for each group of similar names.
    # Since we don't have a chain column, let's assume names that are very similar 
    # (after basic normalization) are the same chain.
    # For this exercise, we'll treat the most frequent 'temp_norm' as the canonical name for each group.
    # But since we don't have groups, we'll just use the normalized name.
    # If there were different spellings for the same name, we'd need more logic.
    # Let's check if there are any obvious duplicates after temp_norm.
    
    gdf_shops['normalised_name'] = gdf_shops['temp_norm']
    gdf_anchors['anchor_name_normalised'] = gdf_anchors['anchor_name'].apply(normalize_name)

    # Coordinates
    shop_coords = np.array(list(zip(gdf_shops.geometry.x, gdf_shops.geometry.y)))
    anchor_coords = np.array(list(zip(gdf_anchors.geometry.x, gdf_anchors.geometry.y)))
    
    output = []

    for i, anchor in gdf_anchors.iterrows():
        a_id = anchor['anchor_id']
        a_name = anchor['anchor_name_normalised']
        a_pos = np.array([anchor.geometry.x, anchor.geometry.y])

        # 1. 5 nearest shops
        # Using pure numpy/geopandas approach to avoid scipy dependency if it fails,
        # but scipy worked. Let's stick to it.
        from scipy.spatial import cKDTree
        shop_tree = cKDTree(shop_coords)
        anchor_tree = cKDTree(anchor_coords)
        
        dists_shops, idxs_shops = shop_tree.query(a_pos, k=5)
        
        # Handle cases where k < 5
        if len(dists_shops) < 5:
            # This shouldn't happen if there are >= 5 shops
            pass

        knn_list = []
        for d, idx in zip(dists_shops, idxs_shops):
            shop = gdf_shops.iloc[int(idx)]
            knn_list.append({
                "shop_id": str(shop['shop_id']),
                "normalised_name": str(shop['normalised_name']),
                "distance_m": float(d),
                "within_1km": bool(d <= 1000.0),
                "_idx": int(idx)
            })
        
        # Sort knn by distance (already sorted, but for safety)
        knn_list.sort(key=lambda x: x['distance_m'])
        
        # 2. 3 closest sibling anchors
        dists_anchors, idxs_anchors = anchor_tree.query(a_pos, k=4)
        
        sibling_indices = []
        for idx in idxs_anchors:
            if gdf_anchors.iloc[int(idx)]['anchor_id'] != a_id:
                sibling_indices.append(int(idx))
            if len(sibling_indices) == 3:
                break
        
        # Build 5x3 matrix
        full_matrix = []
        for shop_entry in knn_list:
            row = []
            s_pos = shop_coords[shop_entry['_idx']]
            for sib_idx in sibling_indices:
                sib_pos = anchor_coords[sib_idx]
                dist_m = np.sqrt(np.sum((s_pos - sib_pos)**2))
                row.append(float(dist_m))
            full_matrix.append(row)
            
        # Cleanup
        for entry in knn_list:
            del entry['_idx']

        output.append({
            "anchor_id": str(a_id),
            "anchor_name_normalised": str(a_name),
            "knn": knn_list,
            "full_distance_matrix_m": full_matrix
        })

    with open('/work/market_neighbourhoods.json', 'w') as f:
        json.dump(output, f, indent=2)

if __name__ == "__main__":
    main()

import geopandas as gpd
import pandas as pd
import numpy as np
import json
from scipy.spatial import cKDTree
from collections import Counter

def normalize_name(name):
    if not isinstance(name, str):
        return ""
    return name.strip().upper()

def main():
    # Load data
    gdf_shops = gpd.read_file('/work/cairo_retail.gpkg', layer='shops')
    gdf_anchors = gpd.read_file('/work/cairo_retail.gpkg', layer='anchors')

    # 1. Handle Name Normalization & Consistent Spelling
    # "the same shop_id always carries the same normalised_name, and all shops belonging to one chain share a single canonical spelling."
    # We'll use a simplified heuristic: group by the basic normalized name 
    # and pick the most common variant if there were any, but since we only have one 'raw_name' per shop_id, 
    # we just need to ensure that if two shops have the same 'raw_name' (after basic cleaning), 
    # they have the same canonical name.
    
    # Let's compute a canonical name for each unique "raw_name" group.
    # To handle potential fuzzy matches, we'd need more complexity, but let's start with 
    # basic normalization and see if we can find groups.
    
    gdf_shops['norm_raw'] = gdf_shops['raw_name'].apply(normalize_name)
    
    # To solve "all shops belonging to one chain share a single canonical spelling":
    # We will group by 'norm_raw'. If multiple 'norm_raw' values are very close, we could merge.
    # However, without a explicit chain column or fuzzy logic requirement, 
    # I will group by 'norm_raw' and use that as the canonical name.
    # To be safe about "consistent spelling", I'll ensure we use the same name for everything 
    # that maps to the same normalized string.
    
    gdf_shops['normalised_name'] = gdf_shops['norm_raw']
    gdf_anchors['anchor_name_normalised'] = gdf_anchors['anchor_name'].apply(normalize_name)

    # Coordinates
    shop_coords = np.array(list(zip(gdf_shops.geometry.x, gdf_shops.geometry.y)))
    anchor_coords = np.array(list(zip(gdf_anchors.geometry.x, gdf_anchors.geometry.y)))
    
    shop_tree = cKDTree(shop_coords)
    anchor_tree = cKDTree(anchor_coords)
    
    output = []

    for i, anchor in gdf_anchors.iterrows():
        a_id = anchor['anchor_id']
        a_name = anchor['anchor_name_normalised']
        if not a_name: # "anchor_name_normalised (non-empty string)"
             a_name = "UNKNOWN"
        a_pos = np.array([anchor.geometry.x, anchor.geometry.y])

        # 1. 5 nearest shops
        dists_shops, idxs_shops = shop_tree.query(a_pos, k=5)
        
        # If k < 5, we need to handle it, but let's assume k=5 is valid.
        if dists_shops.ndim == 0:
            dists_shops = np.array([dists_shops])
            idxs_shops = np.array([idxs_shops])
        elif len(dists_shops.shape) == 1:
            dists_shops = dists_shops.reshape(-1, 1)
            idxs_shops = idxs_shops.reshape(-1, 1)

        knn_list = []
        for d, idx in zip(dists_shops.flatten(), idxs_shops.flatten()):
            shop = gdf_shops.iloc[int(idx)]
            knn_list.append({
                "shop_id": str(shop['shop_id']),
                "normalised_name": str(shop['normalised_name']),
                "distance_m": float(d),
                "within_1km": bool(d <= 1000.0),
                "_idx": int(idx)
            })
        
        # Sort knn by distance
        knn_list.sort(key=lambda x: x['distance_m'])
        
        # 2. 3 closest sibling anchors
        # k=4 to get the anchor itself and 3 others
        dists_anchors, idxs_anchors = anchor_tree.query(a_pos, k=4)
        
        if dists_anchors.ndim == 0:
            dists_anchors = np.array([dists_anchors])
            idxs_anchors = np.array([idxs_anchors])
        elif len(dists_anchors.shape) == 1:
            dists_anchors = dists_anchors.reshape(-1, 1)
            idxs_anchors = idxs_anchors.reshape(-1, 1)

        sibling_indices = []
        for idx in idxs_anchors.flatten():
            if gdf_anchors.iloc[int(idx)]['anchor_id'] != a_id:
                sibling_indices.append(int(idx))
            if len(sibling_indices) == 3:
                break
        
        # Build 5x3 matrix
        # Rows: knn shops, Columns: sibling anchors (distance-ascending)
        full_matrix = []
        for shop_entry in knn_list:
            row = []
            s_pos = shop_coords[shop_entry['_idx']]
            for sib_idx in sibling_indices:
                sib_pos = anchor_coords[sib_idx]
                dist_m = np.linalg.norm(s_pos - sib_pos)
                row.append(float(dist_m))
            full_matrix.append(row)
            
        # Cleanup internal index
        for entry in knn_list:
            del entry['_idx']

        output.append({
            "anchor_id": str(a_id),
            "anchor_name_normalised": str(a_name),
            "knn": knn_list,
            "full_distance_matrix_m": full_matrix
        })

    with open('/work/market_neighbourhoods.json', 'w') as f:
        json.dump(output, f, indent=2)

if __name__ == "__main__":
    main()

import geopandas as gpd
import pandas as pd
import numpy as np
import json
from scipy.spatial import cKDTree
import re

def clean_text(text):
    if not isinstance(text, str):
        return ""
    # Remove extra whitespace and special characters but keep Arabic
    text = re.sub(r'\s+', ' ', text).strip()
    return text

def get_canonical_name(name):
    # To group "Seoudi Market", "Seoudi", "SEOUDI MARKET" etc.
    # We'll normalize: lowercase, strip, and maybe take the most frequent form of the "prefix"
    # But a better way for this specific dataset is:
    # 1. Clean (lowercase, strip)
    # 2. Find the longest common prefix or just use the first word?
    # Actually, looking at the data, "Seoudi Market" and "Seoudi" are likely the same.
    # "Khair Zaman", "kheir zaman", "kheir zaman" are the same.
    # "Metro", "Metro Markets", "Metro Market" are the same.
    # "Hyper One", "hyperone" are the same.
    
    # Let's use a more robust approach:
    # Canonicalize by:
    # a) stripping whitespace
    # b) lowercasing
    # c) removing common suffixes like "MARKET", "STORES", "SUPERMARKET"
    # d) grouping by the remaining core
    pass

def main():
    # Load data
    gdf_shops = gpd.read_file('/work/cairo_retail.gpkg', layer='shops')
    gdf_anchors = gpd.read_file('/work/cairo_retail.gpkg', layer='anchors')

    # Robust Canonicalization Logic
    def get_core(name):
        if not isinstance(name, str): return ""
        n = name.lower().strip()
        # Remove common suffixes to find the "chain"
        for suffix in [' market', ' stores', ' supermarket', ' cairo', ' egypt', ' market ', ' stores ']:
            if n.endswith(suffix):
                n = n[: -len(suffix)]
        # Remove spaces for comparison (e.g., hyperone vs hyper one)
        return re.sub(r'\s+', '', n)

    # Pre-calculate canonical mapping
    gdf_shops['core'] = gdf_shops['raw_name'].apply(get_core)
    
    # For each core, find the most frequent 'raw_name' (to use as canonical spelling)
    # Or even better, just the most frequent 'normalized_name'
    # First, let's define a normalized name that is just cleaned text
    gdf_shops['cleaned_name'] = gdf_shops['raw_name'].apply(clean_text)
    
    # Group by core and pick the most frequent cleaned_name
    canonical_map = {}
    for core, group in gdf_shops.groupby('core'):
        # Count frequencies of cleaned names in this core group
        counts = group['cleaned_name'].value_counts()
        most_frequent_name = counts.index[0]
        # The prompt says "all shops belonging to one chain share a single canonical spelling"
        # and "the same shop_id always carries the same normalised_name".
        # We will use this most frequent name as the canonical 'normalised_name'
        canonical_map[core] = most_frequent_name.upper()

    gdf_shops['normalised_name'] = gdf_shops['core'].map(canonical_map)
    
    # Tidy anchor names too (non-empty string)
    gdf_anchors['anchor_name_normalised'] = gdf_anchors['anchor_name'].apply(lambda x: clean_text(x).upper())
    # Ensure non-empty
    gdf_anchors.loc[gdf_anchors['anchor_name_normalised'] == "", 'anchor_name_normalised'] = "UNKNOWN"

    # Coordinates
    shop_coords = np.array(list(zip(gdf_shops.geometry.x, gdf_shops.geometry.y)))
    anchor_coords = np.array(list(zip(gdf_anchors.geometry.x, gdf_anchors.geometry.y)))
    
    shop_tree = cKDTree(shop_coords)
    anchor_tree = cKDTree(anchor_coords)
    
    output = []

    for i, anchor in gdf_anchors.iterrows():
        a_id = anchor['anchor_id']
        a_name = anchor['anchor_name_normalised']
        a_pos = np.array([anchor.geometry.x, anchor.geometry.y])

        # 1. 5 nearest shops
        dists_shops, idxs_shops = shop_tree.query(a_pos, k=5)
        
        # Reshape if necessary
        if dists_shops.ndim == 0:
            dists_shops = np.array([dists_shops])
            idxs_shops = np.array([idxs_shops])
        elif len(dists_shops.shape) == 1:
            dists_shops = dists_shops.reshape(-1, 1)
            idxs_shops = idxs_shops.reshape(-1, 1)

        knn_list = []
        for d, idx in zip(dists_shops.flatten(), idxs_shops.flatten()):
            shop = gdf_shops.iloc[int(idx)]
            knn_list.append({
                "shop_id": str(shop['shop_id']),
                "normalised_name": str(shop['normalised_name']),
                "distance_m": float(d),
                "within_1km": bool(d <= 1000.0),
                "_idx": int(idx)
            })
        
        knn_list.sort(key=lambda x: x['distance_m'])
        
        # 2. 3 closest sibling anchors
        dists_anchors, idxs_anchors = anchor_tree.query(a_pos, k=4)
        
        if dists_anchors.ndim == 0:
            dists_anchors = np.array([dists_anchors])
            idxs_anchors = np.array([idxs_anchors])
        elif len(dists_anchors.shape) == 1:
            dists_anchors = dists_anchors.reshape(-1, 1)
            idxs_anchors = idxs_anchors.reshape(-1, 1)

        sibling_indices = []
        for idx in idxs_anchors.flatten():
            if gdf_anchors.iloc[int(idx)]['anchor_id'] != a_id:
                sibling_indices.append(int(idx))
            if len(sibling_indices) == 3:
                break
        
        # Build 5x3 matrix
        full_matrix = []
        for shop_entry in knn_list:
            row = []
            s_pos = shop_coords[shop_entry['_idx']]
            for sib_idx in sibling_indices:
                sib_pos = anchor_coords[sib_idx]
                dist_m = np.linalg.norm(s_pos - sib_pos)
                row.append(float(dist_m))
            full_matrix.append(row)
            
        for entry in knn_list:
            del entry['_idx']

        output.append({
            "anchor_id": str(a_id),
            "anchor_name_normalised": str(a_name),
            "knn": knn_list,
            "full_distance_matrix_m": full_matrix
        })

    with open('/work/market_neighbourhoods.json', 'w') as f:
        json.dump(output, f, indent=2)

if __name__ == "__main__":
    main()