def find_latest_package(self, package, include_dev):
from clikit.io import NullIO
from poetry.puzzle.provider import Provider
from poetry.version.version_selector import VersionSelector
# find the latest version allowed in this pool
if package.source_type in ("git", "file", "directory"):
requires = self.poetry.package.requires
if include_dev:
requires = requires + self.poetry.package.dev_requires
for dep in requires:
if dep.name == package.name:
provider = Provider(self.poetry.package, self.poetry.pool,
NullIO())
if dep.is_vcs():
return provider.search_for_vcs(dep)[0]
if dep.is_file():
return provider.search_for_file(dep)[0]
if dep.is_directory():
return provider.search_for_directory(dep)[0]
name = package.name
selector = VersionSelector(self.poetry.pool)
return selector.find_best_candidate(
name, ">={}".format(package.pretty_version))
def find_latest_package(
self, package: Package, root: ProjectPackage
) -> Package | None:
from cleo.io.null_io import NullIO
from poetry.puzzle.provider import Provider
from poetry.version.version_selector import VersionSelector
# find the latest version allowed in this pool
if package.source_type in ("git", "file", "directory"):
requires = root.all_requires
for dep in requires:
if dep.name == package.name:
provider = Provider(root, self.poetry.pool, NullIO())
if dep.is_vcs():
dep = cast(VCSDependency, dep)
return provider.search_for_vcs(dep)[0]
if dep.is_file():
dep = cast(FileDependency, dep)
return provider.search_for_file(dep)[0]
if dep.is_directory():
dep = cast(DirectoryDependency, dep)
return provider.search_for_directory(dep)[0]
name = package.name
selector = VersionSelector(self.poetry.pool)
return selector.find_best_candidate(name, f">={package.pretty_version}")
def find_latest_package(self, package: "Package",
root: "ProjectPackage") -> Union["Package", bool]:
from cleo.io.null_io import NullIO
from poetry.puzzle.provider import Provider
from poetry.version.version_selector import VersionSelector
# find the latest version allowed in this pool
if package.source_type in ("git", "file", "directory"):
requires = root.all_requires
for dep in requires:
if dep.name == package.name:
provider = Provider(root, self.poetry.pool, NullIO())
if dep.is_vcs():
return provider.search_for_vcs(dep)[0]
if dep.is_file():
return provider.search_for_file(dep)[0]
if dep.is_directory():
return provider.search_for_directory(dep)[0]
name = package.name
selector = VersionSelector(self.poetry.pool)
return selector.find_best_candidate(
name, ">={}".format(package.pretty_version))
def find_latest_package(self, package):
# find the latest version allowed in this pool
if package.source_type == 'git':
return
name = package.name
selector = VersionSelector(self.poetry.pool)
return selector.find_best_candidate(name, f'>={package.version}')
def find_latest_package(self, package):
from poetry.version.version_selector import VersionSelector
# find the latest version allowed in this pool
if package.source_type == "git":
return
name = package.name
selector = VersionSelector(self.poetry.pool)
return selector.find_best_candidate(name, ">={}".format(package.pretty_version))
def find_latest_package(self, package):
from poetry.version.version_selector import VersionSelector
# find the latest version allowed in this pool
if package.source_type == "git":
return
name = package.name
selector = VersionSelector(self.poetry.pool)
return selector.find_best_candidate(name, ">={}".format(package.pretty_version))
def _find_best_version_for_package(self,
name,
required_version=None
) -> Tuple[str, str]:
selector = VersionSelector(self.poetry.pool)
package = selector.find_best_candidate(name, required_version)
if not package:
# TODO: find similar
raise ValueError(
f'Could not find a matching version of package {name}')
return (package.pretty_name,
selector.find_recommended_require_version(package))
def _find_best_version_for_package(
self,
name,
required_version=None): # type: (...) -> Tuple[str, str]
from poetry.version.version_selector import VersionSelector
selector = VersionSelector(self.poetry.pool)
package = selector.find_best_candidate(name, required_version)
if not package:
# TODO: find similar
raise ValueError(
'Could not find a matching version of package {}'.format(name))
return (package.pretty_name,
selector.find_recommended_require_version(package))
def _find_best_version_for_package(
self, name, required_version=None, allow_prereleases=False
): # type: (...) -> Tuple[str, str]
from poetry.version.version_selector import VersionSelector
selector = VersionSelector(self._get_pool())
package = selector.find_best_candidate(
name, required_version, allow_prereleases=allow_prereleases
)
if not package:
# TODO: find similar
raise ValueError(
"Could not find a matching version of package {}".format(name)
)
return (package.pretty_name, selector.find_recommended_require_version(package))
def _find_best_version_for_package(
self, name, required_version=None, allow_prereleases=False, source=None
): # type: (...) -> Tuple[str, str]
from poetry.version.version_selector import VersionSelector
selector = VersionSelector(self._get_pool())
package = selector.find_best_candidate(
name, required_version, allow_prereleases=allow_prereleases, source=source
)
if not package:
# TODO: find similar
raise ValueError(
"Could not find a matching version of package {}".format(name)
)
return package.pretty_name, selector.find_recommended_require_version(package)
def find_latest_package(self, package):
from poetry.io import NullIO
from poetry.puzzle.provider import Provider
from poetry.version.version_selector import VersionSelector
# find the latest version allowed in this pool
if package.source_type == "git":
for dep in self.poetry.package.requires:
if dep.name == package.name and dep.is_vcs():
return Provider(
self.poetry.package, self.poetry.pool, NullIO()
).search_for_vcs(dep)[0]
name = package.name
selector = VersionSelector(self.poetry.pool)
return selector.find_best_candidate(name, ">={}".format(package.pretty_version))
def _find_best_version_for_package(
self,
name: str,
required_version: Optional[str] = None,
allow_prereleases: bool = False,
source: Optional[str] = None,
) -> Tuple[str, str]:
from poetry.version.version_selector import VersionSelector
selector = VersionSelector(self._get_pool())
package = selector.find_best_candidate(
name, required_version, allow_prereleases=allow_prereleases, source=source
)
if not package:
# TODO: find similar
raise ValueError(f"Could not find a matching version of package {name}")
return package.pretty_name, selector.find_recommended_require_version(package)
