def context(py_ver: PyVer):
context = DEFAULT_CONTEXT.copy()
context.update(dict(
platform_version='', # remove highly impure platform_version
python_version=py_ver.python_version(),
python_full_version=py_ver.python_full_version()
))
return context
def __init__(self, py_ver: PyVer, platform, system, *args, **kwargs):
self.context = context(py_ver, platform, system)
self.context_wheel = self.context.copy()
self.context_wheel['extra'] = None
self.py_ver = py_ver
self.py_ver_parsed = parse_ver(py_ver.python_full_version())
self.py_ver_digits = py_ver.digits()
self.platform = platform
self.system = system
def context(py_ver: PyVer, platform: str, system: str):
context = DEFAULT_CONTEXT.copy()
context.update(
dict(
platform_version='', # remove impure platform_version
platform_release='', # remove impure kernel verison
platform_system=system[0].upper() +
system[1:], # eg. Linux or Darwin
platform_machine=platform, # eg. x86_64
python_version=py_ver.python_version(),
python_full_version=py_ver.python_full_version()))
return context
def test_select_wheel_for_py_ver(expected, py_ver, wheel_fn, system, platform):
prov = providers.WheelDependencyProvider('',
py_ver=PyVer(py_ver),
system=system,
platform=platform)
w = WheelRelease(*([""] * 3), wheel_fn, *([""] * 3))
assert prov._wheel_type_ok(w) == expected
def main():
disable_checks = load_env('disable_checks')
nixpkgs_commit = load_env('nixpkgs_commit')
nixpkgs_tarball_sha256 = load_env('nixpkgs_tarball_sha256')
nixpkgs_json = load_env('nixpkgs_json')
out_file = load_env('out_file')
py_ver_str = load_env('py_ver_str')
prefer_nixpkgs = load_env('prefer_nixpkgs')
pypi_deps_db_data_dir = load_env('pypi_deps_db_data_dir')
pypi_fetcher_commit = load_env('pypi_fetcher_commit')
pypi_fetcher_tarball_sha256 = load_env('pypi_fetcher_tarball_sha256')
requirements = load_env('requirements')
py_ver = PyVer(py_ver_str)
nixpkgs = NixpkgsDirectory(nixpkgs_json)
deps_db = DependencyDB(py_ver, pypi_deps_db_data_dir)
generator = OverlaysGenerator(
py_ver,
nixpkgs_commit,
nixpkgs_tarball_sha256,
nixpkgs,
pypi_fetcher_commit,
pypi_fetcher_tarball_sha256,
disable_checks,
ResolvelibResolver(nixpkgs, deps_db),
prefer_nixpkgs=prefer_nixpkgs,
)
reqs = parse_reqs(requirements)
expr = generator.generate(reqs)
with open(out_file, 'w') as f:
f.write(expr)
def __init__(self, py_ver: PyVer, platform, system, *args, **kwargs):
self.context = context(py_ver, platform, system)
self.context_wheel = self.context.copy()
self.context_wheel['extra'] = None
self.py_ver_digits = py_ver.digits()
self.platform = platform
self.system = system
def gen(args, nixpkgs_rev, nixpkgs_sha256, return_expr=False):
with open(args.r) as f:
requirements = f.read().strip()
o_file = tempfile.mktemp()
versionPy = PyVer(args.python)
editionPy = "" # minimal # Full
#versionPyNix = "python" +str(versionPy.digits())+ editionPy
versionPyNix = getVersion(dct=versionConfig['versionConfig'],
interpreter="python",
versionNixStyle=True,
versionNumer=False)
cmd = f'nix-build {pwd}/nix/call_mach.nix -o {o_file}' \
f' --argstr requirements "{requirements}"' \
f' --argstr python_attr {versionPyNix}' \
f' --argstr nixpkgs_rev {nixpkgs_rev}' \
f' --argstr nixpkgs_sha {nixpkgs_sha256}'
proc = sp.run(cmd, shell=True, stdout=sys.stderr)
if proc.returncode:
exit(1)
with open(f"{o_file}/share/mach_nix_file.nix") as src:
expr = src.read()
if return_expr:
return expr
if getattr(args, 'o', None):
with open(args.o, 'w') as dest:
dest.write(expr)
print(f"Expression written to {args.o}")
else:
print(expr)
def __init__(self, py_ver: PyVer, data_dir, *args, **kwargs):
super(DependencyDB, self).__init__(*args, **kwargs)
self.data = LazyBucketDict(data_dir)
self.context = context(py_ver)
self.py_ver_digits = py_ver.digits()
for name, releases in self.data.items():
key = self._unify_key(name)
if key != name:
self.data[key] = self.data[name]
del self.data[name]
def do():
providers_json = load_env('providers')
conda_channels_json = load_env('conda_channels_json')
disable_checks = load_env('disable_checks')
nixpkgs_json = load_env('nixpkgs_json')
out_file = load_env('out_file')
provider_settings = ProviderSettings(providers_json)
py_ver_str = load_env('py_ver_str')
pypi_deps_db_src = load_env('pypi_deps_db_src')
pypi_fetcher_commit = load_env('pypi_fetcher_commit')
pypi_fetcher_sha256 = load_env('pypi_fetcher_sha256')
requirements = load_env('requirements')
platform, system = load_env('system').split('-')
py_ver = PyVer(py_ver_str)
nixpkgs = NixpkgsIndex(nixpkgs_json)
deps_provider = CombinedDependencyProvider(
conda_channels_json=conda_channels_json,
nixpkgs=nixpkgs,
provider_settings=provider_settings,
pypi_deps_db_src=pypi_deps_db_src,
py_ver=py_ver,
platform=platform,
system=system)
generator = OverridesGenerator(
py_ver,
nixpkgs,
pypi_fetcher_commit,
pypi_fetcher_sha256,
disable_checks,
ResolvelibResolver(nixpkgs, deps_provider),
)
reqs = filter_reqs_by_eval_marker(parse_reqs(requirements),
context(py_ver, platform, system))
try:
expr = generator.generate(reqs)
except ResolutionImpossible as e:
handle_resolution_impossible(e, requirements, providers_json,
py_ver_str)
exit(1)
else:
with open(out_file, 'w') as f:
f.write(expr)
def env(args, nixpkgs_rev, nixpkgs_sha256):
target_dir = args.directory
py_ver = PyVer(args.python)
expr = gen(args, nixpkgs_rev, nixpkgs_sha256, return_expr=True)
machnix_file = f"{target_dir}/machnix.nix"
shell_nix_file = f"{target_dir}/shell.nix"
default_nix_file = f"{target_dir}/default.nix"
python_nix_file = f"{target_dir}/python.nix"
python_nix_content = dedent(f"""
let
nixpkgs_commit = "{nixpkgs_rev}";
nixpkgs_sha256 = "{nixpkgs_sha256}";
pkgs = import (builtins.fetchTarball {{
name = "nixpkgs";
url = "https://github.com/nixos/nixpkgs/tarball/${{nixpkgs_commit}}";
sha256 = nixpkgs_sha256;
}}) {{ config = {{}}; overlays = []; }};
python = pkgs.python{str(py_ver.digits())};
result = import ./machnix.nix {{ inherit pkgs python; }};
manylinux1 = pkgs.pythonManylinuxPackages.manylinux1;
overrides = result.overrides manylinux1 pkgs.autoPatchelfHook;
py = python.override {{ packageOverrides = overrides; }};
in
py.withPackages (ps: result.select_pkgs ps)
""")
if not os.path.isdir(target_dir):
if os.path.exists(target_dir):
print(
f'Error: {target_dir} already exists and is not a directory!')
exit(1)
os.mkdir(target_dir)
with open(machnix_file, 'w') as machnix:
machnix.write(expr)
with open(python_nix_file, 'w') as python:
python.write(python_nix_content)
with open(shell_nix_file, 'w') as shell:
shell.write("(import ./python.nix).env\n")
with open(default_nix_file, 'w') as default:
default.write("import ./shell.nix\n")
print(f"\nInitialized python environment in {target_dir}\n"
f"To activate it, execute: 'nix-shell {target_dir}'")
def gen(args, return_expr=False):
with open(args.r) as f:
requirements = f.read().strip()
o_file = tempfile.mktemp()
py_ver = PyVer(args.python)
cmd = f'nix-build {pwd}/nix/call_mach.nix -o {o_file}' \
f' --argstr requirements "{requirements}"' \
f' --argstr python_attr python{py_ver.digits()}'
proc = sp.run(cmd, shell=True, stdout=sys.stderr)
if proc.returncode:
exit(1)
with open(f"{o_file}/share/mach_nix_file.nix") as src:
expr = src.read()
if return_expr:
return expr
if getattr(args, 'o', None):
with open(args.o, 'w') as dest:
dest.write(expr)
print(f"Expression written to {args.o}")
else:
print(expr)
def __init__(self, py_ver: PyVer, *args, **kwargs):
self.context = context(py_ver)
self.context_wheel = self.context.copy()
self.context_wheel['extra'] = None
self.py_ver_digits = py_ver.digits()
def env(args, nixpkgs_ref):
target_dir = args.directory
py_ver = PyVer(args.python)
default_nix_file = f"{target_dir}/default.nix"
inputs_nix_file = f"{target_dir}/inputs.nix"
lock_file = f"{target_dir}/lock.toml"
python_nix_file = f"{target_dir}/python.nix"
requirements_file = f"{target_dir}/requirements.txt"
shell_nix_file = f"{target_dir}/shell.nix"
machnix_version = os.environ.get("MACHNIX_VERSION", default=None)
if machnix_version is None:
with open(f"{pwd}/VERSION") as f:
machnix_version = f.read()
with open(args.r) as f:
requirements = f.read().strip()
inputs_nix_content = dedent(f"""
with builtins;
let
lock = fromTOML (readFile ./lock.toml);
in rec {{
pkgs = import (builtins.fetchTarball {{
name = "nixpkgs";
url = "https://github.com/nixos/nixpkgs/tarball/${{lock.nixpkgs.rev}}";
sha256 = "${{lock.nixpkgs.sha256}}";
}}) {{ config = {{}}; overlays = []; }};
mach-nix = import (builtins.fetchTarball {{
url = "https://github.com/DavHau/mach-nix/tarball/${{lock.mach-nix.rev}}";
sha256 = lock.mach-nix.sha256;
}}) {{
python = "python{py_ver.digits()}";
inherit pkgs;
}};
}}
""")
python_nix_content = dedent(f"""
with (import ./inputs.nix);
mach-nix.mkPython {{
requirements = builtins.readFile ./requirements.txt;
}}
""")
shell_nix_content = dedent(f"""
with (import ./inputs.nix);
pkgs.mkShell {{
buildInputs = [
mach-nix.mach-nix
(import ./python.nix)
];
}}
""")
# ensure target path exists
if not os.path.isdir(target_dir):
if os.path.exists(target_dir):
print(f'Error: {target_dir} already exists and is not a directory!')
exit(1)
os.mkdir(target_dir)
# update lock file if mach-nix version mismatch
update_lock_file(lock_file, 'DavHau', "mach-nix", machnix_version)
update_lock_file(lock_file, 'nixos', "nixpkgs", nixpkgs_ref)
# write requirements file
with open(default_nix_file, 'w') as default:
default.write("import ./shell.nix\n")
with open(inputs_nix_file, 'w') as default:
default.write(inputs_nix_content)
with open(python_nix_file, 'w') as python:
python.write(python_nix_content)
with open(requirements_file, "w") as dest:
dest.write(requirements)
with open(shell_nix_file, 'w') as shell:
shell.write(shell_nix_content)
class c:
HEADER = '\033[95m'
OKBLUE = '\033[94m'
OKCYAN = '\033[96m'
OKGREEN = '\033[92m'
WARNING = '\033[93m'
FAIL = '\033[91m'
ENDC = '\033[0m'
BOLD = '\033[1m'
UNDERLINE = '\033[4m'
print(f"\nInitialized python environment in: {c.OKCYAN}{target_dir}{c.ENDC}\n"
f"To change python requirements, modify the file: {c.OKCYAN}{requirements_file}{c.ENDC}\n\n"
f"To activate the environment, execute: {c.BOLD}{c.OKGREEN}nix-shell {target_dir}{c.ENDC}")
