def test_dump(requirements_path: Path):
converter = PoetryConverter()
resolver = converter.load_resolver(requirements_path / 'poetry.toml')
reqs = Requirement.from_graph(graph=resolver.graph, lock=False)
assert len(reqs) > 2
content = converter.dumps(reqs=reqs, project=resolver.graph.metainfo)
assert 'requests = ' in content
assert 'extras = ["security"]' in content
assert 'toml = "==0.*,>=0.9.0"' in content
assert 'https://github.com/django/django.git' in content
parsed = tomlkit.parse(content)['tool']['poetry']
assert '>=0.9' in parsed['dependencies']['toml']
assert '>=2.13' in parsed['dependencies']['requests']['version']
assert {'security'} == set(parsed['dependencies']['requests']['extras'])
assert parsed['dependencies']['pathlib2']['allows-prereleases'] is True
assert parsed['dependencies']['pathlib2']['python'] == '==2.7.*,>=2.7.0'
assert parsed['dependencies']['django'][
'git'] == 'https://github.com/django/django.git'
assert parsed['dependencies']['django']['rev'] == '1.11.4'
assert 'pytest' in parsed['dev-dependencies']
def test_format_req():
deps = DependencyMaker.from_params(
raw_name='Django',
constraint='>=1.9',
source=RootDependency(),
)
content = PIPFileConverter()._format_req(Requirement(deps[0], lock=False))
assert content == '>=1.9'
def fast_filter(root, *, deep=True):
resolver = Resolver(
graph=Graph(root),
mutator=Mutator(),
)
resolver.graph.fast_apply()
resolver.apply_envs(envs={'main'}, deep=deep)
reqs = Requirement.from_graph(resolver.graph, lock=False)
return {req.name: req for req in reqs}
def test_dump():
converter = PIPFileConverter()
resolver = converter.load_resolver(Path('tests') / 'requirements' / 'pipfile.toml')
reqs = Requirement.from_graph(graph=resolver.graph, lock=False)
assert len(reqs) > 2
content = converter.dumps(reqs=reqs, project=resolver.graph.metainfo)
assert 'requests = ' in content
assert "extras = ['socks']" in content
assert 'records = ">0.5.0"' in content
def test_dump_dependency_links(temp_path):
path = Path('tests') / 'requirements' / 'egg-info'
temp_path /= 'test.egg-info'
converter = EggInfoConverter()
resolver = converter.load_resolver(path)
reqs = Requirement.from_graph(graph=resolver.graph, lock=False)
converter.dump(reqs=reqs, path=temp_path, project=resolver.graph.metainfo)
content = (temp_path / 'dependency_links.txt').read_text()
assert content.strip() == 'git+https://github.com/gwtwod/poetrylibtest#egg=libtest'
def test_dump(requirements_path: Path):
converter = PIPFileLockConverter()
resolver = converter.load_resolver(requirements_path / 'pipfile.lock.json')
reqs = Requirement.from_graph(graph=resolver.graph, lock=False)
assert len(reqs) > 2
content = converter.dumps(reqs=reqs, project=resolver.graph.metainfo)
content = json.loads(content)
assert content['default']['chardet']['version'] == '==3.0.4'
assert 'nose' not in content['default']
assert 'nose' in content['develop']
def test_dump(requirements_path: Path):
converter = PoetryLockConverter()
resolver = converter.load_resolver(requirements_path / 'poetry.lock.toml')
reqs = Requirement.from_graph(graph=resolver.graph, lock=False)
assert len(reqs) > 2
content = converter.dumps(reqs=reqs, project=resolver.graph.metainfo)
assert 'name = "enum34"' in content
assert 'Python 3.4 Enum backported' in content
parsed = tomlkit.parse(content)['package']
parsed = {dep['name']: dep for dep in parsed}
def test_load_dump_load_deps(converter, path):
root1 = converter.load(path)
reqs1 = Requirement.from_graph(graph=Graph(root1), lock=False)
content = converter.dumps(reqs1, project=root1)
root2 = converter.loads(content)
reqs2 = Requirement.from_graph(graph=Graph(root2), lock=False)
map1 = {req.name: req for req in reqs1}
map2 = {req.name: req for req in reqs2}
assert set(map1) == set(map2), 'loaded and dumped different deps set'
# check all params
exclude = {'sources', 'description'}
if isinstance(converter, converters.EggInfoConverter):
exclude.add('git')
for name, req1 in map1.items():
req2 = map2[name]
d1 = {k: v for k, v in req1 if k not in exclude}
d2 = {k: v for k, v in req2 if k not in exclude}
assert d1 == d2
# check warehouse URL
for name, req1 in map1.items():
req2 = map2[name]
if isinstance(req1.dep.repo, RepositoriesRegistry):
assert len(req1.dep.repo.repos) == len(req2.dep.repo.repos)
for repo1, repo2 in zip(req1.dep.repo.repos, req2.dep.repo.repos):
assert repo1.name == repo2.name
assert repo1.url == repo2.url
# exactly one dev or main env should be specified for dep
for name, req1 in map1.items():
req2 = map2[name]
assert req1.is_dev is not req1.is_main
assert req2.is_dev is not req2.is_main
# check envs (extras)
for name, req1 in map1.items():
req2 = map2[name]
assert req1.dep.envs == req2.dep.envs
def test_dumps_deps(requirements_path: Path):
path = requirements_path / 'setup.py'
converter = SetupPyConverter()
resolver = converter.load_resolver(path)
reqs = Requirement.from_graph(graph=resolver.graph, lock=False)
assert len(reqs) > 2
content = converter.dumps(reqs=reqs, project=resolver.graph.metainfo)
print(content)
root = SetupPyConverter().loads(content)
needed = {'attrs', 'cached-property', 'packaging', 'requests', 'colorama', 'libtest'}
assert {dep.name for dep in root.dependencies} == needed
def test_dumps_deps():
path = Path('tests') / 'requirements' / 'sdist.tar.gz'
converter = SDistConverter()
resolver = converter.load_resolver(path)
reqs = Requirement.from_graph(graph=resolver.graph, lock=False)
assert len(reqs) > 2
content = EggInfoConverter().dumps(reqs=reqs, project=resolver.graph.metainfo)
assert 'Requires-Dist: requests' in content
parsed = Parser().parsestr(content)
needed = {'attrs', 'cached-property', 'packaging', 'requests'}
assert set(parsed.get_all('Requires-Dist')) == needed
def test_preserve_path(temp_path: Path, path: str, expected: str):
(temp_path / 'project').mkdir()
(temp_path / 'project' / 'setup.py').touch()
req_path = (temp_path / 'requirements.txt')
req_path.write_text(path)
converter = PIPConverter(lock=False).copy(project_path=temp_path)
root = converter.load(req_path)
req = Requirement(dep=root.dependencies[0], lock=False)
dumped = converter.dumps(reqs=[req], project=root)
if expected is None:
expected = path
assert dumped.strip() == expected
def test_load_dump_load_metainfo(converter, path, exclude):
root1 = converter.load(path)
reqs1 = Requirement.from_graph(graph=Graph(root1), lock=False)
content = converter.dumps(reqs1, project=root1)
root2 = converter.loads(content)
root1.dependencies = None
root2.dependencies = None
for field in exclude:
setattr(root1, field, None)
setattr(root2, field, None)
assert attr.asdict(root1) == attr.asdict(root2)
def test_conda_dumps_new():
root = RootDependency(raw_name='check-me')
deps = []
deps.extend(DependencyMaker.from_requirement(source=root, req='matplotlib==2.0.2'))
deps.extend(DependencyMaker.from_requirement(source=root, req='numpy'))
reqs = [Requirement(dep=dep, lock=False) for dep in deps]
content = CondaConverter().dumps(reqs=reqs, project=root)
doc = yaml_load(content)
assert doc['name'] == 'check-me'
assert doc['channels'] == ['defaults']
assert doc['dependencies'] == ['matplotlib ==2.0.2', 'numpy']
def test_dependency_links_load():
content = """
__import__("setuptools").setup(
name="lol",
version="0.1.0",
install_requires=["libtest"],
dependency_links=["git+https://github.com/gwtwod/poetrylibtest#egg=libtest-0.1.0"],
)
"""
converter = SetupPyConverter()
resolver = converter.loads_resolver(content.strip())
reqs = Requirement.from_graph(graph=resolver.graph, lock=False)
reqs = {req.name: req for req in reqs}
assert type(reqs['libtest'].link) is VCSLink
def test_dumps_metainfo():
path = Path('tests') / 'requirements' / 'egg-info'
converter = EggInfoConverter()
resolver = converter.load_resolver(path)
reqs = Requirement.from_graph(graph=resolver.graph, lock=False)
assert len(reqs) > 2
content = converter.dumps(reqs=reqs, project=resolver.graph.metainfo)
assert 'Requires-Dist: requests' in content
parsed = Parser().parsestr(content)
assert parsed.get('Name') == 'dephell'
assert parsed.get('Version') == '0.2.0'
assert parsed.get('Home-Page') == 'https://github.com/orsinium/dephell'
def check(root: RootDependency,
resolved: bool = True,
missed=None,
envs: set = None,
**deps):
resolver = Resolver(
graph=Graph(root),
mutator=Mutator(),
)
with patch(
target='dephell.controllers._dependency.get_repo',
return_value=resolver.graph._roots[0].repo,
):
result = resolver.resolve(debug=True, silent=True)
if envs is not None:
resolver.apply_envs(envs=envs)
reqs = Requirement.from_graph(resolver.graph, lock=True)
reqs = {req.name: req for req in reqs}
try:
assert result is resolved
except AssertionError:
if result is False:
print(analyze_conflict(resolver=resolver))
raise
assert resolver.graph.applied
for name in sorted(deps.keys()):
if name not in reqs:
raise AssertionError('Dep not in graph: ' + name)
print(name, reqs[name].version)
for name, version in deps.items():
assert reqs[name].version == version, '{}: {} != {}'.format(
name, reqs[name].version, version)
if missed:
for name in missed:
assert name not in reqs, '{} must be missed but it is not'.format(
name)
def test_dumps_deps(requirements_path: Path):
path = requirements_path / 'egg-info'
converter = EggInfoConverter()
resolver = converter.load_resolver(path)
reqs = Requirement.from_graph(graph=resolver.graph, lock=False)
assert len(reqs) > 2
content = converter.dumps(reqs=reqs, project=resolver.graph.metainfo)
assert 'Requires-Dist: requests' in content
parsed = Parser().parsestr(content)
needed = {
'attrs',
'cached-property',
'packaging',
'requests',
'libtest',
'colorama; extra == "windows"',
}
assert set(parsed.get_all('Requires-Dist')) == needed
def test_preserve_reqs_format(req, temp_path: Path):
content = dedent("""
[tool.poetry]
name = "test"
version = "1.2.3"
[tool.poetry.dependencies]
python = "*"
{req}
""").format(req=req)
converter = PoetryConverter(project_path=temp_path)
resolver = converter.loads_resolver(content)
reqs = Requirement.from_graph(graph=resolver.graph, lock=False)
new_content = converter.dumps(
reqs=reqs,
project=resolver.graph.metainfo,
content=content,
)
assert content == new_content
def test_repository_preserve(converter):
repo = RepositoriesRegistry()
repo.add_repo(url='https://example.com', name='insane')
repo.add_repo(url='https://pypi.org/simple/', name='pypi')
root = RootDependency()
dep1 = DependencyMaker.from_params(
source=root,
raw_name='dephell',
constraint='*',
repo=repo,
)[0]
req = Requirement(dep=dep1, roots=[root.name], lock=False)
content1 = converter.dumps([req], project=root)
root2 = converter.loads(content1)
assert len(root2.dependencies) == 1
dep2 = root2.dependencies[0]
repos1 = [attr.asdict(repo) for repo in dep1.repo.repos]
repos2 = [attr.asdict(repo) for repo in dep2.repo.repos]
assert repos1 == repos2
def test_format():
root = RootDependency()
text = ('hypothesis[django]<=3.0.0; '
'python_version == "2.7" and '
'platform_python_implementation == "CPython"')
req = PackagingRequirement(text)
deps = DependencyMaker.from_requirement(root, req)
# test dep
assert deps[0].name == 'hypothesis'
assert deps[1].name == 'hypothesis[django]'
assert str(deps[0].constraint) == '<=3.0.0'
assert str(deps[0].marker).startswith('python_version == "2.7"')
# test format
req = Requirement(dep=deps[0], lock=False)
req.extra_deps = (deps[1], )
result = PIPConverter(lock=False)._format_req(req=req)
assert 'hypothesis[django]' in result
assert '<=3.0.0' in result
assert 'python_version == "2.7"' in result
assert 'from root' not in result
assert result.startswith(text)
"""
Замена оригинальной команде `dephell convert deps`
тк иногда с ней бывают проблемы и она падает с TypeError
"""
import pathlib
from dephell import converters
from dephell.controllers import Graph
from dephell.models import Requirement
BASEDIR = pathlib.Path(__file__).parent
if __name__ == '__main__':
pc = converters.PoetryConverter()
spc = converters.SetupPyConverter()
root = pc.load(BASEDIR.joinpath('pyproject.toml'))
if root.readme.markup == 'md':
# SetupPyConverter принудительно конвертирует README в rst
# чтобы этого не допустить - обманываем его
root.readme.markup = 'rst'
reqs = Requirement.from_graph(graph=Graph(root), lock=False)
content = spc.dumps(reqs, project=root)
BASEDIR.joinpath('setup.py').write_text(content)
print('setup.py was updated successfully')
def test_load():
resolver = InstalledConverter().load_resolver(None)
reqs = Requirement.from_graph(graph=resolver.graph, lock=True)
reqs = {req.name: req for req in reqs}
assert 'pytest' in reqs
