def _validate_license(self, license: str) -> str:
from poetry.core.spdx.helpers import license_by_id
if license:
license_by_id(license)
return license
def test_license_by_id_is_case_insensitive() -> None:
license = license_by_id("mit")
assert license.id == "MIT"
license = license_by_id("miT")
assert license.id == "MIT"
def test_license_by_id() -> None:
license = license_by_id("MIT")
assert license.id == "MIT"
assert license.name == "MIT License"
assert license.is_osi_approved
assert not license.is_deprecated
license = license_by_id("LGPL-3.0-or-later")
assert license.id == "LGPL-3.0-or-later"
assert license.name == "GNU Lesser General Public License v3.0 or later"
assert license.is_osi_approved
assert not license.is_deprecated
def test_classifier():
license = license_by_id("lgpl-3.0-or-later")
assert license.classifier == (
"License :: "
"OSI Approved :: "
"GNU Lesser General Public License v3 or later (LGPLv3+)")
def test_license_by_id_custom() -> None:
license = license_by_id("Custom")
assert license.id == "Custom"
assert license.name == "Custom"
assert not license.is_osi_approved
assert not license.is_deprecated
def test_license_by_id_with_full_name():
license = license_by_id("GNU Lesser General Public License v3.0 or later")
assert license.id == "LGPL-3.0-or-later"
assert license.name == "GNU Lesser General Public License v3.0 or later"
assert license.is_osi_approved
assert not license.is_deprecated
def license(self, value: str | License | None) -> None:
from poetry.core.spdx.helpers import license_by_id
from poetry.core.spdx.license import License
if value is None or isinstance(value, License):
self._license = value
else:
self._license = license_by_id(value)
def license(self, value: Optional[Union[str, "License"]]) -> None:
from poetry.core.spdx.helpers import license_by_id
from poetry.core.spdx.license import License # noqa
if value is None:
self._license = value
elif isinstance(value, License):
self._license = value
else:
self._license = license_by_id(value)
def test_classifier_no_classifer():
license = license_by_id("Leptonica")
assert license.classifier == "License :: Other/Proprietary License"
def test_classifier_no_classifer_osi_approved():
license = license_by_id("LiLiQ-R-1.1")
assert license.classifier == "License :: OSI Approved"
def test_classifier_name():
license = license_by_id("lgpl-3.0-or-later")
assert (license.classifier_name ==
"GNU Lesser General Public License v3 or later (LGPLv3+)")
def test_classifier_name_no_classifer_osi_approved():
license = license_by_id("LiLiQ-R-1.1")
assert license.classifier_name is None
def test_proprietary_license() -> None:
license = license_by_id("Proprietary")
assert license.classifier == "License :: Other/Proprietary License"
def configure_package(
cls,
package: ProjectPackage,
config: dict[str, Any],
root: Path,
with_groups: bool = True,
) -> ProjectPackage:
from poetry.core.packages.dependency import Dependency
from poetry.core.packages.dependency_group import MAIN_GROUP
from poetry.core.packages.dependency_group import DependencyGroup
from poetry.core.spdx.helpers import license_by_id
package.root_dir = root
for author in config["authors"]:
package.authors.append(combine_unicode(author))
for maintainer in config.get("maintainers", []):
package.maintainers.append(combine_unicode(maintainer))
package.description = config.get("description", "")
package.homepage = config.get("homepage")
package.repository_url = config.get("repository")
package.documentation_url = config.get("documentation")
try:
license_: License | None = license_by_id(config.get("license", ""))
except ValueError:
license_ = None
package.license = license_
package.keywords = config.get("keywords", [])
package.classifiers = config.get("classifiers", [])
if "readme" in config:
if isinstance(config["readme"], str):
package.readmes = (root / config["readme"], )
else:
package.readmes = tuple(root / readme
for readme in config["readme"])
if "platform" in config:
package.platform = config["platform"]
if "dependencies" in config:
cls._add_package_group_dependencies(
package=package,
group=MAIN_GROUP,
dependencies=config["dependencies"])
if with_groups and "group" in config:
for group_name, group_config in config["group"].items():
group = DependencyGroup(group_name,
optional=group_config.get(
"optional", False))
cls._add_package_group_dependencies(
package=package,
group=group,
dependencies=group_config["dependencies"],
)
if with_groups and "dev-dependencies" in config:
cls._add_package_group_dependencies(
package=package,
group="dev",
dependencies=config["dev-dependencies"])
extras = config.get("extras", {})
for extra_name, requirements in extras.items():
package.extras[extra_name] = []
# Checking for dependency
for req in requirements:
req = Dependency(req, "*")
for dep in package.requires:
if dep.name == req.name:
dep.in_extras.append(extra_name)
package.extras[extra_name].append(dep)
break
if "build" in config:
build = config["build"]
if not isinstance(build, dict):
build = {"script": build}
package.build_config = build or {}
if "include" in config:
package.include = []
for include in config["include"]:
if not isinstance(include, dict):
include = {"path": include}
formats = include.get("format", [])
if formats and not isinstance(formats, list):
formats = [formats]
include["format"] = formats
package.include.append(include)
if "exclude" in config:
package.exclude = config["exclude"]
if "packages" in config:
package.packages = config["packages"]
# Custom urls
if "urls" in config:
package.custom_urls = config["urls"]
return package
def test_license_by_id_invalid() -> None:
with pytest.raises(ValueError):
license_by_id("")
def test_proprietary_license():
license = license_by_id("Proprietary")
assert "License :: Other/Proprietary License" == license.classifier
def test_custom_license():
license = license_by_id("Amazon Software License")
assert "License :: Other/Proprietary License" == license.classifier
def test_classifier_name_no_classifer() -> None:
license = license_by_id("Leptonica")
assert license.classifier_name == "Other/Proprietary License"
