# /// script
# dependencies = [
# "toml",
# "rich",
# ]
# ///
# To run the script use `uv run convert_pipfile_to_uv.py` (this way it automagically installs the dependencies)
import re
from pathlib import Path
from urllib.parse import urlparse, urlunparse
import toml
from rich import print
from rich.prompt import Confirm, Prompt
PIPFILE_TO_UV_DEP_NAMES = {
"packages": "dependencies",
"dev-packages": "dev-dependencies",
}
# Override toml.TomlEncoder.dump_list to add newline and indentation
def _dump_list(self, v):
sep = ","
indentation = 4
NL = "\n"
INDENT = " " * indentation
s = (
"["
+ NL
+ INDENT
+ (sep + NL + INDENT).join([str(self.dump_value(u)) for u in v])
+ (sep + NL)
+ "]"
)
return s
toml.TomlEncoder.dump_list = _dump_list
def strip_url_credentials(url: str) -> str:
"""
Remove username and password from URL if present.
"""
parsed = urlparse(url)
# Create new netloc without credentials
netloc = parsed.hostname
if parsed.port:
netloc = f"{netloc}:{parsed.port}"
# Reconstruct URL without credentials
clean_url = urlunparse(
(
parsed.scheme,
netloc,
parsed.path,
parsed.params,
parsed.query,
parsed.fragment,
)
)
return clean_url
def dump_custom_version(package: str, version: dict) -> str:
"""
Handle custom version formats (e.g., git, ref, index).
"""
if "extras" in version:
extras_str = ",".join(version["extras"])
package = f"{package}[{extras_str}]"
if "git" in version:
git_url = version["git"]
ref = version.get("ref", "main")
return f"{package} @ {git_url}@{ref}"
if "version" in version:
return f"{package}{version['version']}"
return package
def convert_pipfile_to_pyproject(
pipfile_path: Path,
output_path: Path,
project_name: str,
project_version: str,
project_description: str,
python_version: str = "pipfile",
):
# Load the Pipfile
with open(pipfile_path) as pipfile:
pipfile_data = toml.load(pipfile)
pyproject_data = {
"project": {
"name": project_name,
"version": project_version,
"dependencies": [],
"dev-dependencies": [], # tmp for easier map
},
"tool": {"uv": {"dev-dependencies": [], "sources": {}}},
}
if project_description:
pyproject_data["project"]["description"] = project_description
if python_version == "pipfile" and "python_version" in (
pipfile_requires := pipfile_data.get("requires", {})
):
python_version = pipfile_requires["python_version"]
if python_version:
python_version = (
f">={python_version}" if python_version[0].isdigit() else python_version
)
pyproject_data["project"]["requires-python"] = python_version
# Handle sources from Pipfile
if "source" in pipfile_data:
pyproject_data["tool"]["uv"]["index"] = []
for source in pipfile_data["source"]:
# Create source entry with cleaned URL (no credentials)
source_entry = {
"name": source["name"].replace("-", "_"),
"url": strip_url_credentials(source["url"]),
}
pyproject_data["tool"]["uv"]["index"].append(source_entry)
# Track packages with custom index
packages_with_index = {}
# Convert dependencies and handle index-specific packages
for pipfile_name, uv_name in PIPFILE_TO_UV_DEP_NAMES.items():
if pipfile_name in pipfile_data:
for package, version in pipfile_data[pipfile_name].items():
if isinstance(version, str):
if version == "*":
pyproject_data["project"][uv_name].append(f"{package}")
else:
pyproject_data["project"][uv_name].append(f"{package}{version}")
elif isinstance(version, dict):
# Check for index specification
if "index" in version:
packages_with_index[package] = {"index": version["index"]}
# Add custom version formats
pyproject_data["project"][uv_name].append(
dump_custom_version(package, version)
)
# Add packages with custom index to tool.uv.sources
if packages_with_index:
for package, index_info in packages_with_index.items():
index_info["index"] = index_info["index"].replace("-", "_")
pyproject_data["tool"]["uv"]["sources"][package] = index_info
# moving dev-dependencies to tool.uv
pyproject_data["tool"]["uv"]["dev-dependencies"] = pyproject_data["project"].pop(
"dev-dependencies"
)
pyproject_data_str = toml.dumps(pyproject_data, encoder=toml.TomlEncoder())
pyproject_data_str = transform_pyproject_data(pyproject_data_str)
output_path.parent.mkdir(parents=True, exist_ok=True)
with open(output_path, "w") as output_file:
output_file.write(pyproject_data_str)
print(f"[green]pyproject.toml generated at '{output_path}'[/green]")
def transform_pyproject_data(input_str: str) -> str:
"""
Transforms the input string containing pyproject data by modifying sections
that match the pattern "[tool.uv.sources.<something>]" and lines that start
with "index =".
Specifically, it performs the following transformations:
1. For lines that match the pattern "[tool.uv.sources.<something>]", it changes
them to "[tool.uv.sources]".
2. For lines within the section that start with "index =", it extracts the value
within the quotes and formats it as "<something> = {index = "<value>"}".
Args:
input_str (str): The input string containing pyproject data.
Returns:
str: The transformed pyproject data as a string.
"""
lines = input_str.split("\n")
transformed_lines = []
current_section = None
for line in lines:
# Check if the line starts with the pattern "[tool.uv.sources."
match = re.match(r"^\[tool\.uv\.sources\.(.*?)\]$", line.strip())
if match:
current_section = match.group(1)
transformed_lines.append("[tool.uv.sources]")
# Check if the line has the format "index = "<somethingB>""
elif current_section and line.strip().startswith("index ="):
index_value = re.search(r'"(.+?)"', line.strip()).group(1)
transformed_lines.append(f'{current_section} = {{index = "{index_value}"}}')
current_section = None
else:
transformed_lines.append(line.rstrip())
return "\n".join(transformed_lines)
def get_input_with_default(prompt, default):
user_input = Prompt.ask(prompt, default=default)
return user_input if user_input else default
def main():
print("[cyan]Welcome to the Pipfile to pyproject.toml converter![/cyan]")
print("[cyan]Please provide the following information:[/cyan]")
pipfile_path = None
while not pipfile_path:
pipfile_path = get_input_with_default(
"Enter the path to your Pipfile: ", "Pipfile"
)
pipfile_path = Path(pipfile_path).resolve()
if not pipfile_path.exists():
print(f"[red]File not found: {pipfile_path}[/red]")
pipfile_path = None
output_path = get_input_with_default(
"Enter the output path for pyproject.toml", "pyproject.toml"
)
output_path = Path(output_path).resolve()
if output_path.exists():
print(
f"[red]CRITICAL WARNING: pyproject.toml file already exists at {output_path}[/red]"
)
if not Confirm.ask("Do you want to proceed?", default=True):
print("[red]Exiting...[/red]")
exit(1)
# try find project name
# 1. Pipfile parent directory name
project_name = pipfile_path.parent.name
project_name = get_input_with_default("Enter the project name", project_name)
project_version = get_input_with_default("Enter the project version", "0.1.0")
project_description = get_input_with_default("Enter the project description", "")
python_version = get_input_with_default(
"Enter the required Python version", "pipfile"
)
convert_pipfile_to_pyproject(
pipfile_path,
output_path,
project_name,
project_version,
project_description,
python_version,
)
if __name__ == "__main__":
main()