# multilib is not enabled for this srpm in MMD.

              try:

                  mmd_component = mmd.get_rpm_components()[srpm]

                  multilib = multilib.get() if multilib else set()

                  # The `multilib` set defines the list of architectures for which

                  # the multilib is enabled.

          # the return deps should be runtime requires or buildrequires.

          normdeps = lambda mmd, fn: [{name: streams.get()

                                       for name, streams in getattr(dep, fn)().items()}

          # Each solvable object has name, version, architecture and list of

          # provides/requires/conflicts which defines its relations with other solvables.

              # Fill in the "Requires" of this module, so we can track its dependencies

              # on other modules.

              solvable.add_deparray(solv.SOLVABLE_REQUIRES, requires)

              # Add "Conflicts: module(name)", because TODO, ask ignatenko.

              # Using this trick, libsolv will try to solve all the buildrequires/requires pairs,

              # because they are expressed as separate Solvables and we are able to distinguish

              # between them thanks to context value.

              for c, deps in enumerate(mmd.get_dependencies()):

                  # $n:$s:$c-$v.src

                  solvable = self.build_repo.add_solvable()

          # Get the requires from the real "dependencies" section in MMD.

          mmd_requires = {}

          for deps in mmd.get_dependencies():

                  if name not in mmd_requires:

                      mmd_requires[name] = set()

                  mmd_requires[name] = mmd_requires[name].union(streams.get())

                      dep_mmd = local_module.mmd()

                      for key in keys:

                          if key in dep_mmd.get_profiles().keys():

                      continue

                  build = models.ModuleBuild.get_build_from_nsvc(

                  # Take note of what rpms are in this dep's profile

                  for key in keys:

                      if key in dep_mmd.get_profiles().keys():

          # Return the union of all rpms in all profiles of the given keys

          return results

                  dep_mmd = local_module.mmd()

                  for key in keys:

                      if key in dep_mmd.get_profiles().keys():

                  continue

              # Find the dep in the built modules in MBS

                  # Take note of what rpms are in this dep's profile.

                  for key in keys:

                      if key in dep_mmd.get_profiles().keys():

          # Return the union of all rpms in all profiles of the given keys.

          return results

      @staticmethod

      def extract_modulemd(yaml, strict=False):

          try:

              mmd.upgrade()

          except Exception:

              raise ValueError('Invalid modulemd')

      """

      for deps in mmd.get_dependencies():

          expanded = {}

              streams_set = Modulemd.SimpleSet()

              streams_set.set(_expand_mse_streams(

                  session, name, streams, default_streams, raise_if_stream_ambigous))

          deps.set_requires(expanded)

          expanded = {}

              streams_set = Modulemd.SimpleSet()

              streams_set.set(_expand_mse_streams(

                  session, name, streams, default_streams, raise_if_stream_ambigous))

          for mmd_list in added_mmds.values():

              for mmd in mmd_list:

                  for deps in mmd.get_dependencies():

      return mmds

      # At first get all the buildrequires of the module of interest.

      for deps in mmd.get_dependencies():

          mmds = _get_mmds_from_requires(

              raise_if_stream_ambigous)

      # Now get the requires of buildrequires recursively.

          for mmd in mmds[mmd_key]:

              for deps in mmd.get_dependencies():

                  mmds = _get_mmds_from_requires(

                      raise_if_stream_ambigous)

      # Make single list from dict of lists.

          # will build this MMD against.

          new_dep = Modulemd.Dependencies()

          dep = mmd_copy.get_dependencies()[dependencies_id]

          for req_name, req_streams in dep_requires.items():

              if req_name not in dep_buildrequires:

                  # This require is not a buildrequire so just copy this runtime requirement to

          # to the specific commit available at the time of

          # submission (now).

          pkgref = module_build_service.scm.SCM(

      except Exception as e:

          log.exception(e)

          return {'error': "Failed to get the latest commit for %s#%s" % (

      return {

          'pkg_ref': pkgref,

          'error': None

      }

              xmd['mbs']['rpms'] = {}

          # Add missing data in RPM components

          for pkgname, pkg in mmd.get_rpm_components().items():

                  raise Forbidden(

                      "Custom component repositories aren't allowed.  "

                  raise Forbidden(

                      "Custom component caches aren't allowed.  "

                      "%r bears cache %r" % (pkgname, pkg.cache))

                  pkg.set_repository(conf.rpms_default_repository + pkgname)

                  pkg.set_cache(conf.rpms_default_cache + pkgname)

                  pkg.set_ref('master')

          # Add missing data in included modules components

          for modname, mod in mmd.get_module_components().items():

                  raise Forbidden(

                      "Custom module repositories aren't allowed.  "

                  mod.set_repository(conf.modules_default_repository + modname)

                  mod.set_ref('master')

          # Check that SCM URL is valid and replace potential branches in pkg refs

  def validate_mmd(mmd):

      for modname, mod in mmd.get_module_components().items():

              raise Forbidden(

                  "Custom module repositories aren't allowed.  "

  def merge_included_mmd(mmd, included_mmd):

          return

      rpm_weights = module_build_service.builder.GenericBuilder.get_build_weights(

      all_components.sort(key=lambda x: x.get_buildorder())

      # We do not start with batch = 0 here, because the first batch is

      # reserved for module-build-macros. First real components must be

          # set to our current batch, so the components of this module

          # are built in the right global order.

          if isinstance(component, Modulemd.ComponentModule):

              # It is OK to whitelist all URLs here, because the validity

              # of every URL have been already checked in format_mmd(...).

              included_mmd = _fetch_mmd(full_url, whitelist_url=True)[0]

                                              previous_buildorder, main_mmd, session=session)

              continue

          build = models.ComponentBuild(

              module_id=module.id,

              format="rpms",

              scmurl=full_url,

              batch=batch,

              ref=component_ref,

          )

          session.add(build)

                  previous_buildorder = pkg.get_buildorder()

                  batch += 1

              build = module_build_service.models.ComponentBuild(

                  module_id=2,

                  format="rpms",

                  scmurl=full_url,

                  batch=batch,

          components2 = mmd2.get_rpm_components().values()

          # Store components to database in different order than for 570 to

          # reproduce the reusing issue.

          components2.sort(key=lambda x: x.get_buildorder())

          previous_buildorder = None

          batch = 1

                  previous_buildorder = pkg.get_buildorder()

                  batch += 1

              build = module_build_service.models.ComponentBuild(

                  module_id=3,

                  format="rpms",

                  scmurl=full_url,

                  batch=batch,

  BASE_DIR = os.path.dirname(__file__)

  STAGED_DATA_DIR = os.path.join(BASE_DIR, 'staged_data')

  PLATFORM_MODULEMD = _mmd.dumps()

  TESTMODULE_MODULEMD = _mmd2.dumps()

  _mmd3.set_context("c2c572ed")

  TESTMODULE_MODULEMD_SECOND_CONTEXT = _mmd3.dumps()

          mmd = module.mmd()

          mmd.set_name('testmodule2')

          mmd.set_version(20180123171545)

          requires['testmodule'] = Modulemd.SimpleSet()

          requires['testmodule'].add('master')

          mmd.get_dependencies()[0].set_requires(requires)

          module_mmds = resolver.get_module_modulemds('testmodule', 'master', '20180205135154',

                                                      '9c690d0e')

          nsvcs = set(

              for m in module_mmds

          )

          expected = set(["testmodule:master:20180205135154:9c690d0e"])

          resolver = mbs_resolver.GenericResolver.create(tests.conf, backend='mbs')

          ret = resolver.get_module_modulemds('testmodule', 'master', version)

          nsvcs = set(

              for m in ret

          )

          expected = set(["testmodule:master:20180205135154:9c690d0e",

          module_build_service.utils.format_mmd(mmd, scmurl)

          # Make sure that original refs are not changed.

          assert set(mmd_pkg_refs) == set(hashes_returned.keys())

          assert br.keys() == ['platform']

          assert br.values()[0].get() == ['f28']

          xmd = {

              buildrequires = set()

              dep = mmd.get_dependencies()[0]

                  for req_stream in req_streams.get():

                      buildrequires.add(":".join([req_name, req_stream]))

              buildrequires_per_mmd_buildrequires.add(frozenset(buildrequires))

              assert len(mmd.get_dependencies()) == 1

              mmd_requires = set()

              dep = mmd.get_dependencies()[0]

                  for req_stream in req_streams.get():

                      mmd_requires.add(":".join([req_name, req_stream]))

              requires_per_mmd.add(frozenset(mmd_requires))