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}