Skip to content
The Chat Archive
gemini-2.5-flash· Google LMArena Human Preference 140K

jak z tej strony https://wiki.openstreetmap.org/wiki/Map_features zescrapowac wszytskie…

  1. User

    jak z tej strony https://wiki.openstreetmap.org/wiki/Map_features zescrapowac wszytskie tagi do jakiegos uzytecznego formatu

  2. Assistant

    Zeskrapowanie wszystkich tagów z tej strony Wiki OpenStreetMap jest trochę bardziej skomplikowane niż mogłoby się wydawać na pierwszy rzut oka, ze względu na różnorodną strukturę HTML, w jakiej tagi są prezentowane (tabele, listy, nagłówki, zagnieżdżone elementy).

    Będziemy potrzebować bibliotek requests do pobierania strony i BeautifulSoup do parsowania HTML.

    Podejście do parsowania:

    1. Pobranie strony: Pobieramy zawartość strony HTML.
    2. Znalezienie głównej sekcji treści: Tagi znajdują się w głównej sekcji treści, zazwyczaj w div z ID mw-content-text.
    3. Iteracja przez kategorie i nagłówki: Strona jest podzielona na sekcje (np. "Highways", "Amenities") za pomocą nagłówków <h2>. Wewnątrz tych sekcji są nagłówki <h3> i <h4>, które często reprezentują konkretne klucze (np. amenity) lub pełne tagi (amenity=restaurant).
    4. Ekstrakcja danych:
      • Tabele: Najczęściej tagi są prezentowane w tabelach (<table>), gdzie jedna kolumna to wartość (lub cały tag key=value), a druga to opis. Musimy zidentyfikować te tabele i wyodrębnić wiersze.
      • Paragrafy i listy: Czasami tagi (szczególnie złożone lub relacje) są opisane bezpośrednio w paragrafach (<p>) lub listach (<ul>), często z użyciem tagu <code> do wyróżnienia samego taga.
    5. Normalizacja danych: Ujednolicimy format do słownika z kluczami takimi jak category, key, value, tag (czyli key=value) i description.
    6. Czyszczenie tekstu: Usuniemy zbędne elementy, takie jak [edit], odnośniki do szablonów wiki (np. {{tag|...}}) czy nadmiarowe spacje.

    Poniżej przedstawiam kod Pythona, który próbuje sprostać tym wyzwaniom. Należy pamiętać, że strony Wiki są dynamiczne i ich struktura może się zmieniać, co może wymagać aktualizacji skryptu.

    import requests
    from bs4 import BeautifulSoup
    import json
    import re
    
    def clean_wiki_text(text):
        """
        Czyści tekst z typowych elementów wiki, takich jak [edit] i szablony {{...}}.
        """
        if text is None:
            return ""
        text = text.replace('[edit]', '').strip()
        # Usuwanie szablonów wiki {{...}}
        text = re.sub(r'\{\{[^}]+\}\}', '', text)
        # Usuwanie linków wiki [[...]]
        text = re.sub(r'\[\[[^\]]+\|([^\]]+)\]\]', r'\1', text) # Keep text, remove link
        text = re.sub(r'\[\[([^\]]+)\]\]', r'\1', text) # For links without custom text
        # Usuwanie odnośników do przypisów [1], [2] itp.
        text = re.sub(r'\[\d+\]', '', text)
        text = text.strip()
        return text
    
    def scrape_osm_map_features(url="https://wiki.openstreetmap.org/wiki/Map_features"):
        """
        Skrapuje tagi ze strony OpenStreetMap Map Features.
        """
        response = requests.get(url)
        soup = BeautifulSoup(response.content, 'html.parser')
    
        all_tags_data = []
    
        # Znajdujemy główny kontener treści, gdzie znajdują się wszystkie tagi
        content_div = soup.find('div', id='mw-content-text')
        if not content_div:
            print("Nie znaleziono głównego kontenera treści. Sprawdź strukturę strony.")
            return []
    
        # Iterujemy przez nagłówki h2 (główne kategorie, np. "Highways", "Amenities")
        current_category = "General" # Domyślna kategoria
    
        # Zbierz wszystkie elementy, które mogą być nagłówkami kategorii lub kluczy,
        # tabelami lub paragrafami/listami zawierającymi opisy
        elements = content_div.find_all(['h2', 'h3', 'h4', 'table', 'p', 'ul'])
    
        current_key_context = None # Np. 'amenity'
        current_full_tag_heading = None # Np. 'amenity=restaurant' jeśli nagłówek był konkretnym tagiem
    
        for element in elements:
            # Obsługa nagłówków kategorii (h2)
            if element.name == 'h2':
                current_category = clean_wiki_text(element.get_text())
                current_key_context = None # Reset kontekstu klucza
                current_full_tag_heading = None # Reset kontekstu pełnego taga
                # print(f"\n--- Kategoria: {current_category} ---")
            
            # Obsługa nagłówków kluczy (h3, h4)
            elif element.name in ['h3', 'h4']:
                code_tag = element.find('code')
                if code_tag:
                    potential_tag_text = clean_wiki_text(code_tag.get_text())
                    if '=' in potential_tag_text:
                        # To jest nagłówek dla konkretnego tagu (np. "amenity=restaurant")
                        current_full_tag_heading = potential_tag_text
                        current_key_context = potential_tag_text.split('=', 1)[0]
                        
                        # Dodaj ten konkretny tag jako wpis, jeśli nie jest już w tabeli
                        # (często jest powtórzony w tabeli poniżej jako jeden z wartości)
                        description_for_heading = ""
                        next_sibling = element.find_next_sibling()
                        if next_sibling and (next_sibling.name == 'p' or next_sibling.name == 'ul'):
                            # Próbuj wyciągnąć opis bezpośrednio po nagłówku
                            desc_text = clean_wiki_text(next_sibling.get_text())
                            if desc_text and not next_sibling.find('table'): # Upewnij się, że to nie jest wstęp do tabeli
                                description_for_heading = desc_text
    
                        all_tags_data.append({
                            'category': current_category,
                            'key': current_key_context,
                            'value': potential_tag_text.split('=', 1)[1],
                            'tag': potential_tag_text,
                            'description': description_for_heading
                        })
    
                    else:
                        # To jest nagłówek dla klucza (np. "amenity")
                        current_key_context = potential_tag_text
                        current_full_tag_heading = None # Reset
    
                else:
                    # Nagłówki bez tagu `<code>` (np. "Relations")
                    current_key_context = clean_wiki_text(element.get_text())
                    current_full_tag_heading = None # Reset
    
            # Obsługa tabel
            elif element.name == 'table' and current_key_context:
                # Zakładamy, że pierwsza kolumna zawiera wartość/tag, a druga opis
                # Próbujemy znaleźć nagłówki kolumn, aby zidentyfikować, czy to tabela klucz=wartość
                headers = [clean_wiki_text(th.get_text()).lower() for th in element.find_all('th')]
                is_main_tag_table = 'value' in headers and 'description' in headers # Typowa tabela z value/description
                
                for row in element.find_all('tr'):
                    cols = row.find_all(['td', 'th'])
                    if not cols: # Pusta linia
                        continue
                    
                    # Próba identyfikacji, czy to wiersz nagłówkowy
                    if row.find('th') and not any(tag['tag'] == current_key_context for tag in all_tags_data): # Jeśli ma th i to pierwszy wiersz, prawdopodobnie nagłówek
                        continue # Pomijamy nagłówek tabeli
    
                    if len(cols) >= 2:
                        raw_val_or_tag_col = clean_wiki_text(cols[0].get_text())
                        raw_desc_col = clean_wiki_text(cols[1].get_text())
    
                        parsed_key = current_key_context
                        parsed_value = None
                        parsed_tag = None
    
                        # Jeśli pierwsza kolumna zawiera 'key=value'
                        if '=' in raw_val_or_tag_col:
                            temp_parts = raw_val_or_tag_col.split('=', 1)
                            if len(temp_parts) == 2:
                                parsed_key = temp_parts[0]
                                parsed_value = temp_parts[1]
                                parsed_tag = raw_val_or_tag_col
                        elif current_key_context:
                            # Jeśli nagłówek h3/h4 to tylko klucz (np. "amenity"),
                            # to pierwsza kolumna w tabeli jest wartością.
                            parsed_value = raw_val_or_tag_col
                            parsed_tag = f"{current_key_context}={parsed_value}"
                        
                        # Jeśli ten tag jest już w danych (np. dodany z nagłówka), zaktualizuj opis
                        # lub dodaj, jeśli to nowy tag.
                        found = False
                        if parsed_tag:
                            for item in all_tags_data:
                                if item['tag'] == parsed_tag:
                                    if not item['description']: # Jeśli opis był pusty, uzupełnij
                                        item['description'] = raw_desc_col
                                    found = True
                                    break
                            if not found:
                                all_tags_data.append({
                                    'category': current_category,
                                    'key': parsed_key,
                                    'value': parsed_value,
                                    'tag': parsed_tag,
                                    'description': raw_desc_col
                                })
    
            # Obsługa paragrafów i list (szukamy tagów w <code>)
            elif element.name in ['p', 'ul']:
                # Sprawdzamy, czy w danym paragrafie/liście są tagi w <code>
                for code_tag_in_text in element.find_all('code'):
                    potential_tag = clean_wiki_text(code_tag_in_text.get_text())
                    if '=' in potential_tag:
                        key_part = potential_tag.split('=', 1)[0]
                        value_part = potential_tag.split('=', 1)[1]
                        
                        # Spróbuj wyciągnąć opis z otaczającego tekstu, usuwając sam tag
                        description_from_text = clean_wiki_text(element.get_text().replace(potential_tag, ''))
                        
                        # Dodaj tylko jeśli nie ma duplikatu
                        existing_tags = {item['tag'] for item in all_tags_data}
                        if potential_tag not in existing_tags:
                            all_tags_data.append({
                                'category': current_category,
                                'key': key_part,
                                'value': value_part,
                                'tag': potential_tag,
                                'description': description_from_text
                            })
        
        # Usuń potencjalne duplikaty na podstawie 'tag'
        unique_tags = {}
        for item in all_tags_data:
            if item['tag'] not in unique_tags:
                unique_tags[item['tag']] = item
            else:
                # Jeśli już istnieje, a nowy opis jest dłuższy/lepszy, zaktualizuj
                if len(item['description']) > len(unique_tags[item['tag']]['description']):
                    unique_tags[item['tag']]['description'] = item['description']
                # Jeśli brakuje klucza/wartości, a nowy element ma, uzupełnij
                if not unique_tags[item['tag']]['key'] and item['key']:
                    unique_tags[item['tag']]['key'] = item['key']
                if not unique_tags[item['tag']]['value'] and item['value']:
                    unique_tags[item['tag']]['value'] = item['value']
    
    
        return list(unique_tags.values())
    
    if __name__ == "__main__":
        tags = scrape_osm_map_features()
        
        if tags:
            # Zapisz do pliku JSON
            with open('osm_map_features.json', 'w', encoding='utf-8') as f:
                json.dump(tags, f, indent=4, ensure_ascii=False)
            print(f"Pomyślnie zebrano {len(tags)} unikalnych tagów i zapisano do osm_map_features.json")
    
            # Opcjonalnie: Zapisz do CSV
            import csv
            with open('osm_map_features.csv', 'w', encoding='utf-8', newline='') as f:
                fieldnames = ['category', 'key', 'value', 'tag', 'description']
                writer = csv.DictWriter(f, fieldnames=fieldnames)
                writer.writeheader()
                for tag in tags:
                    writer.writerow(tag)
            print(f"Zapisano również do osm_map_features.csv")
        else:
            print("Nie udało się zebrać żadnych tagów.")
    
    

    Jak to działa i na co zwrócić uwagę:

    1. clean_wiki_text(text): Ta funkcja jest kluczowa do usunięcia "brudów" z tekstu pobranego ze strony Wiki, takich jak linki [[...]], szablony {{...}} czy [edit] pojawiające się przy nagłówkach.
    2. Struktura iteracji: Skrypt iteruje przez wszystkie elementy HTML, które mogą być nagłówkami (h2, h3, h4), tabelami (table), paragrafami (p) lub listami (ul). Dzieje się tak, ponieważ kontekst (np. aktualny klucz tagu) zależy od poprzedzających nagłówków.
    3. Kontekst current_key_context i current_full_tag_heading:
      • current_key_context przechowuje aktualnie przetwarzany klucz taga (np. amenity), który pochodzi z nagłówka <h3> lub <h4>.
      • current_full_tag_heading jest ustawiany, jeśli nagłówek <h3> lub <h4> sam w sobie jest już pełnym tagiem (key=value, np. amenity=restaurant).
    4. Parsowanie tabel: To najczęstsze źródło tagów. Skrypt próbuje odróżnić wiersze nagłówkowe od wierszy danych i zakłada, że pierwsze dwie kolumny zawierają interesujące nas informacje.
      • Jeśli kolumna zawiera już key=value, to jest używana jako kompletny tag.
      • Jeśli kolumna zawiera tylko value, to current_key_context jest dołączany, tworząc key=value.
    5. Parsowanie paragrafów i list: Szukamy w nich tagów osadzonych w tagach <code>. Jest to przydatne dla tagów opisywanych bezpośrednio w tekście, a nie w tabelach.
    6. Unikalność i aktualizacja: Na końcu, skrypt przechodzi przez wszystkie zebrane tagi i deduplikuje je na podstawie pełnego taga (key=value), jednocześnie starając się zachować najdłuższy/najbardziej kompletny opis.

    Użycie:

    1. Zapisz kod jako plik .py (np. scrape_osm.py).
    2. Uruchom go z terminala: python scrape_osm.py.
    3. Po zakończeniu, w tym samym katalogu znajdziesz pliki osm_map_features.json i osm_map_features.csv z zebranymi danymi.

    Potencjalne ulepszenia i uwagi:

    • Złożoność relacji: Strona Wiki OSM zawiera również opisy relacji (np. Relation:multipolygon). Ten skrypt skupia się głównie na pojedynczych tagach key=value. Aby poprawnie przetwarzać relacje, trzeba by dodać bardziej zaawansowaną logikę do analizy ich struktury.
    • Warianty opisów: Niektóre opisy na stronie Wiki są bardzo szczegółowe, inne bardzo krótkie. Skrypt próbuje wybrać najlepszy opis w przypadku duplikatów, ale zawsze może być miejsce na poprawę.
    • Struktura tagów zagnieżdżonych: Niektóre tagi są podtagami dla innych (np. lit dla highway=residential). Skrypt w obecnej formie traktuje lit=yes jako oddzielny tag, co jest poprawne dla większości zastosowań, ale nie oddaje hierarchii.
    • Odporność na zmiany strony: Jeśli struktura HTML strony Wiki znacząco się zmieni, skrypt będzie wymagał aktualizacji.

    Ten skrypt powinien dać Ci solidną bazę danych tagów z opisami, którą możesz wykorzystać w swoim modelu oceny lokalizacji.

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.