how to do request base_url without trailing slash?

[valq7711]

async with httpx.AsyncClient(base_url='http://localhost:8000/api/books') as client:
   response = await client.request('GET', '') 

This example does request 'http://localhost:8000/api/books/', but I don't want trailing slash, how do I achieve that?

Note:
That's not the case described #2673, as final url is not empty.
The above issue is about joining - if nothing was passed => no join should be made.

[rafalkrupinski]

What's wrong with

async with httpx.AsyncClient(base_url='http://localhost:8000/api') as client:
   response = await client.request('GET', 'books')

[valq7711]

the same as with

async with httpx.AsyncClient() as client:
   response = await client.request('GET', 'http://localhost:8000/api/books')

Under http://localhost:8000/api/books may live a whole universe of the books-api (including only the books route - yeah, people do that too, and this is by no means an exceptional case - surprise :) ), so if I have to prepend every route with 'books' (i.e. with the same repeating string) what's the point of base_url?

[rafalkrupinski]

what's the point of base_url?

So yo don't have to prepend 'http://localhost:8000/api/' to every route ;)

Or you could do this:

async with httpx.AsyncClient(base_url='http://localhost:8000/api/books') as client:
   books = await client.request('GET', 'http://localhost:8000/api/books')
   other_stuff = await client.request('GET', 'other_path')

this way you need to use the full address in one corner-case.

[valq7711]

what's the point of base_url?

So yo don't have to prepend 'http://localhost:8000/api/' to every route ;)

Or you could do this:

async with httpx.AsyncClient(base_url='http://localhost:8000/api/books') as client:
   books = await client.request('GET', 'http://localhost:8000/api/books')
   other_stuff = await client.request('GET', 'other_path')

this way you need to use the full address in one corner-case.

Sorry, but it is a very bad solution, as client may be passed as argument to a service, that nothing knows about base_url and before you suggest me to use something like await client.request('GET', client.base_url) keep in mind, that client.base_url returns url with trailing slash

[aleksandaratanasov]

I agree with @valq7711 and will expand on his/her comment.

I am currently inheriting from httpx.AsyncClient in order to construct a quick OGC WCS async client for a project keeping dep pkgs to a minimum (there is the owslib among others that already covers WCS).

The format is http://example.com/wcs/product_name. Right after that the parameters come, e.g. request=GetCapabilities. I am unable to construct a valid URL for a GET request, since my URL looks like

http://example.com/wcs/product_name/?request=GetCapabilities

instead of

http://example.com/wcs/product_name?request=GetCapabilities

due to the automatically added trailing slash. Upon passing the base_url to the httpx client class, I do not add any slash. I believe that any extras (including extending a path if it's already present in the base URL) should be manually and intentionally set by the developer. E.g. if I have

http://example.com

as base_url, whenever doing a GET request using that client I would simply do

client.get('/some_path`)

The current state puts a rather strange restriction on what a base URL is supposed to be and breaks its reuse in case of only parameters being added (WCS example above). Not also that web browsers do not complain about double slash (at least not latest version of Chrome, Firefox and Edge), so if the base URL already has a trailing slash and the developer calls e.g. GET by adding more to the path, it will not cause issues.

[mr-bronson]

web browsers do not complain about double slash

It's not about whether a browser "complains". The double slash can cause problems of interpretation with relative URL resolution.

Most (but not all) servers are going to treat a request for https://example.com/subdir//page.htm the same as a request for https://example.com/subdir/page.htm. But the problem comes when the browser is trying to access resources or links on the page loaded with the double slash where the URL is relative.
From https://example.com/subdir/page.htm the relative link ../img/pic.png correctly maps to https://example.com/img/pic.png.
But from https://example.com/subdir//page.htm it will map to https://example.com/subdir/img/pic.png.

Optimally, I think the server should give user agents a redirect for links with duplicate slashes so that the user agent only loads the resource from the canonical address.

See more discussion here: https://stackoverflow.com/questions/10161177/url-with-multiple-forward-slashes-does-it-break-anything

[loesak]

I too find the behavior of always adding a slash to the end of the base URL a bit unexpected/undesirable. The explanatory comment in _client.py#_merge_url is a bit telling.

When building a client library using httpx against and extensive API, I'd like to not have to repeat common paths shared among many endpoints, so I broke out my code such that each method that call a common path has its own client with the base API that includes the common path. However, with httpx adding the trailing slash to all base paths does not work for me. So now i guess I'll have to do my own URL building to reduce the duplication of the common path use.

In general, I prefer libraries that let me decide the behavior I want and let me fail when I get it wrong. Or at least provide and escape hatch if the library is trying to be "smart" for me. To me, the behavior, logically, should be:

url_to_calls = unmodified_provided_client_base_url + unmodified_provided_invoked_url

# examples
# "https://some.url.com/my/path" = "https://some.url.com" + "/my/path"
# "https://some.url.com/my/path" = "https://some.url.com/my" + "/path"
# "https://some.url.com/my/path" = "https://some.url.com/my/" + "path"
# "https://some.url.com/my//path" = "https://some.url.com/my/" + "/path"
# "https://some.url.com//my/path" = "https://some.url.com/" + "/my/path"
# "https://some.url.com/my/path" = "https://some.url.com/my/path" + ""

Also it would be very nice if the url field on all client calls (get, post, put, etc) was optional

url_to_calls = unmodified_provided_client_base_url + unmodified_provided_invoked_url if unmodified_provided_invoked_url is not None else ""

[tomchristie]

Probably a smarter approach is just not to allow paths in base_url at all.

More clear design constraints, less ambiguous behaviors.