def __call__(self) -> bool:
resolver = get_resolver(reqs=self.args.name)
name = next(iter(resolver.graph.get_layer(0))).dependencies[0].name
# resolve (and merge)
self.logger.info('build dependencies graph...')
resolved = resolver.resolve(silent=self.config['silent'])
if not resolved:
conflict = analyze_conflict(resolver=resolver)
self.logger.warning('conflict was found')
print(conflict)
return False
# make venv
venvs = VEnvs(path=self.config['venv'])
venv = venvs.get_by_name(name)
if venv.exists():
self.logger.error('already installed', extra=dict(package=name))
return False
python = get_python(self.config)
self.logger.info('creating venv...',
extra=dict(
venv=str(venv.path),
python=str(python.path),
))
venv.create(python_path=python.path)
# install
reqs = Requirement.from_graph(graph=resolver.graph, lock=True)
self.logger.info('installation...',
extra=dict(
executable=venv.python_path,
packages=len(reqs),
))
code = PackageManager(executable=venv.python_path).install(reqs=reqs)
if code != 0:
return False
# get entrypoints
entrypoints = get_entrypoints(venv=venv, name=name)
if entrypoints is None:
return False
# copy console scripts
self.logger.info('copy executables...',
extra=dict(package=name, path=self.config['bin']))
for entrypoint in entrypoints:
if entrypoint.group != 'console_scripts':
continue
if not (venv.bin_path / entrypoint.name).exists():
self.logger.error('cannot find script in venv',
extra=dict(script=entrypoint.name))
else:
self._publish_script(
src=venv.bin_path / entrypoint.name,
dst=Path(self.config['bin']) / entrypoint.name,
)
self.logger.info('copied', extra=dict(script=entrypoint.name))
return True
def __call__(self) -> bool:
venvs = VEnvs(path=self.config['venv'])
for name in self.args.name:
name = canonicalize_name(name)
venv = venvs.get_by_name(name)
if not venv.exists():
self.logger.error('jail does not exist', extra=dict(package=name))
return False
# remove symlinks on entrypoints
self.logger.info('remove executables...')
for entrypoint in venv.bin_path.iterdir():
global_entrypoint = Path(self.config['bin']) / entrypoint.name
if not global_entrypoint.exists():
continue
if not global_entrypoint.resolve().samefile(entrypoint):
continue
global_entrypoint.unlink()
self.logger.info('removed', extra=dict(script=entrypoint.name))
# remove venv
shutil.rmtree(venv.path)
self.logger.info('jail removed', extra=dict(package=name))
return True
def __call__(self) -> bool:
resolver = get_resolver(reqs=self.args.name)
name = next(iter(resolver.graph.get_layer(0))).dependencies[0].name
# make venv
venvs = VEnvs(path=self.config['venv'])
venv = venvs.get_by_name(name)
if venv.exists():
self.logger.error('already installed', extra=dict(package=name))
return False
python = get_python(self.config)
self.logger.info('creating venv...',
extra=dict(
venv=str(venv.path),
python=str(python.path),
))
venv.create(python_path=python.path)
# install
ok = install_deps(
resolver=resolver,
python_path=venv.python_path,
logger=self.logger,
silent=self.config['silent'],
)
if not ok:
return False
# get entrypoints
entrypoints = get_entrypoints(venv=venv, name=name)
if entrypoints is None:
return False
# copy console scripts
self.logger.info('copy executables...',
extra=dict(package=name, path=self.config['bin']))
for entrypoint in entrypoints:
if entrypoint.group != 'console_scripts':
continue
entrypoint_filename = entrypoint.name
if IS_WINDOWS:
entrypoint_filename += '.exe'
if not (venv.bin_path / entrypoint_filename).exists():
self.logger.error('cannot find script in venv',
extra=dict(script=entrypoint.name))
continue
self._publish_script(
src=venv.bin_path / entrypoint_filename,
dst=Path(self.config['bin']) / entrypoint_filename,
)
self.logger.info('copied', extra=dict(script=entrypoint.name))
return True
def test_iter(temp_path):
venvs = VEnvs(path=temp_path / 'venvs' / '{project}')
(temp_path / 'papa').mkdir()
venv1 = venvs.get(project_path=temp_path / 'papa', env='emeritus')
venv1.create()
venv2 = venvs.get_by_name(name='ghost')
venv2.create()
assert {str(venv.path) for venv in venvs} == {str(venv1.path), str(venv2.path)}
def __call__(self) -> bool:
venvs = VEnvs(path=self.config['venv'])
name = canonicalize_name(self.args.name)
venv = venvs.get_by_name(name)
if not venv.exists():
self.logger.error('jail does not exist', extra=dict(package=name))
return False
# get list of exposed entrypoints
entrypoints_names = []
for entrypoint in venv.bin_path.iterdir():
global_entrypoint = Path(self.config['bin']) / entrypoint.name
if not global_entrypoint.exists():
continue
if not global_entrypoint.resolve().samefile(entrypoint):
continue
entrypoints_names.append(entrypoint.name)
root = InstalledConverter().load(paths=[venv.lib_path], names={name})
version = None
for subdep in root.dependencies:
if subdep.name != name:
continue
version = str(subdep.constraint).replace('=', '')
data = dict(
name=name,
path=str(venv.path),
entrypoints=entrypoints_names,
version=version,
size=dict(
lib=format_size(get_path_size(venv.lib_path)),
total=format_size(get_path_size(venv.path)),
),
)
print(
make_json(
data=data,
key=self.config.get('filter'),
colors=not self.config['nocolors'],
table=self.config['table'],
))
return True
def test_get_by_name(temp_path):
venvs = VEnvs(path=temp_path / 'venvs' / '{project}' / '{env}')
venv = venvs.get_by_name(name='papa')
assert str(venv.path) == str(temp_path / 'venvs' / 'papa')
