kopia lustrzana https://github.com/jupyterhub/repo2docker
149 wiersze
5.8 KiB
Python
149 wiersze
5.8 KiB
Python
"""Generates Dockerfiles based on an input matrix based on Python."""
|
|
import os
|
|
|
|
from ...utils import is_local_pip_requirement, open_guess_encoding
|
|
from ..conda import CondaBuildPack
|
|
|
|
|
|
class PythonBuildPack(CondaBuildPack):
|
|
"""Setup Python for use with a repository."""
|
|
|
|
@property
|
|
def python_version(self):
|
|
if hasattr(self, "_python_version"):
|
|
return self._python_version
|
|
|
|
try:
|
|
with open(self.binder_path("runtime.txt")) as f:
|
|
runtime = f.read().strip()
|
|
except FileNotFoundError:
|
|
runtime = ""
|
|
|
|
if not runtime.startswith("python-"):
|
|
# not a Python runtime (e.g. R, which subclasses this)
|
|
# use the default Python
|
|
self._python_version = self.major_pythons["3"]
|
|
self.log.warning(
|
|
f"Python version unspecified, using current default Python version {self._python_version}. This will change in the future."
|
|
)
|
|
return self._python_version
|
|
|
|
py_version_info = runtime.split("-", 1)[1].split(".")
|
|
py_version = ""
|
|
if len(py_version_info) == 1:
|
|
py_version = self.major_pythons[py_version_info[0]]
|
|
else:
|
|
# get major.minor
|
|
py_version = ".".join(py_version_info[:2])
|
|
self._python_version = py_version
|
|
return self._python_version
|
|
|
|
def _get_pip_scripts(self):
|
|
"""Get pip install scripts
|
|
|
|
added to preassemble unless local references are found,
|
|
in which case this happens in assemble.
|
|
"""
|
|
# KERNEL_PYTHON_PREFIX is the env with the kernel,
|
|
# whether it's distinct from the notebook or the same.
|
|
pip = "${KERNEL_PYTHON_PREFIX}/bin/pip"
|
|
scripts = []
|
|
if self.separate_kernel_env:
|
|
# using legacy Python kernel
|
|
# requirements3.txt allows installation in the notebook server env
|
|
nb_requirements_file = self.binder_path("requirements3.txt")
|
|
if os.path.exists(nb_requirements_file):
|
|
scripts.append(
|
|
(
|
|
"${NB_USER}",
|
|
# want the $NB_PYHTON_PREFIX environment variable, not for
|
|
# Python's string formatting to try and replace this
|
|
f'${{NB_PYTHON_PREFIX}}/bin/pip install --no-cache-dir -r "{nb_requirements_file}"',
|
|
)
|
|
)
|
|
|
|
# install requirements.txt in the kernel env
|
|
requirements_file = self.binder_path("requirements.txt")
|
|
if os.path.exists(requirements_file):
|
|
scripts.append(
|
|
(
|
|
"${NB_USER}",
|
|
f'{pip} install --no-cache-dir -r "{requirements_file}"',
|
|
)
|
|
)
|
|
return scripts
|
|
|
|
@property
|
|
def _should_preassemble_pip(self):
|
|
"""Peek in requirements.txt to determine if we can assemble from only env files
|
|
|
|
If there are any local references, e.g. `-e .`,
|
|
stage the whole repo prior to installation.
|
|
"""
|
|
if not os.path.exists("binder") and os.path.exists("setup.py"):
|
|
# can't install from subset if we're using setup.py
|
|
return False
|
|
for name in ("requirements.txt", "requirements3.txt"):
|
|
requirements_txt = self.binder_path(name)
|
|
if not os.path.exists(requirements_txt):
|
|
continue
|
|
with open_guess_encoding(requirements_txt) as f:
|
|
for line in f:
|
|
if is_local_pip_requirement(line):
|
|
return False
|
|
|
|
# didn't find any local references,
|
|
# allow assembly from subset
|
|
return True
|
|
|
|
def get_preassemble_script_files(self):
|
|
assemble_files = super().get_preassemble_script_files()
|
|
for name in ("requirements.txt", "requirements3.txt"):
|
|
requirements_txt = self.binder_path(name)
|
|
if os.path.exists(requirements_txt):
|
|
assemble_files[requirements_txt] = requirements_txt
|
|
return assemble_files
|
|
|
|
def get_preassemble_scripts(self):
|
|
"""Return scripts to run before adding the full repository"""
|
|
scripts = super().get_preassemble_scripts()
|
|
if self._should_preassemble_pip:
|
|
scripts.extend(self._get_pip_scripts())
|
|
return scripts
|
|
|
|
def get_assemble_scripts(self):
|
|
"""Return series of build steps that require the full repository"""
|
|
# If we have a runtime.txt & that's set to python-2.7,
|
|
# requirements.txt will be installed in the *kernel* env
|
|
# and requirements3.txt (if it exists)
|
|
# will be installed in the python 3 notebook server env.
|
|
assemble_scripts = super().get_assemble_scripts()
|
|
setup_py = "setup.py"
|
|
# KERNEL_PYTHON_PREFIX is the env with the kernel,
|
|
# whether it's distinct from the notebook or the same.
|
|
pip = "${KERNEL_PYTHON_PREFIX}/bin/pip"
|
|
if not self._should_preassemble_pip:
|
|
assemble_scripts.extend(self._get_pip_scripts())
|
|
|
|
# setup.py exists *and* binder dir is not used
|
|
if not self.binder_dir and os.path.exists(setup_py):
|
|
assemble_scripts.append(("${NB_USER}", f"{pip} install --no-cache-dir ."))
|
|
return assemble_scripts
|
|
|
|
def detect(self):
|
|
"""Check if current repo should be built with the Python buildpack."""
|
|
requirements_txt = self.binder_path("requirements.txt")
|
|
runtime_txt = self.binder_path("runtime.txt")
|
|
setup_py = "setup.py"
|
|
|
|
if os.path.exists(runtime_txt):
|
|
with open(runtime_txt) as f:
|
|
runtime = f.read().strip()
|
|
if runtime.startswith("python-"):
|
|
return True
|
|
else:
|
|
return False
|
|
if not self.binder_dir and os.path.exists(setup_py):
|
|
return True
|
|
return os.path.exists(requirements_txt)
|