def convert(
project: Project, filename: PathLike, options: Optional[Namespace]
) -> Tuple[Dict[str, Any], Dict[str, Any]]:
with open(filename, encoding="utf-8") as fp:
data = toml.load(fp)
result = {}
settings = {}
if "pipenv" in data:
settings["allow_prereleases"] = data["pipenv"].get("allow_prereleases", False)
if "requires" in data:
python_version = data["requires"].get("python_full_version") or data[
"requires"
].get("python_version")
result["requires-python"] = f">={python_version}"
if "source" in data:
settings["source"] = data["source"]
result["dependencies"] = make_array(
[
convert_pipfile_requirement(k, req)
for k, req in data.get("packages", {}).items()
],
True,
)
settings["dev-dependencies"] = {
"dev": make_array(
[
convert_pipfile_requirement(k, req)
for k, req in data.get("dev-packages", {}).items()
],
True,
)
}
return result, settings
def convert(project, filename):
with open(filename, encoding="utf-8") as fp:
data = toml.load(fp)
result = {}
settings = {}
if "pipenv" in data:
settings["allow_prereleases"] = data["pipenv"].get(
"allow_prereleases", False)
if "requires" in data:
python_version = data["requires"].get(
"python_full_version") or data["requires"].get("python_version")
result["requires-python"] = f">={python_version}"
if "source" in data:
settings["source"] = data["source"]
result["dependencies"] = make_array(
[
convert_pipfile_requirement(k, req)
for k, req in data.get("packages", {}).items()
],
True,
)
result["dev-dependencies"] = make_array(
[
convert_pipfile_requirement(k, req)
for k, req in data.get("dev-packages", {}).items()
],
True,
)
return result, settings
def do_init(
project: Project,
name: str = "",
version: str = "",
license: str = "MIT",
author: str = "",
email: str = "",
python_requires: str = "",
) -> None:
"""Bootstrap the project and create a pyproject.toml"""
data = {
"project": {
"name": name,
"version": version,
"description": "",
"authors": array_of_inline_tables([{"name": author, "email": email}]),
"license": make_inline_table({"text": license}),
"urls": {"homepage": ""},
"dependencies": make_array([], True),
"dev-dependencies": make_array([], True),
"requires-python": python_requires,
"dynamic": ["classifiers"],
},
"build-system": {"requires": ["pdm-pep517"], "build-backend": "pdm.pep517.api"},
}
if python_requires and python_requires != "*":
get_specifier(python_requires)
if not project.pyproject:
project._pyproject = data
else:
project._pyproject["project"] = data["project"]
project._pyproject["build-system"] = data["build-system"]
project.write_pyproject()
def dev_dependencies(self, value: dict) -> None:
self.settings["dev-dependencies"] = {
"dev": make_array(
[_convert_req(key, req) for key, req in value.items()], True
),
}
raise Unset()
def format_lockfile(
mapping: Dict[str, Candidate],
fetched_dependencies: Dict[str, List[Requirement]],
summary_collection: Dict[str, str],
) -> Dict:
"""Format lock file from a dict of resolved candidates, a mapping of dependencies
and a collection of package summaries.
"""
packages = tomlkit.aot()
file_hashes = tomlkit.table()
for k, v in sorted(mapping.items()):
base = tomlkit.table()
base.update(v.as_lockfile_entry())
base.add("summary", summary_collection[strip_extras(k)[0]])
deps = make_array([r.as_line() for r in fetched_dependencies[k]], True)
if len(deps) > 0:
base.add("dependencies", deps)
packages.append(base)
if v.hashes:
key = f"{k} {v.version}"
array = tomlkit.array()
array.multiline(True)
for filename, hash_value in v.hashes.items():
inline = make_inline_table({"file": filename, "hash": hash_value})
array.append(inline)
if array:
file_hashes.add(key, array)
doc = tomlkit.document()
doc.add("package", packages)
metadata = tomlkit.table()
metadata.add("files", file_hashes)
doc.add("metadata", metadata)
return doc
def dev_dependencies(self, value):
return make_array(
[
Requirement.from_req_dict(name, req).as_line()
for name, req in value.items()
],
True,
)
def dependencies(self, value: Dict[str, str]) -> List[str]:
return make_array(
[
Requirement.from_req_dict(name, req).as_line()
for name, req in value.items()
],
True,
)
def dev_dependencies(self, value: Dict[str, RequirementDict]) -> None:
self.settings["dev-dependencies"] = {
"dev": make_array(
[
Requirement.from_req_dict(name, req).as_line()
for name, req in value.items()
],
True,
)
}
raise Unset()
def convert(project, filename):
ireqs, finder = parse_requirement_file(str(filename))
reqs = [ireq_as_line(ireq) for ireq in ireqs]
data = {"dependencies": make_array(reqs, True)}
settings = {}
if finder.index_urls:
sources = [convert_url_to_source(finder.index_urls[0], "pypi")]
sources.extend(convert_url_to_source(url) for url in finder.index_urls[1:])
settings["source"] = sources
return data, settings
def dependencies(self, source):
rv = []
value, extras = dict(source["dependencies"]), source.pop("extras", {})
for key, req_dict in value.items():
optional = getattr(req_dict, "items", None) and req_dict.pop(
"optional", False)
req = _convert_req(key, req_dict)
if optional:
extra = next((k for k, v in extras.items() if key in v), None)
if extra:
self._data.setdefault("optional-dependencies",
{}).setdefault(extra, []).append(req)
else:
rv.append(req)
del source["dependencies"]
return make_array(rv, True)
def name(self, metadata: Dict[str, Any]) -> str:
# name
module = metadata.pop("module")
self._data["name"] = metadata.pop("dist-name", module)
# version and description
if (Path(module) / "__init__.py").exists():
source = Path(module) / "__init__.py"
else:
source = Path(f"{module}.py")
version = self._data.get("version")
description = self._data.get("description")
description_in_ast, version_in_ast = get_docstring_and_version_via_ast(
source)
self._data["version"] = version or version_in_ast or ""
self._data["description"] = description or description_in_ast or ""
self.warn_against_dynamic_version_or_docstring(
source, self._data["version"], self._data["description"])
# author and maintainer
if "author" in metadata:
self._data["authors"] = _get_author(metadata)
if "maintainer" in metadata:
self._data["maintainers"] = _get_author(metadata, "maintainer")
if "license" in metadata:
self._data["license"] = make_inline_table(
{"text": metadata.pop("license")})
self._data["dynamic"] = ["classifiers"]
if "urls" in metadata:
self._data["urls"] = metadata.pop("urls")
if "home-page" in metadata:
self._data.setdefault("urls",
{})["homepage"] = metadata.pop("home-page")
if "description-file" in metadata:
self._data["readme"] = metadata.pop("description-file")
if "requires-python" in metadata:
self._data["requires-python"] = metadata.pop("requires-python")
self._data["dynamic"] = ["classifiers"]
# requirements
self._data["dependencies"] = make_array(metadata.pop("requires", []),
True)
self._data["optional-dependencies"] = metadata.pop(
"requires-extra", {})
# Add remaining metadata as the same key
self._data.update(metadata)
return self._data["name"]
def do_init(
project: Project,
name: str = "",
version: str = "",
description: str = "",
license: str = "MIT",
author: str = "",
email: str = "",
python_requires: str = "",
) -> None:
"""Bootstrap the project and create a pyproject.toml"""
data = {
"project": {
"name": name,
"version": version,
"description": description,
"authors": array_of_inline_tables([{"name": author, "email": email}]),
"license": make_inline_table({"text": license}),
"dependencies": make_array([], True),
},
"build-system": {
"requires": ["pdm-pep517>=0.12.0"],
"build-backend": "pdm.pep517.api",
},
}
if python_requires and python_requires != "*":
data["project"]["requires-python"] = python_requires # type: ignore
if name and version:
readme = next(project.root.glob("README*"), None)
if readme is None:
readme = project.root.joinpath("README.md")
readme.write_text(f"# {name}\n\n{description}\n")
data["project"]["readme"] = readme.name # type: ignore
get_specifier(python_requires)
if not project.pyproject:
project._pyproject = data
else:
project._pyproject["project"] = data["project"] # type: ignore
project._pyproject["build-system"] = data["build-system"] # type: ignore
project.write_pyproject()
signals.post_init.send(project)
def name(self, metadata):
# name
module = metadata.pop("module")
self._data["name"] = metadata.pop("dist-name", module)
# version
parent_dir = Path(self.filename).parent
if (parent_dir / module / "__init__.py").exists():
source = parent_dir / module / "__init__.py"
else:
source = parent_dir / f"{module}.py"
self._data["version"] = self.VERSION_RE.findall(
source.read_text(encoding="utf-8"))[0]
# author and maintainer
if "author" in metadata:
self._data["authors"] = _get_author(metadata)
if "maintainer" in metadata:
self._data["maintainers"] = _get_author(metadata, "maintainer")
if "license" in metadata:
self._data["license"] = make_inline_table(
{"text", metadata.pop("license")})
self._data["dynamic"] = ["classifiers"]
if "urls" in metadata:
self._data["urls"] = metadata.pop("urls")
if "home-page" in metadata:
self._data.setdefault("urls",
{})["homepage"] = metadata.pop("home-page")
if "description-file" in metadata:
self._data["readme"] = metadata.pop("description-file")
if "requires-python" in metadata:
self._data["requires-python"] = metadata.pop("requires-python")
self._data["dynamic"] = ["classifiers"]
# requirements
self._data["dependencies"] = make_array(metadata.pop("requires", []),
True)
self._data["optional-dependencies"] = metadata.pop(
"requires-extra", {})
# Add remaining metadata as the same key
self._data.update(metadata)
return self._data["name"]
def convert(
project: Project, filename: PathLike, options: Namespace
) -> tuple[Mapping[str, Any], Mapping[str, Any]]:
ireqs, finder = parse_requirement_file(str(filename))
with project.core.ui.logging("build"):
reqs = [ireq_as_line(ireq, project.environment) for ireq in ireqs]
deps = make_array(reqs, True)
data: dict[str, Any] = {}
settings: dict[str, Any] = {}
if options.dev:
settings["dev-dependencies"] = {options.group or "dev": deps}
elif options.group:
data["optional-dependencies"] = {options.group: deps}
else:
data["dependencies"] = deps
if finder.index_urls:
sources = [convert_url_to_source(finder.index_urls[0], "pypi")]
sources.extend(convert_url_to_source(url) for url in finder.index_urls[1:])
settings["source"] = sources
return data, settings
def format_lockfile(
mapping: dict[str, Candidate],
fetched_dependencies: dict[str, list[Requirement]],
summary_collection: dict[str, str],
) -> dict:
"""Format lock file from a dict of resolved candidates, a mapping of dependencies
and a collection of package summaries.
"""
packages = atoml.aot()
file_hashes = atoml.table()
for k, v in sorted(mapping.items()):
base = atoml.table()
base.update(v.as_lockfile_entry()) # type: ignore
base.add("summary", summary_collection[strip_extras(k)[0]])
deps = make_array(sorted(r.as_line() for r in fetched_dependencies[k]),
True)
if len(deps) > 0:
base.add("dependencies", deps)
packages.append(base) # type: ignore
if v.hashes:
key = f"{strip_extras(k)[0]} {v.version}"
if key in file_hashes:
continue
array = atoml.array().multiline(True)
for filename, hash_value in v.hashes.items():
inline = make_inline_table({
"file": filename,
"hash": hash_value
})
array.append(inline) # type: ignore
if array:
file_hashes.add(key, array)
doc = atoml.document()
doc.add("package", packages) # type: ignore
metadata = atoml.table()
metadata.add("files", file_hashes)
doc.add("metadata", metadata) # type: ignore
return cast(dict, doc)
def convert(project, filename, options):
ireqs, finder = parse_requirement_file(str(filename))
with project.core.ui.logging("build"):
reqs = [ireq_as_line(ireq, project.environment) for ireq in ireqs]
deps = make_array(reqs, True)
data = {"dependencies": [], "dev-dependencies": []}
if options.dev and options.section:
raise PdmUsageError(
"Can't specify --dev and --section at the same time")
elif options.dev:
data["dev-dependencies"] = deps
elif options.section:
data["optional-dependencies"] = {options.section: deps}
else:
data["dependencies"] = deps
settings = {}
if finder.index_urls:
sources = [convert_url_to_source(finder.index_urls[0], "pypi")]
sources.extend(
convert_url_to_source(url) for url in finder.index_urls[1:])
settings["source"] = sources
return data, settings
def dev_dependencies(self, value):
return make_array(
[_convert_req(key, req) for key, req in value.items()], True)
