## 2023

- checkrequirements is now a thin wrapper
around poetry show and sets an exit code
only. **Note:** this only supports poetry
based environments. `requirements.txt`
and other build systems are no longer supported!

Author: FredHappyface

CHANGELOG.md

@@ -3,6 +3,10 @@
 All major and minor version changes will be documented in this file. Details of
 patch-level version changes can be found in [commit messages](../../commits/master).
 
+## 2023
+
+- checkrequirements is now a thin wrapper around poetry show and sets an exit code only. **Note:** this only supports poetry based environments. `requirements.txt` and other build systems are no longer supported!
+
 ## 2022.0.1 - 2022/04/06
 
 - Remove metprint

README.md

@@ -13,41 +13,13 @@
 
 <img src="readme-assets/icons/name.png" alt="Project Icon" width="750">
 
-Check that your requirements.txt is up to date with the most recent package
-versions
+Uses poetry to check outdated dependencies and set a status code to 1 if outdated packages are found. This is ideal for ci/cd. If running manually, its better to use poetry directly.
 
-## Example Use
-
-See below for the output if you run `checkrequirements` in this directory
-
-```txt
->> checkrequirements
-+    OK: requests
-+    OK: requirements-parser
-```
-
-### Help
-
-```txt
-usage: __main__.py [-h] [--requirements-file REQUIREMENTS_FILE]
-
-Check that your requirements.txt is up to date with the most recent package versions
-
-optional arguments:
-  -h, --help            show this help message and exit
-  --requirements-file REQUIREMENTS_FILE, -r REQUIREMENTS_FILE
-                        requirements file
-```
-
-You can also import this into your own project and use any of the functions
-in the DOCS
+**Note:** this only supports poetry based environments. `requirements.txt` and other build systems are not currently supported!
 
 <!-- omit in toc -->
 ## Table of Contents
 
