Skip to content
The Chat Archive
Geminigemini-2.5-flash-preview-04-17· GoogleHugging Face LMArena Human Preference 140K

czy możesz napisać kod do pobierania plików z strony bunkr.si

From a Chatbot Arena battleThe same person sent this prompt to two anonymous models at once. Compare it with MiniMaxminimax-m1’s answer.
  1. User

    czy możesz napisać kod do pobierania plików z strony bunkr.si

  2. Gemini Assistant

    Jasne, mogę napisać przykładowy kod w Pythonie, który może pomóc w pobieraniu plików ze strony bunkr.si.

    Ważne uwagi przed użyciem:

    1. Struktura strony: Strony internetowe, zwłaszcza takie jak bunkr.si, mogą zmieniać swoją strukturę HTML. Kod opiera się na znalezieniu konkretnych elementów (np. linków do plików) w kodzie strony. Jeśli strona bunkr.si zmieni sposób wyświetlania plików, ten kod może przestać działać.
    2. Warunki korzystania: Upewnij się, że Twoje działania są zgodne z warunkami korzystania ze strony bunkr.si. Automatyczne pobieranie plików może być zabronione.
    3. Prywatność i legalność: Używaj tego skryptu wyłącznie do pobierania treści, do których masz prawo dostępu i pobierania. Nie używaj go do nielegalnego lub nieuprawnionego pobierania materiałów chronionych prawem autorskim.
    4. Złożoność: Bunkr.si używa albumów (/a/albumID) i stron widoków pojedynczych plików (/v/fileID). Skrypt musi najpierw znaleźć linki do pojedynczych plików na stronie albumu, a następnie odwiedzić każdą ze stron pojedynczych plików, aby znaleźć bezpośredni link do pobrania.
    5. JavaScript: Jeśli strona bunkr.si intensywnie wykorzystuje JavaScript do ładowania treści lub generowania linków, proste pobranie kodu HTML (jak robi ten skrypt) może być niewystarczające. W takim przypadku potrzebne byłyby bardziej zaawansowane narzędzia, takie jak Selenium lub Playwright, co znacznie zwiększyłoby złożoność. Ten skrypt zakłada, że kluczowe linki są dostępne w początkowym kodzie HTML.

    Wymagane biblioteki:

    • requests: Do wysyłania żądań HTTP.
    • beautifulsoup4: Do parsowania HTML.
    • os: Do pracy z systemem plików (tworzenie katalogów, ścieżki).
    • argparse: Do obsługi argumentów wiersza poleceń (ułatwia użycie skryptu).
    • urllib.parse: Do łączenia adresów URL i parsowania ścieżek.
    • re: Do wyrażeń regularnych (np. do wyodrębniania nazwy pliku).

    Instalacja bibliotek:

    pip install requests beautifulsoup4
    

    Kod (Python):

    import requests
    from bs4 import BeautifulSoup
    import os
    import argparse
    from urllib.parse import urljoin, unquote, urlparse
    import re
    import time
    
    def get_filename_from_cd(cd):
        """Wyodrębnia nazwę pliku z nagłówka Content-Disposition."""
        if not cd:
            return None
        # Szukaj filename lub filename* (obsługuje kodowanie UTF-8)
        fname_match = re.findall('filename\*?=(?:utf-8\'\')?"?([^"]+)"?', cd, flags=re.IGNORECASE)
        if fname_match:
            try:
                # Próba dekodowania URL (np. %20 na spację)
                return unquote(fname_match[-1]) # Weź ostatnie dopasowanie (często to filename*)
            except Exception:
                 return fname_match[-1] # W przypadku błędu dekodowania użyj surowej nazwy
        return None
    
    def sanitize_filename(filename):
        """Usuwa znaki niedozwolone w nazwach plików."""
        if not filename:
            return "downloaded_file"
        # Zamień niedozwolone znaki na podkreślnik
        invalid_chars = r'[<>:"/\\|?*]'
        filename = re.sub(invalid_chars, '_', filename)
        # Usuń kropki z początku lub końca nazwy (mogą powodować problemy na niektórych systemach)
        filename = filename.lstrip('.').rstrip('.')
        # Upewnij się, że nazwa nie jest pusta po sanitacji
        if not filename:
             return "downloaded_file"
        return filename
    
    def find_unique_filename(filepath):
        """Zapobiega nadpisywaniu plików, dodając numery do nazwy."""
        if not os.path.exists(filepath):
            return filepath
        base, ext = os.path.splitext(filepath)
        i = 1
        while True:
            new_filepath = f"{base} ({i}){ext}"
            if not os.path.exists(new_filepath):
                return new_filepath
            i += 1
    
    def download_file(url, output_dir, suggested_filename=None):
        """Pobiera plik ze wskazanego URL do katalogu wyjściowego."""
        print(f"  -> Pobieranie: {url}")
        try:
            # Użyj stream=True do pobierania dużych plików bez ładowania całości do pamięci
            with requests.get(url, stream=True, timeout=30) as r:
                r.raise_for_status() # Zgłoś błąd dla kodów statusu 4xx/5xx
    
                # Określenie nazwy pliku
                filename = suggested_filename
                cd = r.headers.get('Content-Disposition')
                if cd:
                    filename = get_filename_from_cd(cd)
    
                if not filename:
                    # Alternatywa: weź z URL (ostatni segment ścieżki)
                    path = urlparse(url).path
                    filename = os.path.basename(path)
                    # Spróbuj oczyścić nazwę z URL
                    if not filename or filename == '/' or '.' not in filename:
                         filename = f"downloaded_file_{int(time.time())}" # Ostateczność
    
                filename = sanitize_filename(filename)
                if not filename: # Sprawdzenie po sanitacji
                     filename = f"downloaded_file_{int(time.time())}"
    
    
                filepath = os.path.join(output_dir, filename)
                unique_filepath = find_unique_filename(filepath)
    
                print(f"     Zapisywanie jako: {os.path.basename(unique_filepath)}")
    
                # Można dodać pasek postępu (np. z biblioteką tqdm)
                # total_size = int(r.headers.get('content-length', 0))
                # progress_bar = tqdm(total=total_size, unit='B', unit_scale=True, desc=os.path.basename(unique_filepath))
    
                with open(unique_filepath, 'wb') as f:
                    for chunk in r.iter_content(chunk_size=8192): # Pobieraj w kawałkach
                        # if progress_bar: progress_bar.update(len(chunk))
                        f.write(chunk)
    
                # if progress_bar: progress_bar.close()
                print("     Pobieranie zakończone.")
    
        except requests.exceptions.RequestException as e:
            print(f"     Błąd podczas pobierania {url}: {e}")
        except IOError as e:
            print(f"     Błąd podczas zapisu pliku {os.path.basename(filepath)}: {e}")
        except Exception as e:
             print(f"     Wystąpił nieoczekiwany błąd podczas pobierania {url}: {e}")
    
    
    def download_bunkr_album(album_url, output_dir):
        """Pobiera wszystkie pliki ze wskazanego albumu bunkr.si."""
        print(f"Próba pobrania z albumu: {album_url}")
    
        # Upewnij się, że katalog wyjściowy istnieje
        os.makedirs(output_dir, exist_ok=True)
    
        try:
            # Pobierz stronę albumu
            print("Pobieranie strony albumu...")
            response = requests.get(album_url, timeout=30)
            response.raise_for_status() # Zgłoś błąd dla kodów statusu 4xx/5xx
    
            soup = BeautifulSoup(response.text, 'html.parser')
    
            # --- ZNAJDŹ LINKI DO STRON POJEDYNCZYCH PLIKÓW NA STRONIE ALBUMU ---
            # To jest najbardziej wrażliwa część - zależy od struktury HTML bunkr.si.
            # Często linki do pojedynczych plików znajdują się w tagach <a> otaczających miniatury.
            # Szukamy tagów <a> których atrybut href wygląda na link do strony widoku (/v/) lub pobierania (/d/).
            # Poniższy selektor jest PRZYKŁADOWY i może wymagać dostosowania!
            # Może być konieczna inspekcja kodu HTML konkretnego albumu (np. za pomocą narzędzi deweloperskich przeglądarki).
            # Szukamy linków, które prowadzą do ścieżek /v/ lub /d/
            file_page_links = set() # Użyj zbioru, aby uniknąć duplikatów
    
            # Próba znalezienia linków do stron plików (często mają ścieżkę /v/ lub /d/)
            # Szukamy wszystkich linków z href, a następnie filtrujemy
            potential_links = soup.select('a[href]')
    
            for link_tag in potential_links:
                 href = link_tag.get('href')
                 if href:
                      parsed_href = urlparse(href)
                      # Sprawdź, czy ścieżka URL zaczyna się od /v/ lub /d/
                      if parsed_href.path.startswith('/v/') or parsed_href.path.startswith('/d/'):
                           full_url = urljoin(album_url, href)
                           # Można dodać dalsze filtrowanie, jeśli np. są inne linki /v/ lub /d/
                           # które nie są plikami (np. /v/user/profile/...)
                           # Na razie dodajemy wszystkie pasujące
                           file_page_links.add(full_url)
    
            print(f"Znaleziono {len(file_page_links)} potencjalnych stron widoku/pobierania plików.")
    
            if not file_page_links:
                 print("Nie znaleziono linków do stron plików na stronie albumu przy użyciu typowych wzorców.")
                 print("Próba znalezienia bezpośrednich linków do mediów (atrybuty src) na stronie albumu...")
                 # Alternatywa: czasami bezpośrednie linki do plików (np. img src, video src) są na stronie albumu.
                 media_links = set()
                 # Szukaj tagów z atrybutem src, które mogą być bezpośrednimi linkami do mediów
                 for tag in soup.select('img[src], source[src], video[src], audio[src]'):
                      src = tag.get('src')
                      if src:
                           full_src = urljoin(album_url, src)
                           # Podstawowe sprawdzenie, czy link wygląda na plik medialny (może wymagać lepszego filtrowania)
                           # np. unikaj linków do miniatur
                           if any(full_src.lower().endswith(ext) for ext in ['.jpg', '.jpeg', '.png', '.gif', '.mp4', '.webm', '.mp3', '.ogg', '.webp']):
                                media_links.add(full_src)
    
                 if media_links:
                     print(f"Znaleziono {len(media_links)} potencjalnych bezpośrednich linków do mediów na stronie albumu.")
                     print("Próba pobrania tych plików bezpośrednio...")
                     for i, direct_link in enumerate(media_links):
                         print(f"\n--- Pobieranie bezpośredniego pliku {i+1}/{len(media_links)} ---")
                         # Sugerowana nazwa pliku z ostatniego segmentu URL
                         suggested_name = os.path.basename(urlparse(direct_link).path)
                         if suggested_name and suggested_name != '/' and '.' in suggested_name:
                             download_file(direct_link, output_dir, suggested_name)
                         else:
                             download_file(direct_link, output_dir) # Pobierz bez sugerowanej nazwy
    
                 if not file_page_links and not media_links:
                    print("Nie znaleziono żadnych linków do pobrania. Sprawdź URL i strukturę strony.")
                 return # Zakończ, jeśli nie znaleziono żadnych linków
    
            # --- PRZETWARZANIE LINKÓW DO STRON PLIKÓW ---
            for i, file_page_url in enumerate(file_page_links):
                 print(f"\n--- Przetwarzanie strony pliku {i+1}/{len(file_page_links)}: {file_page_url} ---")
    
                 try:
                     # Pobierz stronę pojedynczego pliku
                     file_response = requests.get(file_page_url, timeout=30)
                     file_response.raise_for_status()
                     file_soup = BeautifulSoup(file_response.text, 'html.parser')
    
                     # --- ZNAJDŹ BEZPOŚREDNI LINK DO POBRANIA NA STRONIE PLIKU ---
                     # To również zależy od struktury HTML strony pliku.
                     # Szukaj:
                     # 1. Taga <a> z tekstem "Download" lub klasą CSS wskazującą na przycisk pobierania.
                     # 2. Taga <a> którego href zawiera '/download/' lub bezpośrednio linkuje do pliku.
                     # 3. Atrybutu src tagów <video>, <audio>, <img> na tej stronie.
    
                     direct_download_link = None
                     suggested_filename = None # Sugerowana nazwa pliku ze strony
    
                     # Próba znalezienia dedykowanego przycisku/linku do pobrania
                     # Często zawiera href="/download/..." lub ma specyficzną klasę
                     # Szukaj pierwszego <a> z href zawierającym '/download/'
                     download_button = file_soup.select_one('a[href*="/download/"]')
                     if download_button:
                          direct_download_link = urljoin(file_page_url, download_button.get('href'))
                          # Spróbuj znaleźć nazwę pliku w pobliżu przycisku lub w tytule strony
                          # Szukaj elementów z nazwą pliku, np. h1, div.filename
                          filename_element = file_soup.select_one('h1.file-title, div.filename, title')
                          if filename_element:
                               suggested_filename = filename_element.get_text(strip=True)
                               # Dodaj rozszerzenie, jeśli brakuje, a można je odgadnąć z linku
                               if '.' not in suggested_filename and '.' in direct_download_link:
                                   ext = os.path.splitext(urlparse(direct_download_link).path)[1]
                                   if ext and len(ext) <= 5: # Podstawowe sprawdzenie czy to rozsądne rozszerzenie
                                       suggested_filename += ext
    
    
                     # Jeśli nie znaleziono przycisku pobierania, szukaj bezpośrednich źródeł mediów
                     if not direct_download_link:
                          print("  Nie znaleziono dedykowanego linku pobierania, szukanie bezpośrednich źródeł mediów...")
                          # Szukaj pierwszego src w tagach video, audio, img, source
                          media_source = file_soup.select_one('video source[src], audio source[src], img[src], video[src], audio[src]')
                          if media_source:
                               direct_download_link = urljoin(file_page_url, media_source.get('src'))
                               # Spróbuj uzyskać nazwę pliku ze ścieżki URL lub z elementu na stronie
                               path_filename = os.path.basename(urlparse(direct_download_link).path)
                               if path_filename and path_filename != '/' and '.' in path_filename:
                                   suggested_filename = path_filename
                               else:
                                    # Spróbuj znaleźć nazwę pliku w tytule strony lub w elemencie h1/div.filename
                                    filename_element = file_soup.select_one('h1.file-title, div.filename, title')
                                    if filename_element:
                                         suggested_filename = filename_element.get_text(strip=True)
                                         # Dodaj rozszerzenie, jeśli brakuje
                                         if '.' not in suggested_filename and '.' in os.path.basename(urlparse(direct_download_link).path):
                                             ext = os.path.splitext(urlparse(direct_download_link).path)[1]
                                             if ext and len(ext) <= 5:
                                                 suggested_filename += ext
                                    elif path_filename and path_filename != '/':
                                         # Użyj nazwy ze ścieżki jako ostatnią sugestię
                                         suggested_filename = path_filename
    
    
                     # --- POBIERZ PLIK ---
                     if direct_download_link:
                          download_file(direct_download_link, output_dir, suggested_filename)
                     else:
                          print(f"  Nie udało się znaleźć bezpośredniego linku pobierania lub źródła mediów na stronie: {file_page_url}")
    
                 except requests.exceptions.RequestException as e:
                     print(f"  Błąd podczas pobierania strony pliku {file_page_url}: {e}")
                 except Exception as e:
                     print(f"  Wystąpił nieoczekiwany błąd podczas przetwarzania strony pliku {file_page_url}: {e}")
    
                 # Opcjonalnie: dodaj małe opóźnienie między żądaniami, aby nie obciążać serwera
                 # time.sleep(0.5) # Dostosuj według potrzeb
    
        except requests.exceptions.RequestException as e:
            print(f"Błąd podczas pobierania strony albumu {album_url}: {e}")
        except Exception as e:
            print(f"Wystąpił nieoczekiwany błąd: {e}")
    
    # --- Główny blok wykonawczy ---
    if __name__ == "__main__":
        parser = argparse.ArgumentParser(description="Pobiera pliki z albumu bunkr.si.")
        parser.add_argument("album_url", help="Adres URL albumu bunkr.si (np. https://bunkr.si/a/albumID)")
        parser.add_argument("-o", "--output", default="downloads", help="Katalog wyjściowy dla pobranych plików (domyślnie: ./downloads)")
    
        args = parser.parse_args()
    
        # Podstawowa walidacja URL
        if not args.album_url.startswith('http://') and not args.album_url.startswith('https://'):
             print("Błąd: URL musi zaczynać się od http:// lub https://")
             exit(1)
        # Dodatkowe ostrzeżenie, jeśli URL nie wygląda na album (brak /a/)
        if not '/a/' in args.album_url:
            print("Ostrzeżenie: Podany URL nie wygląda na URL albumu (brak '/a/'). Skrypt spróbuje go przetworzyć, ale może to się nie powieść, jeśli to inny typ strony.")
    
        download_bunkr_album(args.album_url, args.output)
    

    Jak używać skryptu:

    1. Zapisz powyższy kod jako plik .py, np. bunkr_downloader.py.

    2. Upewnij się, że masz zainstalowane wymagane biblioteki (requests, beautifulsoup4). Jeśli nie, uruchom pip install requests beautifulsoup4.

    3. Uruchom skrypt z wiersza poleceń, podając URL albumu bunkr.si jako argument:

      python bunkr_downloader.py https://bunkr.si/a/PRZYKLADOWE_ID_ALBUMU
      
    4. Pliki zostaną pobrane do katalogu downloads w tym samym miejscu, co skrypt. Możesz zmienić katalog wyjściowy za pomocą opcji -o:

      python bunkr_downloader.py https://bunkr.si/a/PRZYKLADOWE_ID_ALBUMU -o /ścieżka/do/moich/pobrań
      

    Dostosowanie selektorów HTML:

    Jeśli skrypt nie znajdzie plików (np. wypisze komunikaty o braku linków), prawdopodobnie musisz zaktualizować selektory CSS w kodzie. Aby to zrobić:

    1. Otwórz stronę albumu bunkr.si w przeglądarce.
    2. Kliknij prawym przyciskiem myszy na miniaturę lub nazwę pliku, który chcesz pobrać.
    3. Wybierz "Zbadaj element" (Inspect element).
    4. Przyjrzyj się strukturze HTML. Znajdź tag <a>, który prowadzi do strony pojedynczego pliku (często otacza miniaturę). Zobacz, jakie ma klasy CSS lub jak jest zagnieżdżony. Zaktualizuj linię szukającą file_page_links. Obecnie szuka linków, których href zaczyna się od /v/ lub /d/.
    5. Otwórz stronę pojedynczego pliku (klikając na miniaturę w przeglądarce).
    6. Zbadaj element "Pobierz" lub tagi <video>, <img>, <audio>. Znajdź tag <a>, który prowadzi bezpośrednio do pliku lub tag src w tagach mediów. Sprawdź jego klasy CSS, ID lub strukturę href. Zaktualizuj linie szukające direct_download_link i media_source. Obecnie priorytetem jest link z href zawierającym /download/, a potem src z tagów mediów.

    Pamiętaj, że to narzędzie jest przykładem i może wymagać dostosowania do konkretnego przypadku i zmian na stronie docelowej. Używaj go odpowiedzialnie.

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