def handle(self):
from poetry.__version__ import __version__
from poetry.repositories.pypi_repository import PyPiRepository
from poetry.semver import Version
from poetry.utils._compat import decode
version = self.argument("version")
if not version:
version = ">=" + __version__
repo = PyPiRepository(fallback=False)
packages = repo.find_packages("poetry",
version,
allow_prereleases=self.option("preview"))
if not packages:
self.line("No release found for the specified version")
return
packages.sort(key=cmp_to_key(lambda x, y: 0 if x.version == y.version
else int(x.version < y.version or -1)))
release = None
for package in packages:
if package.is_prerelease():
if self.option("preview"):
release = package
break
continue
release = package
break
if release is None:
self.line("No new release found")
return
if release.version == Version.parse(__version__):
self.line("You are using the latest version")
return
try:
self.update(release)
except subprocess.CalledProcessError as e:
self.line("")
self.output.block(
[
"[CalledProcessError]",
"An error has occured: {}".format(str(e)),
decode(e.output),
],
style="error",
)
return e.returncode
def handle(self):
from poetry.__version__ import __version__
from poetry.repositories.pypi_repository import PyPiRepository
from poetry.semver.comparison import less_than
version = self.argument('version')
if not version:
version = '>=' + __version__
repo = PyPiRepository(fallback=False)
packages = repo.find_packages('poetry',
version,
allow_prereleases=self.option('preview'))
if not packages:
self.line('No release found for the specified version')
return
packages.sort(
key=cmp_to_key(lambda x, y: 0 if x.version == y.version else -1 *
int(less_than(x.version, y.version) or -1)))
release = None
for package in reversed(packages):
if package.is_prerelease():
if self.option('preview'):
release = package
break
continue
release = package
break
if release is None:
self.line('No new release found')
return
if release.version == __version__:
self.line('You are using the latest version')
return
try:
self.update(release)
except subprocess.CalledProcessError as e:
self.line('')
self.output.block([
'[CalledProcessError]', 'An error has occured: {}'.format(
str(e)), e.output
],
style='error')
return e.returncode
def handle(self):
from poetry.__version__ import __version__
from poetry.repositories.pypi_repository import PyPiRepository
from poetry.semver import Version
from poetry.utils._compat import Path
current = Path(__file__)
try:
current.relative_to(self.home)
except ValueError:
raise RuntimeError(
"Poetry was not installed with the recommended installer. "
"Cannot update automatically.")
version = self.argument("version")
if not version:
version = ">=" + __version__
repo = PyPiRepository(fallback=False)
packages = repo.find_packages("poetry",
version,
allow_prereleases=self.option("preview"))
if not packages:
self.line("No release found for the specified version")
return
packages.sort(key=cmp_to_key(lambda x, y: 0 if x.version == y.version
else int(x.version < y.version or -1)))
release = None
for package in packages:
if package.is_prerelease():
if self.option("preview"):
release = package
break
continue
release = package
break
if release is None:
self.line("No new release found")
return
if release.version == Version.parse(__version__):
self.line("You are using the latest version")
return
self.update(release)
def handle(self) -> None:
from poetry.__version__ import __version__
from poetry.core.packages.dependency import Dependency
from poetry.core.semver.version import Version
from poetry.repositories.pypi_repository import PyPiRepository
self._check_recommended_installation()
version = self.argument("version")
if not version:
version = ">=" + __version__
repo = PyPiRepository(fallback=False)
packages = repo.find_packages(
Dependency("poetry", version, allows_prereleases=self.option("preview"))
)
if not packages:
self.line("No release found for the specified version")
return
packages.sort(
key=cmp_to_key(
lambda x, y: 0
if x.version == y.version
else int(x.version < y.version or -1)
)
)
release = None
for package in packages:
if package.is_prerelease():
if self.option("preview"):
release = package
break
continue
release = package
break
if release is None:
self.line("No new release found")
return
if release.version == Version.parse(__version__):
self.line("You are using the latest version")
return
self.update(release)
def test_get_should_invalid_cache_on_too_many_redirects_error(mocker):
delete_cache = mocker.patch("cachecontrol.caches.file_cache.FileCache.delete")
response = Response()
response.encoding = "utf-8"
response.raw = BytesIO(encode('{"foo": "bar"}'))
mocker.patch(
"cachecontrol.adapter.CacheControlAdapter.send",
side_effect=[TooManyRedirects(), response],
)
repository = PyPiRepository()
repository._get("https://pypi.org/pypi/async-timeout/json")
assert delete_cache.called
def test_get_should_invalid_cache_on_too_many_redirects_error(mocker: MockerFixture):
delete_cache = mocker.patch("cachecontrol.caches.file_cache.FileCache.delete")
response = Response()
response.status_code = 200
response.encoding = "utf-8"
response.raw = BytesIO(encode('{"foo": "bar"}'))
mocker.patch(
"poetry.utils.authenticator.Authenticator.get",
side_effect=[TooManyRedirects(), response],
)
repository = PyPiRepository()
repository._get("https://pypi.org/pypi/async-timeout/json")
assert delete_cache.called
def run(venv_name: str, proj_path: str) -> None:
proj_path_is_dir = os.path.isdir(proj_path)
proposed_venv_path = f"{proj_path}/{venv_name}"
venv_is_correct = os.path.isdir(proposed_venv_path)
if platform.system() == "Windows":
venv_is_correct = venv_is_correct and os.listdir(
proposed_venv_path) == ["Include", "Lib", "pyvenv.cfg", "Scripts"]
else:
venv_is_correct = venv_is_correct and os.listdir(
proposed_venv_path) == [
"include", "lib", "lib64", "bin", "pyvenv.cfg"
]
if not proj_path_is_dir:
raise Exception(f"{proj_path} is not a directory.")
if venv_is_correct:
raise Exception(
f"{proj_path} already has a Python virtual environment {venv_name}"
)
files = list_python_files(proj_path, venv_name)
dependencies = list_dependencies(files)
filtered_dependencies = filter(
lambda dependency: PyPiRepository().search(dependency), dependencies)
setup_venv(filtered_dependencies)
def configure_sources(cls, poetry: Poetry, sources: List[Dict[str, str]],
config: Config, io: "IO") -> None:
for source in sources:
repository = cls.create_legacy_repository(source, config)
is_default = bool(source.get("default", False))
is_secondary = bool(source.get("secondary", False))
if io.is_debug():
message = f"Adding repository {repository.name} ({repository.url})"
if is_default:
message += " and setting it as the default one"
elif is_secondary:
message += " and setting it as secondary"
io.write_line(message)
poetry.pool.add_repository(repository,
is_default,
secondary=is_secondary)
# Put PyPI last to prefer private repositories
# unless we have no default source AND no primary sources
# (default = false, secondary = false)
if poetry.pool.has_default():
if io.is_debug():
io.write_line("Deactivating the PyPI repository")
else:
from poetry.repositories.pypi_repository import PyPiRepository
default = not poetry.pool.has_primary_repositories()
poetry.pool.add_repository(PyPiRepository(), default, not default)
def pool():
pool = Pool()
pool.add_repository(PyPiRepository(disable_cache=True))
pool.add_repository(
LegacyRepository("foo", "https://foo.bar/simple/", disable_cache=True))
return pool
def pool(self) -> Pool:
if self._pool is not None:
return self._pool
from poetry.repositories.pool import Pool
from poetry.repositories.pypi_repository import PyPiRepository
pool = Pool()
pool.add_repository(PyPiRepository())
return pool
def _get_pool(self) -> "Pool":
from poetry.repositories import Pool
from poetry.repositories.pypi_repository import PyPiRepository
if isinstance(self, EnvCommand):
return self.poetry.pool
if self._pool is None:
self._pool = Pool()
self._pool.add_repository(PyPiRepository())
return self._pool
def pool(self):
if self._pool is not None:
return self._pool
from poetry.repositories.pool import Pool
from poetry.repositories.pypi_repository import PyPiRepository
pool = Pool()
pool.add_repository(PyPiRepository(fallback=False))
self._pool = pool
return self._pool
def handle(self) -> None:
from poetry.repositories.pypi_repository import PyPiRepository
results = PyPiRepository().search(self.argument("tokens"))
for result in results:
self.line("")
name = f"<info>{result.name}</>"
name += f" (<comment>{result.version}</>)"
self.line(name)
if result.description:
self.line(f" {result.description}")
def handle(self) -> None:
from poetry.repositories.pypi_repository import PyPiRepository
results = PyPiRepository().search(self.argument("tokens"))
for result in results:
self.line("")
name = "<info>{}</>".format(result.name)
name += " (<comment>{}</>)".format(result.version)
self.line(name)
if result.description:
self.line(" {}".format(result.description))
def handle(self):
from poetry.repositories.pypi_repository import PyPiRepository
flags = PyPiRepository.SEARCH_FULLTEXT
if self.option("only-name"):
flags = PyPiRepository.SEARCH_NAME
results = PyPiRepository().search(self.argument("tokens"), flags)
for result in results:
self.line("")
name = "<info>{}</>".format(result.name)
name += " (<comment>{}</>)".format(result.version)
self.line(name)
if result.description:
self.line(" {}".format(result.description))
def handle(self):
from poetry.repositories.pypi_repository import PyPiRepository
flags = PyPiRepository.SEARCH_FULLTEXT
if self.option('only-name'):
flags = PyPiRepository.SEARCH_FULLTEXT
results = PyPiRepository().search(self.argument('tokens'), flags)
for result in results:
self.line('')
name = '<info>{}</>'.format(
result.name
)
name += ' (<comment>{}</>)'.format(result.version)
self.line(name)
if result.description:
self.line(
' {}'.format(result.description)
)
def test_urls():
repository = PyPiRepository()
assert "https://pypi.org/simple/" == repository.url
assert "https://pypi.org/simple/" == repository.authenticated_url
def solve_pypi(
pip_specs: Dict[str, src_parser.Dependency],
use_latest: List[str],
pip_locked: Dict[str, src_parser.LockedDependency],
conda_locked: Dict[str, src_parser.LockedDependency],
python_version: str,
platform: str,
verbose: bool = False,
) -> Dict[str, src_parser.LockedDependency]:
"""
Solve pip dependencies for the given platform
Parameters
----------
conda :
Path to conda, mamba, or micromamba
use_latest :
Names of packages to update to the latest version compatible with pip_specs
pip_specs :
PEP440 package specifications
pip_locked :
Previous solution for the given platform (pip packages only)
conda_locked :
Current solution of conda-only specs for the given platform
python_version :
Version of Python in conda_locked
platform :
Target platform
verbose :
Print chatter from solver
"""
dummy_package = ProjectPackage("_dummy_package_", "0.0.0")
dependencies = [get_dependency(spec) for spec in pip_specs.values()]
for dep in dependencies:
dummy_package.add_dependency(dep)
pypi = PyPiRepository()
pool = Pool(repositories=[pypi])
installed = Repository()
locked = Repository()
python_packages = dict()
for dep in conda_locked.values():
if dep.name.startswith("__"):
continue
try:
pypi_name = conda_name_to_pypi_name(dep.name).lower()
except KeyError:
continue
# Prefer the Python package when its name collides with the Conda package
# for the underlying library, e.g. python-xxhash (pypi: xxhash) over xxhash
# (pypi: no equivalent)
if pypi_name not in python_packages or pypi_name != dep.name:
python_packages[pypi_name] = dep.version
# treat conda packages as both locked and installed
for name, version in python_packages.items():
for repo in (locked, installed):
repo.add_package(Package(name=name, version=version))
# treat pip packages as locked only
for spec in pip_locked.values():
locked.add_package(get_package(spec))
if verbose:
io = ConsoleIO()
io.set_verbosity(VERY_VERBOSE)
else:
io = NullIO()
s = Solver(
dummy_package,
pool=pool,
installed=installed,
locked=locked,
io=io,
)
to_update = list({spec.name
for spec in pip_locked.values()
}.intersection(use_latest))
env = PlatformEnv(python_version, platform)
# find platform-specific solution (e.g. dependencies conditioned on markers)
with s.use_environment(env):
result = s.solve(use_latest=to_update)
chooser = Chooser(pool, env=env)
# Extract distributions from Poetry package plan, ignoring uninstalls
# (usually: conda package with no pypi equivalent) and skipped ops
# (already installed)
requirements: List[src_parser.LockedDependency] = []
for op in result:
if not isinstance(op, Uninstall) and not op.skipped:
# Take direct references verbatim
source: Optional[src_parser.DependencySource] = None
if op.package.source_type == "url":
url, fragment = urldefrag(op.package.source_url)
hash_type, hash = fragment.split("=")
hash = src_parser.HashModel(**{hash_type: hash})
source = src_parser.DependencySource(type="url",
url=op.package.source_url)
# Choose the most specific distribution for the target
else:
link = chooser.choose_for(op.package)
url = link.url_without_fragment
hash = src_parser.HashModel(**{link.hash_name: link.hash})
requirements.append(
src_parser.LockedDependency(
name=op.package.name,
version=str(op.package.version),
manager="pip",
source=source,
platform=platform,
dependencies={
dep.name: str(dep.constraint)
for dep in op.package.requires
},
url=url,
hash=hash,
))
# use PyPI names of conda packages to walking the dependency tree and propagate
# categories from explicit to transitive dependencies
planned = {
**{dep.name: dep
for dep in requirements},
# prefer conda packages so add them afterwards
}
for conda_name, dep in conda_locked.items():
try:
pypi_name = conda_name_to_pypi_name(conda_name).lower()
except KeyError:
# no conda-name found, assuming conda packages do NOT intersect with the pip package
continue
planned[pypi_name] = dep
src_parser._apply_categories(requested=pip_specs, planned=planned)
return {dep.name: dep for dep in requirements}
