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')