Roadmap for 1.0 release?

[xkortex]

Hi, first I just wanna say I love httpx and I've already swapped it out for all of my prior requests needs.

The 1.0-rc has been out for about 9 months, and I was just curious if there was any kind of roadmap or timeline for the full 1.0 release. If not, I think it might be nice to have a roadmap issue showing what the various blockers are, such as this pinned issue for poetry. That way contributors would know what issues they could focus on.

No pressure, I was just curious if this was something I could look forward to in the next few months. I'm very excited for it ^_^

I didn't see any other issues pertaining to a feature roadmap, except maybe this: #1797
and this: #1220 (comment)

[tomchristie]

Great question, yup.

From my perspective #2252 is one blocker I'd like to see resolved, and then following that possibly some minor tidying up on the API for working with URLs. Everything has been nice and API stable for a while, so I'm more concerned with "what package dependencies should 1.0 have".

[xkortex]

Interesting! I've actually spent some time poking at the problem of URl (and URI) parsing. If you want I can actually review that PR and compare it against the URL test suite I've been working on (maybe in a week or so, next week is heavy).

Just curious, have you considered making class URL(str) instead of plain class URL:? This is the approach I've been using internally, and the really convenient thing about it is it's automatically printable, json-encodable, etc. I call it the "tagged string" approach.

Mine starts like this (I've been working on one that can handle both URNs and URLs, otherwise s/URI/URL/g):

class URI(str):
    """
    Structured representation of an RFC 3986 URI
    URIs can be URLs or URNs
    URIs ALWAYS have a scheme and almost always a path.

    """

    __slots__ = ('_scheme', '_authority', '_path', '_query', '_fragment')

    @no_type_check
    def __new__(cls, uri: Union[str, 'URI']) -> 'URI':
        """
        """
        if isinstance(uri, cls):
            return uri

        return cls.parse(uri)

    @classmethod
    def parse(cls, uri: Union[str, 'URI']) -> 'URI':
        if uri is None or len(uri) == 0:
            raise ValueError("URI could not be parsed. No uri value was provided")

        match = regex_rfc3986.match(uri)  # this is the hard part! I'm using regex for now still but plan on a proper parser

        if match is None:
            raise ValueError(f"Does not match valid RFC 3986 URI: {uri!r}")
        gd = match.groupdict()

        return cls._from_parsed(uri, **gd)

    @classmethod
    def _from_parsed(cls, uri: str, scheme: str, authority: Optional[str], path: Optional[str],
                     query: Optional[str], fragment: Optional[str]) -> 'URI':
         
        # this is the clever bit. create a blank string subclass and populate the captured fields. 
        # the result is an immutable object that is referentially transparent with str, with added fields 
        self = str.__new__(cls, uri)
        self._scheme = scheme
        self._authority = authority
        self._path = path
        self._query = query
        self._fragment = fragment
        return self
       
       
    ... 
class URL(URI): 
    ... like URI but with stipulation it must have an authority

[PH-KDX]

I'd like to use httpx as a dependency, and I bumped into this discussion.
Does this mean that only internal implementation details are still changing between the 1.0.0b0 pre-release and the 1.0.0 stable release? Or are there also going to be breaking API changes?