", ".join([name, stream, str(version), context]), strict)

              )

          module_tags = {}

          if mmd:

              queried_mmd = mmd

                  mmd.get_context() or models.DEFAULT_MODULE_CONTEXT,

              ])

          else:

                  self.db_session, name, stream, version, context)

                  raise UnprocessableEntity(

                      "The module {} was not found".format(

                          ":".join([name, stream, version, context]))

                  )

              nsvc = ":".join([name, stream, version, context])

          xmd_mbs = queried_mmd.get_xmd().get("mbs", {})

          buildrequires = xmd_mbs["buildrequires"]

          side_tag = xmd_mbs.get("side_tag")

          for br_name, details in buildrequires.items():

              build = models.ModuleBuild.get_build_from_nsvc(

                  self.db_session,

                  side_tag_format = build.mmd().get_xmd().get("mbs", {}).get("koji_side_tag_format")

                  if side_tag_format:

                      koji_tag = side_tag_format.format(side_tag=side_tag)

                      log.info("Using side tag for base module %s: %s", br_name, koji_tag)

                  else:

                      log.warning("Side tag requested, but base module %s lacks koji_side_tag_format"

              module_tags.setdefault(koji_tag, [])

              module_tags[koji_tag].append(build.mmd())

          return module_tags

      def resolve_requires(self, requires):

  # SPDX-License-Identifier: MIT

  from __future__ import absolute_import

  import os

  from datetime import datetime

  from mock import patch, PropertyMock

  import tests

  class TestDBModule:

      def test_get_buildrequired_modulemds(self):

      @pytest.mark.parametrize("missing_format", [False, True])

      def test_get_module_build_dependencies_side_tag(

          """

          Test that we get the correct base module tag when a side tag is specified

          """

              db_session.commit()

              expected = {"module-f28-build"}

          resolver = mbs_resolver.GenericResolver.create(db_session, conf, backend="db")

      def test_get_module_build_dependencies_recursive(self, reuse_component_init_data):

          """