parameters: (self, requirements, env=None, installer=None,  # noqa: C901
                  replace_conflicting=False, extras=None)
return_statement: return to_activate
docstring: 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.
docstring_summary: List all distributions needed to (recursively) meet `requirements`
docstring_tokens: List all distributions needed to ( recursively ) meet requirements
function: def resolve(self, requirements, env=None, installer=None,  # noqa: C901
                  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
function_tokens: def resolve ( self , requirements , env = None , installer = None , # noqa: C901 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