forceupdate 0.1.0__py3-none-any.whl

forceupdate/versions/pypi.py

@@ -0,0 +1,220 @@
+"""Les versions PyPI : PEP 440, avec ``packaging``.
+
+Une contrainte est d'abord lue comme un ``SpecifierSet`` de PEP 440 (``>=2.25, <3``,
+``~=1.4``, ``==1.2.*``). Ce que ``SpecifierSet`` refuse est de la syntaxe Poetry ou
+Pipfile, que les parseurs gardent telle qu'écrite (E03), traduite ici en PEP 440 :
+
+- ``^1.2.3`` → ``>=1.2.3,<2.0.0``, ``^0.2.3`` → ``>=0.2.3,<0.3.0``, ``^0.0.3`` →
+  ``>=0.0.3,<0.0.4`` : la borne haute est la prochaine version « cassante » ;
+- ``~1.2.3`` → ``>=1.2.3,<1.3.0``, ``~1`` → ``>=1,<2`` ;
+- ``1.2.*`` (ou ``1.2.x``) → ``==1.2.*``, une version nue ``6.0.2`` → ``==6.0.2`` ;
+- ``*`` (Poetry et Pipfile) : toutes les versions ;
+- plusieurs contraintes séparées par des virgules ou des espaces (``>= 1.2 < 2.0``) ;
+- ``||`` : une union. ``SpecifierSet`` ne sait faire que des intersections, d'où une
+  liste d'ensembles.
+
+Une contrainte est un ensemble de versions : ``2.0rc1`` respecte ``>=1.0``. Ce sont
+les candidates (``VersionScheme.candidates``) qui écartent les pré-versions.
+"""
+
+import functools
+import re
+
+from packaging.specifiers import InvalidSpecifier, SpecifierSet
+from packaging.version import InvalidVersion as _PackagingInvalidVersion
+from packaging.version import Version
+
+from forceupdate.models import Ecosystem, Gap
+from forceupdate.versions.base import Constraint, InvalidConstraint, InvalidVersion, VersionScheme
+
+_LOWER_OPERATORS = frozenset({">=", ">", "==", "~=", "==="})
+"""Les opérateurs qui donnent une borne basse ; ``!=``, ``<`` et ``<=`` n'en donnent pas."""
+
+_OR = re.compile(r"\s*\|\|?\s*")
+_OPERATOR = re.compile(r"===|==|!=|<>|<=|>=|~=|<|>|=|\^|~")
+_SINGLE = re.compile(rf"(?P<op>{_OPERATOR.pattern})?\s*(?P<version>\S+)")
+_ANY = re.compile(r"v?[xX*](?:\.[xX*])*")
+_WILDCARD = re.compile(r"v?(?P<prefix>[0-9]+(?:\.[0-9]+)*)(?:\.[xX*])+")
+
+
+class PypiConstraint(Constraint[Version]):
+    """Une contrainte PEP 440, ou une union de contraintes (``||`` de Poetry)."""
+
+    def __init__(self, sets: tuple[SpecifierSet, ...]) -> None:
+        self.sets = sets
+        """Les ensembles de l'union : une version doit en respecter au moins un."""
+
+    def __repr__(self) -> str:
+        return f"PypiConstraint({' || '.join(str(s) or '*' for s in self.sets)})"
+
+    def contains(self, version: Version) -> bool:
+        return any(specifiers.contains(version, prereleases=True) for specifiers in self.sets)
+
+    def lower_bound(self) -> str | None:
+        """La plus haute borne basse de chaque ensemble, puis la plus petite de l'union. Une
+        borne exclue (``>1.2``) est rendue telle quelle : PEP 440 n'a pas de « version
+        suivante », c'est la meilleure approximation."""
+        lowest: tuple[Version, str] | None = None
+        for specifiers in self.sets:
+            bounds = []
+            for specifier in specifiers:
+                if specifier.operator not in _LOWER_OPERATORS:
+                    continue
+                text = specifier.version.removesuffix(".*")
+                try:
+                    bounds.append((Version(text), text))
+                except _PackagingInvalidVersion:
+                    continue  # « === » accepte n'importe quel texte
+            if not bounds:
+                return None
+            bound = max(bounds, key=lambda pair: pair[0])
+            if lowest is None or bound[0] < lowest[0]:
+                lowest = bound
+        return None if lowest is None else lowest[1]
+
+    def exact(self) -> str | None:
+        """``==1.2.3`` (sans joker) ou ``===1.2.3``, seul : sa version. Une version nue de
+        Poetry (``6.0.2``) est traduite en ``==``."""
+        if len(self.sets) != 1:
+            return None
+        specifiers = list(self.sets[0])
+        if len(specifiers) != 1:
+            return None
+        (specifier,) = specifiers
+        if specifier.operator == "===" or (
+            specifier.operator == "==" and not specifier.version.endswith(".*")
+        ):
+            return specifier.version
+        return None
+
+
+class PypiVersions(VersionScheme[Version]):
+    """PEP 440. L'époque (``1!2.0``) compte : en changer est une majeure."""
+
+    ecosystem = Ecosystem.PYPI
+
+    def parse(self, version: str) -> Version:
+        return _parse(version)
+
+    def parse_constraint(self, constraint: str) -> PypiConstraint:
+        return _parse_constraint(constraint)
+
+    def _release(self, version: Version) -> tuple[int, int, int]:
+        major, minor, patch = (*version.release, 0, 0)[:3]
+        return major, minor, patch
+
+    def _is_pre(self, version: Version) -> bool:
+        return version.is_prerelease
+
+    def _same_release(self, a: Version, b: Version) -> bool:
+        return (a.epoch, _stripped(a.release)) == (b.epoch, _stripped(b.release))
+
+    def _gap(self, a: Version, b: Version) -> Gap:
+        if a.epoch != b.epoch:
+            return Gap.MAJOR
+        return super()._gap(a, b)
+
+
+PYPI = PypiVersions()
+
+
+def _stripped(release: tuple[int, ...]) -> tuple[int, ...]:
+    """``(1, 2, 0)`` → ``(1, 2)`` : ``1.2`` et ``1.2.0`` sont la même version."""
+    end = len(release)
+    while end > 1 and release[end - 1] == 0:
+        end -= 1
+    return release[:end]
+
+
+@functools.lru_cache(maxsize=4096)
+def _parse(version: str) -> Version:
+    try:
+        return Version(version)
+    except _PackagingInvalidVersion:
+        raise InvalidVersion(f"version PEP 440 illisible : {version!r}") from None
+
+
+@functools.lru_cache(maxsize=1024)
+def _parse_constraint(constraint: str) -> PypiConstraint:
+    try:
+        return PypiConstraint((SpecifierSet(constraint),))
+    except InvalidSpecifier:
+        pass
+    try:
+        return PypiConstraint(tuple(_poetry_set(part) for part in _OR.split(constraint.strip())))
+    except ValueError:  # InvalidSpecifier et InvalidVersion de packaging en sont
+        message = f"contrainte PEP 440 ou Poetry illisible : {constraint!r}"
+        raise InvalidConstraint(message) from None
+
+
+def _poetry_set(text: str) -> SpecifierSet:
+    """Un membre d'une union Poetry : des contraintes séparées par des virgules ou des
+    espaces, toutes à respecter. Un opérateur seul (``>= 1.2``) va avec ce qui suit. Un
+    membre vide (``^1 || || ^2``) est refusé, comme le fait Poetry."""
+    if not text.strip():
+        raise ValueError(text)
+    specifiers: list[str] = []
+    operator = ""
+    for token in re.split(r"[\s,]+", text):
+        if not token:
+            continue
+        if _OPERATOR.fullmatch(token):
+            if operator:
+                raise ValueError(token)
+            operator = token
+            continue
+        specifiers.extend(_poetry_single(operator + token))
+        operator = ""
+    if operator:
+        raise ValueError(operator)
+    return SpecifierSet(",".join(specifiers))
+
+
+def _poetry_single(text: str) -> list[str]:
+    """Une contrainte Poetry, en spécificateurs PEP 440 (aucun pour ``*``)."""
+    match = _SINGLE.fullmatch(text)
+    if match is None:
+        raise ValueError(text)
+    operator, written = match.group("op") or "", match.group("version")
+    if _ANY.fullmatch(written):
+        if operator not in ("", "=", "==", ">="):
+            raise ValueError(text)
+        return []
+    wildcard = _WILDCARD.fullmatch(written)
+    if wildcard is not None:
+        if operator not in ("", "=", "==", "!="):
+            raise ValueError(text)
+        return [f"{'!=' if operator == '!=' else '=='}{wildcard.group('prefix')}.*"]
+    version = Version(written)
+    if operator == "^":
+        return [f">={version}", f"<{_next_breaking(version)}"]
+    if operator == "~":
+        index = 0 if len(version.release) == 1 else 1
+        return [f">={version}", f"<{_bump(version, index)}"]
+    if operator in ("", "="):
+        return [f"=={version}"]
+    if operator == "<>":
+        return [f"!={version}"]
+    return [f"{operator}{version}"]
+
+
+def _next_breaking(version: Version) -> str:
+    """La borne haute de ``^`` : la prochaine majeure, ou en 0.x la prochaine mineure
+    (``^0.2.3`` → ``0.3.0``), ou en 0.0.x le prochain correctif (``^0.0.3`` → ``0.0.4``).
+    Comme Poetry, ``^0`` va jusqu'à ``1`` et ``^0.0`` jusqu'à ``0.1``."""
+    release = version.release
+    if release[0] > 0 or len(release) == 1:
+        return _bump(version, 0)
+    if release[1] > 0 or len(release) == 2:
+        return _bump(version, 1)
+    return _bump(version, 2)
+
+
+def _bump(version: Version, index: int) -> str:
+    """La version stable où le nombre ``index`` monte de 1 et ceux d'après passent à 0,
+    écrite avec autant de nombres que ``version`` : ``1.2.3`` monté en 1 donne ``1.3.0``."""
+    release = version.release
+    width = max(len(release), index + 1)
+    numbers = (*release[:index], release[index] + 1, *([0] * (width - index - 1)))
+    text = ".".join(str(number) for number in numbers)
+    return f"{version.epoch}!{text}" if version.epoch else text

