2025-10-18 04:21:26 -04:00
43 changed files with 321 additions and 1832 deletions
--- a/.github/workflows/buildx.yml
+++ b/.github/workflows/buildx.yml
@ -9,9 +9,6 @@ on:
  push:
    tags:
      - '*'
  release:
    types:
      - published
 jobs:
  on-success:
@ -38,46 +35,17 @@ jobs:
          registry: ghcr.io
          username: ${{ github.actor }}
          password: ${{ secrets.GITHUB_TOKEN }}
-      # Disabled: only build on release events now
+      - name: build and push the image
-      # - name: build and push the image
+        if: startsWith(github.ref, 'refs/heads/main') && github.actor == 'benbusby'
      #   if: startsWith(github.ref, 'refs/heads/main') && (github.actor == 'benbusby' || github.actor == 'Don-Swanson')
      #   run: |
      #     docker run --rm --privileged multiarch/qemu-user-static --reset -p yes
      #     docker buildx ls
      #     docker buildx build --push \
      #       --tag benbusby/whoogle-search:latest \
      #       --platform linux/amd64,linux/arm64 .
      #     docker buildx build --push \
      #       --tag ghcr.io/benbusby/whoogle-search:latest \
      #       --platform linux/amd64,linux/arm64 .
      - name: build and push release (version + latest)
        if: github.event_name == 'release' && github.event.release.prerelease == false && (github.actor == 'benbusby' || github.actor == 'Don-Swanson')
        run: |
          TAG="${{ github.event.release.tag_name }}"
          VERSION="${TAG#v}"
          docker run --rm --privileged multiarch/qemu-user-static --reset -p yes
          docker buildx ls
          docker buildx build --push \
            --tag benbusby/whoogle-search:${VERSION} \
            --tag benbusby/whoogle-search:latest \
-            --platform linux/amd64,linux/arm/v7,linux/arm64 .
+            --platform linux/amd64,linux/arm64 .
          docker buildx build --push \
            --tag ghcr.io/benbusby/whoogle-search:${VERSION} \
            --tag ghcr.io/benbusby/whoogle-search:latest \
-            --platform linux/amd64,linux/arm/v7,linux/arm64 .
+            --platform linux/amd64,linux/arm64 .
      - name: build and push pre-release (version only)
        if: github.event_name == 'release' && github.event.release.prerelease == true && (github.actor == 'benbusby' || github.actor == 'Don-Swanson')
        run: |
          TAG="${{ github.event.release.tag_name }}"
          VERSION="${TAG#v}"
          docker run --rm --privileged multiarch/qemu-user-static --reset -p yes
          docker buildx ls
          docker buildx build --push \
            --tag benbusby/whoogle-search:${VERSION} \
            --platform linux/amd64,linux/arm/v7,linux/arm64 .
          docker buildx build --push \
            --tag ghcr.io/benbusby/whoogle-search:${VERSION} \
            --platform linux/amd64,linux/arm/v7,linux/arm64 .
      - name: build and push tag
        if: startsWith(github.ref, 'refs/tags')
        run: |
--- a/.github/workflows/pypi.yml
+++ b/.github/workflows/pypi.yml
@ -38,37 +38,21 @@ jobs:
          password: ${{ secrets.TEST_PYPI_API_TOKEN }}
          repository_url: https://test.pypi.org/legacy/
  publish:
    # Gate real PyPI publishing to stable SemVer tags only
    if: startsWith(github.ref, 'refs/tags/')
    name: Build and publish to PyPI
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: Check if stable release
        id: check_tag
        run: |
          TAG="${{ github.ref_name }}"
          if echo "$TAG" | grep -qE '^v?[0-9]+\.[0-9]+\.[0-9]+$'; then
            echo "is_stable=true" >> $GITHUB_OUTPUT
            echo "Tag '$TAG' is a stable release. Will publish to PyPI."
          else
            echo "is_stable=false" >> $GITHUB_OUTPUT
            echo "Tag '$TAG' is not a stable release (contains pre-release suffix). Skipping PyPI publish."
          fi
      - name: Set up Python 3.9
        if: steps.check_tag.outputs.is_stable == 'true'
        uses: actions/setup-python@v5
        with:
          python-version: 3.9
      - name: Install pypa/build
        if: steps.check_tag.outputs.is_stable == 'true'
        run: >-
          python -m
          pip install
          build
          --user
      - name: Build binary wheel and source tarball
        if: steps.check_tag.outputs.is_stable == 'true'
        run: >-
          python -m
          build
@ -77,7 +61,7 @@ jobs:
          --outdir dist/
          .
      - name: Publish distribution to PyPI
-        if: steps.check_tag.outputs.is_stable == 'true'
+        if: startsWith(github.ref, 'refs/tags')
        uses: pypa/gh-action-pypi-publish@master
        with:
          password: ${{ secrets.PYPI_API_TOKEN }}
--- a/.github/workflows/stale.yml
+++ b/.github/workflows/stale.yml
@ -1,33 +0,0 @@
 # This workflow warns and then closes issues and PRs that have had no activity for a specified amount of time.
 #
 # You can adjust the behavior by modifying this file.
 # For more information, see:
 # https://github.com/actions/stale
 name: Mark stale issues and pull requests
 on:
  schedule:
  - cron: '35 10 * * *'
 jobs:
  stale:
    runs-on: ubuntu-latest
    permissions:
      issues: write
      pull-requests: write
    steps:
    - uses: actions/stale@v10
      with:
        days-before-stale: 90
        days-before-close: 7
        stale-issue-message: 'This issue has been automatically marked as stale due to inactivity. If it is still valid please comment within 7 days or it will be auto-closed.'
        close-issue-message: 'Closing this issue due to prolonged inactivity.'
        # Disabled PR Closing for now, but pre-staged the settings
        days-before-pr-stale: -1
        days-before-pr-close: -1
        operations-per-run: 100
        stale-pr-message: "This PR appears to be stale.  If it is still valid please comment within 14 days or it will be auto-closed."
        close-pr-message: "This PR was closed as stale."
        exempt-issue-labels: 'keep-open,enhancement,critical,dependencies,documentation'
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@ -1,13 +0,0 @@
 repos:
  - repo: https://github.com/astral-sh/ruff-pre-commit
    rev: v0.6.9
    hooks:
      - id: ruff
        args: [--fix]
      - id: ruff-format
  - repo: https://github.com/psf/black
    rev: 24.8.0
    hooks:
      - id: black
        args: [--quiet]
--- a/2
+++ b/2
@ -100,4 +100,4 @@ EXPOSE $EXPOSE_PORT
 HEALTHCHECK --interval=30s --timeout=5s \
  CMD curl -f http://localhost:${EXPOSE_PORT}/healthz || exit 1
