def supports_python2(self):
return self._package.python_constraint.matches(
MultiConstraint([
Constraint('>=', '2.0.0'),
Constraint('<', '3.0.0')
])
)
def _filter_operations(self,
ops,
repo
): # type: (List[Operation], Repository) -> None
extra_packages = [p.name for p in
self._get_extra_packages(repo)]
for op in ops:
if isinstance(op, Update):
package = op.target_package
else:
package = op.package
if op.job_type == 'uninstall':
continue
parser = VersionParser()
python = '.'.join([str(i) for i in self._venv.version_info[:3]])
if 'python' in package.requirements:
python_constraint = parser.parse_constraints(
package.requirements['python']
)
if not python_constraint.matches(Constraint('=', python)):
# Incompatible python versions
op.skip('Not needed for the current python version')
continue
if not package.python_constraint.matches(Constraint('=', python)):
op.skip('Not needed for the current python version')
continue
if 'platform' in package.requirements:
platform_constraint = GenericConstraint.parse(
package.requirements['platform']
)
if not platform_constraint.matches(
GenericConstraint('=', sys.platform)
):
# Incompatible systems
op.skip('Not needed for the current platform')
continue
if self._update:
extras = {}
for extra, deps in self._package.extras.items():
extras[extra] = [dep.name for dep in deps]
else:
extras = {}
for extra, deps in self._locker.lock_data.get('extras', {}).items():
extras[extra] = [dep.lower() for dep in deps]
# If a package is optional and not requested
# in any extra we skip it
if package.optional:
if package.name not in extra_packages:
op.skip('Not required')
# If the package is a dev package and dev packages
# are not requests, we skip it
if package.category == 'dev' and not self.is_dev_mode():
op.skip('Dev dependencies not requested')
def find_packages(self,
name: str,
constraint: Union[Constraint, str, None] = None,
extras: Union[list, None] = None) -> List[Package]:
"""
Find packages on the remote server.
"""
packages = []
if constraint is not None and not isinstance(constraint,
BaseConstraint):
version_parser = VersionParser()
constraint = version_parser.parse_constraints(constraint)
info = self.get_package_info(name)
versions = []
for version, release in info['releases'].items():
if (not constraint or
(constraint and constraint.matches(Constraint('=', version)))):
versions.append(version)
for version in versions:
packages.append(self.package(name, version, extras=extras))
return packages
def all_classifiers(self):
classifiers = copy.copy(self.classifiers)
# Automatically set python classifiers
parser = VersionParser()
if self.python_versions == '*':
python_constraint = parser.parse_constraints('~2.7 || ^3.4')
else:
python_constraint = self.python_constraint
for version in sorted(self.AVAILABLE_PYTHONS):
if len(version) == 1:
constraint = parser.parse_constraints(version + '.*')
else:
constraint = Constraint('=', version)
if python_constraint.matches(constraint):
classifiers.append(
'Programming Language :: Python :: {}'.format(version))
# Automatically set license classifiers
if self.license:
classifiers.append(self.license.classifier)
classifiers = set(classifiers)
return sorted(classifiers)
def find_packages(self, name, constraint=None, extras=None):
name = name.lower()
packages = []
if extras is None:
extras = []
if not isinstance(constraint, BaseConstraint):
parser = VersionParser()
constraint = parser.parse_constraints(constraint)
for package in self.packages:
if name == package.name:
pkg_constraint = Constraint('==', package.version)
if constraint is None or constraint.matches(pkg_constraint):
for extra in extras:
if extra in package.extras:
for dep in package.extras[extra]:
dep.activate()
package.requires += package.extras[extra]
packages.append(package)
return packages
def find_packages(self, name, constraint=None, extras=None):
packages = []
if constraint is not None and not isinstance(constraint,
BaseConstraint):
version_parser = VersionParser()
constraint = version_parser.parse_constraints(constraint)
key = name
if constraint:
key = f'{key}:{str(constraint)}'
if self._cache.store('matches').has(key):
versions = self._cache.store('matches').get(key)
else:
candidates = [str(c.version) for c in self._repository.find_all_candidates(name)]
versions = []
for version in candidates:
if version in versions:
continue
if (
not constraint
or (constraint and constraint.matches(Constraint('=', version)))
):
versions.append(version)
self._cache.store('matches').put(key, versions, 5)
for version in versions:
packages.append(self.package(name, version, extras=extras))
return packages
def accepts(self, package: 'poetry.packages.Package') -> bool:
"""
Determines if the given package matches this dependency.
"""
return (self._name == package.name
and self._constraint.matches(Constraint('=', package.version))
and (not package.is_prerelease() or self.allows_prereleases()))
def find_packages(self, name, constraint=None,
extras=None,
allow_prereleases=False):
name = name.lower()
packages = []
if extras is None:
extras = []
if constraint is None:
constraint = '*'
if not isinstance(constraint, BaseConstraint):
parser = VersionParser()
constraint = parser.parse_constraints(constraint)
for package in self.packages:
if name == package.name:
pkg_constraint = Constraint('==', package.version)
if constraint is None or constraint.matches(pkg_constraint):
for dep in package.requires:
for extra in extras:
if extra not in package.extras:
continue
reqs = package.extras[extra]
for req in reqs:
if req.name == dep.name:
dep.activate()
packages.append(package)
return packages
def is_requirement_satisfied_by(self, requirement, activated, package):
if isinstance(requirement, Package):
return requirement == package
if package.is_prerelease() and not requirement.accepts_prereleases():
vertex = activated.vertex_named(package.name)
if not any([r.allows_prereleases() for r in vertex.requirements]):
return False
return requirement.constraint.matches(Constraint(
'==', package.version))
def search_for(self, dependency):
if dependency in self._search_for:
return self._search_for[dependency]
results = []
for spec in self._packages[dependency.name]:
if not dependency.allows_prereleases() and spec.is_prerelease():
continue
if dependency.constraint.matches(Constraint('==', spec.version)):
results.append(spec)
return results
def find_packages(self,
name, # type: str
constraint=None, # type: Union[Constraint, str, None]
extras=None, # type: Union[list, None]
allow_prereleases=False # type: bool
): # type: (...) -> List[Package]
"""
Find packages on the remote server.
"""
if constraint is not None and not isinstance(constraint, BaseConstraint):
version_parser = VersionParser()
constraint = version_parser.parse_constraints(constraint)
info = self.get_package_info(name)
packages = []
for version, release in info['releases'].items():
if not release:
# Bad release
self._log(
'No release information found for {}-{}, skipping'.format(
name, version
),
level='debug'
)
continue
package = Package(name, version)
if package.is_prerelease() and not allow_prereleases:
continue
if (
not constraint
or (constraint and constraint.matches(Constraint('=', version)))
):
if extras is not None:
package.requires_extras = extras
packages.append(package)
self._log(
'{} packages found for {} {}'.format(
len(packages), name, str(constraint)
),
level='debug'
)
return packages
def get_classifers(self):
classifiers = []
# Automatically set python classifiers
parser = VersionParser()
if self._package.python_versions == '*':
python_constraint = parser.parse_constraints('~2.7 || ^3.4')
else:
python_constraint = self._package.python_constraint
for version in sorted(self.AVAILABLE_PYTHONS):
if python_constraint.matches(Constraint('=', version)):
classifiers.append(f'Programming Language :: Python :: {version}')
return classifiers
def _filter_operations(self, ops: List[Operation]):
for op in ops:
if isinstance(op, Update):
package = op.target_package
else:
package = op.package
if op.job_type == 'uninstall':
continue
parser = VersionParser()
python = '.'.join([str(i) for i in sys.version_info[:3]])
if 'python' in package.requirements:
python_constraint = parser.parse_constraints(
package.requirements['python'])
if not python_constraint.matches(Constraint('=', python)):
# Incompatible python versions
op.skip('Not needed for the current python version')
continue
if self._update:
extras = {}
for extra, deps in self._package.extras.items():
extras[extra] = [dep.name for dep in deps]
else:
extras = {}
for extra, deps in self._locker.lock_data.get('extras', {}):
extras[extra] = [dep.lower() for dep in deps]
# If a package is optional and not requested
# in any extra we skip it
if package.optional:
drop = True
for extra in self._extras:
if extra in extras and package.name in extras[extra]:
drop = False
continue
if drop:
op.skip('Not required')