-- [Example Use](#example-use)
-	- [Help](#help)
-- [Documentation](#documentation)
 - [Install With PIP](#install-with-pip)
 - [Language information](#language-information)
 	- [Built for](#built-for)
@@ -79,23 +51,6 @@ in the DOCS
 	- [Support](#support)
 	- [Rationale](#rationale)
 
-## Documentation
-
-A high-level overview of how the documentation is organized organized will help you know
-where to look for certain things:
-
-<!--
-- [Tutorials](/documentation/tutorials) take you by the hand through a series of steps to get
-  started using the software. Start here if you’re new.
--->
-- The [Technical Reference](/documentation/reference) documents APIs and other aspects of the
-  machinery. This documentation describes how to use the classes and functions at a lower level
-  and assume that you have a good high-level understanding of the software.
-<!--
-- The [Help](/documentation/help) guide provides a starting point and outlines common issues that you
-  may have.
--->
-
 ## Install With PIP
 
 ```python

checkrequirements/__init__.py

@@ -1,236 +1,20 @@
-"""Check that your requirements.txt is up to date with the most recent packageversions.
-"""
-from __future__ import annotations
+import subprocess
+import sys
 
-import argparse
-import typing
-from pathlib import Path
-from sys import exit as sysexit
-from sys import stdout
 
-import requests
-import requirements
-from requirements.requirement import Requirement
-
-stdout.reconfigure(encoding="utf-8")
-
-
-class UpdateCompatible(typing.TypedDict):
-	"""UpdateCompatible type."""
-
-	ver: str
-	compatible: bool
-
-
-class Dependency(typing.TypedDict):
-	"""Dependency type."""
-
-	name: str
-	specs: tuple[str]
-	ver: str
-	compatible: bool
-
-
-def semver(version: str) -> list[str]:
-	"""Convert a semver/ python-ver string to a list in the form major, minor patch
-
-	Args:
-		version (str): The version to convert
-
-	Returns:
-		list[str]: A list in the form major, minor, patch
-	"""
-	return version.split(".")
-
-
-def semPad(ver: list[str], length: int) -> list[str]:
-	"""Pad a semver list to the required size. e.g. ["1", "0"] to ["1", "0", "0"].
-
-	Args:
-		ver (list[str]): the semver representation
-		length (int): the new length
-
-	Returns:
-		list[str]: the new semver
-	"""
-	char = "0"
-	if ver[-1] == "*":
-		char = "*"
-	return ver + [char] * (length - len(ver))
-
-
-def partCmp(verA: str, verB: str) -> int:
-	"""Compare parts of a semver.
-
-	Args:
-		verA (str): lhs part to compare
-		verB (str): rhs part to compare
-
-	Returns:
-		int: 0 if equal, 1 if verA > verB and -1 if verA < verB
-	"""
-	if verA == verB or verA == "*" or verB == "*":
-		return 0
-	if int(verA) > int(verB):
-		return 1
-	return -1
-
-
-def _doSemCmp(semA: list[str], semB: list[str], sign: str) -> bool:
-	"""Compare two semvers of equal length. e.g. 1.1.1 and 2.2.2.
-
-	Args:
-		semA (list[str]): lhs to compare
-		semB (list[str]): rhs to compare
-		sign (str): string sign. one of ==, ~=, <=, >=, <, >
-
-	Raises:
-		ValueError: if the sign is not one of the following. or the semvers
-		have differing lengths
-
-	Returns:
-		bool: true if the comparison is met. e.g. 1.1.1, 2.2.2, <= -> True
-	"""
-	if len(semA) != len(semB):
-		raise ValueError
-	# Equal. e.g. 1.1.1 == 1.1.1
-	if sign == "==":
-		for index, _elem in enumerate(semA):
-			if partCmp(semA[index], semB[index]) != 0:
-				return False
-		return True
-	# Compatible. e.g. 1.1.2 ~= 1.1.1
-	if sign == "~=":
-		for index, _elem in enumerate(semA[:-1]):
-			if partCmp(semA[index], semB[index]) != 0:
-				return False
-		if partCmp(semA[-1], semB[-1]) < 0:
-			return False
-		return True
-	# Greater than or equal. e.g. 1.1.2 >= 1.1.1
-	if sign == ">=":
-		for index, _elem in enumerate(semA):
-			cmp = partCmp(semA[index], semB[index])
-			if cmp > 0:
-				return True
-			if cmp < 0:
-				return False
-		return True
-	# Less than or equal. e.g. 1.1.1 <= 1.1.2
-	if sign == "<=":
-		for index, _elem in enumerate(semA):
-			cmp = partCmp(semA[index], semB[index])
-			if cmp < 0:
-				return True
-			if cmp > 0:
-				return False
-		return True
-	# Greater than. e.g. 1.1.2 > 1.1.1
-	if sign == ">":
-		for index, _elem in enumerate(semA):
-			cmp = partCmp(semA[index], semB[index])
-			if cmp > 0:
-				return True
-			if cmp < 0:
-				return False
-		return False
-	# Less than. e.g. 1.1.1 < 1.1.2
-	if sign == "<":
-		for index, _elem in enumerate(semA):
-			cmp = partCmp(semA[index], semB[index])
-			if cmp < 0:
-				return True
-			if cmp > 0:
-				return False
-		return False
-	raise ValueError
-
-
-def semCmp(versionA: str, versionB: str, sign: str) -> bool:
-	"""Compare two semvers of any length. e.g. 1.1 and 2.2.2.
-
-	Args:
-		versionA (list[str]): lhs to compare
-		versionB (list[str]): rhs to compare
-		sign (str): string sign. one of ==, ~=, <=, >=, <, >
-
-	Raises:
-		ValueError: if the sign is not one of the following.
-
-	Returns:
-		bool: true if the comparison is met. e.g. 1.1.1, 2.2.2, <= -> True
-	"""
-	semA = semver(versionA)
-	semB = semver(versionB)
-	semLen = max(len(semA), len(semB))
-	return _doSemCmp(semPad(semA, semLen), semPad(semB, semLen), sign)
-
-
-def updateCompatible(req: Requirement) -> UpdateCompatible:
-	"""Check if the most recent version of a python requirement is compatible with
-	the current version.
-
-	Args:
-		req (Requirement): the requirement object as parsed by requirements_parser
-
-	Returns:
-		UpdateCompatible: return a dict of the most recent version (ver) and
-		is our requirement from requirements.txt or similar compatible
-		with the new version per the version specifier (compatible)
-	"""
-	url = f"https://pypi.org/pypi/{req.name}/json"
-	request = requests.get(url)
-	updateVer = request.json()["info"]["version"]
-	for spec in req.specs:
-		if not semCmp(updateVer, spec[1], spec[0]):
-			return {"ver": updateVer, "compatible": False}
-	return {"ver": updateVer, "compatible": True}
-
-
-def checkRequirements(requirementsFile: str) -> list[Dependency]:
-	"""Check that your requirements.txt is up to date with the most recent package
-	versions. Put in a function so dependants can use this function rather than
-	reimplement it themselves.
-
-	Args:
-		requirementsFile (str): file path to the requirements file
-
-	Returns:
-		Dependency: dictionary containing info on each requirement such as the name,
-		specs (from requirements_parser), ver (most recent version), compatible
-		(is our version compatible with ver)
-	"""
-	reqsDict = []
-	for req in requirements.parse(Path(requirementsFile).read_text(encoding="utf-8")):  # type: ignore
-		reqsDict.append(
-			{"name": req.name, "specs": req.specs, **updateCompatible(req)}
-		)  # type: ignore
-	return reqsDict
+def checkForOutdatedPackages():
+	cmd = ["poetry", "show", "--outdated"]
+	result = subprocess.run(cmd, capture_output=True, text=True)
+	return result.stdout.strip().split("\n")[1:]
 
 
 def cli():
-	"""CLI entry point."""
-	parser = argparse.ArgumentParser(description=__doc__)
-	# yapf: disable
-	parser.add_argument("--requirements-file", "-r",
-	help="requirements file")
-	parser.add_argument("--zero", "-0",
-	help="Return non zero exit code if an incompatible license is found", action="store_true")
-	# yapf: enable
-	args = parser.parse_args()
-	reqsDict = checkRequirements(
-		args.requirements_file if args.requirements_file else "requirements.txt"
-	)
-	if len(reqsDict) == 0:
-		print("/  WARN: No requirements")
-	incompat = False
-	for req in reqsDict:
-		name = req["name"]
-		if req["compatible"]:
-			print(f"+    OK: {name}")
-		else:
-			print(f"+ ERROR: {name}")
-			incompat = True
-	if incompat and args.zero:
-		sysexit(1)
-	sysexit(0)
+	outdatedPackages = checkForOutdatedPackages()
+	if outdatedPackages:
+		print("Outdated packages (powered by poetry):")
+		for package in outdatedPackages:
+			print(package)
+	else:
+		print("No outdated packages.")
+
+	sys.exit(1 if outdatedPackages else 0)