1616import re
1717from dataclasses import dataclass
1818
19+ from packaging .specifiers import InvalidSpecifier , Specifier
20+ from packaging .version import InvalidVersion , Version
21+
1922__all__ = ["ParsedRequirement" , "RewriteResult" , "parse_requirement" , "rewrite_requirement" ]
2023
2124# Longest-first: ``===`` must win over ``==``, and ``>=`` over ``>``.
3033
3134#: Suffix marking a PEP 440 wildcard (``==1.4.*``, ``!=1.0.*``). These match on
3235#: a *prefix* of the release segments, so they must never go through the
33- #: numeric comparison — ``version_key `` maps ``* `` to 0, which would read
34- #: ``1.0.*`` as ``1.0.0`` and quietly answer the wrong question.
36+ #: numeric comparison — a numeric compare would read ``1.0.* `` as ``1.0.0 `` and
37+ #: quietly answer the wrong question.
3538_WILDCARD = ".*"
3639
3740
@@ -59,29 +62,42 @@ class RewriteResult:
5962 reason : str | None = None
6063
6164
62- def version_key (version : str ) -> tuple [int , ...]:
63- """Coarse PEP 440 release-segment ordering.
64-
65- ``packaging`` isn't a CLI dependency (see ``test_no_framework_deps.py``),
66- so this compares the numeric release segments only. Good enough to answer
67- "does the latest release trip this upper bound", which is all it's for.
68- """
69- parts : list [int ] = []
70- for part in version .split ("." ):
71- digits = re .match (r"\d+" , part )
72- parts .append (int (digits .group ()) if digits else 0 )
73- return tuple (parts )
65+ def is_valid_version (version : str | None ) -> bool :
66+ """Is ``version`` a string PEP 440 can order? ``None`` and legacy spellings are not."""
67+ try :
68+ Version (version ) # ty: ignore[invalid-argument-type] # None -> TypeError, handled
69+ except (InvalidVersion , TypeError ):
70+ return False
71+ return True
7472
7573
7674def _compare (left : str , right : str ) -> int :
77- """Three-way compare two versions on their release segments, zero-padded."""
78- a , b = version_key (left ), version_key (right )
79- width = max (len (a ), len (b ))
80- a += (0 ,) * (width - len (a ))
81- b += (0 ,) * (width - len (b ))
75+ """Three-way PEP 440 comparison, including pre/dev/post releases."""
76+ a , b = Version (left ), Version (right )
8277 return (a > b ) - (a < b )
8378
8479
80+ def _unparseable (parsed : ParsedRequirement , latest : str ) -> str | None :
81+ """The first version that is not valid PEP 440, or ``None``.
82+
83+ Legacy spellings (``==1.x``, ``===local-build``) can't be ordered, so the
84+ requirement is reported as a skip instead of aborting the whole run.
85+ """
86+ for candidate in (
87+ latest ,
88+ * (v [: - len (_WILDCARD )] if v .endswith (_WILDCARD ) else v for _ , v in parsed .clauses ),
89+ ):
90+ if not is_valid_version (candidate ):
91+ return candidate
92+ for op , version in parsed .clauses :
93+ if op in ("<" , "<=" , "!=" ) and not version .endswith (_WILDCARD ):
94+ try : # a valid Version can still be an invalid bound, e.g. ``<1.0+local``
95+ Specifier (f"{ op } { version } " )
96+ except InvalidSpecifier :
97+ return version
98+ return None
99+
100+
85101def parse_requirement (spec : str ) -> ParsedRequirement | None :
86102 """Split a PEP 508 requirement string, or ``None`` if the name is unusable."""
87103 base , sep , marker = spec .partition (";" )
@@ -117,9 +133,10 @@ def _render(parsed: ParsedRequirement, clauses: tuple[tuple[str, str], ...]) ->
117133
118134def _matches_wildcard (version : str , pattern : str ) -> bool :
119135 """Does ``version`` fall under a PEP 440 wildcard like ``1.4.*``?"""
120- prefix = version_key (pattern [: - len (_WILDCARD )])
121- release = version_key (version )
122- return len (release ) >= len (prefix ) and release [: len (prefix )] == prefix
136+ try :
137+ return Specifier (f"=={ pattern } " ).contains (version , prereleases = True )
138+ except InvalidSpecifier :
139+ return False
123140
124141
125142def _compatible_band (version : str ) -> str | None :
@@ -151,13 +168,8 @@ def _allows(op: str, version: str, latest: str) -> bool:
151168 if op == "~=" :
152169 band = _compatible_band (version )
153170 return band is not None and _matches_wildcard (latest , band )
154- cmp = _compare (latest , version )
155- if op == "<" :
156- return cmp < 0
157- if op == "<=" :
158- return cmp <= 0
159- if op == "!=" :
160- return cmp != 0
171+ if op in ("<" , "<=" , "!=" ):
172+ return Specifier (f"{ op } { version } " ).contains (latest , prereleases = True )
161173 # ``>`` — already satisfied by anything newer than the pin.
162174 return True
163175
@@ -193,7 +205,11 @@ def _bump(op: str, version: str, latest: str) -> str:
193205 if len (parts ) < segments :
194206 return version
195207 candidate = "." .join (parts [:segments ])
196- return candidate if _compare (candidate , version ) > 0 else version
208+ # A pre-release ``latest`` truncates to a release above itself
209+ # (``1.5.0rc1`` -> ``1.5``), which nothing published satisfies yet.
210+ if _compare (candidate , version ) > 0 and _compare (candidate , latest ) <= 0 :
211+ return candidate
212+ return version
197213 if op in _FLOOR_OPS :
198214 return latest if _compare (latest , version ) > 0 else version
199215 return version
@@ -217,6 +233,10 @@ def rewrite_requirement(spec: str, latest: str, *, loosen: bool = False) -> Rewr
217233 new = f"{ parsed .name } { parsed .extras } >={ latest } { parsed .marker } "
218234 return RewriteResult (None ) if new == spec .strip () else RewriteResult (new )
219235
236+ bad = _unparseable (parsed , latest )
237+ if bad is not None :
238+ return RewriteResult (None , reason = f"unsupported version spelling { bad !r} " )
239+
220240 blocker = _excluded_by (parsed , latest )
221241 if blocker is not None :
222242 return RewriteResult (None , reason = f"{ latest } excluded by { blocker } " )
0 commit comments