from module_build_service import conf, log, build_logs, Modulemd, glib

  from module_build_service.scm import SCM

  logging.basicConfig(level=logging.DEBUG)

              with open(mmd_path, 'rb') as mmd_f:

                  raw_data = mmd_f.read()

                  data = to_text_type(raw_data)

                  ret['filename'] = mmd_filename

                  ret['filesize'] = len(raw_data)

                  ret['checksum'] = hashlib.md5(raw_data).hexdigest()

  import module_build_service.messaging

  from module_build_service.glib import from_variant_dict

  DEFAULT_MODULE_CONTEXT = '00000000'

          return session.query(ModuleBuild).filter_by(koji_tag=tag).first()

      def mmd(self):

          try:

          except Exception:

              log.exception('An error occurred while trying to parse the modulemd')

              raise ValueError("Invalid modulemd")

      @property

      def previous_non_failed_state(self):

          :return: Tuple with build_context, strem_build_context, runtime_context and

                   context hashes.

          """

          try:

          except Exception:

              raise ValueError("Invalid modulemd")

          mbs_xmd = mmd.get_xmd().get('mbs', {})

              less than or equal the stream version computed from `stream`.

          :return: List of Modulemd metadata instances matching the query

          """

          if version and context:

              mmd = self._get_module(name, stream, version, context, strict=strict)

              if mmd is None:

                  return

          with models.make_session(self.config) as session:

              if not version and not context:

  from module_build_service import models

  from module_build_service.errors import UnprocessableEntity

  from module_build_service.resolver.base import GenericResolver

  from module_build_service.utils.general import import_mmd

  log = logging.getLogger()

              if strict:

                  raise UnprocessableEntity("Failed to find module in MBS %r" % query)

              else:

          if version is None and "stream_version_lte" not in kwargs:

              # Only return the latest version

                  else:

                      return None

          return mmds

      def get_buildrequired_modulemds(self, name, stream, base_module_nsvc):

          :rtype: list

          :return: List of modulemd metadata.

          """

          modules = self._get_modules(name, stream, strict=False,

                                      base_module_br=base_module_nsvc)

      def resolve_profiles(self, mmd, keys):

          """

              for module in modules:

                  yaml = module['modulemd']

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

                  for key in keys:

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

              queried_module = self._get_module(

                  name, stream, version, context, strict=strict)

              yaml = queried_module['modulemd']

          if (not queried_mmd or not queried_mmd.get_xmd().get('mbs') or

                  'buildrequires' not in queried_mmd.get_xmd()['mbs'].keys()):

                  if m["koji_tag"] is None:

                      continue

                  module_tags.setdefault(m["koji_tag"], [])

          return module_tags

                  module_name, module_stream, module_version,

                  module_context, strict=True)

              if module.get('modulemd'):

                  if mmd.get_xmd().get('mbs') and 'commit' in mmd.get_xmd()['mbs'].keys():

                      commit_hash = mmd.get_xmd()['mbs']['commit']

          data = resp.json()

          if data['items']:

              modulemd = data['items'][0]['modulemd']

          else:

              return None

  from abc import ABCMeta, abstractmethod

  import module_build_service.config as cfg

  class GenericResolver(six.with_metaclass(ABCMeta)):

      @staticmethod

      def extract_modulemd(yaml, strict=False):

      @abstractmethod

      def get_module_modulemds(self, name, stream, version=None, context=None, strict=False,

  import shutil

  import tempfile

  import os

  from multiprocessing.dummy import Pool as ThreadPool

  from datetime import datetime

  import copy

  from gi.repository import GLib

  import module_build_service.scm

  from module_build_service import conf, db, log, models, Modulemd

  from module_build_service.errors import (

      ValidationError, UnprocessableEntity, Forbidden, Conflict)

  from module_build_service import glib

  def record_filtered_rpms(mmd):

      """

      # Imported here to allow import of utils in GenericBuilder.

      from module_build_service.builder import GenericBuilder

      resolver = GenericResolver.create(conf)

      builder = GenericBuilder.backends[conf.system]

      :return: List with submitted module builds.

      """

      import koji  # Placed here to avoid py2/py3 conflicts...

      log.debug('Submitted %s module build for %s:%s:%s',

                ("scratch" if params.get('scratch', False) else "normal"),

                  error = 'The modulemd file {} not found!'.format(os.path.basename(yaml))

                  log.error('The modulemd file %s not found!', yaml)

          else:

              log.debug('Modulemd content:\n%s', yaml)

          log.exception(error)

          raise UnprocessableEntity(error)

      return mmd

  def load_local_builds(local_build_nsvs, session=None):

      """

      Loads previously finished local module builds from conf.mock_resultsdir

  import time

  import hashlib

  from traceback import extract_stack

  import koji

  import module_build_service

  from module_build_service import db

  from module_build_service.config import init_config

  from module_build_service.models import ModuleBuild, ComponentBuild, make_session, BUILD_STATES

  from module_build_service import glib, Modulemd

      db.drop_all()

      db.create_all()

      if add_platform_module:

          import_mmd(db.session, mmd)

      """

      clean_database()

      if multiple_stream_versions:

          for stream in ["f28.0.0", "f29.0.0", "f29.1.0", "f29.2.0"]:

              mmd.set_name("platform")

              mmd.set_stream(stream)

      current_dir = os.path.dirname(__file__)

      formatted_testmodule_yml_path = os.path.join(

          current_dir, 'staged_data', 'formatted_testmodule.yaml')

      mmd.get_rpm_components()['tangerine'].set_buildorder(0)

      platform_br = module_build_service.models.ModuleBuild.query.get(1)

      current_dir = os.path.dirname(__file__)

      formatted_testmodule_yml_path = os.path.join(

          current_dir, 'staged_data', 'formatted_testmodule.yaml')

      platform_br = module_build_service.models.ModuleBuild.query.get(1)

          current_dir = os.path.dirname(__file__)

          formatted_testmodule_yml_path = os.path.join(

              current_dir, 'staged_data', 'shared-userspace-570.yaml')

          module_build = module_build_service.models.ModuleBuild(

              name=mmd.get_name(),

          # Create shared-userspace-577, state is WAIT, no component built

          formatted_testmodule_yml_path = os.path.join(

              current_dir, 'staged_data', 'shared-userspace-577.yaml')

          module_build = module_build_service.models.ModuleBuild(

              name=mmd2.get_name(),

          Test that when a build is submitted with a buildrequire without a Koji tag,

          MBS doesn't supply it as a dependency to the builder.

          """

          module_build_service.utils.import_mmd(db.session, metadata_mmd)

          FakeSCM(mocked_scm, 'testmodule', 'testmodule_br_metadata_module.yaml',

      def test_finalize_mmd_devel(self):

          self.cg.devel = True

          mmd = self.cg.module.mmd()

          # Check that -devel suffix is set.

          assert new_mmd.get_name().endswith("-devel")

  from datetime import datetime

  import module_build_service

  from tests import db, clean_database

  from module_build_service.config import init_config

  from module_build_service.models import ModuleBuild, BUILD_STATES

  app = module_build_service.app

  def module_build_from_modulemd(yaml):

      build = ModuleBuild()

      build.name = mmd.get_name()

      build.stream = mmd.get_stream()

  import module_build_service.resolver as mbs_resolver

  from module_build_service import app, db, models, glib, utils, Modulemd

  from module_build_service.models import ModuleBuild

  import tests

          tests.reuse_component_init_data()

      def test_get_buildrequired_modulemds(self):

          mmd.set_stream('f30.1.3')

          import_mmd(db.session, mmd)

          platform_f300103 = ModuleBuild.query.filter_by(stream='f30.1.3').one()

  from module_build_service.utils import to_text_type

  import module_build_service.resolver as mbs_resolver

  from module_build_service import db

  from module_build_service.models import ModuleBuild

  import tests

          tests.reuse_component_init_data()

      def test_get_buildrequired_modulemds(self):

          mmd.set_stream('f8')

          import_mmd(db.session, mmd)

          platform_f8 = ModuleBuild.query.filter_by(stream='f8').one()

  import module_build_service.resolver as mbs_resolver

  import module_build_service.utils

  import module_build_service.models

  import tests

      def test_get_module_build_dependencies_empty_buildrequires(self, mock_session,

                                                                 testmodule_mmd_9c690d0e):

          # Wipe out the dependencies

          mmd.set_dependencies()

          xmd = glib.from_variant_dict(mmd.get_xmd())

                      set(['bar'])

              }

              assert result == expected

  from datetime import datetime

  from werkzeug.datastructures import FileStorage

  from mock import patch

  import module_build_service.utils

  import module_build_service.scm

  from module_build_service import models, conf

      @pytest.mark.parametrize('context', ["c1", None])

      def test_import_mmd_contexts(self, context):

          mmd.set_context(context)

          xmd = glib.from_variant_dict(mmd.get_xmd())

          scheduler_init_data(1)

          mmd_path = path.abspath(path.join(

              __file__, path.pardir, path.pardir, 'staged_data', 'build_metadata_module.yaml'))

          module_build_service.utils.import_mmd(db.session, metadata_mmd)

          build_one = models.ModuleBuild.query.get(2)

          v = module_build_service.utils.submit.get_prefixed_version(mmd)

          assert v == 7000120180205135154

      def test_submit_build_new_mse_build(self, generate_expanded_mmds):

          """

          Tests that finished build can be resubmitted in case the resubmitted

          generate_expanded_mmds.return_value = [mmd1, mmd2]

          # Create a copy of mmd1 without xmd.mbs, since that will cause validate_mmd to fail

          mmd1_copy.set_xmd({})

          builds = module_build_service.utils.submit_module_build("foo", mmd1_copy, {})

          ret = {b.mmd().get_context(): b.state for b in builds}

      def test__get_base_module_mmds(self):

          """Ensure the correct results are returned without duplicates."""

          init_data(data_size=1, multiple_stream_versions=True)

          deps = mmd.get_dependencies()

          brs = deps[0].get_buildrequires()

          brs['platform'].set(['f29.1.0', 'f29.2.0'])

      def test__get_base_module_mmds_virtual_streams(self, virtual_streams):

          """Ensure the correct results are returned without duplicates."""

          init_data(data_size=1, multiple_stream_versions=True)

          deps = mmd.get_dependencies()

          brs = deps[0].get_buildrequires()

          brs['platform'].set(['f29.2.0'])

      def test__get_base_module_mmds_virtual_streams_latest_stream_version(self):

          init_data(data_size=1, multiple_stream_versions=True)

          deps = mmd.get_dependencies()

          brs = deps[0].get_buildrequires()

          brs['platform'].set(['f35'])

  from requests.utils import quote

  import hashlib

  import pytest

  import re

  from tests import app, init_data, clean_database, reuse_component_init_data

  from tests.test_scm import base_dir as scm_base_dir

  from module_build_service.errors import UnprocessableEntity

  from module_build_service.models import ModuleBuild

  import module_build_service.config as mbs_config

  import module_build_service.scheduler.handlers.modules

  from module_build_service.glib import dict_values, from_variant_dict

      def test_query_base_module_br_filters(self):

          reuse_component_init_data()

          mmd.set_stream('f30.1.3')

          import_mmd(db.session, mmd)

          platform_f300103 = ModuleBuild.query.filter_by(stream='f30.1.3').one()

          assert data['state_trace'][0]['state'] == 0

          assert data['tasks'] == {}

          assert data['siblings'] == []

          # Make sure the buildrequires entry was created

          module = ModuleBuild.query.get(8)

          rv = self.client.post(post_url, data=json.dumps(json_input))

          data = json.loads(rv.data)

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

          dep = mmd.get_dependencies()[0]

          assert set(dep.get_buildrequires()['platform'].get()) == expected_br

          assert data['state_trace'][0]['state'] == 0

          assert data['tasks'] == {}

          assert data['siblings'] == []

          # Make sure the buildrequires entry was created

          module = ModuleBuild.query.get(8)

          assert data['state_trace'][0]['state'] == 0

          assert data['tasks'] == {}

          assert data['siblings'] == []

          # Make sure the buildrequires entry was created

          module = ModuleBuild.query.get(8)

          init_data(data_size=1, multiple_stream_versions=True)

          # Create a platform for whatever the override is so the build submission succeeds

          if platform_override:

              platform_mmd.set_stream(platform_override)

              if platform_override == 'el8.0.0':

                  xmd = from_variant_dict(platform_mmd.get_xmd())

          data = json.loads(rv.data)

          assert rv.status_code == 201

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

          dep = mmd.get_dependencies()[0]

          if platform_override:

          mocked_regexes.return_value = [r'(?:\-LP\-)(.+)$']

          init_data(data_size=1, multiple_stream_versions=True)

          # Create a platform for the override so the build submission succeeds

          platform_mmd.set_stream('product1.3')

          import_mmd(db.session, platform_mmd)

          data = json.loads(rv.data)

          assert rv.status_code == 201

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

          dep = mmd.get_dependencies()[0]

          # The buildrequire_override value should take precedence over the stream override from

          versioning and no virtual streams, that the dependency resolution succeeds.

          """

          init_data(data_size=1, multiple_stream_versions=True)

          platform_mmd.set_stream('el8.0.0')

          import_mmd(db.session, platform_mmd)

              post_url, data=json.dumps({'branch': 'product1.2', 'scmurl': scm_url}))

          assert rv.status_code == 201

          data = json.loads(rv.data)[0]

          assert mmd.get_xmd()['mbs']['disttag_marking'] == 'product12'