(self, requirements, env=None, installer=None,
                replace_conflicting=False, extras=None)
return to_activate
List all distributions needed to (recursively) meet `requirements`

        `requirements` must be a sequence of ``Requirement`` objects.  `env`,
        if supplied, should be an ``Environment`` instance.  If
        not supplied, it defaults to all distributions available within any
        entry or distribution in the working set.  `installer`, if supplied,
        will be invoked with each requirement that cannot be met by an
        already-installed distribution; it should return a ``Distribution`` or
        ``None``.

        Unless `replace_conflicting=True`, raises a VersionConflict exception
        if
        any requirements are found on the path that have the correct name but
        the wrong version.  Otherwise, if an `installer` is supplied it will be
        invoked to obtain the correct version of the requirement and activate
        it.

        `extras` is a list of the extras to be used with these requirements.
        This is important because extra requirements may look like `my_req;
        extra = "my_extra"`, which would otherwise be interpreted as a purely
        optional requirement.  Instead, we want to be able to assert that these
        requirements are truly required.
List all distributions needed to (recursively) meet `requirements`
List all distributions needed to ( recursively ) meet requirements
def resolve(self, requirements, env=None, installer=None,
                replace_conflicting=False, extras=None):
        """List all distributions needed to (recursively) meet `requirements`

        `requirements` must be a sequence of ``Requirement`` objects.  `env`,
        if supplied, should be an ``Environment`` instance.  If
        not supplied, it defaults to all distributions available within any
        entry or distribution in the working set.  `installer`, if supplied,
        will be invoked with each requirement that cannot be met by an
        already-installed distribution; it should return a ``Distribution`` or
        ``None``.

        Unless `replace_conflicting=True`, raises a VersionConflict exception
        if
        any requirements are found on the path that have the correct name but
        the wrong version.  Otherwise, if an `installer` is supplied it will be
        invoked to obtain the correct version of the requirement and activate
        it.

        `extras` is a list of the extras to be used with these requirements.
        This is important because extra requirements may look like `my_req;
        extra = "my_extra"`, which would otherwise be interpreted as a purely
        optional requirement.  Instead, we want to be able to assert that these
        requirements are truly required.
        """

        # set up the stack
        requirements = list(requirements)[::-1]
        # set of processed requirements
        processed = {}
        # key -> dist
        best = {}
        to_activate = []

        req_extras = _ReqExtras()

        # Mapping of requirement to set of distributions that required it;
        # useful for reporting info about conflicts.
        required_by = collections.defaultdict(set)

        while requirements:
            # process dependencies breadth-first
            req = requirements.pop(0)
            if req in processed:
                # Ignore cyclic or redundant dependencies
                continue

            if not req_extras.markers_pass(req, extras):
                continue

            dist = best.get(req.key)
            if dist is None:
                # Find the best distribution and add it to the map
                dist = self.by_key.get(req.key)
                if dist is None or (dist not in req and replace_conflicting):
                    ws = self
                    if env is None:
                        if dist is None:
                            env = Environment(self.entries)
                        else:
                            # Use an empty environment and workingset to avoid
                            # any further conflicts with the conflicting
                            # distribution
                            env = Environment([])
                            ws = WorkingSet([])
                    dist = best[req.key] = env.best_match(
                        req, ws, installer,
                        replace_conflicting=replace_conflicting
                    )
                    if dist is None:
                        requirers = required_by.get(req, None)
                        raise DistributionNotFound(req, requirers)
                to_activate.append(dist)
            if dist not in req:
                # Oops, the "best" so far conflicts with a dependency
                dependent_req = required_by[req]
                raise VersionConflict(dist, req).with_context(dependent_req)

            # push the new requirements onto the stack
            new_requirements = dist.requires(req.extras)[::-1]
            requirements.extend(new_requirements)

            # Register the new requirements needed by req
            for new_requirement in new_requirements:
                required_by[new_requirement].add(req.project_name)
                req_extras[new_requirement] = req.extras

            processed[req] = True

        # return list of distros to activate
        return to_activate
def resolve ( self , requirements , env = None , installer = None , replace_conflicting = False , extras = None ) : # set up the stack requirements = list ( requirements ) [ : : - 1 ] # set of processed requirements processed = { } # key -> dist best = { } to_activate = [ ] req_extras = _ReqExtras ( ) # Mapping of requirement to set of distributions that required it; # useful for reporting info about conflicts. required_by = collections . defaultdict ( set ) while requirements : # process dependencies breadth-first req = requirements . pop ( 0 ) if req in processed : # Ignore cyclic or redundant dependencies continue if not req_extras . markers_pass ( req , extras ) : continue dist = best . get ( req . key ) if dist is None : # Find the best distribution and add it to the map dist = self . by_key . get ( req . key ) if dist is None or ( dist not in req and replace_conflicting ) : ws = self if env is None : if dist is None : env = Environment ( self . entries ) else : # Use an empty environment and workingset to avoid # any further conflicts with the conflicting # distribution env = Environment ( [ ] ) ws = WorkingSet ( [ ] ) dist = best [ req . key ] = env . best_match ( req , ws , installer , replace_conflicting = replace_conflicting ) if dist is None : requirers = required_by . get ( req , None ) raise DistributionNotFound ( req , requirers ) to_activate . append ( dist ) if dist not in req : # Oops, the "best" so far conflicts with a dependency dependent_req = required_by [ req ] raise VersionConflict ( dist , req ) . with_context ( dependent_req ) # push the new requirements onto the stack new_requirements = dist . requires ( req . extras ) [ : : - 1 ] requirements . extend ( new_requirements ) # Register the new requirements needed by req for new_requirement in new_requirements : required_by [ new_requirement ] . add ( req . project_name ) req_extras [ new_requirement ] = req . extras processed [ req ] = True # return list of distros to activate return to_activate