forceupdate-0.1.0.dist-info/METADATA

@@ -0,0 +1,79 @@
+Metadata-Version: 2.5
+Name: forceupdate
+Version: 0.1.0
+Summary: Trouve les dépendances à mettre à jour (versions, failles, fins de vie) et fait les mises à jour : en local, ou par pull request sur GitHub, GitLab et Bitbucket.
+Project-URL: Homepage, https://github.com/Pauzzle-ozz/forceupdate
+Project-URL: Repository, https://github.com/Pauzzle-ozz/forceupdate
+Project-URL: Issues, https://github.com/Pauzzle-ozz/forceupdate/issues
+Author: Pauzzle
+License-Expression: MIT
+License-File: LICENSE
+Keywords: dependencies,end-of-life,osv,outdated,pull-request,update,vulnerabilities
+Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: Environment :: Console
+Classifier: Environment :: Web Environment
+Classifier: Intended Audience :: Developers
+Classifier: Natural Language :: French
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Security
+Classifier: Topic :: Software Development
+Classifier: Topic :: System :: Software Distribution
+Classifier: Topic :: Utilities
+Requires-Python: >=3.11
+Requires-Dist: httpx>=0.28.1
+Requires-Dist: packaging>=26.3
+Requires-Dist: platformdirs>=4.13.6
+Requires-Dist: pyyaml>=6.0.3
+Requires-Dist: rich>=15.0.0
+Requires-Dist: typer>=0.27.3
+Description-Content-Type: text/markdown
+
+# forceupdate
+
+On donne du code à l'outil : un dossier, un fichier, ou tous ses dépôts GitHub,
+GitLab et Bitbucket. Dans une interface web qui tourne sur son ordinateur, il
+montre les langages et les dépendances, et dit ce qui doit être mis à jour :
+versions en retard, failles, fins de vie, paquets dépréciés. On coche les mises à
+jour voulues, puis il les fait : en local il réécrit les fichiers, sur une forge il
+ouvre une pull request par dépôt.
+
+En construction. L'outil sera publié gratuitement sur PyPI
+(`uv tool install forceupdate`), sous licence MIT.
+
+Déjà là, en ligne de commande, pour Python et npm : `forceupdate scan <dossier>`
+dit quelles dépendances ont une faille connue (d'après [OSV](https://osv.dev),
+indirectes comprises, avec la version qui la corrige), une version plus récente,
+une version retirée, ou sont dépréciées.
+
+```bash
+forceupdate scan .                              # rapport dans le terminal
+forceupdate scan . --format json -o rapport.json   # ou md ; toujours en UTF-8
+forceupdate scan . --fail-on vuln               # code 1 si une faille est connue
+forceupdate scan . --fail-on major              # code 1 si une majeure (ou pire) attend
+forceupdate scan . --offline                    # seulement le cache, sans réseau
+```
+
+Autres options : `--no-dev`, `--transitive`, `--no-cache` (`forceupdate scan --help`).
+
+`forceupdate update <dossier>` montre, pour l'instant sans rien écrire, les mises à
+jour qu'il ferait : vers quelle version, quelle contrainte réécrire (dans son style :
+`^4.17.0` devient `^4.21.2`), quel lockfile régénérer. Correctifs, mineures et
+corrections de failles sont choisis ; les majeures sont proposées à part.
+
+```bash
+forceupdate update .                     # correctifs et mineures (--level minor)
+forceupdate update . --level major       # majeures comprises
+forceupdate update . --security-only     # seulement les corrections de failles
+forceupdate update . --exclude "eslint*" --ecosystem npm
+```
+
+- [docs/BRIEF.md](docs/BRIEF.md) : l'idée, les décisions prises, les pièges
+- [docs/JSON_FORMAT.md](docs/JSON_FORMAT.md) : le format du rapport JSON
+- [PLAN.md](PLAN.md) : le plan étape par étape, et l'avancement
+- [reference/README.md](reference/README.md) : le code déjà disponible, repris d'Argos

