Request missing subpath when built with two leading slashes

[smac89]

I was soo perplexed by this until I realized that httpx was ignoring part of the path that was used to build the request.

The client was built with the following:

httpx.Client(base_url='http://127.0.0.1:8282/Foo')

Then I built a request using the following:

client.build_request("GET", "//foobar/dev03/image.jpeg")

This was indeed a typo, which I didn't see at the time. However, it turns out that when this request is built, the url turns out to be:

http://127.0.0.1:8282/Foo/dev03/image.jpeg

It has essentially stripped off the //foobar part. I was quite confused for some time why it does that, until I started debugging.

Is this a bug, or expected behavior? I certainly didn't expect it.

[lovelydinosaur]

Is this a bug, or expected behavior?

Personally I think it's a misdesign, and that base_url should only allow <scheme>://<hostname>/ style URLs.

Including a path prefix is always confusing because it's non-obvious if the behaviour will be a strict URL join or some form of URL append.

Eg. what behavior is expected for...

client = Client(base_url="https://www.example.com/that")
response = client.get("/this")

I certainly didn't expect it.

Yeah it's a confusing part of the API, and yes it does look like you've found yourself a corner-case bit of particularly broken behavior.

[Vittuu]

I reproduced your exact result on HTTPX 0.28.1. There are two steps behind the missing foobar:

1. Parsing //foobar/dev03/image.jpeg treats foobar as the host, not a path segment:

   url = httpx.URL("//foobar/dev03/image.jpeg")
   assert url.host == "foobar"
   assert url.raw_path == b"/dev03/image.jpeg"
   assert url.scheme == ""
   assert url.is_relative_url

2. Client._merge_url handles that URL as relative because it lacks a scheme. It appends only its raw_path to the base URL and keeps the base URL's host. At that point, foobar is already outside the path, so it is lost during the merge.

Thus the URL parsing is understandable, but the client merge gives the corner-case behavior @lovelydinosaur identified. It is also different from standard urljoin, which would resolve //foobar/... to the new host using the base URL's scheme. I would not rely on the client's current result for a scheme-relative URL.

For the typo in your example, use one leading slash or none:

import httpx

with httpx.Client(base_url="http://127.0.0.1:8282/Foo", trust_env=False) as client:
    for path in ("/foobar/dev03/image.jpeg", "foobar/dev03/image.jpeg"):
        request = client.build_request("GET", path)
        assert str(request.url) == (
            "http://127.0.0.1:8282/Foo/foobar/dev03/image.jpeg"
        )

    # If foobar really is the destination host, supply the scheme explicitly.
    request = client.build_request("GET", "http://foobar/dev03/image.jpeg")
    assert str(request.url) == "http://foobar/dev03/image.jpeg"

The single leading slash above still preserves /Foo/: the client's relative-URL merge appends to the base path, rather than doing urljoin's root-relative resolution.

AI assistance: Codex. The parsing assertions, your original URL, both corrected paths, and the explicit-host case were checked with HTTPX 0.28.1 / Python 3.12.3. These tests only build requests; they do not send traffic or claim that the library has been fixed.