code: def resolve(self, requirements, max_rounds=20):
          
          resolution = Resolution(self.provider, self.reporter)
          resolution.resolve(requirements, max_rounds=max_rounds)
          return resolution.state
docs: Take a collection of constraints, spit out the resolution result.
  
          The return value is a representation to the final resolution result. It
          is a tuple subclass with two public members:
  
          * `mapping`: A dict of resolved candidates. Each key is an identifier
              of a requirement (as returned by the provider's `identify` method),
              and the value is the resolved candidate.
          * `graph`: A `DirectedGraph` instance representing the dependency tree.
              The vertices are keys of `mapping`, and each edge represents *why*
              a particular package is included. A special vertex `None` is
              included to represent parents of user-supplied requirements.
  
          The following exceptions may be raised if a resolution cannot be found:
  
          * `NoVersionsAvailable`: A requirement has no available candidates.
          * `ResolutionImpossible`: A resolution cannot be found for the given
              combination of requirements.
          * `ResolutionTooDeep`: The dependency tree is too deeply nested and
              the resolver gave up. This is usually caused by a circular
              dependency, but you can try to resolve this by increasing the
              `max_rounds` argument.