forceupdate-0.1.0.dist-info/RECORD

@@ -0,0 +1,50 @@
+forceupdate/__init__.py,sha256=nvXmzV66i6mGi0cA6KGe9XAFI6ZFsC_JAGh2hXRBhiw,294
+forceupdate/__main__.py,sha256=qdONtCBWrdHpmsR0pgXnNG0aES0L1naFQfF4ii-ZMyY,145
+forceupdate/cli.py,sha256=2mlXt_EFwln4aKCVYK6d7Br-Cw1cMoPHna1rBjciElc,10266
+forceupdate/engine.py,sha256=MiWJZPidF3DIdNiLHcMr0rcYbWuAoPkAT09C56XdQ04,13502
+forceupdate/models.py,sha256=1cPhuI2PSYpFiuxezYQD5Rjv9gHaXrLKzpK5ZbHmCSo,21051
+forceupdate/advisories/__init__.py,sha256=FlLhOJuX4IrWypwkASzO1EmkgkE5sRkoCvPBDxiu4ZA,726
+forceupdate/advisories/cvss.py,sha256=OG2BRnq4wfeQO21gQLQMH7LSLZgpkBg4Vfu7V1JjdL8,3910
+forceupdate/advisories/osv.py,sha256=B3WMX_kbMdnKwQWvzU8XOTxLPNHoNO1GqHVcfXYpe4A,24468
+forceupdate/checks/__init__.py,sha256=df1PxBVmvYVZ9b1-_Reo8qR2pT4Bg7XXDXvIHehLNFo,1992
+forceupdate/checks/base.py,sha256=eCWBN52oMB16IIWm8KiqRMEkycRpYY0y_tqtDxtaFcc,4530
+forceupdate/checks/deprecated.py,sha256=-ltM-uk70bagACwPI28ppisvcdKHDuSKeJQ7TkwRh5w,4896
+forceupdate/checks/outdated.py,sha256=AGLce2rwGHMLt_a_oEJQjxS-zgiEeM2joALFaTSHpaU,8466
+forceupdate/checks/priority.py,sha256=8glruncOQ9B9dqtzV_9ktpJTwmZUF87OBG153Y74tlk,3257
+forceupdate/checks/vulns.py,sha256=qbyvE7VOPoTXIlxJjlN-VfVpLwo7QWsPs03PbNTkcAc,9074
+forceupdate/detect/__init__.py,sha256=pMbCQpPnourANnrMc-REg1xdxSFRsRUX1thsjVpqOPs,252
+forceupdate/detect/languages.py,sha256=OrPZ-XKsb65S_j6ZNmnKxhtbVWb-Li1mwZqFgQyAFuk,8182
+forceupdate/detect/manifests.py,sha256=FuoQwBGSs1gl3yMHV-YdhGhnNSX3OxWxeBuYv45qK3U,16855
+forceupdate/net/__init__.py,sha256=gcRKy3BPqjSXWNl3IHp5n2VOFOAA1cOsmK20swFQZWI,613
+forceupdate/net/cache.py,sha256=RRLpVQ6Vjx-lvb128j03CwcVzImcFQmKNsGorZhsQSc,8357
+forceupdate/net/http.py,sha256=LSYu_NkCrfV5d94Ab8SO1WYc91FnJELk1162QRK6XoI,10756
+forceupdate/parsers/__init__.py,sha256=6h1t46qCtJfFL5yqIfuFGShkGM4Rmnvp1KPmgDbDF9U,2050
+forceupdate/parsers/base.py,sha256=VrXxJA2Ji3PzMW4-2vWSVaZNZ42oRaUJ6gNKjY88Ff8,852
+forceupdate/parsers/json_spans.py,sha256=ywu0LyEvwloh3ggu-gIKIRlI-2KY4ofqrIrBrVs7oiA,4615
+forceupdate/parsers/lockfiles.py,sha256=pjqTEY1rttqXhCGKI9e744ufgiGhYhZX55OQ2AUrAd8,9276
+forceupdate/parsers/npm.py,sha256=ToMjPZ2NR06MKcF0FZK9VSWOQPrMg6QqiT7dLCeTxuY,51959
+forceupdate/parsers/python.py,sha256=35l3wylybIi3P7FXnZBkK5e6HBEiQIeh0M2MfxiRigg,54764
+forceupdate/parsers/toml_spans.py,sha256=_RQ6XE8aPYeuGgDhcTXZJrI5aSB6htSe0stpvhsU0cA,11277
+forceupdate/registries/__init__.py,sha256=t4RB2YnItGB6SSdvFRLI29-kXoTC02gAlicw_yhODx4,1585
+forceupdate/registries/base.py,sha256=EszlJsJcoQAlr4eQxG7Rg1o5rTeh-CYMes2qntuqxkc,11958
+forceupdate/registries/npm.py,sha256=qCJEnwxSJLhXZc4CB_PJlkSUF9tziPtmdBR9wiX3KrM,6000
+forceupdate/registries/pypi.py,sha256=1Bzxtc6ntk8tUy3Y16OaEngRhJm142TcZcWcFhxPLnM,9503
+forceupdate/report/__init__.py,sha256=cKQ7z_8Zcc1Mus1IZ4Ph-WitZTDEj0XwPnZqdDbgvjc,14008
+forceupdate/report/json.py,sha256=VeC-edvPMMfJO3GyDjHJYp7bWbYsRujVLayu4d6nGWk,1249
+forceupdate/report/markdown.py,sha256=HxFo1kqmFfF-6aU4n37CaKXXeHxk46ID2nfheU4pLUw,6873
+forceupdate/report/terminal.py,sha256=I9AeLVAdk5DLNBbb7la-_Hne4FQ7A07S0iA__Mc-sE8,14434
+forceupdate/sources/__init__.py,sha256=cCTdZagiRUJX9xfvGq-xSQ9wfO9NTIxCUnNm52uc1yU,92
+forceupdate/sources/base.py,sha256=hi30KkEJ906hmGg2Dw2KGupbb_LDJQiJq8p_VwRmwac,1465
+forceupdate/sources/local.py,sha256=o33l7kuzrisc3zc2QJEcBQJWqkeYlJJklTmzStQGDE4,6728
+forceupdate/update/__init__.py,sha256=hY4Jv05vixin7erLsgFgV6dc8YdtAcGoOWvGKNG6Y64,387
+forceupdate/update/constraints.py,sha256=JwmTmu5MEBFTAYWhC3KA2bc0yYorIr3YE_-MMhMiX_I,13686
+forceupdate/update/planner.py,sha256=veqf1e5AcZh83XXr-ADsIYmCdpW9GuJ-4qU0Ra5SUtA,24177
+forceupdate/versions/__init__.py,sha256=ncj35iHZmtN1REuNiZ050ngZEFZ13MSnrQCuD37-Imo,1355
+forceupdate/versions/base.py,sha256=ovJJ3fpy83j-E-6PVIKSsEyHTg5svWd3JYYBLpgf5_E,9747
+forceupdate/versions/npm.py,sha256=3afAoPKY3PhTlTy-N_hON2mCyFeGuy8fvf7sf_Mql9I,16108
+forceupdate/versions/pypi.py,sha256=p2_U7LrUpwOq7-RXw2vp0GinLF2_LLHSKeGhKa2aD70,8831
+forceupdate-0.1.0.dist-info/METADATA,sha256=uLpo1mYMxUcnO36xisrd5JG3-YonmytaUUzrYsHxS7o,3861
+forceupdate-0.1.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+forceupdate-0.1.0.dist-info/entry_points.txt,sha256=z9xkY45qdOeWnoRw-Ll0ZoYHiHvXaSy7E6jkxQ_vKts,52
+forceupdate-0.1.0.dist-info/licenses/LICENSE,sha256=UtjnCPB9u2A_FtDj1lqxhH8XUS8wqjAkh2Df-dIIpMY,1064
+forceupdate-0.1.0.dist-info/RECORD,,

forceupdate-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.4
+Root-Is-Purelib: true
+Tag: py3-none-any

forceupdate-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+forceupdate = forceupdate.cli:app

forceupdate-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Pauzzle
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.