refactor

Author: FredHappyface

licensecheck/__init__.py

@@ -1,5 +1,5 @@
 """Entry point for python -m licensecheck."""
 
-from licensecheck.cli import cli, main
+from licensecheck.io.cli import cli, main
 
 _ = (cli, main)

licensecheck/__main__.py

@@ -2,6 +2,6 @@
 
 from __future__ import annotations
 
-from licensecheck import cli
+from licensecheck.io.cli import cli
 
 cli()

licensecheck/checker.py

@@ -5,8 +5,10 @@
 from fnmatch import fnmatch
 
 from licensecheck import license_matrix
+from licensecheck.models.constants import JOINS
+from licensecheck.models.license import License
+from licensecheck.models.packageinfo import PackageInfo
 from licensecheck.packageinfo import PackageInfoManager
-from licensecheck.types import JOINS, License, PackageInfo, ucstr
 
 
 def check(
@@ -15,12 +17,12 @@ def check(
 	extras: set[str],
 	this_license: License,
 	package_info_manager: PackageInfoManager,
-	ignore_packages: set[ucstr] | None = None,
-	fail_packages: set[ucstr] | None = None,
-	ignore_licenses: set[ucstr] | None = None,
-	fail_licenses: set[ucstr] | None = None,
-	only_licenses: set[ucstr] | None = None,
-	skip_dependencies: set[ucstr] | None = None,
+	ignore_packages: set[str] | None = None,
+	fail_packages: set[str] | None = None,
+	ignore_licenses: set[str] | None = None,
+	fail_licenses: set[str] | None = None,
+	only_licenses: set[str] | None = None,
+	skip_dependencies: set[str] | None = None,
 ) -> tuple[bool, set[PackageInfo]]:
 	# Def values
 	ignore_packages = ignore_packages or set()
@@ -38,10 +40,10 @@ def check(
 	)
 
 	ignoreLicensesType = license_matrix.licenseType(
-		ucstr(JOINS.join(ignore_licenses)), ignore_licenses
+		str(JOINS.join(ignore_licenses)), ignore_licenses
 	)
-	failLicensesType = license_matrix.licenseType(ucstr(JOINS.join(fail_licenses)), ignore_licenses)
-	onlyLicensesType = license_matrix.licenseType(ucstr(JOINS.join(only_licenses)), ignore_licenses)
+	failLicensesType = license_matrix.licenseType(str(JOINS.join(fail_licenses)), ignore_licenses)
+	onlyLicensesType = license_matrix.licenseType(str(JOINS.join(only_licenses)), ignore_licenses)
 	# licenseType will always return NO_LICENSE when onlyLicenses is empty
 	if License.NO_LICENSE in onlyLicensesType:
 		onlyLicensesType.remove(License.NO_LICENSE)
@@ -60,7 +62,7 @@ def check(
 		else:
 			package.licenseCompat = license_matrix.depCompatWMyLice(
 				this_license,
-				license_matrix.licenseType(ucstr(package.license), ignore_licenses),
+				license_matrix.licenseType(str(package.license), ignore_licenses),
 				ignoreLicensesType,
 				failLicensesType,
 				onlyLicensesType,

tests/platform_independent/__init__.py licensecheck/io/__init__.pytests/platform_independent/__init__.py renamed to licensecheck/io/__init__.py

@@ -1,6 +1,4 @@
-"""Output the licenses used by dependencies and check if these are compatible with the project
-license.
-"""
+"""Output the licenses used by dependencies and check if these are compatible with the project license."""
 
 from __future__ import annotations
 
@@ -9,12 +7,14 @@
 from pathlib import Path
 from sys import exit as sysexit
 from sys import stdin, stdout
-from typing import Any
 
 from configurator import Config
 from configurator.node import ConfigNode
 
-from licensecheck import checker, fmt, license_matrix, packageinfo, types
+from licensecheck import checker, license_matrix, packageinfo
+from licensecheck.io import fmt
+from licensecheck.models.config import LC_Config
+from licensecheck.models.packageinfo import PackageInfo
 
 stdout.reconfigure(encoding="utf-8")  # type: ignore[general-type-issues]
 
@@ -115,23 +115,11 @@ def cli() -> None:  # pragma: no cover
 		else:
 			stdin_path.write_text("\n".join(stdin.readlines()), encoding="utf-8")
 
-	ec = main(args)
-	stdin_path.unlink(missing_ok=True)
-
-	sysexit(ec)
-
-
-def main(args: dict[str, Any]) -> int:
-	"""Test entry point.
-
-	Note: FHConfParser (Parses in the following order: `pyproject.toml`,
-	`setup.cfg`, `licensecheck.toml`, `licensecheck.json`,
-	`licensecheck.ini`, `~/licensecheck.toml`, `~/licensecheck.json`, `~/licensecheck.ini`)
-	"""
-	exitCode = 0
-
 	config: ConfigNode = Config()
 
+	# (Parses in the following order: `pyproject.toml`,
+	# `setup.cfg`, `licensecheck.toml`, `licensecheck.json`,
+	# `licensecheck.ini`, `~/licensecheck.toml`, `~/licensecheck.json`, `~/licensecheck.ini`)
 	config_files = [
 		"~/licensecheck.json",
 		"~/licensecheck.toml",
@@ -145,71 +133,79 @@ def main(args: dict[str, Any]) -> int:
 		config += Config.from_path(file, optional=True)
 
 	scopedData: ConfigNode = config.get("tool", {}).get("licensecheck", ConfigNode())
-	scopedConfig: dict[str, Any] = {**scopedData.data, **args}
+	licensecheckConf: LC_Config = LC_Config.from_mapping(**scopedData.data, **args)
+
+	ec = main(licensecheckConf)
+	stdin_path.unlink(missing_ok=True)
+
+	sysexit(ec)
+
+
+def main(licensecheckConf: LC_Config) -> int:
+	"""Test entry point."""
+	exitCode = 0
 
 	# File
-	requirements_paths = scopedConfig.get("requirements_paths") or ["__stdin__"]
+	requirements_paths = licensecheckConf.requirements_paths or {"__stdin__"}
 	output_file = (
 		stdout
-		if scopedConfig.get("file") in [None, ""]
-		else Path(scopedConfig.get("file", "")).open("w", encoding="utf-8")
+		if licensecheckConf.file in [None, ""]
+		else Path(licensecheckConf.file or "").open("w", encoding="utf-8")
 	)
 
 	# Get my license
-	this_license_text = scopedConfig.get("license") or packageinfo.ProjectMetadata.get_license()
+	this_license_text = licensecheckConf.license or packageinfo.ProjectMetadata.get_license()
 	this_license = license_matrix.licenseType(this_license_text).pop()
 
-	def getFromConfig(key: str) -> set[types.ucstr]:
-		return set(map(types.ucstr, scopedConfig.get(key, [])))
-
 	package_info_manager = packageinfo.PackageInfoManager(
-		scopedConfig.get("pypi_api", "https://pypi.org")
+		licensecheckConf.pypi_api or "https://pypi.org"
 	)
 
 	incompatible, depsWithLicenses = checker.check(
 		requirements_paths=set(requirements_paths),
-		groups=set(scopedConfig.get("groups", [])),
-		extras=set(scopedConfig.get("extras", [])),
+		groups=licensecheckConf.groups,
+		extras=licensecheckConf.extras,
 		this_license=this_license,
 		package_info_manager=package_info_manager,
-		ignore_packages=getFromConfig("ignore_packages"),
-		fail_packages=getFromConfig("fail_packages"),
-		ignore_licenses=getFromConfig("ignore_licenses"),
-		fail_licenses=getFromConfig("fail_licenses"),
-		only_licenses=getFromConfig("only_licenses"),
-		skip_dependencies=getFromConfig("skip_dependencies"),
+		ignore_packages=licensecheckConf.ignore_packages,
+		fail_packages=licensecheckConf.fail_packages,
+		ignore_licenses=licensecheckConf.ignore_licenses,
+		fail_licenses=licensecheckConf.fail_licenses,
+		only_licenses=licensecheckConf.only_licenses,
+		skip_dependencies=licensecheckConf.skip_dependencies,
 	)
 
 	# Format the results
-	hide_output_parameters = [
-		types.ucstr(x) for x in scopedConfig.get("hide_output_parameters", [])
-	]
-	available_params = [param.name.upper() for param in fields(types.PackageInfo)]
+	hide_output_parameters = licensecheckConf.hide_output_parameters
+
+	available_params = [param.name.upper() for param in fields(PackageInfo)]
 	if not all(hop in available_params for hop in hide_output_parameters):
 		msg = (
 			f"Invalid parameter(s) in `hide_output_parameters`. "
 			f"Valid parameters are: {', '.join(available_params)}"
 		)
 		raise ValueError(msg)
-	if scopedConfig.get("format", "simple") in fmt.formatMap:
+
+	format_ = licensecheckConf.format or "simple"
+	if licensecheckConf.format in fmt.formatMap:
 		print(
 			fmt.fmt(
-				scopedConfig.get("format", "simple"),
+				format_,
 				this_license,
 				sorted(depsWithLicenses),
 				hide_output_parameters,
-				show_only_failing=scopedConfig.get("show_only_failing", False),
+				show_only_failing=licensecheckConf.show_only_failing,
 			),
 			file=output_file,
 		)
 	else:
 		exitCode = 2
 
 	# Exit code of 1 if args.zero
-	if scopedConfig.get("zero", False) and incompatible:
+	if licensecheckConf.zero and incompatible:
 		exitCode = 1
 
 	# Cleanup + exit
-	if scopedConfig.get("file") not in [None, ""]:
+	if licensecheckConf.file not in [None, ""]:
 		output_file.close()
 	return exitCode

licensecheck/cli.py licensecheck/io/cli.pylicensecheck/cli.py renamed to licensecheck/io/cli.py

@@ -1,4 +1,5 @@
-"""The formatter is reponsible for outputting the list of PackageInfo[s].
+"""
+The formatter is reponsible for outputting the list of PackageInfo[s].
 
 Note the PackageInfo has the following attributes, that we can use to build each output format:
 - name: str
@@ -7,7 +8,7 @@
 - size: int = -1
 - homePage: str
 - author: str
-- license: ucstr
+- license: str
 - licenseCompat: bool
 - errorCode: int = 0
 
@@ -51,7 +52,8 @@
 from rich.console import Console
 from rich.table import Table
 
-from licensecheck.types import License, PackageInfo, ucstr
+from licensecheck.models.license import License
+from licensecheck.models.packageinfo import PackageInfo
 
 THISDIR = Path(__file__).resolve().parent
 
@@ -63,12 +65,12 @@
 
 
 def _printLicense(licenseEnum: License) -> str:
-	"""Output a license as plain text.
+	"""
+	Output a license as plain text.
 
 	:param License licenseEnum: License
 	:return str: license of plain text
 	"""
-
 	licenseMap = {
 		License.PUBLIC: "PUBLIC DOMAIN/ CC-PDDC/ CC0-1.0",
 		License.UNLICENSE: "UNLICENSE/ WTFPL",
@@ -105,7 +107,8 @@ def _printLicense(licenseEnum: License) -> str:
 
 
 def stripAnsi(string: str) -> str:
-	"""Strip ansi codes from a given string.
+	"""
+	Strip ansi codes from a given string.
 
 	Args:
 	----
@@ -123,13 +126,13 @@ def ansi(
 	myLice: License,
 	packages: list[dict[str, Any]],
 ) -> str:
-	"""Format to ansi.
+	"""
+	Format to ansi.
 
 	:param License myLice: project license
 	:param list[dict[str, Any]] packages: list of PackageCompats to format.
 	:return str: string to send to specified output in ansi format
 	"""
-
 	string = StringIO()
 
 	console = Console(file=string, color_system="truecolor", safe_box=False)
@@ -181,7 +184,8 @@ def plainText(
 	myLice: License,
 	packages: list[dict[str, Any]],
 ) -> str:
-	"""Format to plain text.
+	"""
+	Format to plain text.
 
 	:param License myLice: project license
 	:param list[dict[str, Any]] packages: list of PackageCompats to format.
@@ -195,13 +199,13 @@ def markdown(
 	myLice: License,
 	packages: list[dict[str, Any]],
 ) -> str:
-	"""Format to markdown.
+	"""
+	Format to markdown.
 
 	:param License myLice: project license
 	:param list[dict[str, Any]] packages: list of PackageCompats to format.
 	:return str: string to send to specified output in markdown format
 	"""
-
 	info = "\n".join(f"- {k}: {v}" for k, v in INFO.items())
 	strBuf = [f"## Info\n\n{info}\n\n## Project License\n\n{_printLicense(myLice)}\n"]
 
@@ -242,7 +246,8 @@ def html(
 	myLice: License,
 	packages: list[dict[str, Any]],
 ) -> str:
-	"""Format to html.
+	"""
+	Format to html.
 
 	:param License myLice: project license
 	:param list[dict[str, Any]] packages: list of PackageCompats to format.
@@ -256,13 +261,13 @@ def html(
 
 
 def raw(myLice: License, packages: list[dict[str, Any]]) -> str:
-	"""Format to json.
+	"""
+	Format to json.
 
 	:param License myLice: project license
 	:param list[dict[str, Any]] packages: list of PackageCompats to format.
 	:return str: string to send to specified output in json format
 	"""
-
 	return json.dumps(
 		{
 			"info": INFO,
@@ -277,13 +282,13 @@ def rawCsv(
 	myLice: License,
 	packages: list[dict[str, Any]],
 ) -> str:
-	"""Format to csv.
+	"""
+	Format to csv.
 
 	:param License myLice: project license
 	:param list[dict[str, Any]] packages: list of PackageCompats to format.
 	:return str: string to send to specified output in csv format
 	"""
-
 	if len(packages) == 0:
 		return ""
 
@@ -299,19 +304,20 @@ def fmt(
 	format_: str,
 	myLice: License,
 	packages: list[PackageInfo],
-	hide_parameters: list[ucstr] | None = None,
+	hide_parameters: set[str] | None = None,
 	*,
 	show_only_failing: bool = False,
 ) -> str:
-	"""Format to a given format by `format_`.
+	"""
+	Format to a given format by `format_`.
 
 	:param License myLice: project license
 	:param list[PackageInfo] packages: list of PackageCompats to format.
-	:param list[ucstr] hide_parameters: list of parameters to ignore in the output.
+	:param set[str] hide_parameters: set of parameters to ignore in the output.
 	:param bool show_only_failing: output only failing packages, defaults to False.
 	:return str: string to send to specified output in ansi format
 	"""
-	hide_parameters = hide_parameters or []
+	hide_parameters = hide_parameters or set()
 	if show_only_failing:
 		packages = [x for x in packages if not x.licenseCompat]