def test_wheel_package():
module_path = fixtures_dir / 'complete'
WheelBuilder.make(Poetry.create(str(module_path)), NullVenv(), NullIO())
whl = module_path / 'dist' / 'my_package-1.2.3-py3-none-any.whl'
assert whl.exists()
def test_wheel_module():
module_path = fixtures_dir / 'module1'
WheelBuilder.make(Poetry.create(str(module_path)), NullVenv(), NullIO())
whl = module_path / 'dist' / 'module1-0.1-py2.py3-none-any.whl'
assert whl.exists()
def test_wheel_prerelease():
module_path = fixtures_dir / "prerelease"
WheelBuilder.make(Poetry.create(str(module_path)), NullEnv(), NullIO())
whl = module_path / "dist" / "prerelease-0.1b1-py2.py3-none-any.whl"
assert whl.exists()
def test_package_with_include(mocker):
# Patch git module to return specific excluded files
p = mocker.patch("poetry.vcs.git.Git.get_ignored_files")
p.return_value = [
str(
Path(__file__).parent / "fixtures" / "with-include" / "extra_dir" /
"vcs_excluded.txt"),
str(
Path(__file__).parent / "fixtures" / "with-include" / "extra_dir" /
"sub_pkg" / "vcs_excluded.txt"),
]
module_path = fixtures_dir / "with-include"
WheelBuilder.make(Poetry.create(str(module_path)), NullEnv(), NullIO())
whl = module_path / "dist" / "with_include-1.2.3-py3-none-any.whl"
assert whl.exists()
with zipfile.ZipFile(str(whl)) as z:
names = z.namelist()
assert len(names) == len(set(names))
assert "with_include-1.2.3.dist-info/LICENSE" in names
assert "extra_dir/__init__.py" in names
assert "extra_dir/vcs_excluded.txt" in names
assert "extra_dir/sub_pkg/__init__.py" in names
assert "extra_dir/sub_pkg/vcs_excluded.txt" not in names
assert "my_module.py" in names
assert "notes.txt" in names
assert "package_with_include/__init__.py" in names
def test_make_setup():
poetry = Poetry.create(project("complete"))
builder = SdistBuilder(poetry, NullVenv(), NullIO())
setup = builder.build_setup()
setup_ast = ast.parse(setup)
setup_ast.body = [n for n in setup_ast.body if isinstance(n, ast.Assign)]
ns = {}
exec(compile(setup_ast, filename="setup.py", mode="exec"), ns)
assert ns["packages"] == [
"my_package",
"my_package.sub_pkg1",
"my_package.sub_pkg2",
]
assert ns["install_requires"] == [
"cachy[msgpack]>=0.2.0,<0.3.0", "cleo>=0.6,<0.7"
]
assert ns["entry_points"] == {
"console_scripts": [
"my-2nd-script = my_package:main2",
"my-script = my_package:main",
]
}
assert ns["extras_require"] == {"time": ["pendulum>=1.4,<2.0"]}
def test_poetry_with_multi_constraints_dependency():
poetry = Poetry.create(
str(fixtures_dir / "project_with_multi_constraints_dependency"))
package = poetry.package
assert len(package.requires) == 2
def poetry(self) -> Poetry:
if self._poetry is not None:
return self._poetry
self._poetry = Poetry.create(os.getcwd())
return self._poetry
def test_complete():
module_path = fixtures_dir / 'complete'
builder = CompleteBuilder(Poetry.create(module_path), NullVenv(True),
NullIO())
builder.build()
whl = module_path / 'dist' / 'my_package-1.2.3-py3-none-any.whl'
assert whl.exists()
zip = zipfile.ZipFile(str(whl))
try:
entry_points = zip.read('my_package-1.2.3.dist-info/entry_points.txt')
assert decode(entry_points.decode()) == """\
[console_scripts]
my-2nd-script=my_package:main2
my-script=my_package:main
"""
wheel_data = decode(zip.read('my_package-1.2.3.dist-info/WHEEL'))
assert wheel_data == """\
Wheel-Version: 1.0
Generator: poetry {}
Root-Is-Purelib: true
Tag: py3-none-any
""".format(__version__)
wheel_data = decode(zip.read('my_package-1.2.3.dist-info/METADATA'))
assert wheel_data == """\
Metadata-Version: 2.1
Name: my-package
Version: 1.2.3
Summary: Some description.
Home-page: https://poetry.eustace.io/
License: MIT
Keywords: packaging,dependency,poetry
Author: Sébastien Eustace
Author-email: [email protected]
Requires-Python: >=3.6,<4.0
Classifier: License :: OSI Approved :: MIT License
Classifier: Programming Language :: Python :: 3
Classifier: Programming Language :: Python :: 3.6
Classifier: Programming Language :: Python :: 3.7
Classifier: Topic :: Software Development :: Build Tools
Classifier: Topic :: Software Development :: Libraries :: Python Modules
Provides-Extra: time
Requires-Dist: cachy[msgpack] (>=0.2.0,<0.3.0)
Requires-Dist: cleo (>=0.6,<0.7)
Requires-Dist: pendulum (>=1.4,<2.0); extra == "time"
Description-Content-Type: text/x-rst
My Package
==========
"""
finally:
zip.close()
def test_with_src_module_dir():
poetry = Poetry.create(project('source_package'))
builder = SdistBuilder(poetry, NullVenv(), NullIO())
# Check setup.py
setup = builder.build_setup()
setup_ast = ast.parse(setup)
setup_ast.body = [n for n in setup_ast.body if isinstance(n, ast.Assign)]
ns = {}
exec(compile(setup_ast, filename="setup.py", mode="exec"), ns)
assert ns['package_dir'] == {'': 'src'}
assert ns['packages'] == [
'package_src',
]
builder.build()
sdist = fixtures_dir / 'source_package' / 'dist' / 'package-src-0.1.tar.gz'
assert sdist.exists()
tar = tarfile.open(str(sdist), 'r')
assert 'package-src-0.1/src/package_src/__init__.py' in tar.getnames()
assert 'package-src-0.1/src/package_src/module.py' in tar.getnames()
def test_with_src_module_dir():
poetry = Poetry.create(project("source_package"))
builder = SdistBuilder(poetry, NullVenv(), NullIO())
# Check setup.py
setup = builder.build_setup()
setup_ast = ast.parse(setup)
setup_ast.body = [n for n in setup_ast.body if isinstance(n, ast.Assign)]
ns = {}
exec(compile(setup_ast, filename="setup.py", mode="exec"), ns)
assert ns["package_dir"] == {"": "src"}
assert ns["packages"] == ["package_src"]
builder.build()
sdist = fixtures_dir / "source_package" / "dist" / "package-src-0.1.tar.gz"
assert sdist.exists()
tar = tarfile.open(str(sdist), "r")
assert "package-src-0.1/src/package_src/__init__.py" in tar.getnames()
assert "package-src-0.1/src/package_src/module.py" in tar.getnames()
def test_package_src():
module_path = fixtures_dir / "source_package"
builder = CompleteBuilder(
Poetry.create(module_path), NullEnv(execute=True), NullIO()
)
builder.build()
sdist = module_path / "dist" / "package-src-0.1.tar.gz"
assert sdist.exists()
with tarfile.open(str(sdist), "r") as tar:
assert "package-src-0.1/src/package_src/module.py" in tar.getnames()
whl = module_path / "dist" / "package_src-0.1-py2.py3-none-any.whl"
assert whl.exists()
zip = zipfile.ZipFile(str(whl))
try:
assert "package_src/__init__.py" in zip.namelist()
assert "package_src/module.py" in zip.namelist()
finally:
zip.close()
def test_wheel_prerelease():
module_path = fixtures_dir / "prerelease"
WheelBuilder.make(Poetry.create(str(module_path)), NullVenv(), NullIO())
whl = module_path / "dist" / "prerelease-0.1b1-py2.py3-none-any.whl"
assert whl.exists()
def prepare_metadata_for_build_wheel(metadata_directory, config_settings=None):
name = prepare_metadata_for_build_wheel.__wrapped__(
metadata_directory, config_settings)
if os.environ.get('READTHEDOCS') != 'True':
return name
poetry = Poetry.create(".")
metadata = Path(metadata_directory) / name / 'METADATA'
text = metadata.read_text(encoding='utf-8')
try:
# Start of long description.
index = text.index('\n\n')
except ValueError:
# End of text, minus trailing newline.
index = len(text) - 1
dev_requires = '\n'.join(f'Requires-Dist: {d.to_pep_508()}'
for d in poetry.package.dev_requires)
new_text = f'{text[:index]}\n{dev_requires}{text[index:]}'
metadata.write_text(new_text, encoding='utf-8')
Path('/tmp/foo.txt').write_text(new_text, encoding='utf-8')
return name
def build_sdist(sdist_directory, config_settings=None):
"""Builds an sdist, places it in sdist_directory"""
poetry = Poetry.create(".")
path = SdistBuilder(poetry, SystemEnv(Path(sys.prefix)),
NullIO()).build(Path(sdist_directory))
return unicode(path.name)
def _get_package(path):
poetry = Poetry.create(path)
package = poetry._package
package.scripts = poetry._local_config.get('scripts')
builder = Builder(poetry, venv=None, io=NullIO)
# builder.find_files_to_add()
package.entrypoints = builder.convert_entry_points()
return package
def handle(self):
# Load poetry config and display errors, if any
poetry_file = Poetry.locate(Path.cwd())
config = TomlFile(str(poetry_file)).read()["tool"]["poetry"]
check_result = Poetry.check(config, strict=True)
if not check_result["errors"] and not check_result["warnings"]:
self.info("All set!")
return 0
for error in check_result["errors"]:
self.line("<error>Error: {}</error>".format(error))
for error in check_result["warnings"]:
self.line("<warning>Warning: {}</warning>".format(error))
return 1
def test_create_fails_on_invalid_configuration():
with pytest.raises(RuntimeError) as e:
Poetry.create(
Path(__file__).parent / "fixtures" / "invalid_pyproject" / "pyproject.toml"
)
if PY2:
expected = """\
The Poetry configuration is invalid:
- u'description' is a required property
"""
else:
expected = """\
The Poetry configuration is invalid:
- 'description' is a required property
"""
assert expected == str(e.value)
def test_make_pkg_info(mocker):
get_metadata_content = mocker.patch(
"poetry.masonry.builders.builder.Builder.get_metadata_content")
poetry = Poetry.create(project("complete"))
builder = SdistBuilder(poetry, NullEnv(), NullIO())
builder.build_pkg_info()
assert get_metadata_content.called
def build_wheel(wheel_directory, config_settings=None, metadata_directory=None):
"""Builds a wheel, places it in wheel_directory"""
poetry = Poetry.create(".")
return unicode(
WheelBuilder.make_in(
poetry, SystemEnv(Path(sys.prefix)), NullIO(), Path(wheel_directory)
)
)
def get_requires_for_build_wheel(config_settings=None):
"""
Returns a list of requirements for building, as strings
"""
poetry = Poetry.create(".")
main, _ = SdistBuilder.convert_dependencies(poetry.package, poetry.package.requires)
return main
def poetry(self):
from poetry.poetry import Poetry
if self._poetry is not None:
return self._poetry
self._poetry = Poetry.create(os.getcwd())
return self._poetry
def test_proper_python_requires_if_three_digits_precision_version_specified():
poetry = Poetry.create(project("single_python"))
builder = SdistBuilder(poetry, NullEnv(), NullIO())
pkg_info = builder.build_pkg_info()
p = Parser()
parsed = p.parsestr(to_str(pkg_info))
assert parsed["Requires-Python"] == "==2.7.15"
def test_proper_python_requires_if_single_version_specified():
poetry = Poetry.create(project("simple_version"))
builder = SdistBuilder(poetry, NullVenv(), NullIO())
pkg_info = builder.build_pkg_info()
p = Parser()
parsed = p.parsestr(to_str(pkg_info))
assert parsed["Requires-Python"] == ">=3.6,<3.7"
def test_package_with_include(mocker):
# Patch git module to return specific excluded files
p = mocker.patch("poetry.vcs.git.Git.get_ignored_files")
p.return_value = [
str(
Path(__file__).parent
/ "fixtures"
/ "with-include"
/ "extra_dir"
/ "vcs_excluded.txt"
),
str(
Path(__file__).parent
/ "fixtures"
/ "with-include"
/ "extra_dir"
/ "sub_pkg"
/ "vcs_excluded.txt"
),
]
poetry = Poetry.create(project("with-include"))
builder = SdistBuilder(poetry, NullEnv(), NullIO())
# Check setup.py
setup = builder.build_setup()
setup_ast = ast.parse(setup)
setup_ast.body = [n for n in setup_ast.body if isinstance(n, ast.Assign)]
ns = {}
exec(compile(setup_ast, filename="setup.py", mode="exec"), ns)
assert "package_dir" not in ns
assert ns["packages"] == ["extra_dir", "extra_dir.sub_pkg", "package_with_include"]
assert ns["package_data"] == {"": ["*"]}
assert ns["modules"] == ["my_module"]
builder.build()
sdist = fixtures_dir / "with-include" / "dist" / "with-include-1.2.3.tar.gz"
assert sdist.exists()
with tarfile.open(str(sdist), "r") as tar:
names = tar.getnames()
assert len(names) == len(set(names))
assert "with-include-1.2.3/LICENSE" in names
assert "with-include-1.2.3/README.rst" in names
assert "with-include-1.2.3/extra_dir/__init__.py" in names
assert "with-include-1.2.3/extra_dir/vcs_excluded.txt" in names
assert "with-include-1.2.3/extra_dir/sub_pkg/__init__.py" in names
assert "with-include-1.2.3/extra_dir/sub_pkg/vcs_excluded.txt" not in names
assert "with-include-1.2.3/my_module.py" in names
assert "with-include-1.2.3/notes.txt" in names
assert "with-include-1.2.3/package_with_include/__init__.py" in names
assert "with-include-1.2.3/pyproject.toml" in names
assert "with-include-1.2.3/setup.py" in names
assert "with-include-1.2.3/PKG-INFO" in names
def poetry(self):
from poetry.poetry import Poetry
if self._poetry is not None:
return self._poetry
self._poetry = Poetry.create(os.getcwd())
return self._poetry
def test_prelease():
poetry = Poetry.create(project('prerelease'))
builder = SdistBuilder(poetry, NullVenv(), NullIO())
builder.build()
sdist = fixtures_dir / 'prerelease' / 'dist' / 'prerelease-0.1b1.tar.gz'
assert sdist.exists()
def test_package():
poetry = Poetry.create(project('complete'))
builder = SdistBuilder(poetry, NullVenv(), NullIO())
builder.build()
sdist = fixtures_dir / 'complete' / 'dist' / 'my-package-1.2.3.tar.gz'
assert sdist.exists()
def test_prelease():
poetry = Poetry.create(project("prerelease"))
builder = SdistBuilder(poetry, NullEnv(), NullIO())
builder.build()
sdist = fixtures_dir / "prerelease" / "dist" / "prerelease-0.1b1.tar.gz"
assert sdist.exists()
def test_make_pkg_info_any_python():
poetry = Poetry.create(project("module1"))
builder = SdistBuilder(poetry, NullEnv(), NullIO())
pkg_info = builder.build_pkg_info()
p = Parser()
parsed = p.parsestr(to_str(pkg_info))
assert "Requires-Python" not in parsed
def poetry(tmp_dir: str, config: Config) -> Poetry:
poetry = Poetry(
CWD / "pyproject.toml",
{},
ProjectPackage("simple-project", "1.2.3"),
Locker(CWD / "poetry.lock", {}),
config,
)
return poetry
def test_wheel_package():
module_path = fixtures_dir / "complete"
WheelBuilder.make(Poetry.create(str(module_path)), NullEnv(), NullIO())
whl = module_path / "dist" / "my_package-1.2.3-py3-none-any.whl"
assert whl.exists()
with zipfile.ZipFile(str(whl)) as z:
assert "my_package/sub_pkg1/__init__.py" in z.namelist()
def test_wheel_module_src():
module_path = fixtures_dir / "source_file"
WheelBuilder.make(Poetry.create(str(module_path)), NullEnv(), NullIO())
whl = module_path / "dist" / "module_src-0.1-py2.py3-none-any.whl"
assert whl.exists()
with zipfile.ZipFile(str(whl)) as z:
assert "module_src.py" in z.namelist()
def test_wheel_module_src():
module_path = fixtures_dir / "source_file"
WheelBuilder.make(Poetry.create(str(module_path)), NullVenv(), NullIO())
whl = module_path / "dist" / "module_src-0.1-py2.py3-none-any.whl"
assert whl.exists()
z = zipfile.ZipFile(str(whl))
assert "module_src.py" in z.namelist()
def test_wheel_package():
module_path = fixtures_dir / "complete"
WheelBuilder.make(Poetry.create(str(module_path)), NullVenv(), NullIO())
whl = module_path / "dist" / "my_package-1.2.3-py3-none-any.whl"
assert whl.exists()
z = zipfile.ZipFile(str(whl))
assert "my_package/sub_pkg1/__init__.py" in z.namelist()
def test_poetry_with_packages_and_includes():
poetry = Poetry.create(
str(fixtures_dir.parent / "masonry" / "builders" / "fixtures" / "with-include")
)
package = poetry.package
assert package.packages == [
{"include": "extra_dir/**/*.py"},
{"include": "my_module.py"},
{"include": "package_with_include"},
]
assert package.include == ["extra_dir/vcs_excluded.txt", "notes.txt"]
def test_wheel_c_extension():
module_path = fixtures_dir / "extended"
builder = CompleteBuilder(Poetry.create(module_path), NullVenv(True), NullIO())
builder.build()
sdist = fixtures_dir / "extended" / "dist" / "extended-0.1.tar.gz"
assert sdist.exists()
tar = tarfile.open(str(sdist), "r")
assert "extended-0.1/build.py" in tar.getnames()
assert "extended-0.1/extended/extended.c" in tar.getnames()
whl = list((module_path / "dist").glob("extended-0.1-cp*-cp*-*.whl"))[0]
assert whl.exists()
zip = zipfile.ZipFile(str(whl))
has_compiled_extension = False
for name in zip.namelist():
if name.startswith("extended/extended") and name.endswith((".so", ".pyd")):
has_compiled_extension = True
assert has_compiled_extension
try:
wheel_data = decode(zip.read("extended-0.1.dist-info/WHEEL"))
assert (
re.match(
"""(?m)^\
Wheel-Version: 1.0
Generator: poetry {}
Root-Is-Purelib: false
Tag: cp[23]\d-cp[23]\dmu?-.+
$""".format(
__version__
),
wheel_data,
)
is not None
)
finally:
zip.close()
def test_module_src():
module_path = fixtures_dir / "source_file"
builder = CompleteBuilder(Poetry.create(module_path), NullVenv(True), NullIO())
builder.build()
sdist = module_path / "dist" / "module-src-0.1.tar.gz"
assert sdist.exists()
with tarfile.open(str(sdist), "r") as tar:
assert "module-src-0.1/src/module_src.py" in tar.getnames()
whl = module_path / "dist" / "module_src-0.1-py2.py3-none-any.whl"
assert whl.exists()
zip = zipfile.ZipFile(str(whl))
try:
assert "module_src.py" in zip.namelist()
finally:
zip.close()
PEP-517 compliant buildsystem API
"""
import logging
from pathlib import Path
from poetry.poetry import Poetry
from poetry.io import NullIO
from poetry.utils.venv import Venv
from .builders import SdistBuilder
from .builders import WheelBuilder
log = logging.getLogger(__name__)
# PEP 517 specifies that the CWD will always be the source tree
poetry = Poetry.create(".")
def get_requires_for_build_wheel(config_settings=None):
"""
Returns a list of requirements for building, as strings
"""
main, extras = SdistBuilder.convert_dependencies(poetry.package.requires)
return main + extras
# For now, we require all dependencies to build either a wheel or an sdist.
get_requires_for_build_sdist = get_requires_for_build_wheel
def test_check_fails():
complete = TomlFile(fixtures_dir / "complete.toml")
content = complete.read()["tool"]["poetry"]
content["this key is not in the schema"] = ""
with pytest.raises(InvalidProjectFile):
Poetry.check(content)
def test_complete():
module_path = fixtures_dir / "complete"
builder = CompleteBuilder(Poetry.create(module_path), NullVenv(True), NullIO())
builder.build()
whl = module_path / "dist" / "my_package-1.2.3-py3-none-any.whl"
assert whl.exists()
zip = zipfile.ZipFile(str(whl))
try:
entry_points = zip.read("my_package-1.2.3.dist-info/entry_points.txt")
assert (
decode(entry_points.decode())
== """\
[console_scripts]
my-2nd-script=my_package:main2
my-script=my_package:main
"""
)
wheel_data = decode(zip.read("my_package-1.2.3.dist-info/WHEEL"))
assert (
wheel_data
== """\
Wheel-Version: 1.0
Generator: poetry {}
Root-Is-Purelib: true
Tag: py3-none-any
""".format(
__version__
)
)
wheel_data = decode(zip.read("my_package-1.2.3.dist-info/METADATA"))
assert (
wheel_data
== """\
Metadata-Version: 2.1
Name: my-package
Version: 1.2.3
Summary: Some description.
Home-page: https://poetry.eustace.io/
License: MIT
Keywords: packaging,dependency,poetry
Author: Sébastien Eustace
Author-email: [email protected]
Requires-Python: >=3.6,<4.0
Classifier: License :: OSI Approved :: MIT License
Classifier: Programming Language :: Python :: 3
Classifier: Programming Language :: Python :: 3.6
Classifier: Programming Language :: Python :: 3.7
Classifier: Topic :: Software Development :: Build Tools
Classifier: Topic :: Software Development :: Libraries :: Python Modules
Provides-Extra: time
Requires-Dist: cachy[msgpack] (>=0.2.0,<0.3.0)
Requires-Dist: cleo (>=0.6,<0.7)
Requires-Dist: pendulum (>=1.4,<2.0); extra == "time"
Description-Content-Type: text/x-rst
My Package
==========
"""
)
finally:
zip.close()
def test_poetry():
poetry = Poetry.create(str(fixtures_dir / "sample_project"))
package = poetry.package
assert package.name == "my-package"
assert package.version.text == "1.2.3"
assert package.description == "Some description."
assert package.authors == ["Sébastien Eustace <*****@*****.**>"]
assert package.license.id == "MIT"
assert (
package.readme.relative_to(fixtures_dir).as_posix()
== "sample_project/README.rst"
)
assert package.homepage == "https://poetry.eustace.io"
assert package.repository_url == "https://github.com/sdispater/poetry"
assert package.keywords == ["packaging", "dependency", "poetry"]
assert package.python_versions == "~2.7 || ^3.6"
assert str(package.python_constraint) == ">=2.7,<2.8 || >=3.6,<4.0"
dependencies = {}
for dep in package.requires:
dependencies[dep.name] = dep
cleo = dependencies["cleo"]
assert cleo.pretty_constraint == "^0.6"
assert not cleo.is_optional()
pendulum = dependencies["pendulum"]
assert pendulum.pretty_constraint == "branch 2.0"
assert pendulum.is_vcs()
assert pendulum.vcs == "git"
assert pendulum.branch == "2.0"
assert pendulum.source == "https://github.com/sdispater/pendulum.git"
assert pendulum.allows_prereleases()
requests = dependencies["requests"]
assert requests.pretty_constraint == "^2.18"
assert not requests.is_vcs()
assert not requests.allows_prereleases()
assert requests.is_optional()
assert requests.extras == ["security"]
pathlib2 = dependencies["pathlib2"]
assert pathlib2.pretty_constraint == "^2.2"
assert pathlib2.python_versions == "~2.7"
assert not pathlib2.is_optional()
demo = dependencies["demo"]
assert demo.is_file()
assert not demo.is_vcs()
assert demo.name == "demo"
assert demo.pretty_constraint == "0.1.0"
demo = dependencies["my-package"]
assert not demo.is_file()
assert demo.is_directory()
assert not demo.is_vcs()
assert demo.name == "my-package"
assert demo.pretty_constraint == "0.1.2"
assert demo.package.requires[0].name == "pendulum"
assert demo.package.requires[1].name == "cachy"
assert demo.package.requires[1].extras == ["msgpack"]
simple_project = dependencies["simple-project"]
assert not simple_project.is_file()
assert simple_project.is_directory()
assert not simple_project.is_vcs()
assert simple_project.name == "simple-project"
assert simple_project.pretty_constraint == "1.2.3"
assert simple_project.package.requires == []
assert "db" in package.extras
classifiers = package.classifiers
assert classifiers == [
"Topic :: Software Development :: Build Tools",
"Topic :: Software Development :: Libraries :: Python Modules",
]
assert package.all_classifiers == [
"License :: OSI Approved :: MIT License",
"Programming Language :: Python :: 2",
"Programming Language :: Python :: 2.7",
"Programming Language :: Python :: 3",
"Programming Language :: Python :: 3.6",
"Programming Language :: Python :: 3.7",
"Topic :: Software Development :: Build Tools",
"Topic :: Software Development :: Libraries :: Python Modules",
]
def __init__(
self,
path, # type: Path
category="main", # type: str
optional=False, # type: bool
base=None, # type: Path
develop=False, # type: bool
):
from . import dependency_from_pep_508
from .package import Package
self._path = path
self._base = base
self._full_path = path
self._develop = develop
if self._base and not self._path.is_absolute():
self._full_path = self._base / self._path
if not self._full_path.exists():
raise ValueError("Directory {} does not exist".format(self._path))
if self._full_path.is_file():
raise ValueError("{} is a file, expected a directory".format(self._path))
# Checking content to dertermine actions
setup = self._full_path / "setup.py"
pyproject = TomlFile(self._full_path / "pyproject.toml")
has_poetry = False
if pyproject.exists():
pyproject_content = pyproject.read(True)
has_poetry = (
"tool" in pyproject_content and "poetry" in pyproject_content["tool"]
)
if not setup.exists() and not has_poetry:
raise ValueError(
"Directory {} does not seem to be a Python package".format(
self._full_path
)
)
if has_poetry:
from poetry.masonry.builders import SdistBuilder
from poetry.poetry import Poetry
poetry = Poetry.create(self._full_path)
builder = SdistBuilder(poetry, NullVenv(), NullIO())
with setup.open("w") as f:
f.write(decode(builder.build_setup()))
package = poetry.package
self._package = Package(package.pretty_name, package.version)
self._package.requires += package.requires
self._package.dev_requires += package.dev_requires
self._package.python_versions = package.python_versions
self._package.platform = package.platform
else:
# Execute egg_info
current_dir = os.getcwd()
os.chdir(str(self._full_path))
try:
cwd = base
venv = Venv.create(NullIO(), cwd=cwd)
venv.run("python", "setup.py", "egg_info")
finally:
os.chdir(current_dir)
egg_info = list(self._full_path.glob("*.egg-info"))[0]
meta = pkginfo.UnpackedSDist(str(egg_info))
if meta.requires_dist:
reqs = list(meta.requires_dist)
else:
reqs = []
requires = egg_info / "requires.txt"
if requires.exists():
with requires.open() as f:
reqs = parse_requires(f.read())
package = Package(meta.name, meta.version)
package.description = meta.summary
for req in reqs:
package.requires.append(dependency_from_pep_508(req))
if meta.requires_python:
package.python_versions = meta.requires_python
if meta.platforms:
platforms = [p for p in meta.platforms if p.lower() != "unknown"]
if platforms:
package.platform = " || ".join(platforms)
self._package = package
self._package.source_type = "directory"
self._package.source_url = self._path.as_posix()
super(DirectoryDependency, self).__init__(
self._package.name,
self._package.version,
category=category,
optional=optional,
allows_prereleases=True,
)
def test_check():
complete = TomlFile(fixtures_dir / "complete.toml")
content = complete.read(raw=True)["tool"]["poetry"]
assert Poetry.check(content)