-CMD ["/bin/sh", "-c", "misc/tor/start-tor.sh & ./run"]
+CMD misc/tor/start-tor.sh & ./run
--- a/LETA_INTEGRATION.md
+++ b/LETA_INTEGRATION.md
@ -1,137 +0,0 @@
 # Mullvad Leta Backend Integration
 ## Overview
 Whoogle Search now supports using Mullvad Leta (https://leta.mullvad.net) as an alternative search backend. This provides an additional privacy-focused search option that routes queries through Mullvad's infrastructure.
 ## Features
 - **Backend Selection**: Users can choose between Google (default) and Mullvad Leta as the search backend
 - **Privacy-Focused**: Leta is designed for privacy and doesn't track searches
 - **Seamless Integration**: Results from Leta are automatically converted to Whoogle's display format
 - **Automatic Tab Filtering**: Image, video, news, and map tabs are automatically hidden when using Leta (as these are not supported)
 ## Limitations
 When using the Mullvad Leta backend, the following search types are **NOT supported**:
 - Image search (`tbm=isch`)
 - Video search (`tbm=vid`)
 - News search (`tbm=nws`)
 - Map search
 Attempting to use these search types with Leta enabled will show an error message and redirect to the home page.
 ## Configuration
 ### Via Web Interface
 1. Click the "Config" button on the Whoogle home page
 2. Scroll down to find the "Use Mullvad Leta Backend" checkbox
 3. **Leta is enabled by default** - uncheck the box to use Google instead
 4. Click "Apply" to save your settings
 ### Via Environment Variable
 Leta is **enabled by default**. To disable it and use Google instead:
 ```bash
 WHOOGLE_CONFIG_USE_LETA=0
 ```
 To explicitly enable it (though it's already default):
 ```bash
 WHOOGLE_CONFIG_USE_LETA=1
 ```
 ## Implementation Details
 ### Files Modified
 1. **app/models/config.py**
   - Added `use_leta` configuration option
   - Added to `safe_keys` list for URL parameter passing
 2. **app/request.py**
   - Modified `Request.__init__()` to use Leta URL when configured
   - Added `gen_query_leta()` function to format queries for Leta's API
   - Leta uses different query parameters than Google:
     - `engine=google` (or `brave`)
     - `country=XX` (lowercase country code)
     - `language=XX` (language code without `lang_` prefix)
     - `lastUpdated=d|w|m|y` (time period filter)
     - `page=N` (pagination, 1-indexed)
 3. **app/filter.py**
   - Added `convert_leta_to_whoogle()` method to parse Leta's HTML structure
   - Modified `clean()` method to detect and convert Leta results
   - Leta results use `<article>` tags with specific classes that are converted to Whoogle's format
 4. **app/routes.py**
   - Added validation to prevent unsupported search types when using Leta
   - Shows user-friendly error message when attempting image/video/news/map searches with Leta
 5. **app/utils/results.py**
   - Modified `get_tabs_content()` to accept `use_leta` parameter
   - Filters out non-web search tabs when Leta is enabled
 6. **app/templates/index.html**
   - Added checkbox in settings panel for enabling/disabling Leta backend
   - Includes helpful tooltip explaining Leta's limitations
 ## Technical Details
 ### Query Parameter Mapping
 | Google Parameter | Leta Parameter | Notes |
 |-----------------|----------------|-------|
 | `q=<query>` | `q=<query>` | Same format |
 | `gl=<country>` | `country=<code>` | Lowercase country code |
 | `lr=<lang>` | `language=<code>` | Without `lang_` prefix |
 | `tbs=qdr:d` | `lastUpdated=d` | Time filters mapped |
 | `start=10` | `page=2` | Converted to 1-indexed pages |
 | `tbm=isch/vid/nws` | N/A | Not supported |
 ### Leta HTML Structure
 Leta returns results in this structure:
 ```html
 <article class="svelte-fmlk7p">
  <a href="<result-url>">
    <h3>Result Title</h3>
  </a>
  <cite>display-url.com</cite>
  <p class="result__body">Result snippet/description</p>
 </article>
 ```
 This is converted to Whoogle's expected format for consistent display.
 ## Testing
 To test the Leta integration:
 1. Enable Leta in settings
 2. Perform a regular web search - should see results from Leta
 3. Try to access an image/video/news tab - should see error message
 4. Check pagination works correctly
 5. Verify country and language filters work
 6. Test time period filters (past day/week/month/year)
 ## Environment Variables
 - `WHOOGLE_CONFIG_USE_LETA`: Set to `0` to disable Leta and use Google instead (default: `1` - Leta enabled)
 ## Future Enhancements
 Potential improvements for future versions:
 - Add Brave as an alternative engine option (Leta supports both Google and Brave)
 - Implement image search support if Leta adds this capability
 - Add per-query backend selection (bang-style syntax)
 - Cache Leta results for improved performance
 ## Notes
 - Leta's search results are cached on their end, so you may see "cached X days ago" messages
 - Leta requires no API key or authentication
 - Leta respects Tor configuration if enabled in Whoogle
 - User agent settings apply to Leta requests as well
--- a/README.md
+++ b/README.md
@ -1,12 +1,10 @@
 >[!WARNING]
 >
->**Mullvad Leta Backend Now Available!**
+>As of 16 January, 2025, Google seemingly no longer supports performing search queries without JavaScript enabled. This is a fundamental part of how Whoogle
 >works -- Whoogle requests the JavaScript-free search results, then filters out garbage from the results page and proxies all external content for the user.
 >
->As of 16 January, 2025, Google seemingly no longer supports performing search queries without JavaScript enabled. We have made multiple workarounds, but as of 2 October 2025, Google has killed off all remaining methods we had to retrieve results from them originally. While we work to rebuild and hopefully find new ways to continue on, we have released a stopgap which uses [Mullvad Leta](https://leta.mullvad.net) (an alternative privacy-focused search backend) as the default (but disable-able) backend leveraging their Google results. 
+>This is possibly a breaking change that will mean the end for Whoogle. I'll continue monitoring the status of their JS-free results and looking into workarounds,
->
+>and will make another post if a solution is found (or not).
 >**Leta is now enabled by default**. It provides anonymous search results through Mullvad's infrastructure without requiring JavaScript. While Leta doesn't support image, video, news, or map searches, it provides privacy-focused web search results.
 >
 >To switch back to Google (if it becomes available again), you can disable Leta in the config settings or set `WHOOGLE_CONFIG_USE_LETA=0` in your environment variables. See [LETA_INTEGRATION.md](LETA_INTEGRATION.md) for more details.
 ___
@ -16,6 +14,7 @@ ___
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 [![tests](https://github.com/benbusby/whoogle-search/actions/workflows/tests.yml/badge.svg)](https://github.com/benbusby/whoogle-search/actions/workflows/tests.yml)
 [![buildx](https://github.com/benbusby/whoogle-search/actions/workflows/buildx.yml/badge.svg)](https://github.com/benbusby/whoogle-search/actions/workflows/buildx.yml)
 [![codebeat badge](https://codebeat.co/badges/e96cada2-fb6f-4528-8285-7d72abd74e8d)](https://codebeat.co/projects/github-com-benbusby-shoogle-master)
 [![Docker Pulls](https://img.shields.io/docker/pulls/benbusby/whoogle-search)](https://hub.docker.com/r/benbusby/whoogle-search)
 <table>
@ -58,7 +57,6 @@ Contents
 10. [Screenshots](#screenshots)
 ## Features
 - **Mullvad Leta backend support** - Privacy-focused alternative to Google (enabled by default)
 - No ads or sponsored content
 - No JavaScript\*
 - No cookies\*\*
@ -77,7 +75,6 @@ Contents
 - User-defined [custom bangs](#custom-bangs)
 - Optional location-based searching (i.e. results near \<city\>)
 - Optional NoJS mode to view search results in a separate window with JavaScript blocked
 - JSON output for results via content negotiation (see "JSON results (API)")
 <sup>*No third party JavaScript. Whoogle can be used with JavaScript disabled, but if enabled, uses JavaScript for things like presenting search suggestions.</sup>
@ -466,8 +463,6 @@ There are a few optional environment variables available for customizing a Whoog
 | WHOOGLE_SHOW_FAVICONS | Show/hide favicons next to search result URLs. Default on.                               |
 | WHOOGLE_UPDATE_CHECK  | Enable/disable the automatic daily check for new versions of Whoogle. Default on.        |
 | WHOOGLE_FALLBACK_ENGINE_URL | Set a fallback Search Engine URL when there is internal server error or instance is rate-limited. Search query is appended to the end of the URL (eg. https://duckduckgo.com/?k1=-1&q=). |
 | WHOOGLE_BUNDLE_STATIC | When set to 1, serve a single bundled CSS and JS file generated at startup to reduce requests. Default off. |
 | WHOOGLE_HTTP2         | Enable HTTP/2 for upstream requests (via httpx). Default on — set to 0 to force HTTP/1.1. |
 ### Config Environment Variables
 These environment variables allow setting default config values, but can be overwritten manually by using the home page config menu. These allow a shortcut for destroying/rebuilding an instance to the same config state every time.
@ -494,35 +489,12 @@ These environment variables allow setting default config values, but can be over
 | WHOOGLE_CONFIG_PREFERENCES_ENCRYPTED | Encrypt preferences token, requires preferences key             |
 | WHOOGLE_CONFIG_PREFERENCES_KEY       | Key to encrypt preferences in URL (REQUIRED to show url)        |
 | WHOOGLE_CONFIG_ANON_VIEW             | Include the "anonymous view" option for each search result      |
 | WHOOGLE_CONFIG_USE_LETA              | Use Mullvad Leta as search backend (default: enabled). Set to 0 to use Google instead |
 ## Usage
 Same as most search engines, with the exception of filtering by time range.
 To filter by a range of time, append ":past <time>" to the end of your search, where <time> can be `hour`, `day`, `month`, or `year`. Example: `coronavirus updates :past hour`
 ### JSON results (API)
 Whoogle can return filtered results as JSON using the same sanitization rules as the HTML view.
 - Send `Accept: application/json` or append `format=json` to the search URL.
 - Example: `/search?q=whoogle` with `Accept: application/json`, or `/search?q=whoogle&format=json`.
 - Response shape:
 ```
 {
  "query": "whoogle",
  "search_type": "",
  "results": [
    {"href": "https://example.com/page", "text": "Example Page"},
    ...
  ]
 }
 ```
 Special cases:
 - Feeling Lucky returns HTTP 303 with body `{ "redirect": "<url>" }`.
 - Temporary blocks (captcha) return HTTP 503 with `{ "blocked": true, "error_message": "...", "query": "..." }`.
 ## Extra Steps
 ### Set Whoogle as your primary search engine
@ -658,14 +630,6 @@ server {
 You can then add SSL support using LetsEncrypt by following a guide such as [this one](https://www.nginx.com/blog/using-free-ssltls-certificates-from-lets-encrypt-with-nginx/).
 ### Static asset bundling (optional)
 Whoogle can optionally serve a single bundled CSS and JS to reduce the number of HTTP requests.
 - Enable by setting `WHOOGLE_BUNDLE_STATIC=1` and restarting the app.
 - On startup, Whoogle concatenates local CSS/JS into hashed files under `app/static/build/` and templates will prefer those bundles.
 - When disabled (default), templates load individual CSS/JS files for easier development.
 - Note: Theme CSS (`*-theme.css`) are still loaded separately to honor user theme selection.
 ## Contributing
 Under the hood, Whoogle is a basic Flask app with the following structure:
@ -717,20 +681,6 @@ def contains(x: list, y: int) -> bool:
 Whoogle currently supports translations using [`translations.json`](https://github.com/benbusby/whoogle-search/blob/main/app/static/settings/translations.json). Language values in this file need to match the "value" of the according language in [`languages.json`](https://github.com/benbusby/whoogle-search/blob/main/app/static/settings/languages.json) (i.e. "lang_en" for English, "lang_es" for Spanish, etc). After you add a new set of translations to `translations.json`, open a PR with your changes and they will be merged in as soon as possible.
 ## FAQ
 **What is Mullvad Leta and why is it the default?**
 Mullvad Leta is a privacy-focused search service provided by [Mullvad VPN](https://mullvad.net/en/leta). As of January 2025, Google disabled JavaScript-free search results, which breaks Whoogle's core functionality. Leta provides an excellent alternative that:
 - Doesn't require JavaScript
 - Provides privacy-focused search results through Mullvad's infrastructure
 - Uses Google's search index (so results are similar to what you'd expect)
 - Doesn't track or log your searches
 **Limitations:** Leta only supports regular web search - no images, videos, news, or maps. If you need these features and Google's JavaScript-free search becomes available again, you can disable Leta in settings or set `WHOOGLE_CONFIG_USE_LETA=0`.
 For more details, see [LETA_INTEGRATION.md](LETA_INTEGRATION.md).
 **What's the difference between this and [Searx](https://github.com/asciimoo/searx)?**
 Whoogle is intended to only ever be deployed to private instances by individuals of any background, with as little effort as possible. Prior knowledge of/experience with the command line or deploying applications is not necessary to deploy Whoogle, which isn't the case with Searx. As a result, Whoogle is missing some features of Searx in order to be as easy to deploy as possible.
@ -749,9 +699,28 @@ A lot of the app currently piggybacks on Google's existing support for fetching
 | Website | Country | Language | Cloudflare |
 |-|-|-|-|
 | [https://search.albony.xyz](https://search.albony.xyz/) | 🇮🇳 IN | Multi-choice |  |
 | [https://search.garudalinux.org](https://search.garudalinux.org) | 🇫🇮 FI | Multi-choice | ✅ |
 | [https://search.dr460nf1r3.org](https://search.dr460nf1r3.org) | 🇩🇪 DE | Multi-choice | ✅ |
 | [https://s.tokhmi.xyz](https://s.tokhmi.xyz) | 🇺🇸 US | Multi-choice | ✅ |
 | [https://search.sethforprivacy.com](https://search.sethforprivacy.com) | 🇩🇪 DE | English | |
 | [https://whoogle.dcs0.hu](https://whoogle.dcs0.hu) | 🇭🇺 HU | Multi-choice | |
 | [https://gowogle.voring.me](https://gowogle.voring.me) | 🇺🇸 US | Multi-choice | |
 | [https://whoogle.privacydev.net](https://whoogle.privacydev.net) | 🇫🇷 FR | English | |
 | [https://wg.vern.cc](https://wg.vern.cc) | 🇺🇸 US | English |  |
 | [https://whoogle.hxvy0.gq](https://whoogle.hxvy0.gq) | 🇨🇦 CA | Turkish Only | ✅ |
 | [https://whoogle.hostux.net](https://whoogle.hostux.net) | 🇫🇷 FR | Multi-choice | |
 | [https://whoogle.lunar.icu](https://whoogle.lunar.icu) | 🇩🇪 DE | Multi-choice | ✅ |
 | [https://wgl.frail.duckdns.org](https://wgl.frail.duckdns.org) | 🇧🇷 BR | Multi-choice | |
 | [https://whoogle.no-logs.com](https://whoogle.no-logs.com/) | 🇸🇪 SE | Multi-choice | |
 | [https://whoogle.ftw.lol](https://whoogle.ftw.lol) | 🇩🇪 DE | Multi-choice | |
 | [https://whoogle-search--replitcomreside.repl.co](https://whoogle-search--replitcomreside.repl.co) | 🇺🇸 US | English |  |
 | [https://search.notrustverify.ch](https://search.notrustverify.ch) | 🇨🇭 CH | Multi-choice |  |
 | [https://whoogle.datura.network](https://whoogle.datura.network) | 🇩🇪 DE | Multi-choice | |
 | [https://whoogle.yepserver.xyz](https://whoogle.yepserver.xyz) | 🇺🇦 UA | Multi-choice | |
 | [https://search.nezumi.party](https://search.nezumi.party) | 🇮🇹 IT | Multi-choice | |
 | [https://search.snine.nl](https://search.snine.nl) | 🇳🇱 NL | Mult-choice | ✅ |
 * A checkmark in the "Cloudflare" category here refers to the use of the reverse proxy, [Cloudflare](https://cloudflare.com). The checkmark will not be listed for a site which uses Cloudflare DNS but rather the proxying service which grants Cloudflare the ability to monitor traffic to the website.
@ -759,7 +728,17 @@ A lot of the app currently piggybacks on Google's existing support for fetching
 | Website | Country | Language |
 |-|-|-|
-NONE of the existing Onion accessible sites appear to be live anymore
+| [http://whoglqjdkgt2an4tdepberwqz3hk7tjo4kqgdnuj77rt7nshw2xqhqad.onion](http://whoglqjdkgt2an4tdepberwqz3hk7tjo4kqgdnuj77rt7nshw2xqhqad.onion) | 🇺🇸 US |  Multi-choice
 | [http://nuifgsnbb2mcyza74o7illtqmuaqbwu4flam3cdmsrnudwcmkqur37qd.onion](http://nuifgsnbb2mcyza74o7illtqmuaqbwu4flam3cdmsrnudwcmkqur37qd.onion) | 🇩🇪 DE |  English
 | [http://whoogle.vernccvbvyi5qhfzyqengccj7lkove6bjot2xhh5kajhwvidqafczrad.onion](http://whoogle.vernccvbvyi5qhfzyqengccj7lkove6bjot2xhh5kajhwvidqafczrad.onion/) | 🇺🇸 US | English |
 | [http://whoogle.g4c3eya4clenolymqbpgwz3q3tawoxw56yhzk4vugqrl6dtu3ejvhjid.onion](http://whoogle.g4c3eya4clenolymqbpgwz3q3tawoxw56yhzk4vugqrl6dtu3ejvhjid.onion/) | 🇫🇷 FR | English |
 | [http://whoogle.daturab6drmkhyeia4ch5gvfc2f3wgo6bhjrv3pz6n7kxmvoznlkq4yd.onion](http://whoogle.daturab6drmkhyeia4ch5gvfc2f3wgo6bhjrv3pz6n7kxmvoznlkq4yd.onion/) | 🇩🇪 DE | Multi-choice | |
 #### I2P Instances
 | Website | Country | Language |
 |-|-|-|
 | [http://verneks7rfjptpz5fpii7n7nrxilsidi2qxepeuuf66c3tsf4nhq.b32.i2p](http://verneks7rfjptpz5fpii7n7nrxilsidi2qxepeuuf66c3tsf4nhq.b32.i2p) | 🇺🇸 US | English |
 ## Screenshots
 #### Desktop
--- a/app/init.py
+++ b/app/init.py
@ -18,8 +18,6 @@ import warnings
 from werkzeug.middleware.proxy_fix import ProxyFix
 from app.utils.misc import read_config_bool
 from app.services.http_client import HttpxClient
 from app.services.provider import close_all_clients
 from app.version import __version__
 app = Flask(__name__, static_folder=os.path.dirname(
@ -52,19 +50,24 @@ app.config['STATIC_FOLDER'] = os.getenv(
 app.config['BUILD_FOLDER'] = os.path.join(
    app.config['STATIC_FOLDER'], 'build')
 app.config['CACHE_BUSTING_MAP'] = {}
-app.config['BUNDLE_STATIC'] = read_config_bool('WHOOGLE_BUNDLE_STATIC')
+app.config['LANGUAGES'] = json.load(open(
-with open(os.path.join(app.config['STATIC_FOLDER'], 'settings/languages.json'), 'r', encoding='utf-8') as f:
+    os.path.join(app.config['STATIC_FOLDER'], 'settings/languages.json'),
-    app.config['LANGUAGES'] = json.load(f)
+    encoding='utf-8'))
-with open(os.path.join(app.config['STATIC_FOLDER'], 'settings/countries.json'), 'r', encoding='utf-8') as f:
+app.config['COUNTRIES'] = json.load(open(
-    app.config['COUNTRIES'] = json.load(f)
+    os.path.join(app.config['STATIC_FOLDER'], 'settings/countries.json'),
-with open(os.path.join(app.config['STATIC_FOLDER'], 'settings/time_periods.json'), 'r', encoding='utf-8') as f:
+    encoding='utf-8'))
-    app.config['TIME_PERIODS'] = json.load(f)
+app.config['TIME_PERIODS'] = json.load(open(
-with open(os.path.join(app.config['STATIC_FOLDER'], 'settings/translations.json'), 'r', encoding='utf-8') as f:
+    os.path.join(app.config['STATIC_FOLDER'], 'settings/time_periods.json'),
-    app.config['TRANSLATIONS'] = json.load(f)
+    encoding='utf-8'))
-with open(os.path.join(app.config['STATIC_FOLDER'], 'settings/themes.json'), 'r', encoding='utf-8') as f:
+app.config['TRANSLATIONS'] = json.load(open(
-    app.config['THEMES'] = json.load(f)
+    os.path.join(app.config['STATIC_FOLDER'], 'settings/translations.json'),
-with open(os.path.join(app.config['STATIC_FOLDER'], 'settings/header_tabs.json'), 'r', encoding='utf-8') as f:
+    encoding='utf-8'))
-    app.config['HEADER_TABS'] = json.load(f)
+app.config['THEMES'] = json.load(open(
    os.path.join(app.config['STATIC_FOLDER'], 'settings/themes.json'),
    encoding='utf-8'))
 app.config['HEADER_TABS'] = json.load(open(
    os.path.join(app.config['STATIC_FOLDER'], 'settings/header_tabs.json'),
    encoding='utf-8'))
 app.config['CONFIG_PATH'] = os.getenv(
    'CONFIG_VOLUME',
    os.path.join(app.config['STATIC_FOLDER'], 'config'))
@ -83,17 +86,6 @@ app.config['BANG_FILE'] = os.path.join(
    app.config['BANG_PATH'],
    'bangs.json')
 # Global services registry (simple DI)
 app.services = {}
@app.teardown_appcontext
 def _teardown_clients(exception):
    try:
        close_all_clients()
    except Exception:
        pass
 # Ensure all necessary directories exist
 if not os.path.exists(app.config['CONFIG_PATH']):
    os.makedirs(app.config['CONFIG_PATH'])
@ -111,14 +103,14 @@ if not os.path.exists(app.config['BUILD_FOLDER']):
 app_key_path = os.path.join(app.config['CONFIG_PATH'], 'whoogle.key')
 if os.path.exists(app_key_path):
    try:
-        with open(app_key_path, 'r', encoding='utf-8') as f:
+        app.config['SECRET_KEY'] = open(app_key_path, 'r').read()
            app.config['SECRET_KEY'] = f.read()
    except PermissionError:
        app.config['SECRET_KEY'] = str(b64encode(os.urandom(32)))
 else:
    app.config['SECRET_KEY'] = str(b64encode(os.urandom(32)))
-    with open(app_key_path, 'w', encoding='utf-8') as key_file:
+    with open(app_key_path, 'w') as key_file:
        key_file.write(app.config['SECRET_KEY'])
        key_file.close()
 app.config['PERMANENT_SESSION_LIFETIME'] = timedelta(days=365)
 # NOTE: SESSION_COOKIE_SAMESITE must be set to 'lax' to allow the user's
@ -154,8 +146,7 @@ app.config['CSP'] = 'default-src \'none\';' \
 generating_bangs = False
 if not os.path.exists(app.config['BANG_FILE']):
    generating_bangs = True
-    with open(app.config['BANG_FILE'], 'w', encoding='utf-8') as f:
+    json.dump({}, open(app.config['BANG_FILE'], 'w'))
        json.dump({}, f)
    bangs_thread = threading.Thread(
        target=gen_bangs_json,
        args=(app.config['BANG_FILE'],))
@ -183,58 +174,10 @@ for cb_dir in cache_busting_dirs:
            map_path = map_path[1:]
        app.config['CACHE_BUSTING_MAP'][cb_file] = map_path
 # Optionally create simple bundled assets (opt-in via WHOOGLE_BUNDLE_STATIC=1)
 if app.config['BUNDLE_STATIC']:
    # CSS bundle: include all css except theme files (end with -theme.css)
    css_dir = os.path.join(app.config['STATIC_FOLDER'], 'css')
    css_parts = []
    for name in sorted(os.listdir(css_dir)):
        if not name.endswith('.css'):
            continue
        if name.endswith('-theme.css'):
            continue
        try:
            with open(os.path.join(css_dir, name), 'r', encoding='utf-8') as f:
                css_parts.append(f.read())
        except Exception:
            pass
    css_bundle = '\n'.join(css_parts)
    if css_bundle:
        css_tmp = os.path.join(app.config['BUILD_FOLDER'], 'app.css')
        with open(css_tmp, 'w', encoding='utf-8') as f:
            f.write(css_bundle)
        css_hashed = gen_file_hash(app.config['BUILD_FOLDER'], 'app.css')
        os.replace(css_tmp, os.path.join(app.config['BUILD_FOLDER'], css_hashed))
        map_path = os.path.join('app/static/build', css_hashed)
        app.config['CACHE_BUSTING_MAP']['bundle.css'] = map_path
    # JS bundle: include all js files
    js_dir = os.path.join(app.config['STATIC_FOLDER'], 'js')
    js_parts = []
    for name in sorted(os.listdir(js_dir)):
        if not name.endswith('.js'):
            continue
        try:
            with open(os.path.join(js_dir, name), 'r', encoding='utf-8') as f:
                js_parts.append(f.read())
        except Exception:
            pass
    js_bundle = '\n;'.join(js_parts)
    if js_bundle:
        js_tmp = os.path.join(app.config['BUILD_FOLDER'], 'app.js')
        with open(js_tmp, 'w', encoding='utf-8') as f:
            f.write(js_bundle)
        js_hashed = gen_file_hash(app.config['BUILD_FOLDER'], 'app.js')
        os.replace(js_tmp, os.path.join(app.config['BUILD_FOLDER'], js_hashed))
        map_path = os.path.join('app/static/build', js_hashed)
        app.config['CACHE_BUSTING_MAP']['bundle.js'] = map_path
 # Templating functions
 app.jinja_env.globals.update(clean_query=clean_query)
 app.jinja_env.globals.update(
    cb_url=lambda f: app.config['CACHE_BUSTING_MAP'][f.lower()])
 app.jinja_env.globals.update(
    bundle_static=lambda: app.config.get('BUNDLE_STATIC', False))
 # Attempt to acquire tor identity, to determine if Tor config is available
 send_tor_signal(Signal.HEARTBEAT)
--- a/app/filter.py
+++ b/app/filter.py
@ -142,127 +142,6 @@ class Filter:
    def elements(self):
        return self._elements
    def convert_leta_to_whoogle(self, soup) -> BeautifulSoup:
        """Converts Leta search results HTML to Whoogle-compatible format
        Args:
            soup: BeautifulSoup object containing Leta results
        Returns:
            BeautifulSoup: Converted HTML in Whoogle format
        """
        # Find all Leta result articles
        articles = soup.find_all('article', class_='svelte-fmlk7p')
        if not articles:
            # No results found, return empty results page
            return soup
        # Create a new container for results with proper Whoogle CSS class
        main_div = BeautifulSoup(features='html.parser').new_tag('div', attrs={'id': 'main'})
        for article in articles:
            # Extract data from Leta article
            link_tag = article.find('a', href=True)
            if not link_tag:
                continue
            url = link_tag.get('href', '')
            title_tag = article.find('h3')
            title = title_tag.get_text(strip=True) if title_tag else ''
            snippet_tag = article.find('p', class_='result__body')
            snippet = snippet_tag.get_text(strip=True) if snippet_tag else ''
            cite_tag = article.find('cite')
            display_url = cite_tag.get_text(strip=True) if cite_tag else url
            # Create Whoogle-style result div with proper CSS class
            result_div = BeautifulSoup(features='html.parser').new_tag(
                'div', attrs={'class': [GClasses.result_class_a]}
            )
            result_outer = BeautifulSoup(features='html.parser').new_tag('div')
            # Create a div for the title link
            title_div = BeautifulSoup(features='html.parser').new_tag('div')
            result_link = BeautifulSoup(features='html.parser').new_tag('a', href=url)
            result_title = BeautifulSoup(features='html.parser').new_tag('h3')
            result_title.string = title
            result_link.append(result_title)
            title_div.append(result_link)
            # Create a div for the URL display with cite
            url_div = BeautifulSoup(features='html.parser').new_tag('div')
            result_cite = BeautifulSoup(features='html.parser').new_tag('cite')
            result_cite.string = display_url
            url_div.append(result_cite)
            # Create a div for snippet
            result_snippet = BeautifulSoup(features='html.parser').new_tag('div')
            snippet_span = BeautifulSoup(features='html.parser').new_tag('span')
            snippet_span.string = snippet
            result_snippet.append(snippet_span)
            # Assemble the result with proper structure
            result_outer.append(title_div)
            result_outer.append(url_div)
            result_outer.append(result_snippet)
            result_div.append(result_outer)
            main_div.append(result_div)
        # Find and preserve pagination elements from Leta
        navigation = soup.find('div', class_='navigation')
        if navigation:
            # Convert Leta's "Next" button to Whoogle-style pagination
            next_button = navigation.find('button', attrs={'data-cy': 'next-button'})
            if next_button:
                next_form = next_button.find_parent('form')
                if next_form:
                    # Extract the page number from hidden input
                    page_input = next_form.find('input', attrs={'name': 'page'})
                    if page_input:
                        next_page = page_input.get('value', '2')
                        # Create footer for pagination
                        footer = BeautifulSoup(features='html.parser').new_tag('footer')
                        nav_table = BeautifulSoup(features='html.parser').new_tag('table')
                        nav_tr = BeautifulSoup(features='html.parser').new_tag('tr')
                        nav_td = BeautifulSoup(features='html.parser').new_tag('td')
                        # Calculate start value for Whoogle pagination
                        start_val = (int(next_page) - 1) * 10
                        next_link = BeautifulSoup(features='html.parser').new_tag('a', href=f'search?q={self.query}&start={start_val}')
                        next_link.string = 'Next »'
                        nav_td.append(next_link)
                        nav_tr.append(nav_td)
                        nav_table.append(nav_tr)
                        footer.append(nav_table)
                        main_div.append(footer)
        # Clear the original soup body and add our converted results
        if soup.body:
            soup.body.clear()
            # Add inline style to body for proper width constraints
            if not soup.body.get('style'):
                soup.body['style'] = 'padding: 0 20px; margin: 0 auto; max-width: 1000px;'
            soup.body.append(main_div)
        else:
            # If no body, create one with proper styling
            new_body = BeautifulSoup(features='html.parser').new_tag(
                'body', 
                attrs={'style': 'padding: 0 20px; margin: 0 auto; max-width: 1000px;'}
            )
            new_body.append(main_div)
            if soup.html:
                soup.html.append(new_body)
            else:
                # Create minimal HTML structure
                html_tag = BeautifulSoup(features='html.parser').new_tag('html')
                html_tag.append(new_body)
                soup.append(html_tag)
        return soup
    def encrypt_path(self, path, is_element=False) -> str:
        # Encrypts path to avoid plaintext results in logs
        if is_element:
@ -276,11 +155,6 @@ class Filter:
    def clean(self, soup) -> BeautifulSoup:
        self.soup = soup
        # Check if this is a Leta result page and convert it
        if self.config.use_leta and self.soup.find('article', class_='svelte-fmlk7p'):
            self.soup = self.convert_leta_to_whoogle(self.soup)
        self.main_divs = self.soup.find('div', {'id': 'main'})
        self.remove_ads()
        self.remove_block_titles()
@ -345,7 +219,7 @@ class Filter:
            return
        for d in div.find_all('div', recursive=True):
-            d_text = d.find(string=True, recursive=False)
+            d_text = d.find(text=True, recursive=False)
            # Ensure we're working with tags that contain text content
            if not d_text or not d.string:
@ -421,7 +295,7 @@ class Filter:
            return
        search_string = ' '.join(['-site:' +
                                 _ for _ in self.config.block.split(',')])
-        selected = soup.body.find_all(string=re.compile(search_string))
+        selected = soup.body.findAll(text=re.compile(search_string))
        for result in selected:
            result.string.replace_with(result.string.replace(
@ -488,11 +362,11 @@ class Filter:
        def pull_child_divs(result_div: BeautifulSoup):
            try:
-                top_level_divs = result_div.find_all('div', recursive=False)
+                return result_div.findChildren(
-                if not top_level_divs:
+                    'div', recursive=False
-                    return []
+                )[0].findChildren(
-                return top_level_divs[0].find_all('div', recursive=False)
+                    'div', recursive=False)
-            except Exception:
+            except IndexError:
                return []
        if not self.main_divs:
@ -775,94 +649,50 @@ class Filter:
        """Replaces link locations and page elements if "alts" config
        is enabled
        """
-        # Precompute regex for sites (escape dots) and common prefixes
+        for site, alt in SITE_ALTS.items():
-        site_keys = list(SITE_ALTS.keys())
+            if site != "medium.com" and alt != "":
-        if not site_keys:
+                # Ignore medium.com replacements since these are handled
-            return
+                # specifically in the link description replacement, and medium
-        sites_pattern = re.compile('|'.join([re.escape(k) for k in site_keys]))
+                # results are never given their own "card" result where this
-        prefix_pattern = re.compile(r'^(?:https?:\/\/)?(?:(?:www|mobile|m)\.)?')
+                # replacement would make sense.
-
+                # Also ignore if the alt is empty, since this is used to indicate
-        # 1) Replace bare domain divs (single token) once, avoiding duplicates
+                # that the alt is not enabled.
-        for div in self.soup.find_all('div', string=sites_pattern):
+                for div in self.soup.find_all('div', text=re.compile(site)):
-            if not div or not div.string:
+                    # Use the number of words in the div string to determine if the
-                continue
+                    # string is a result description (shouldn't replace domains used
-            if len(div.string.split(' ')) != 1:
+                    # in desc text).
-                continue
+                    if len(div.string.split(' ')) == 1:
            match = sites_pattern.search(div.string)
            if not match:
                continue
            site = match.group(0)
            alt = SITE_ALTS.get(site, '')
            if not alt:
                continue
            # Skip if already contains the alt to avoid old.old.* repetition
            if alt in div.string:
                continue
                        div.string = div.string.replace(site, alt)
        # 2) Update link hrefs and descriptions in a single pass
            for link in self.soup.find_all('a', href=True):
                # Search and replace all link descriptions
                # with alternative location
                link['href'] = get_site_alt(link['href'])
-
+                link_desc = link.find_all(
-            # Find a description text node matching a known site
+                    text=re.compile('|'.join(SITE_ALTS.keys())))
-            desc_nodes = link.find_all(string=sites_pattern)
+                if len(link_desc) == 0:
            if not desc_nodes:
                continue
            desc_node = desc_nodes[0]
            link_str = str(desc_node)
            # Determine which site key is present in the description
            site_match = sites_pattern.search(link_str)
            if not site_match:
                continue
            site = site_match.group(0)
            alt = SITE_ALTS.get(site, '')
            if not alt:
                    continue
-            # Avoid duplication if alt already present
+                # Replace link description
-            if alt in link_str:
+                link_desc = link_desc[0]
                if site not in link_desc or not alt:
                    continue
            # Medium-specific handling remains to avoid matching substrings
            if 'medium.com' in link_str:
                if link_str.startswith('medium.com') or '.medium.com' in link_str:
                    replaced = SITE_ALTS['medium.com'] + link_str[
                        link_str.find('medium.com') + len('medium.com'):
                    ]
                else:
                    replaced = link_str
            else:
                # If the description looks like a URL with scheme, replace only the host
                if '://' in link_str:
                    scheme, rest = link_str.split('://', 1)
                    host, sep, path = rest.partition('/')
                    # Drop common prefixes from host when swapping to a fully-qualified alt
                    alt_parsed = urlparse.urlparse(alt)
                    alt_host = alt_parsed.netloc if alt_parsed.netloc else alt.replace('https://', '').replace('http://', '')
                    # If alt includes a scheme, prefer its host; otherwise use alt as host
                    if alt_parsed.scheme:
                        new_host = alt_host
                    else:
                        # When alt has no scheme, still replace entire host
                        new_host = alt
                    # Prevent replacing if host already equals target
                    if host == new_host:
                        replaced = link_str
                    else:
                        replaced = f"{scheme}://{new_host}{sep}{path}"
                else:
                    # No scheme in the text; include optional prefixes in replacement
                    # Replace any leading www./m./mobile. + site with alt host (no scheme)
                    alt_parsed = urlparse.urlparse(alt)
                    alt_host = alt_parsed.netloc if alt_parsed.netloc else alt.replace('https://', '').replace('http://', '')
                    # Build a pattern that includes optional prefixes for the specific site
                    site_with_prefix = re.compile(rf'(?:(?:www|mobile|m)\.)?{re.escape(site)}')
                    replaced = site_with_prefix.sub(alt_host, link_str, count=1)
                new_desc = BeautifulSoup(features='html.parser').new_tag('div')
-            new_desc.string = replaced
+                link_str = str(link_desc)
-            desc_node.replace_with(new_desc)
+
                # Medium links should be handled differently, since 'medium.com'
                # is a common substring of domain names, but shouldn't be
                # replaced (i.e. 'philomedium.com' should stay as it is).
                if 'medium.com' in link_str:
                    if link_str.startswith('medium.com') or '.medium.com' in link_str:
                        link_str = SITE_ALTS['medium.com'] + link_str[
                            link_str.find('medium.com') + len('medium.com'):]
                    new_desc.string = link_str
                else:
                    new_desc.string = link_str.replace(site, alt)
                link_desc.replace_with(new_desc)
    def view_image(self, soup) -> BeautifulSoup:
        """Replaces the soup with a new one that handles mobile results and
--- a/app/models/config.py
+++ b/app/models/config.py
@ -37,12 +37,8 @@ def get_rule_for_selector(stylesheet: CSSStyleSheet,
 class Config:
    def __init__(self, **kwargs):
-        # User agent configuration - default to env_conf if environment variables exist, otherwise default
+        # User agent configuration
-        env_user_agent = os.getenv('WHOOGLE_USER_AGENT', '')
+        self.user_agent = kwargs.get('user_agent', 'LYNX_UA')
        env_mobile_agent = os.getenv('WHOOGLE_USER_AGENT_MOBILE', '')
        default_ua_option = 'env_conf' if (env_user_agent or env_mobile_agent) else 'default'
        self.user_agent = kwargs.get('user_agent', default_ua_option)
        self.custom_user_agent = kwargs.get('custom_user_agent', '')
        self.use_custom_user_agent = kwargs.get('use_custom_user_agent', False)
@ -63,8 +59,7 @@ class Config:
            'tbs',
            'user_agent',
            'custom_user_agent',
-            'use_custom_user_agent',
+            'use_custom_user_agent'
            'use_leta'
        ]
        app_config = current_app.config
@ -91,7 +86,6 @@ class Config:
        self.anon_view = read_config_bool('WHOOGLE_CONFIG_ANON_VIEW')
        self.preferences_encrypted = read_config_bool('WHOOGLE_CONFIG_PREFERENCES_ENCRYPTED')
        self.preferences_key = os.getenv('WHOOGLE_CONFIG_PREFERENCES_KEY', '')
        self.use_leta = read_config_bool('WHOOGLE_CONFIG_USE_LETA', default=True)
        self.accept_language = False
@ -102,9 +96,6 @@ class Config:
                if attr in kwargs.keys():
                    setattr(self, attr, kwargs[attr])
                elif attr not in kwargs.keys() and mutable_attrs[attr] == bool:
                    # Only set to False if the attribute wasn't already set to True
                    # by environment defaults (e.g., use_leta defaults to True)
                    if not getattr(self, attr, False):
                    setattr(self, attr, False)
    def __getitem__(self, name):
@ -136,9 +127,10 @@ class Config:
        Returns:
            str -- the new style
        """
-        vars_path = os.path.join(current_app.config['STATIC_FOLDER'], 'css/variables.css')
+        style_sheet = cssutils.parseString(
-        with open(vars_path, 'r', encoding='utf-8') as f:
+            open(os.path.join(current_app.config['STATIC_FOLDER'],
-            style_sheet = cssutils.parseString(f.read())
+                              'css/variables.css')).read()
        )
        modified_sheet = cssutils.parseString(self.style_modified)
        for rule in modified_sheet:
--- a/app/request.py
+++ b/app/request.py
@ -1,10 +1,10 @@
 from app.models.config import Config
 from app.utils.misc import read_config_bool
 from app.services.provider import get_http_client
 from datetime import datetime
 from defusedxml import ElementTree as ET
 import random
-import httpx
+import requests
 from requests import Response, ConnectionError
 import urllib.parse as urlparse
 import os
 from stem import Signal, SocketError
@ -73,31 +73,18 @@ def send_tor_signal(signal: Signal) -> bool:
 def gen_user_agent(config, is_mobile) -> str:
-    # Define the default PlayStation Portable user agent (replaces Lynx)
+    # Define the Lynx user agent
-    DEFAULT_UA = 'Mozilla/4.0 (PSP (PlayStation Portable); 2.00)'
+    LYNX_UA = 'Lynx/2.9.2 libwww-FM/2.14 SSL-MM/1.4.1 OpenSSL/3.4.0'
    # If using custom user agent, return the custom string
    if config.user_agent == 'custom' and config.custom_user_agent:
        return config.custom_user_agent
-    # If using environment configuration
+    # If using Lynx user agent
-    if config.user_agent == 'env_conf':
+    if config.user_agent == 'LYNX_UA':
-        if is_mobile:
+        return LYNX_UA
            env_ua = os.getenv('WHOOGLE_USER_AGENT_MOBILE', '')
            if env_ua:
                return env_ua
        else:
            env_ua = os.getenv('WHOOGLE_USER_AGENT', '')
            if env_ua:
                return env_ua
        # If env vars are not set, fall back to default
        return DEFAULT_UA
-    # If using default user agent
+    # If no custom user agent is set, generate a random one
    if config.user_agent == 'default':
        return DEFAULT_UA
    # If no custom user agent is set, generate a random one (for backwards compatibility)
    firefox = random.choice(['Choir', 'Squier', 'Higher', 'Wire']) + 'fox'
    linux = random.choice(['Win', 'Sin', 'Gin', 'Fin', 'Kin']) + 'ux'
@ -107,75 +94,7 @@ def gen_user_agent(config, is_mobile) -> str:
    return DESKTOP_UA.format("Mozilla", linux, firefox)
 def gen_query_leta(query, args, config) -> str:
    """Builds a query string for Mullvad Leta backend
    Args:
        query: The search query string
        args: Request arguments
        config: User configuration
    Returns:
        str: A formatted query string for Leta
    """
    # Ensure search query is parsable
    query = urlparse.quote(query)
    # Build query starting with 'q='
    query_str = 'q=' + query
    # Always use Google as the engine (Leta supports 'google' or 'brave')
    query_str += '&engine=google'
    # Add country if configured
    if config.country:
        query_str += '&country=' + config.country.lower()
    # Add language if configured
    # Convert from Google's lang format (lang_en) to Leta's format (en)
    if config.lang_search:
        lang_code = config.lang_search.replace('lang_', '')
        query_str += '&language=' + lang_code
    # Handle time period filtering with :past syntax or tbs parameter
    if ':past' in query:
        time_range = str.strip(query.split(':past', 1)[-1]).lower()
        if time_range.startswith('day'):
            query_str += '&lastUpdated=d'
        elif time_range.startswith('week'):
            query_str += '&lastUpdated=w'
        elif time_range.startswith('month'):
            query_str += '&lastUpdated=m'
        elif time_range.startswith('year'):
            query_str += '&lastUpdated=y'
    elif 'tbs' in args or 'tbs' in config:
        result_tbs = args.get('tbs') if 'tbs' in args else config.tbs
        # Convert Google's tbs format to Leta's lastUpdated format
        if result_tbs and 'qdr:d' in result_tbs:
            query_str += '&lastUpdated=d'
        elif result_tbs and 'qdr:w' in result_tbs:
            query_str += '&lastUpdated=w'
        elif result_tbs and 'qdr:m' in result_tbs:
            query_str += '&lastUpdated=m'
        elif result_tbs and 'qdr:y' in result_tbs:
            query_str += '&lastUpdated=y'
    # Add pagination if present
    if 'start' in args:
        start = int(args.get('start', '0'))
        # Leta uses 1-indexed pages, Google uses result offset
        page = (start // 10) + 1
        if page > 1:
            query_str += '&page=' + str(page)
    return query_str
 def gen_query(query, args, config) -> str:
    # If using Leta backend, build query differently
    if config.use_leta:
        return gen_query_leta(query, args, config)
    param_dict = {key: '' for key in VALID_PARAMS}
    # Use :past(hour/day/week/month/year) if available
@ -270,19 +189,11 @@ class Request:
        config: the user's current whoogle configuration
    """
-    def __init__(self, normal_ua, root_path, config: Config, http_client=None):
+    def __init__(self, normal_ua, root_path, config: Config):
        # Use Leta backend if configured, otherwise use Google
        if config.use_leta:
            self.search_url = 'https://leta.mullvad.net/search?'
            self.use_leta = True
        else:
        self.search_url = 'https://www.google.com/search?gbv=1&num=' + str(
-                os.getenv('WHOOGLE_RESULTS_PER_PAGE', 10)) + '&'
+            os.getenv('WHOOGLE_RESULTS_PER_PAGE', 10)) + '&q='
-            self.use_leta = False
+        # Send heartbeat to Tor, used in determining if the user can or cannot
-        
+        # enable Tor for future requests
        # Optionally send heartbeat to Tor to determine availability
        # Only when Tor is enabled in config to avoid unnecessary socket usage
        if config.tor:
        send_tor_signal(Signal.HEARTBEAT)
        self.language = config.lang_search if config.lang_search else ''
@ -325,8 +236,6 @@ class Request:
        self.tor = config.tor
        self.tor_valid = False
        self.root_path = root_path
        # Initialize HTTP client (shared per proxies)
        self.http_client = http_client or get_http_client(self.proxies)
    def __getitem__(self, name):
        return getattr(self, name)
@ -341,11 +250,6 @@ class Request:
            list: The list of matches for possible search suggestions
        """
        # Check if autocomplete is disabled via environment variable
        if os.environ.get('WHOOGLE_AUTOCOMPLETE', '1') == '0':
            return []
        try:
        ac_query = dict(q=query)
        if self.language:
            ac_query['lr'] = self.language
@ -367,13 +271,9 @@ class Request:
        except ET.ParseError:
            # Malformed XML response
            return []
        except Exception as e:
            # Log the error but don't crash - autocomplete is non-essential
            print(f"Autocomplete error: {str(e)}")
            return []
    def send(self, base_url='', query='', attempt=0,
-             force_mobile=False, user_agent=''):
+             force_mobile=False, user_agent='') -> Response:
        """Sends an outbound request to a URL. Optionally sends the request
        using Tor, if enabled by the user.
@ -410,12 +310,10 @@ class Request:
        # view is suppressed correctly
        now = datetime.now()
-        consent_cookie = 'CONSENT=PENDING+987; SOCS=CAESHAgBEhIaAB'
+        cookies = {
-        # Prefer header-based cookies to avoid httpx per-request cookies deprecation
+            'CONSENT': 'PENDING+987',
-        if 'Cookie' in headers:
+            'SOCS': 'CAESHAgBEhIaAB',
-            headers['Cookie'] += '; ' + consent_cookie
+        }
        else:
            headers['Cookie'] = consent_cookie
        # Validate Tor conn and request new identity if the last one failed
        if self.tor and not send_tor_signal(
@ -428,9 +326,8 @@ class Request:
        # Make sure that the tor connection is valid, if enabled
        if self.tor:
            try:
-                tor_check = self.http_client.get('https://check.torproject.org/',
+                tor_check = requests.get('https://check.torproject.org/',
-                                                 headers=headers,
+                                         proxies=self.proxies, headers=headers)
                                                 retries=1)
                self.tor_valid = 'Congratulations' in tor_check.text
                if not self.tor_valid:
@ -438,17 +335,16 @@ class Request:
                        "Tor connection succeeded, but the connection could "
                        "not be validated by torproject.org",
                        disable=True)
-            except httpx.RequestError:
+            except ConnectionError:
                raise TorError(
                    "Error raised during Tor connection validation",
                    disable=True)
-        try:
+        response = requests.get(
            response = self.http_client.get(
            (base_url or self.search_url) + query,
-                headers=headers)
+            proxies=self.proxies,
-        except httpx.HTTPError as e:
+            headers=headers,
-            raise
+            cookies=cookies)
        # Retry query with new identity if using Tor (max 10 attempts)
        if 'form id="captcha-form"' in response.text and self.tor:
--- a/app/routes.py
+++ b/app/routes.py
@ -32,7 +32,8 @@ from app.utils.session import valid_user_session
 from bs4 import BeautifulSoup as bsoup
 from flask import jsonify, make_response, request, redirect, render_template, \
    send_file, session, url_for, g
-import httpx
+from requests import exceptions
 from requests.models import PreparedRequest
 from cryptography.fernet import Fernet, InvalidToken
 from cryptography.exceptions import InvalidSignature
 from werkzeug.datastructures import MultiDict
@ -165,8 +166,7 @@ def before_request_func():
    g.user_request = Request(
        request.headers.get('User-Agent'),
        get_request_url(request.url_root),
-        config=g.user_config
+        config=g.user_config)
    )
    g.app_location = g.user_config.url
@ -283,43 +283,11 @@ def autocomplete():
    #
    # Note: If Tor is enabled, this returns nothing, as the request is
    # almost always rejected
    # Also check if autocomplete is disabled globally
    autocomplete_enabled = os.environ.get('WHOOGLE_AUTOCOMPLETE', '1') != '0'
    return jsonify([
        q,
-        g.user_request.autocomplete(q) if (not g.user_config.tor and autocomplete_enabled) else []
+        g.user_request.autocomplete(q) if not g.user_config.tor else []
    ])
 def clean_text_spacing(text: str) -> str:
    """Clean up text spacing issues from HTML extraction.
    Args:
        text: Text extracted from HTML that may have spacing issues
    Returns:
        Cleaned text with proper spacing
    """
    if not text:
        return text
    # Normalize multiple spaces to single space
    text = re.sub(r'\s+', ' ', text)
    # Fix domain names: remove space before period followed by domain extension
    # Examples: "weather .com" -> "weather.com", "example .org" -> "example.org"
    text = re.sub(r'\s+\.([a-zA-Z]{2,})\b', r'.\1', text)
    # Fix www/http/https patterns
    # Examples: "www .example" -> "www.example"
    text = re.sub(r'\b(www|http|https)\s+\.', r'\1.', text)
    # Fix spaces before common punctuation
    text = re.sub(r'\s+([,;:])', r'\1', text)
    # Strip leading/trailing whitespace
    return text.strip()
@app.route(f'/{Endpoint.search}', methods=['GET', 'POST'])
@session_required
@auth_required
@ -331,7 +299,7 @@ def search():
        get_req_str = urlparse.urlencode(post_data)
        return redirect(url_for('.search') + '?' + get_req_str)
-    search_util = Search(request, g.user_config, g.session_key, user_request=g.user_request)
+    search_util = Search(request, g.user_config, g.session_key)
    query = search_util.new_search_query()
    bang = resolve_bang(query)
@ -342,16 +310,6 @@ def search():
    if not query:
        return redirect(url_for('.index'))
    # Check if using Leta with unsupported search type
    tbm_value = request.args.get('tbm', '').strip()
    if g.user_config.use_leta and tbm_value:
        session['error_message'] = (
            "Image, video, news, and map searches are not supported when using "
            "Mullvad Leta as the search backend. Please disable Leta in settings "
            "or perform a regular web search."
        )
        return redirect(url_for('.index'))
    # Generate response and number of external elements from the page
    try:
        response = search_util.generate_response()
@ -362,15 +320,7 @@ def search():
            'tor']
        return redirect(url_for('.index'))
    wants_json = (
        request.args.get('format') == 'json' or
        'application/json' in request.headers.get('Accept', '') or
        'application/*+json' in request.headers.get('Accept', '')
    )
    if search_util.feeling_lucky:
        if wants_json:
            return jsonify({'redirect': response}), 303
        return redirect(response, code=303)
    # If the user is attempting to translate a string, determine the correct
@ -391,17 +341,8 @@ def search():
        app.logger.error('503 (CAPTCHA)')
        fallback_engine = os.environ.get('WHOOGLE_FALLBACK_ENGINE_URL', '')
        if (fallback_engine):
            if wants_json:
                return jsonify({'redirect': fallback_engine + query}), 302
            return redirect(fallback_engine + query)
        if wants_json:
            return jsonify({
                'blocked': True,
                'error_message': translation['ratelimit'],
                'query': urlparse.unquote(query)
            }), 503
        else:
        return render_template(
            'error.html',
            blocked=True,
@ -422,14 +363,12 @@ def search():
        elif search_util.widget == 'calculator' and not 'nojs' in request.args:
            response = add_calculator_card(html_soup)
-    # Update tabs content (fallback to the raw query if full_query isn't set)
+    # Update tabs content
    full_query_val = getattr(search_util, 'full_query', query)
    tabs = get_tabs_content(app.config['HEADER_TABS'],
-                            full_query_val,
+                            search_util.full_query,
                            search_util.search_type,
                            g.user_config.preferences,
-                            translation,
+                            translation)
                            g.user_config.use_leta)
    # Feature to display currency_card
    # Since this is determined by more than just the
@ -443,118 +382,6 @@ def search():
    home_url = f"home?preferences={preferences}" if preferences else "home"
    cleanresponse = str(response).replace("andlt;","&lt;").replace("andgt;","&gt;")
    if wants_json:
        # Build a parsable JSON from the filtered soup
        json_soup = bsoup(str(response), 'html.parser')
        results = []
        seen = set()
        # Find all result containers (using known result classes)
        result_divs = json_soup.find_all('div', class_=['ZINbbc', 'ezO2md'])
        if result_divs:
            # Process structured Google results with container divs
            for div in result_divs:
                # Find the first valid link in this result container
                link = None
                for a in div.find_all('a', href=True):
                    if a['href'].startswith('http'):
                        link = a
                        break
                if not link:
                    continue
                href = link['href']
                if href in seen:
                    continue
                # Get all text from the result container, not just the link
                text = clean_text_spacing(div.get_text(separator=' ', strip=True))
                if not text:
                    continue
                # Extract title and content separately
                # Title is typically in an h3 tag, CVA68e span, or the main link text
                title = ''
                # First try h3 tag
                h3_tag = div.find('h3')
                if h3_tag:
                    title = clean_text_spacing(h3_tag.get_text(separator=' ', strip=True))
                else:
                    # Try CVA68e class (common title class in Google results)
                    title_span = div.find('span', class_='CVA68e')
                    if title_span:
                        title = clean_text_spacing(title_span.get_text(separator=' ', strip=True))
                    elif link:
                        # Fallback to link text, but exclude URL breadcrumb
                        title = clean_text_spacing(link.get_text(separator=' ', strip=True))
                # Content is the description/snippet text
                # Look for description/snippet elements
                content = ''
                # Common classes for snippets/descriptions in Google results
                snippet_selectors = [
                    {'class_': 'VwiC3b'},   # Standard snippet
                    {'class_': 'FrIlee'},   # Alternative snippet class (common in current Google)
                    {'class_': 's'},        # Another snippet class
                    {'class_': 'st'},       # Legacy snippet class
                ]
                for selector in snippet_selectors:
                    snippet_elem = div.find('span', selector) or div.find('div', selector)
                    if snippet_elem:
                        # Get text but exclude any nested links (like "Related searches")
                        content = clean_text_spacing(snippet_elem.get_text(separator=' ', strip=True))
                        # Only use if it's substantial content (not just the URL breadcrumb)
                        if content and not content.startswith('www.') and '›' not in content:
                            break
                        else:
                            content = ''
                # If no specific content found, use text minus title as fallback
                if not content and title:
                    # Try to extract content by removing title from full text
                    if text.startswith(title):
                        content = text[len(title):].strip()
                    else:
                        content = text
                elif not content:
                    content = text
                seen.add(href)
                results.append({
                    'href': href,
                    'text': text,
                    'title': title,
                    'content': content
                })
        else:
            # Fallback: extract links directly if no result containers found
            for a in json_soup.find_all('a', href=True):
                href = a['href']
                if not href.startswith('http'):
                    continue
                if href in seen:
                    continue
                text = clean_text_spacing(a.get_text(separator=' ', strip=True))
                if not text:
                    continue
                seen.add(href)
                # In fallback mode, the link text serves as both title and text
                results.append({
                    'href': href,
                    'text': text,
                    'title': text,
                    'content': ''
                })
        return jsonify({
            'query': urlparse.unquote(query),
            'search_type': search_util.search_type,
            'results': results
        })
    return render_template(
        'display.html',
        has_update=app.config['HAS_UPDATE'],
@ -631,8 +458,6 @@ def config():
                    print(f"Setting custom user agent to: {config_data['custom_user_agent']}")  # Debug log
            else:
                config_data['use_custom_user_agent'] = False
                # Only clear custom_user_agent if not using custom option
                if config_data['user_agent'] != 'custom':
                config_data['custom_user_agent'] = ''
        # Save config by name to allow a user to easily load later
@ -694,7 +519,7 @@ def element():
        tmp_mem.seek(0)
        return send_file(tmp_mem, mimetype=src_type)
-    except httpx.HTTPError:
+    except exceptions.RequestException:
        pass
    return send_file(io.BytesIO(empty_gif), mimetype='image/gif')
@ -812,7 +637,7 @@ def internal_error(e):
    fallback_engine = os.environ.get('WHOOGLE_FALLBACK_ENGINE_URL', '')
    if (fallback_engine):
-        return redirect(fallback_engine + (query or ''))
+        return redirect(fallback_engine + query)
    localization_lang = g.user_config.get_localization_lang()
    translation = app.config['TRANSLATIONS'][localization_lang]
@ -822,7 +647,7 @@ def internal_error(e):
            translation=translation,
            farside='https://farside.link',
            config=g.user_config,
-            query=urlparse.unquote(query or ''),
+            query=urlparse.unquote(query),
            params=g.user_config.to_params(keys=['preferences'])), 500
--- a/app/services/init.py
+++ b/app/services/init.py
@ -1,2 +0,0 @@
--- a/app/services/http_client.py
+++ b/app/services/http_client.py
@ -1,219 +0,0 @@
 import threading
 import time
 from typing import Any, Dict, Optional, Tuple
 import httpx
 from cachetools import TTLCache
 import ssl
 import os
 # Import h2 exceptions for better error handling
 try:
    from h2.exceptions import ProtocolError as H2ProtocolError
 except ImportError:
    H2ProtocolError = None
 class HttpxClient:
    """Thin wrapper around httpx.Client providing simple retries and optional TTL caching.
    The client is intended to be safe for reuse across requests. Per-request
    overrides for headers/cookies are supported.
    """
    def __init__(
            self,
            proxies: Optional[Dict[str, str]] = None,
            timeout_seconds: float = 15.0,
            cache_ttl_seconds: int = 30,
            cache_maxsize: int = 256,
            http2: bool = True) -> None:
        # Allow disabling HTTP/2 via environment variable
        # HTTP/2 can sometimes cause protocol errors with certain servers
        if os.environ.get('WHOOGLE_DISABLE_HTTP2', '').lower() in ('1', 'true', 't', 'yes', 'y'):
            http2 = False
        client_kwargs = dict(http2=http2,
                             timeout=timeout_seconds,
                             follow_redirects=True)
        # Prefer future-proof mounts when proxies are provided; fall back to proxies=
        self._proxies = proxies or {}
        self._http2 = http2
        # Determine verify behavior and initialize client with fallbacks
        self._verify = self._determine_verify_setting()
        try:
            self._client = self._build_client(client_kwargs, self._verify)
        except ssl.SSLError:
            # Fallback to system trust store
            try:
                system_ctx = ssl.create_default_context()
                self._client = self._build_client(client_kwargs, system_ctx)
                self._verify = system_ctx
            except ssl.SSLError:
                insecure_fallback = os.environ.get('WHOOGLE_INSECURE_FALLBACK', '0').lower() in ('1', 'true', 't', 'yes', 'y')
                if insecure_fallback:
                    self._client = self._build_client(client_kwargs, False)
                    self._verify = False
                else:
                    raise
        self._timeout_seconds = timeout_seconds
        self._cache = TTLCache(maxsize=cache_maxsize, ttl=cache_ttl_seconds)
        self._cache_lock = threading.Lock()
    def _determine_verify_setting(self):
        """Determine SSL verification setting from environment.
        Honors:
        - WHOOGLE_CA_BUNDLE: path to CA bundle file
        - WHOOGLE_SSL_VERIFY: '0' to disable verification
        - WHOOGLE_SSL_BACKEND: 'system' to prefer system trust store
        """
        ca_bundle = os.environ.get('WHOOGLE_CA_BUNDLE', '').strip()
        if ca_bundle:
            return ca_bundle
        verify_env = os.environ.get('WHOOGLE_SSL_VERIFY', '1').lower()
        if verify_env in ('0', 'false', 'no', 'n'):
            return False
        backend = os.environ.get('WHOOGLE_SSL_BACKEND', '').lower()
        if backend == 'system':
            return ssl.create_default_context()
        return True
    def _build_client(self, client_kwargs: Dict[str, Any], verify: Any) -> httpx.Client:
        """Construct httpx.Client with proxies and provided verify setting."""
        kwargs = dict(client_kwargs)
        kwargs['verify'] = verify
        if self._proxies:
            proxy_values = list(self._proxies.values())
            single_proxy = proxy_values[0] if proxy_values and all(v == proxy_values[0] for v in proxy_values) else None
            if single_proxy:
                try:
                    return httpx.Client(proxy=single_proxy, **kwargs)
                except TypeError:
                    try:
                        return httpx.Client(proxies=self._proxies, **kwargs)
                    except TypeError:
                        mounts: Dict[str, httpx.Proxy] = {}
                        for scheme_key, url in self._proxies.items():
                            prefix = f"{scheme_key}://"
                            mounts[prefix] = httpx.Proxy(url)
                        return httpx.Client(mounts=mounts, **kwargs)
            else:
                try:
                    return httpx.Client(proxies=self._proxies, **kwargs)
                except TypeError:
                    mounts: Dict[str, httpx.Proxy] = {}
                    for scheme_key, url in self._proxies.items():
                        prefix = f"{scheme_key}://"
                        mounts[prefix] = httpx.Proxy(url)
                    return httpx.Client(mounts=mounts, **kwargs)
        else:
            return httpx.Client(**kwargs)
    @property
    def proxies(self) -> Dict[str, str]:
        return self._proxies
    def _cache_key(self, method: str, url: str, headers: Optional[Dict[str, str]]) -> Tuple[str, str, Tuple[Tuple[str, str], ...]]:
        normalized_headers = tuple(sorted((headers or {}).items()))
        return (method.upper(), url, normalized_headers)
    def get(self,
            url: str,
            headers: Optional[Dict[str, str]] = None,
            cookies: Optional[Dict[str, str]] = None,
            retries: int = 2,
            backoff_seconds: float = 0.5,
            use_cache: bool = False) -> httpx.Response:
        if use_cache:
            key = self._cache_key('GET', url, headers)
            with self._cache_lock:
                cached = self._cache.get(key)
            if cached is not None:
                return cached
        last_exc: Optional[Exception] = None
        attempt = 0
        while attempt <= retries:
            try:
                # Check if client is closed and recreate if needed
                if self._client.is_closed:
                    self._recreate_client()
                response = self._client.get(url, headers=headers, cookies=cookies)
                if use_cache and response.status_code == 200:
                    with self._cache_lock:
                        self._cache[key] = response
                return response
            except Exception as exc:
                last_exc = exc
                # Check for specific errors that require client recreation
                should_recreate = False
                if isinstance(exc, (httpx.HTTPError, RuntimeError)):
                    if "client has been closed" in str(exc).lower():
                        should_recreate = True
                # Handle H2 protocol errors (connection state issues)
                if H2ProtocolError and isinstance(exc, H2ProtocolError):
                    should_recreate = True
                # Also check if the error message contains h2 protocol error info
                if "ProtocolError" in str(exc) or "ConnectionState.CLOSED" in str(exc):
                    should_recreate = True
                if should_recreate:
                    self._recreate_client()
                    if attempt < retries:
                        time.sleep(backoff_seconds * (2 ** attempt))
                        attempt += 1
                        continue
                # For non-recoverable errors or last attempt, raise
                if attempt == retries:
                    raise
                # For other errors, still retry with backoff
                time.sleep(backoff_seconds * (2 ** attempt))
                attempt += 1
        # Should not reach here
        if last_exc:
            raise last_exc
        raise httpx.HTTPError('Unknown HTTP error')
    def _recreate_client(self) -> None:
        """Recreate the HTTP client when it has been closed."""
        try:
            self._client.close()
        except Exception:
            pass  # Client might already be closed
        # Recreate with same configuration
        client_kwargs = dict(timeout=self._timeout_seconds,
                             follow_redirects=True,
                             http2=self._http2)
        try:
            self._client = self._build_client(client_kwargs, self._verify)
        except ssl.SSLError:
            try:
                system_ctx = ssl.create_default_context()
                self._client = self._build_client(client_kwargs, system_ctx)
                self._verify = system_ctx
            except ssl.SSLError:
                insecure_fallback = os.environ.get('WHOOGLE_INSECURE_FALLBACK', '0').lower() in ('1', 'true', 't', 'yes', 'y')
                if insecure_fallback:
                    self._client = self._build_client(client_kwargs, False)
                    self._verify = False
                else:
                    raise
    def close(self) -> None:
        self._client.close()
--- a/app/services/provider.py
+++ b/app/services/provider.py
@ -1,40 +0,0 @@
 import os
 from typing import Dict, Tuple
 from app.services.http_client import HttpxClient
 _clients: Dict[tuple, HttpxClient] = {}
 def _proxies_key(proxies: Dict[str, str]) -> Tuple[Tuple[str, str], Tuple[str, str]]:
    if not proxies:
        return tuple(), tuple()
    # Separate http/https for stable key
    items = sorted((proxies or {}).items())
    return tuple(items), tuple(items)
 def get_http_client(proxies: Dict[str, str]) -> HttpxClient:
    # Determine HTTP/2 enablement from env (default on)
    http2_env = os.environ.get('WHOOGLE_HTTP2', '1').lower()
    http2_enabled = http2_env in ('1', 'true', 't', 'yes', 'y')
    key = (_proxies_key(proxies or {}), http2_enabled)
    client = _clients.get(key)
    if client is not None:
        return client
    client = HttpxClient(proxies=proxies or None, http2=http2_enabled)
    _clients[key] = client
    return client
 def close_all_clients() -> None:
    for client in list(_clients.values()):
        try:
            client.close()
        except Exception:
            pass
    _clients.clear()
--- a/app/static/js/controller.js
+++ b/app/static/js/controller.js
@ -34,20 +34,6 @@ const setupConfigLayout = () => {
        content.classList.toggle("open");
    });
    // Setup user agent dropdown handler
    const userAgentSelect = document.getElementById("config-user-agent");
    const customUserAgentDiv = document.querySelector(".config-div-custom-user-agent");
    if (userAgentSelect && customUserAgentDiv) {
        userAgentSelect.addEventListener("change", function() {
            if (this.value === "custom") {
                customUserAgentDiv.style.display = "block";
            } else {
                customUserAgentDiv.style.display = "none";
            }
        });
    }
 };
 const loadConfig = event => {
--- a/app/static/settings/countries.json
+++ b/app/static/settings/countries.json
@ -128,6 +128,8 @@
  {"name": "Lithuania", "value": "LT"},
  {"name": "Luxembourg", "value": "LU"},
  {"name": "Macao", "value": "MO"},
  {"name": "Macedonia, the Former Yugosalv Republic of",
    "value": "MK"},
  {"name": "Madagascar", "value": "MG"},
  {"name": "Malawi", "value": "MW"},
  {"name": "Malaysia", "value": "MY"},
@ -160,7 +162,6 @@
  {"name": "Nigeria", "value": "NG"},
  {"name": "Niue", "value": "NU"},
  {"name": "Norfolk Island", "value": "NF"},
  {"name": "North Macedonia", "value": "MK"},
  {"name": "Northern Mariana Islands", "value": "MP"},
  {"name": "Norway", "value": "NO"},
  {"name": "Oman", "value": "OM"},
@ -200,7 +201,8 @@
  {"name": "Solomon Islands", "value": "SB"},
  {"name": "Somalia", "value": "SO"},
  {"name": "South Africa", "value": "ZA"},
-  {"name": "South Georgia and the South Sandwich Islands", "value": "GS"},
+  {"name": "South Georgia and the South Sandwich Islands",
    "value": "GS"},
  {"name": "Spain", "value": "ES"},
  {"name": "Sri Lanka", "value": "LK"},
  {"name": "Sudan", "value": "SD"},
@ -219,10 +221,10 @@
  {"name": "Tonga", "value": "TO"},
  {"name": "Trinidad and Tobago", "value": "TT"},
  {"name": "Tunisia", "value": "TN"},
  {"name": "Turkey", "value": "TR"},
  {"name": "Turkmenistan", "value": "TM"},
  {"name": "Turks and Caicos Islands", "value": "TC"},
  {"name": "Tuvalu", "value": "TV"},
  {"name": "Türkiye", "value": "TR"},
  {"name": "Uganda", "value": "UG"},
  {"name": "Ukraine", "value": "UA"},
  {"name": "United Arab Emirates", "value": "AE"},
--- a/app/static/settings/languages.json
+++ b/app/static/settings/languages.json
@ -46,7 +46,7 @@
  {"name": "Swahili (Kiswahili)", "value": "lang_sw"},
  {"name": "Swedish (Svenska)", "value": "lang_sv"},
  {"name": "Thai (ไทย)", "value": "lang_th"},
-  {"name": "Turkish (Türkçe)", "value": "lang_tr"},
+  {"name": "Turkish (Türk)", "value": "lang_tr"},
  {"name": "Ukrainian (Українська)", "value": "lang_uk"},
  {"name": "Vietnamese (Tiếng Việt)", "value": "lang_vi"},
  {"name": "Welsh (Cymraeg)", "value": "lang_cy"},
--- a/app/static/settings/translations.json
+++ b/app/static/settings/translations.json
@ -1286,61 +1286,5 @@
        "qdr:w": "Τελευταία Βδομάδα",
        "qdr:m": "Τελευταίος Μήνας",
        "qdr:y": "Τελευταίος Χρόνος"
    },
 	 "lang_tr": {
 		"": "--",
 		"search": "Ara",
 		"config": "Seçenekler",
 		"config-country": "Ülke",
 		"config-lang": "Arayüz Dili",
 		"config-lang-search": "Arama Dili",
 		"config-near": "Yakınında",
 		"config-near-help": "Şehir Adı",
 		"config-block": "Engelle",
 		"config-block-help": "Virgülle ayrılmış site listesi",
 		"config-block-title": "Başlığa Göre Engelle",
 		"config-block-title-help": "Regex kullan",
 		"config-block-url": "URL'ye Göre Engelle",
 		"config-block-url-help": "Regex kullan",
 		"config-theme": "Tema",
 		"config-nojs": "Anonim Görünümde Javascript'i Kaldır",
 		"config-anon-view": "Anonim Görünüm Bağlantılarını Göster",
 		"config-dark": "Karanlık Mod",
 		"config-safe": "Güvenli Arama",
 		"config-alts": "Sosyal Medya Bağlantılarını Değiştir",
 		"config-alts-help": "Twitter/YouTube/vb. bağlantıları gizliliğe saygılı alternatiflerle değiştirir.",
 		"config-new-tab": "Bağlantıları Yeni Sekmede Aç",
 		"config-images": "Tam Boyutlu Görsel Arama",
 		"config-images-help": "(Deneysel) Masaüstü görsel aramalarına 'Görseli Görüntüle' seçeneği ekler. Bu, görsel sonuç küçük resimlerinin daha düşük çözünürlükte olmasına neden olur.",
 		"config-tor": "Tor Kullan",
 		"config-get-only": "Yalnızca GET İstekleri",
 		"config-url": "Kök URL",
 		"config-pref-url": "Tercihler URL'si",
 		"config-pref-encryption": "Tercihleri Şifrele",
 		"config-pref-help": "WHOOGLE_CONFIG_PREFERENCES_KEY gerektirir, aksi takdirde bu göz ardı edilir.",
 		"config-css": "Özel CSS",
 		"config-time-period": "Zaman Aralığı",
 		"load": "Yükle",
 		"apply": "Uygula",
 		"save-as": "Farklı Kaydet...",
 		"github-link": "GitHub'da Görüntüle",
 		"translate": "çevir",
 		"light": "açık",
 		"dark": "koyu",
 		"system": "sistem",
 		"ratelimit": "Sunucu hız sınırına ulaştı",
 		"continue-search": "Aramanızı Farside ile sürdürün",
 		"all": "Tümü",
 		"images": "Görseller",
 		"maps": "Haritalar",
 		"videos": "Videolar",
 		"news": "Haberler",
 		"books": "Kitaplar",
 		"anon-view": "Anonim Görünüm",
 		"qdr:h": "Son saat",
 		"qdr:d": "Son 24 saat",
 		"qdr:w": "Geçen hafta",
 		"qdr:m": "Geçen ay",
 		"qdr:y": "Geçen yıl"
    }
 }
--- a/app/templates/display.html
+++ b/app/templates/display.html
@ -9,14 +9,10 @@
    {% endif %}
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <meta name="referrer" content="no-referrer">
    {% if bundle_static() %}
        <link rel="stylesheet" href="/{{ cb_url('bundle.css') }}">
    {% else %}
    <link rel="stylesheet" href="{{ cb_url('logo.css') }}">
    <link rel="stylesheet" href="{{ cb_url('input.css') }}">
    <link rel="stylesheet" href="{{ cb_url('search.css') }}">
    <link rel="stylesheet" href="{{ cb_url('header.css') }}">
    {% endif %}
    {% if config.theme %}
        {% if config.theme == 'system' %}
            <style>
@ -43,14 +39,10 @@
 {{ response|safe }}
 </body>
 {% include 'footer.html' %}
-{% if bundle_static() %}
+{% if autocomplete_enabled == '1' %}
    <script src="/{{ cb_url('bundle.js') }}" defer></script>
 {% else %}
    {% if autocomplete_enabled == '1' %}
    <script src="{{ cb_url('autocomplete.js') }}"></script>
    {% endif %}
    <script src="{{ cb_url('utils.js') }}"></script>
    <script src="{{ cb_url('keyboard.js') }}"></script>
    <script src="{{ cb_url('currency.js') }}"></script>
 {% endif %}
 <script src="{{ cb_url('utils.js') }}"></script>
 <script src="{{ cb_url('keyboard.js') }}"></script>
 <script src="{{ cb_url('currency.js') }}"></script>
 </html>
--- a/app/templates/error.html
+++ b/app/templates/error.html
@ -10,12 +10,8 @@
 {% else %}
    <link rel="stylesheet" href="{{ cb_url(('dark' if config.dark else 'light') + '-theme.css') }}"/>
 {% endif %}
 {% if bundle_static() %}
 <link rel="stylesheet" href="/{{ cb_url('bundle.css') }}">
 {% else %}
 <link rel="stylesheet" href="{{ cb_url('main.css') }}">
 <link rel="stylesheet" href="{{ cb_url('error.css') }}">
 {% endif %}
 <style>{{ config.style }}</style>
 <div>
    <h1>Error</h1>
@ -47,16 +43,6 @@
                        </li>
                    </ul>
                </li>
                <li>
                    <a href="https://git.lolcat.ca/lolcat/4get">4get</a>
                    <ul>
                        <li>
                            <a class="link-color" href="{{farside}}/4get/web?s={{query}}&scraper=google">
                                {{farside}}/4get/web?s={{query}}&scraper=google
                            </a>
                        </li>
                    </ul>
                </li>
            </ul>
            <hr>
            <h4>Other options:</h4>
@ -72,16 +58,6 @@
                        </li>
                    </ul>
                </li>
                <li>
                    <a href="https://4get.ca">4get</a>
                    <ul>
                        <li>
                            <a class="link-color" href="https://4get.ca/web?s={{query}}">
                                4get.ca/web?s={{query}}
                            </a>
                        </li>
                    </ul>
                </li>
                <li>
                    <a href="https://duckduckgo.com">DuckDuckGo</a>
                    <ul>
--- a/app/templates/header.html
+++ b/app/templates/header.html
@ -155,8 +155,4 @@
    </div>
 </div>
 {% if bundle_static() %}
 <script src="/{{ cb_url('bundle.js') }}" defer></script>
 {% else %}
 <script type="text/javascript" src="{{ cb_url('header.js') }}"></script>
 {% endif %}
--- a/app/templates/imageresults.html
+++ b/app/templates/imageresults.html
@ -161,6 +161,7 @@
    .e3goi {
      vertical-align: top;
      padding: 0;
      height: 180px;
    }
    .GpQGbf {
      margin: auto;
@ -209,6 +210,8 @@
      text-align: center;
    }
    .RAyV4b {
      width: 162px;
      height: 140px;
      line-height: 140px;
      overflow: "hidden";
      text-align: center;
@ -217,6 +220,8 @@
      text-align: center;
      margin: auto;
      vertical-align: middle;
      width: 100%;
      height: 100%;
      object-fit: contain;
    }
    .Tor4Ec {
--- a/app/templates/index.html
+++ b/app/templates/index.html
@ -17,21 +17,13 @@
    <meta name="referrer" content="no-referrer">
    <meta name="msapplication-TileColor" content="#ffffff">
    <meta name="msapplication-TileImage" content="static/img/favicon/ms-icon-144x144.png">
    {% if bundle_static() %}
        <script src="/{{ cb_url('bundle.js') }}" defer></script>
    {% else %}
    {% if autocomplete_enabled == '1' %}
        <script src="{{ cb_url('autocomplete.js') }}"></script>
    {% endif %}
    <script type="text/javascript" src="{{ cb_url('controller.js') }}"></script>
    {% endif %}
    <link rel="search" href="opensearch.xml" type="application/opensearchdescription+xml" title="Whoogle Search">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    {% if bundle_static() %}
        <link rel="stylesheet" href="/{{ cb_url('bundle.css') }}">
    {% else %}
    <link rel="stylesheet" href="{{ cb_url('logo.css') }}">
    {% endif %}
    {% if config.theme %}
        {% if config.theme == 'system' %}
            <style>
@ -44,9 +36,7 @@
    {% else %}
        <link rel="stylesheet" href="{{ cb_url(('dark' if config.dark else 'light') + '-theme.css') }}"/>
    {% endif %}
    {% if not bundle_static() %}
    <link rel="stylesheet" href="{{ cb_url('main.css') }}">
    {% endif %}
    <noscript>
        <style>
            #main {
@ -233,12 +223,6 @@
                            <input type="checkbox" name="tor"
                                   id="config-tor" {{ '' if tor_available else 'hidden' }} {{ 'checked' if config.tor else '' }}>
                        </div>
                        <div class="config-div config-div-leta">
                            <label class="tooltip" for="config-leta">Use Mullvad Leta Backend: </label>
                            <input type="checkbox" name="use_leta"
                                   id="config-leta" {{ 'checked' if config.use_leta else '' }}>
                            <div><span class="info-text"> — Uses Mullvad's privacy-focused search. Only supports regular web search (no images/videos/news/maps).</span></div>
                        </div>
                        <div class="config-div config-div-get-only">
                            <label for="config-get-only">{{ translation['config-get-only'] }}: </label>
                            <input type="checkbox" name="get_only"
@ -247,8 +231,8 @@
                        <div class="config-div config-div-user-agent">
                            <label for="config-user-agent">User Agent: </label>
                            <select name="user_agent" id="config-user-agent">
-                                <option value="env_conf" {% if config.user_agent == 'env_conf' %}selected{% endif %}>Use ENV Conf</option>
+                                <option value="LYNX_UA" {% if not config.user_agent or config.user_agent == 'LYNX_UA' %}selected{% endif %}>Lynx Browser</option>
-                                <option value="default" {% if config.user_agent == 'default' %}selected{% endif %}>Default</option>
+                                <option value="" {% if config.user_agent == '' and config.user_agent != 'LYNX_UA' %}selected{% endif %}>Original (Random)</option>
                                <option value="custom" {% if config.user_agent == 'custom' %}selected{% endif %}>Custom</option>
                            </select>
                        </div>
--- a/app/utils/bangs.py
+++ b/app/utils/bangs.py
@ -1,5 +1,5 @@
 import json
-import httpx
+import requests
 import urllib.parse as urlparse
 import os
 import glob
@ -43,8 +43,7 @@ def load_all_bangs(ddg_bangs_file: str, ddg_bangs: dict = {}):
    for i, bang_file in enumerate(bang_files):
        try:
-            with open(bang_file, 'r', encoding='utf-8') as f:
+            bangs |= json.load(open(bang_file))
                bangs |= json.load(f)
        except json.decoder.JSONDecodeError:
            # Ignore decoding error only for the ddg bangs file, since this can
            # occur if file is still being written
@ -64,9 +63,12 @@ def gen_bangs_json(bangs_file: str) -> None:
        None
    """
    try:
        # Request full list from DDG
-    r = httpx.get(DDG_BANGS)
+        r = requests.get(DDG_BANGS)
        r.raise_for_status()
    except requests.exceptions.HTTPError as err:
        raise SystemExit(err)
    # Convert to json
    data = json.loads(r.text)
@ -81,8 +83,7 @@ def gen_bangs_json(bangs_file: str) -> None:
            'suggestion': bang_command + ' (' + row['s'] + ')'
        }
-    with open(bangs_file, 'w', encoding='utf-8') as f:
+    json.dump(bangs_data, open(bangs_file, 'w'))
        json.dump(bangs_data, f)
    print('* Finished creating ddg bangs json')
    load_all_bangs(bangs_file, bangs_data)
--- a/app/utils/misc.py
+++ b/app/utils/misc.py
@ -5,7 +5,7 @@ import io
 import os
 import re
-import httpx
+from requests import exceptions, get
 from urllib.parse import urlparse
 from bs4 import BeautifulSoup as bsoup
 from cryptography.fernet import Fernet
@ -36,8 +36,7 @@ def fetch_favicon(url: str) -> bytes:
        bytes - the favicon bytes, or a placeholder image if one
        was not returned
    """
-    try:
+    response = get(f'{ddg_favicon_site}/{urlparse(url).netloc}.ico')
        response = httpx.get(f'{ddg_favicon_site}/{urlparse(url).netloc}.ico', timeout=2.0)
    if response.status_code == 200 and len(response.content) > 0:
        tmp_mem = io.BytesIO()
@ -45,15 +44,11 @@ def fetch_favicon(url: str) -> bytes:
        tmp_mem.seek(0)
        return tmp_mem.read()
    except Exception:
        # If favicon fetch fails, return placeholder
        pass
    return placeholder_img
 def gen_file_hash(path: str, static_file: str) -> str:
-    with open(os.path.join(path, static_file), 'rb') as f:
+    file_contents = open(os.path.join(path, static_file), 'rb').read()
        file_contents = f.read()
    file_hash = hashlib.md5(file_contents).hexdigest()[:8]
    filename_split = os.path.splitext(static_file)
@ -102,8 +97,8 @@ def get_proxy_host_url(r: Request, default: str, root=False) -> str:
 def check_for_update(version_url: str, current: str) -> int:
    # Check for the latest version of Whoogle
    has_update = ''
-    with contextlib.suppress(httpx.RequestError, AttributeError):
+    with contextlib.suppress(exceptions.ConnectionError, AttributeError):
-        update = bsoup(httpx.get(version_url).text, 'html.parser')
+        update = bsoup(get(version_url).text, 'html.parser')
        latest = update.select_one('[class="Link--primary"]').string[1:]
        current = int(''.join(filter(str.isdigit, current)))
        latest = int(''.join(filter(str.isdigit, latest)))
--- a/app/utils/results.py
+++ b/app/utils/results.py
@ -1,8 +1,7 @@
 from app.models.config import Config
 from app.models.endpoint import Endpoint
 from app.utils.misc import list_to_dict
-from bs4 import BeautifulSoup, NavigableString, MarkupResemblesLocatorWarning
+from bs4 import BeautifulSoup, NavigableString
 import warnings
 import copy
 from flask import current_app
 import html
@ -10,7 +9,7 @@ import os
 import urllib.parse as urlparse
 from urllib.parse import parse_qs
 import re
-warnings.filterwarnings('ignore', category=MarkupResemblesLocatorWarning)
+import warnings
 SKIP_ARGS = ['ref_src', 'utm']
 SKIP_PREFIX = ['//www.', '//mobile.', '//m.']
@ -115,7 +114,7 @@ def bold_search_terms(response: str, query: str) -> BeautifulSoup:
    for word in re.split(r'\s+(?=[^"]*(?:"[^"]*"[^"]*)*$)', query):
        word = re.sub(r'[@_!#$%^&*()<>?/\|}{~:]+', '', word)
        target = response.find_all(
-            string=re.compile(r'' + re.escape(word), re.I))
+            text=re.compile(r'' + re.escape(word), re.I))
        for nav_str in target:
            replace_any_case(nav_str, word)
@ -137,7 +136,7 @@ def has_ad_content(element: str) -> bool:
            or 'ⓘ' in element)
-def get_first_link(soup) -> str:
+def get_first_link(soup: BeautifulSoup) -> str:
    """Retrieves the first result link from the query response
    Args:
@ -148,18 +147,24 @@ def get_first_link(soup) -> str:
    """
    first_link = ''
    orig_details = []
-    # Find the first valid search result link, excluding details elements
+    # Temporarily remove details so we don't grab those links
    for details in soup.find_all('details'):
        temp_details = soup.new_tag('removed_details')
        orig_details.append(details.replace_with(temp_details))
    # Replace hrefs with only the intended destination (no "utm" type tags)
    for a in soup.find_all('a', href=True):
        # Skip links that are inside details elements (collapsible sections)
        if a.find_parent('details'):
            continue
        # Return the first search result URL
        if a['href'].startswith('http://') or a['href'].startswith('https://'):
            first_link = a['href']
            break
    # Add the details back
    for orig_detail, details in zip(orig_details, soup.find_all('removed_details')):
        details.replace_with(orig_detail)
    return first_link
@ -420,8 +425,7 @@ def get_tabs_content(tabs: dict,
                     full_query: str,
                     search_type: str,
                     preferences: str,
-                     translation: dict,
+                     translation: dict) -> dict:
                     use_leta: bool = False) -> dict:
    """Takes the default tabs content and updates it according to the query.
    Args:
@ -429,7 +433,6 @@ def get_tabs_content(tabs: dict,
        full_query: The original search query
        search_type: The current search_type
        translation: The translation to get the names of the tabs
        use_leta: Whether Mullvad Leta backend is being used
    Returns:
        dict: contains the name, the href and if the tab is selected or not
@ -439,11 +442,6 @@ def get_tabs_content(tabs: dict,
        block_idx = full_query.index('-site:')
        map_query = map_query[:block_idx]
    tabs = copy.deepcopy(tabs)
    # If using Leta, remove unsupported tabs (images, videos, news, maps)
    if use_leta:
        tabs = {k: v for k, v in tabs.items() if k == 'all'}
    for tab_id, tab_content in tabs.items():
        # update name to desired language
        if tab_id in translation:
--- a/app/utils/search.py
+++ b/app/utils/search.py
@ -55,7 +55,7 @@ class Search:
        config: the current user config settings
        session_key: the flask user fernet key
    """
-    def __init__(self, request, config, session_key, cookies_disabled=False, user_request=None):
+    def __init__(self, request, config, session_key, cookies_disabled=False):
        method = request.method
        self.request = request
        self.request_params = request.args if method == 'GET' else request.form
@ -66,7 +66,6 @@ class Search:
        self.query = ''
        self.widget = ''
        self.cookies_disabled = cookies_disabled
        self.user_request = user_request
        self.search_type = self.request_params.get(
            'tbm') if 'tbm' in self.request_params else ''
@ -104,7 +103,7 @@ class Search:
                pass
        # Strip '!' for "feeling lucky" queries
-        if match := re.search(r"(^|\s)!($|\s)", q):
+        if match := re.search("(^|\s)!($|\s)", q):
            self.feeling_lucky = True
            start, end = match.span()
            self.query = " ".join([seg for seg in [q[:start], q[end:]] if seg])
@ -149,28 +148,23 @@ class Search:
        # force mobile search when view image is true and
        # the request is not already made by a mobile
        view_image = ('tbm=isch' in full_query
-                      and self.config.view_image)
+                      and self.config.view_image
                      and not g.user_request.mobile)
-        client = self.user_request or g.user_request
+        get_body = g.user_request.send(query=full_query,
-        get_body = client.send(query=full_query,
+                                       force_mobile=view_image,
                               force_mobile=self.config.view_image,
                                       user_agent=self.user_agent)
        # Produce cleanable html soup from response
        get_body_safed = get_body.text.replace("&lt;","andlt;").replace("&gt;","andgt;")
        html_soup = bsoup(get_body_safed, 'html.parser')
        # Ensure we extract only the content within <html> if it exists
        # This prevents doctype declarations from appearing in the output
        if html_soup.html:
            html_soup = html_soup.html
        # Replace current soup if view_image is active
        if view_image:
            html_soup = content_filter.view_image(html_soup)
        # Indicate whether or not a Tor connection is active
-        if (self.user_request or g.user_request).tor_valid:
+        if g.user_request.tor_valid:
            html_soup.insert(0, bsoup(TOR_BANNER, 'html.parser'))
        formatted_results = content_filter.clean(html_soup)
--- a/app/version.py
+++ b/app/version.py
@ -4,4 +4,4 @@ optional_dev_tag = ''
 if os.getenv('DEV_BUILD'):
    optional_dev_tag = '.dev' + os.getenv('DEV_BUILD')
-__version__ = '1.1.0' + optional_dev_tag
+__version__ = '0.9.3' + optional_dev_tag
--- a/charts/whoogle/Chart.yaml
+++ b/charts/whoogle/Chart.yaml
@ -3,7 +3,7 @@ name: whoogle
 description: A self hosted search engine on Kubernetes
 type: application
 version: 0.1.0
-appVersion: 0.9.4
+appVersion: 0.9.3
 icon: https://github.com/benbusby/whoogle-search/raw/main/app/static/img/favicon/favicon-96x96.png
--- a/misc/instances.txt
+++ b/misc/instances.txt
@ -1,6 +1,24 @@
 https://search.albony.xyz
 https://search.garudalinux.org
 https://search.dr460nf1r3.org
 https://search.nezumi.party
 https://s.tokhmi.xyz
 https://search.sethforprivacy.com
-https://whoogle.privacydev.net
+https://whoogle.dcs0.hu
 https://wg.vern.cc
 https://whoogle.lunar.icu
-https://whoogle.4040940.xyz
+https://gowogle.voring.me
 https://whoogle.privacydev.net
 https://whoogle.hostux.net
 https://wg.vern.cc
 https://whoogle.hxvy0.gq
 https://whoogle.ungovernable.men
 https://whoogle2.ungovernable.men
 https://whoogle3.ungovernable.men
 https://wgl.frail.duckdns.org
 https://whoogle.no-logs.com
 https://whoogle.ftw.lol
 https://whoogle-search--replitcomreside.repl.co
 https://search.notrustverify.ch
 https://whoogle.datura.network
 https://whoogle.yepserver.xyz
 https://search.snine.nl
--- a/misc/update-translations.py
+++ b/misc/update-translations.py
@ -1,6 +1,6 @@
 import json
 import pathlib
-import httpx
+import requests
 lingva = 'https://lingva.ml/api/v1/en'
@ -25,7 +25,7 @@ def translate(v: str, lang: str) -> str:
    lingva_req = f'{lingva}/{lang}/{v}'
-    response = httpx.get(lingva_req).json()
+    response = requests.get(lingva_req).json()
    if 'translation' in response:
        return response['translation']
--- a/pyproject.toml
+++ b/pyproject.toml
@ -1,16 +1,3 @@
 [build-system]
 requires = ["setuptools", "wheel"]
 build-backend = "setuptools.build_meta"
 [tool.ruff]
 line-length = 100
 target-version = "py311"
 lint.select = [
  "E", "F", "W",  # pycodestyle/pyflakes
  "I",              # isort
 ]
 lint.ignore = []
 [tool.black]
 line-length = 100
 target-version = ['py311']
--- a/requirements.txt
+++ b/requirements.txt
@ -1,36 +1,37 @@
-attrs==25.3.0
+attrs==22.2.0
-beautifulsoup4==4.13.5
+beautifulsoup4==4.11.2
-brotli==1.1.0
+brotli==1.0.9
-certifi==2025.8.3
+cachelib==0.10.2
-cffi==2.0.0
+certifi==2024.7.4
-click==8.3.0
+cffi==1.17.1
 chardet==5.1.0
 click==8.1.3
 cryptography==3.3.2; platform_machine == 'armv7l'
-cryptography==46.0.1; platform_machine != 'armv7l'
+cryptography==43.0.1; platform_machine != 'armv7l'
-cssutils==2.11.1
+cssutils==2.7.0
 defusedxml==0.7.1
 Flask==2.3.2
-idna==3.10
+idna==3.7
 itsdangerous==2.1.2
-Jinja2==3.1.6
+Jinja2==3.1.5
-MarkupSafe==3.0.2
+MarkupSafe==2.1.2
-more-itertools==10.8.0
+more-itertools==9.0.0
-packaging==25.0
+packaging==23.0
-pluggy==1.6.0
+pluggy==1.0.0
-pycodestyle==2.14.0
+pycodestyle==2.10.0
 pycparser==2.22
 pyOpenSSL==19.1.0; platform_machine == 'armv7l'
-pyOpenSSL==25.3.0; platform_machine != 'armv7l'
+pyOpenSSL==24.2.1; platform_machine != 'armv7l'
-pyparsing==3.2.5
+pyparsing==3.0.9
 PySocks==1.7.1
 pytest==7.2.1
-python-dateutil==2.9.0.post0
+python-dateutil==2.8.2
-httpx[http2,socks]==0.28.1
+requests==2.32.2
-cachetools==6.2.0
+soupsieve==2.4
-soupsieve==2.8
+stem==1.8.1
-stem==1.8.2
+urllib3==1.26.19
-httpcore>=1.0.9
+validators==0.22.0
-h11>=0.16.0
+waitress==3.0.1
-validators==0.35.0
+wcwidth==0.2.6
 waitress==3.0.2
 wcwidth==0.2.14
 Werkzeug==3.0.6
-python-dotenv==1.1.1
+python-dotenv==0.21.1
--- a/setup.cfg
+++ b/setup.cfg
@ -25,7 +25,7 @@ install_requires=
    defusedxml
    Flask
    python-dotenv
-    httpx[http2,socks]
+    requests
    stem
    validators
    waitress
--- a/test/test_alts.py
+++ b/test/test_alts.py
@ -1,114 +0,0 @@
 import copy
 import os
 from bs4 import BeautifulSoup
 from app import app
 from app.filter import Filter
 from app.models.config import Config
 from app.utils.session import generate_key
 from app.utils import results as results_mod
 def build_soup(html: str):
    return BeautifulSoup(html, 'html.parser')
 def make_filter(soup: BeautifulSoup):
    secret_key = generate_key()
    with app.app_context():
        cfg = Config(**{'alts': True})
    f = Filter(user_key=secret_key, config=cfg)
    f.soup = soup
    return f
 def test_no_duplicate_alt_prefix_reddit(monkeypatch):
    original_site_alts = copy.deepcopy(results_mod.SITE_ALTS)
    try:
        # Simulate user setting alt to old.reddit.com
        monkeypatch.setitem(results_mod.SITE_ALTS, 'reddit.com', 'old.reddit.com')
        html = '''
        <div id="main">
          <a href="https://www.reddit.com/r/whoogle">www.reddit.com</a>
          <div>www.reddit.com</div>
          <div>old.reddit.com</div>
        </div>
        '''
        soup = build_soup(html)
        f = make_filter(soup)
        f.site_alt_swap()
        # Href replaced once
        a = soup.find('a')
        assert a['href'].startswith('https://old.reddit.com')
        # Bare domain replaced, but already-alt text stays unchanged (no old.old...)
        divs = [d.get_text() for d in soup.find_all('div') if d.get_text().strip()]
        assert 'old.reddit.com' in divs
        assert 'old.old.reddit.com' not in ''.join(divs)
    finally:
        results_mod.SITE_ALTS.clear()
        results_mod.SITE_ALTS.update(original_site_alts)
 def test_wikipedia_simple_no_lang_param(monkeypatch):
    original_site_alts = copy.deepcopy(results_mod.SITE_ALTS)
    try:
        monkeypatch.setitem(results_mod.SITE_ALTS, 'wikipedia.org', 'https://wikiless.example')
        html = '''
        <div id="main">
          <a href="https://simple.wikipedia.org/wiki/Whoogle">https://simple.wikipedia.org/wiki/Whoogle</a>
          <div>simple.wikipedia.org</div>
        </div>
        '''
        soup = build_soup(html)
        f = make_filter(soup)
        f.site_alt_swap()
        a = soup.find('a')
        # Should be rewritten to the alt host, without ?lang
        assert a['href'].startswith('https://wikiless.example')
        assert '?lang=' not in a['href']
        # Description host replaced once
        text = soup.find('div').get_text()
        assert 'wikiless.example' in text
        assert 'simple.wikipedia.org' not in text
    finally:
        results_mod.SITE_ALTS.clear()
        results_mod.SITE_ALTS.update(original_site_alts)
 def test_single_pass_description_replacement(monkeypatch):
    original_site_alts = copy.deepcopy(results_mod.SITE_ALTS)
    try:
        monkeypatch.setitem(results_mod.SITE_ALTS, 'twitter.com', 'https://nitter.example')
        html = '''
        <div id="main">
          <a href="https://twitter.com/whoogle">https://twitter.com/whoogle</a>
          <div>https://www.twitter.com</div>
        </div>
        '''
        soup = build_soup(html)
        f = make_filter(soup)
        f.site_alt_swap()
        a = soup.find('a')
        assert a['href'].startswith('https://nitter.example')
        # Ensure description got host swapped once, no double scheme or duplication
        main_div = soup.find('div', id='main')
        # The description div is the first inner div under #main in this fixture
        text = main_div.find_all('div')[0].get_text().strip()
        assert text.startswith('https://nitter.example')
        assert 'https://https://' not in text
        assert 'nitter.examplenitter.example' not in text
    finally:
        results_mod.SITE_ALTS.clear()
        results_mod.SITE_ALTS.update(original_site_alts)
--- a/test/test_autocomplete_xml.py
+++ b/test/test_autocomplete_xml.py
@ -1,31 +0,0 @@
 from app import app
 from app.request import Request
 from app.models.config import Config
 class FakeHttpClient:
    def get(self, url, headers=None, cookies=None, retries=0, backoff_seconds=0.5, use_cache=False):
        # Minimal XML in Google Toolbar Autocomplete format
        xml = (
            '<?xml version="1.0"?>\n'
            '<topp>\n'
            '  <CompleteSuggestion><suggestion data="whoogle"/></CompleteSuggestion>\n'
            '  <CompleteSuggestion><suggestion data="whoogle search"/></CompleteSuggestion>\n'
            '</topp>'
        )
        class R:
            text = xml
        return R()
    def close(self):
        pass
 def test_autocomplete_parsing():
    with app.app_context():
        cfg = Config(**{})
    req = Request(normal_ua='UA', root_path='http://localhost:5000', config=cfg, http_client=FakeHttpClient())
    suggestions = req.autocomplete('who')
    assert 'whoogle' in suggestions
    assert 'whoogle search' in suggestions
--- a/test/test_http_client.py
+++ b/test/test_http_client.py
@ -1,33 +0,0 @@
 import types
 import httpx
 import pytest
 from app.services.http_client import HttpxClient
 def test_httpxclient_follow_redirects_and_proxy(monkeypatch):
    calls = []
    class FakeClient:
        def __init__(self, *args, **kwargs):
            calls.append(kwargs)
        def get(self, *args, **kwargs):
            class R:
                status_code = 200
                text = ''
            return R()
        def close(self):
            pass
    monkeypatch.setattr(httpx, 'Client', FakeClient)
    proxies = {'http': 'socks5://127.0.0.1:9050', 'https': 'socks5://127.0.0.1:9050'}
    client = HttpxClient(proxies=proxies)
    # Ensure the constructor attempted to set follow_redirects and one of proxy/proxies
    assert len(calls) == 1
    kwargs = calls[0]
    assert kwargs.get('follow_redirects') is True
    assert ('proxy' in kwargs) or ('proxies' in kwargs) or ('mounts' in kwargs)
--- a/test/test_json.py
+++ b/test/test_json.py
@ -1,79 +0,0 @@
 import json
 import types
 import pytest
 from app.models.endpoint import Endpoint
 from app.utils import search as search_mod
@pytest.fixture
 def stubbed_search_response(monkeypatch):
    # Stub Search.new_search_query to return a stable query
    def fake_new_query(self):
        self.query = 'whoogle'
        return self.query
    # Return a minimal filtered HTML snippet with a couple of links
    html = (
        '<div id="main">'
        '  <a href="https://example.com/page">Example Page</a>'
        '  <a href="/relative">Relative</a>'
        '  <a href="https://example.org/other">Other</a>'
        '</div>'
    )
    def fake_generate(self):
        return html
    monkeypatch.setattr(search_mod.Search, 'new_search_query', fake_new_query)
    monkeypatch.setattr(search_mod.Search, 'generate_response', fake_generate)
 def test_search_json_accept(client, stubbed_search_response):
    rv = client.get(f'/{Endpoint.search}?q=whoogle', headers={'Accept': 'application/json'})
    assert rv._status_code == 200
    data = json.loads(rv.data)
    assert data['query'] == 'whoogle'
    assert isinstance(data['results'], list)
    hrefs = {item['href'] for item in data['results']}
    assert 'https://example.com/page' in hrefs
    assert 'https://example.org/other' in hrefs
    # Relative href should be excluded
    assert not any(href.endswith('/relative') for href in hrefs)
    # Verify new fields are present while maintaining backward compatibility
    for result in data['results']:
        assert 'href' in result
        assert 'text' in result  # Original field maintained
        assert 'title' in result  # New field
        assert 'content' in result  # New field
 def test_search_json_format_param(client, stubbed_search_response):
    rv = client.get(f'/{Endpoint.search}?q=whoogle&format=json')
    assert rv._status_code == 200
    data = json.loads(rv.data)
    assert data['query'] == 'whoogle'
    assert len(data['results']) >= 2
 def test_search_json_feeling_lucky(client, monkeypatch):
    # Force query to be interpreted as feeling lucky and return a redirect URL
    def fake_new_query(self):
        self.query = 'whoogle !'
        # emulate behavior of new_search_query setting feeling_lucky
        self.feeling_lucky = True
        return self.query
    def fake_generate(self):
        return 'https://example.com/lucky'
    monkeypatch.setattr(search_mod.Search, 'new_search_query', fake_new_query)
    monkeypatch.setattr(search_mod.Search, 'generate_response', fake_generate)
    rv = client.get(f'/{Endpoint.search}?q=whoogle%20!', headers={'Accept': 'application/json'})
    assert rv._status_code == 303
    data = json.loads(rv.data)
    assert data['redirect'] == 'https://example.com/lucky'
--- a/test/test_misc.py
+++ b/test/test_misc.py
@ -66,16 +66,5 @@ def test_prefs_url(client):
    rv = client.get(f'{base_url}&preferences={JAPAN_PREFS}')
    assert rv._status_code == 200
-    # Leta may format results differently than Google, so check for either:
+    assert b'ja.wikipedia.org' in rv.data
    # 1. Japanese Wikipedia URL (Google's format)
    # 2. Japanese language results (indicated by Japanese characters or lang param)
    # 3. Any Wikipedia result (Leta may not localize URLs the same way)
    has_ja_wiki = b'ja.wikipedia.org' in rv.data
    has_japanese_content = b'\xe3\x82' in rv.data or b'\xe3\x83' in rv.data  # Japanese characters
    has_wiki_result = b'wikipedia.org' in rv.data
    # Test passes if we get Japanese Wikipedia, Japanese content, or any Wikipedia result
    # (Leta backend may handle language preferences differently)
    assert has_ja_wiki or has_japanese_content or has_wiki_result, \
        "Expected Japanese Wikipedia results or Japanese content in response"
--- a/test/test_results.py
+++ b/test/test_results.py
@ -3,7 +3,6 @@ from app.filter import Filter
 from app.models.config import Config
 from app.models.endpoint import Endpoint
 from app.utils import results
 from app.utils import search as search_mod
 from app.utils.session import generate_key
 from datetime import datetime
 from dateutil.parser import ParserError, parse
@ -33,24 +32,18 @@ def get_search_results(data):
    return result_divs
-def test_get_results(client, monkeypatch):
+def test_get_results(client):
-    def fake_generate(self):
+    # FIXME: Temporary fix while #1211 is investigated
-        # Build 10 results under #main, each with a single inner div
+    return
        items = []
        for i in range(10):
            items.append(f'<div><div><a href="https://example.com/{i}">Item {i}</a></div></div>')
        return f'<div id="main">{"".join(items)}</div>'
    monkeypatch.setattr(search_mod.Search, 'generate_response', fake_generate)
    rv = client.get(f'/{Endpoint.search}?q=test')
    assert rv._status_code == 200
    # Depending on the search, there can be more
    # than 10 result divs
-    results_divs = get_search_results(rv.data)
+    results = get_search_results(rv.data)
-    assert len(results_divs) >= 10
+    assert len(results) >= 10
-    assert len(results_divs) <= 15
+    assert len(results) <= 15
 def test_post_results(client):
@ -94,12 +87,9 @@ def test_block_results(client):
        assert result_site not in 'pinterest.com'
-def test_view_my_ip(client, monkeypatch):
+def test_view_my_ip(client):
-    def fake_generate(self):
+    # FIXME: Temporary fix while #1211 is investigated
-        # Minimal page; ip card is injected later by routes when widget == 'ip'
+    return
        return '<div id="main"></div>'
    monkeypatch.setattr(search_mod.Search, 'generate_response', fake_generate)
    rv = client.get(f'/{Endpoint.search}?q=my ip address')
    assert rv._status_code == 200
@ -110,16 +100,9 @@ def test_view_my_ip(client, monkeypatch):
    assert '127.0.0.1' in str_data
-def test_recent_results(client, monkeypatch):
+def test_recent_results(client):
-    def fake_generate(self):
+    # FIXME: Temporary fix while #1211 is investigated
-        # Create results with a span containing today's date so it passes all windows
+    return
        today = datetime.now().strftime('%b %d, %Y')
        items = []
        for i in range(5):
            items.append(f'<div><div><span>{today}</span></div></div>')
        return f'<div id="main">{"".join(items)}</div>'
    monkeypatch.setattr(search_mod.Search, 'generate_response', fake_generate)
    times = {
        'tbs=qdr:y': 365,
--- a/test/test_routes_json.py
+++ b/test/test_routes_json.py
@ -1,26 +0,0 @@
 import json
 import pytest
 from app.models.endpoint import Endpoint
 from app.utils import search as search_mod
 def test_captcha_json_block(client, monkeypatch):
    def fake_new_query(self):
        self.query = 'test'
        return self.query
    def fake_generate(self):
        # Inject a captcha marker into HTML so route returns 503 JSON
        return '<div>div class="g-recaptcha"</div>'
    monkeypatch.setattr(search_mod.Search, 'new_search_query', fake_new_query)
    monkeypatch.setattr(search_mod.Search, 'generate_response', fake_generate)
    rv = client.get(f'/{Endpoint.search}?q=test&format=json')
    assert rv._status_code == 503
    data = json.loads(rv.data)
    assert data['blocked'] is True
    assert 'error_message' in data
--- a/test/test_tor.py
+++ b/test/test_tor.py
@ -1,52 +0,0 @@
 import pytest
 from app import app
 from app.request import Request, TorError
 from app.models.config import Config
 class FakeResponse:
    def __init__(self, text: str = '', status_code: int = 200, content: bytes = b''):
        self.text = text
        self.status_code = status_code
        self.content = content or b''
 class FakeHttpClient:
    def __init__(self, tor_ok: bool):
        self._tor_ok = tor_ok
    def get(self, url, headers=None, cookies=None, retries=0, backoff_seconds=0.5, use_cache=False):
        if 'check.torproject.org' in url:
            return FakeResponse(text=('Congratulations' if self._tor_ok else 'Not Tor'))
        return FakeResponse(text='', status_code=200, content=b'OK')
    def close(self):
        pass
 def build_config(tor: bool) -> Config:
    # Minimal config with tor flag
    with app.app_context():
        return Config(**{'tor': tor})
 def test_tor_validation_success(monkeypatch):
    # Prevent real Tor signal attempts
    monkeypatch.setattr('app.request.send_tor_signal', lambda signal: True)
    cfg = build_config(tor=True)
    req = Request(normal_ua='TestUA', root_path='http://localhost:5000', config=cfg, http_client=FakeHttpClient(tor_ok=True))
    # Avoid sending a Tor NEWNYM/HEARTBEAT in unit tests by setting attempt>0 false path
    resp = req.send(base_url='https://example.com', query='')
    assert req.tor_valid is True
    assert resp.status_code == 200
 def test_tor_validation_failure(monkeypatch):
    # Prevent real Tor signal attempts
    monkeypatch.setattr('app.request.send_tor_signal', lambda signal: True)
    cfg = build_config(tor=True)
    req = Request(normal_ua='TestUA', root_path='http://localhost:5000', config=cfg, http_client=FakeHttpClient(tor_ok=False))
    with pytest.raises(TorError):
        _ = req.send(base_url='https://example.com', query='')