"pypi": 5, # package_name, version, python_versions

              "rubygems": 6, # gem_name

              "scm": 8, # type, clone_url, committish, subdirectory, spec, srpm_build_method

             }

  BuildRequires: python3-rpkg

  BuildRequires: python3-pytest

  BuildRequires: python3-pytest-cov

  Requires: systemd

  Requires: httpd

  Requires: dist-git

  Requires: python3-requests

  Requires: python3-rpkg

  Requires: python3-munch

  from .exceptions import FileDownloadException, RunCommandException, SrpmQueryException

  from configparser import ConfigParser

  from munch import Munch

  from requests import get

      return upper_wrapper

  def _get_conf(cp, section, option, default, mode=None):

      """

      To make returning items from config parser less irritating

  BuildRequires: python3-devel

  %if %{with check}

  BuildRequires: python3-six

  BuildRequires: python3-flask

  BuildRequires: python3-flask-script

  Requires: xstatic-datatables-common

  Requires: js-html5shiv

  Requires: js-respond

  Provides: bundled(bootstrap-combobox) = 1.1.6

  Provides: bundled(bootstrap-select) = 1.5.4

  from flask import Markup, url_for

  from coprs import app

  from coprs import helpers

  def state_from_num(num):

      if num is None:

          return "unknown"

  @app.template_filter("module_state_from_num")

  def module_state_from_num(num):

      if num is None:

          return "unknown"

  @app.template_filter("os_name_short")

  from sqlalchemy.types import TypeDecorator, VARCHAR

  import json

  from coprs import constants

  from coprs import app

      REPO_DL = "repo_dl"

  class PermissionEnum(with_metaclass(EnumType, object)):

      vals = {"nothing": 0, "request": 1, "approved": 2}

          return [(n, k) for k, n in cls.vals.items() if n != without]

  class BuildSourceEnum(with_metaclass(EnumType, object)):

      vals = {"unset": 0,

              "link": 1,  # url

              "custom": 9, # user-provided script to build sources

             }

  class JSONEncodedDict(TypeDecorator):

      """Represents an immutable structure as a json-encoded string.

  import base64

  import os

  from coprs import db

  from coprs import models

  from coprs import helpers

          query = (models.Action.query

                   .filter(models.Action.result ==

                   .filter(models.Action.action_type !=

                   .order_by(models.Action.created_on.asc()))

          return query

              "chroots": [chroot.name for chroot in copr.active_chroots],

          }

          action = models.Action(

              object_type="repository",

              object_id=0,

              data=json.dumps(data_dict),

              "ownername": copr.owner_name,

              "project_dirnames": [copr_dir.name for copr_dir in copr.dirs],

          }

                                 object_type="copr",

                                 object_id=copr.id,

                                 data=json.dumps(data_dict),

          }

          action = models.Action(

              object_type="build",

              object_id=build.id,

              data=json.dumps(data_dict),

              }

              action = models.Action(

                  data=json.dumps(data_dict),

                  created_on=int(time.time())

              )

          }

          action = models.Action(

              object_type="copr_chroot",

              data=json.dumps(data_dict),

              created_on=int(time.time())

          }

          action = models.Action(

              object_type="copr_chroot",

              data=json.dumps(data_dict),

              created_on=int(time.time())

          }

          action = models.Action(

              object_type="copr",

              data=json.dumps(data_dict),

              created_on=int(time.time()),

      @classmethod

      def send_rawhide_to_release(cls, data):

          action = models.Action(

              object_type="None",

              data=json.dumps(data),

              created_on=int(time.time()),

          """

          action = models.Action(

              object_type="copr",

              old_value="{0}".format(src.full_name),

              new_value="{0}".format(dst.full_name),

          }

          action = models.Action(

              object_type="module",

              object_id=module.id,

              old_value="",

      to [de]serialize model instances for API views.

  """

  class BuildWrapper(object):

      def __init__(self, build):

  from sqlalchemy import desc, asc, bindparam, Integer, String

  from collections import defaultdict

  from coprs import app

  from coprs import db

  from coprs import exceptions

  from coprs import helpers

  from coprs.constants import DEFAULT_BUILD_TIMEOUT, MAX_BUILD_TIMEOUT

  from coprs.exceptions import MalformedArgumentException, ActionInProgressException, InsufficientRightsException, UnrepeatableBuildException

  from coprs.logic import coprs_logic

  from coprs.logic import users_logic

              """)

              res_pending = db.engine.execute(query_pending, start=step_start, end=step_end,

              res_running = db.engine.execute(query_running, start=step_start, end=step_end,

              pending = res_pending.first().pending

              running = res_running.first().running

          """

          query = (models.Build.query

                   .filter(models.Build.canceled == false())

                   .order_by(models.Build.id.asc()))

          if background is not None:

              query = query.filter(models.Build.is_background == (true() if background else false()))

      def get_pending_srpm_build_tasks(cls, background=None):

          query = (models.Build.query

                  .filter(models.Build.canceled == false())

                  .order_by(models.Build.is_background.asc(), models.Build.id.asc()))

          if background is not None:

              query = query.filter(models.Build.is_background == (true() if background else false()))

          query = (models.BuildChroot.query.join(models.Build)

                  .filter(models.Build.canceled == false())

                  .filter(or_(

                      and_(

                          models.BuildChroot.started_on < int(time.time() - 1.1 * MAX_BUILD_TIMEOUT),

                          models.BuildChroot.ended_on.is_(None)

                      )

              package=package,

              copr=package.copr,

              repos=package.copr.repos,

              source_type=package.source_type,

              source_json=source_json,

              submitted_on=int(time.time()),

          db.session.add(build)

          chroots = package.copr.active_chroots

          for chroot in chroots:

              buildchroot = models.BuildChroot(

                  build=build,

                      db.session.add(ch)

              if new_status == StatusEnum("failed"):

              cls.process_update_callback(build)

              db.session.add(build)

          Marks build as failed on all its non-finished chroots

          """

          build = cls.get(build_id).one()

          for chroot in chroots:

          cls.process_update_callback(build)

          return build

          last_build = (

              builds.join(models.BuildChroot)

              .filter(models.BuildChroot.ended_on.isnot(None))

              .order_by(models.BuildChroot.ended_on.desc())

          ).first()

  from .. import db

  from .builds_logic import BuildsLogic

  from coprs import models

  from coprs import exceptions

  from coprs.exceptions import ObjectNotFound

  from coprs.logic.packages_logic import PackagesLogic

  from coprs.logic.actions_logic import ActionsLogic

  from sqlalchemy.orm.exc import NoResultFound

  from sqlalchemy.orm.attributes import get_history

  from coprs import db

  from coprs import exceptions

  from coprs import helpers

      @classmethod

      def unfinished_blocking_actions_for(cls, copr):

          actions = (models.Action.query

                     .filter(models.Action.object_type == "copr")

                     .filter(models.Action.object_id == copr.id)

                     .filter(models.Action.result ==

                     .filter(models.Action.action_type.in_(blocking_actions)))

          return actions

  from libravatar import libravatar_url

  import zlib

  from coprs import constants

  from coprs import db

  from coprs import helpers

  import itertools

  import operator

  import gi

  gi.require_version('Modulemd', '1.0')

      @property

      def still_forking(self):

                      .filter(Action.new_value == self.full_name).all())

      def get_search_related_copr_id(self):

      # Source of the build: description in json, example: git link, srpm url, etc.

      source_json = db.Column(db.Text)

      # Type of failure: type identifier

      # background builds has lesser priority than regular builds.

      is_background = db.Column(db.Boolean, default=False, server_default="0", nullable=False)

      @property

      def fail_type_text(self):

      @property

      def repos_list(self):

      new_value = db.Column(db.String(255))

      # additional data

      data = db.Column(db.Text)

      result = db.Column(

      # optional message from the backend/whatever

      message = db.Column(db.Text)

      # time created as returned by int(time.time())

          Return numeric representation of status of this build

          """

          if any(b for b in self.builds if b.status == StatusEnum("failed")):

      @property

      def state(self):

          """

          Return text representation of status of this build

          """

      @property

      def rpm_filter(self):

  from marshmallow import Schema, fields

  from marshmallow import Schema, fields, validates_schema, ValidationError, validate

  from coprs.rest_api.common import render_build_task

  from ...exceptions import MalformedArgumentException

  from ...logic.builds_logic import BuildsLogic, BuildChrootsLogic

  import flask

  from coprs import db

  from coprs import helpers

  from coprs import models

  @admin_ns.route("/")

  def admin_index():

      return flask.redirect(flask.url_for("admin_ns.legal_flag"))

  @admin_ns.route("/legal-flag/")

  def legal_flag():

      legal_flags = (

          models.LegalFlag.query

  @admin_ns.route("/legal-flag/<int:flag_id>/resolve/", methods=["POST"])

  def legal_flag_resolve(flag_id):

      (models.LegalFlag.query

  @admin_ns.route("/playground/", methods=["POST", "GET"])

  def playground():

      form = forms.AdminPlaygroundSearchForm()

  @admin_ns.route("/playground/<username>/<coprname>/")

  def playground_project(username, coprname):

      copr = coprs_logic.CoprsLogic.get(username, coprname).first()

      if not copr:

  @admin_ns.route("/playground/<username>/<coprname>/set/", methods=["POST"])

  def playground_set(username, coprname):

      copr = coprs_logic.CoprsLogic.get(username, coprname).first()

      if copr:

  from werkzeug import secure_filename

  from coprs import db

  from coprs import exceptions

  from coprs import forms

      Receive information about queue

      """

      output = {

      }

      return flask.jsonify(output)

  from . import get_copr, file_upload, query_params, pagination, Paginator, json2form, GET, POST, PUT, DELETE

  from .json2form import get_form_compatible_data, without_empty_fields

  from werkzeug import secure_filename

  from coprs import db, forms, models

  from coprs.exceptions import (ApiError, InsufficientRightsException, ActionInProgressException,

                                BadRequest, AccessRestricted)

  from coprs.views.misc import api_login_required

  import time

  import sqlalchemy

  from coprs import db, app

  from coprs import helpers

  from coprs import models

  from coprs import exceptions

  from coprs.logic import actions_logic

  from coprs.logic.builds_logic import BuildsLogic, BuildChrootsLogic

  from coprs.logic.complex_logic import ComplexLogic

  from functools import wraps

  from werkzeug import secure_filename

  from coprs import app

  from coprs import db

  from coprs import forms

      else:

          build_chroot_names = set(ch.name for ch in build.chroots)

          build_failed_chroot_names = set(ch.name for ch in build.get_chroots_by_status([

          ]))

          for ch in available_chroots:

              # check checkbox on all the chroots that have not been (successfully) built before

  from pygments.lexers import get_lexer_by_name

  from pygments.formatters import HtmlFormatter

  from coprs import app

  from coprs import db

  from coprs import rcp

                                   monitor=monitor,

                                   oses=oses_grouped,

                                   archs=archs,

  @coprs_ns.route("/<username>/<coprname>/monitor/")

  from urllib.parse import urlparse

  from openid_teams.teams import TeamsRequest

  from coprs import app

  from coprs import db

  from coprs import helpers

      return flask.redirect(flask.url_for("coprs_ns.coprs_show"))

      def view_wrapper(f):

          @functools.wraps(f)

          def decorated_function(*args, **kwargs):

                  return flask.redirect(flask.url_for("misc.login",

                                                      next=flask.request.url))

                  flask.flash("You are not allowed to access admin section.")

                  return flask.redirect(flask.url_for("coprs_ns.coprs_show"))

  import flask

  from time import time

  from coprs.views.status_ns import status_ns

  from coprs.logic import builds_logic

  @status_ns.route("/")

  @status_ns.route("/running/")

  def running():

      return flask.render_template("status/running.html",

                                   number=len(tasks),

                                   tasks=tasks)

  from flask_script import Manager, Command, Option, Group

  from flask_whooshee import Whooshee

  from coprs import app

  from coprs import db

  from coprs import exceptions

  from coprs.views.misc import create_user_wrapper

  from coprs.whoosheers import CoprWhoosheer

  from sqlalchemy import and_, or_

  class TestCommand(Command):

  import coprs

  from coprs import helpers

  from coprs import models

  from coprs.logic.coprs_logic import BranchesLogic

  from unittest import mock

  from unittest.mock import MagicMock

      @pytest.fixture

      def f_actions(self):

          self.f_db()

                                             object_type="copr",

                                             object_id=self.c1.id,

                                             old_value="asd/qwe",

                                             new_value=None,

                                             created_on=int(time.time()))

                                                   data=json.dumps({'task_id': 123}),

                                                   created_on=int(time.time()))

          self.db.session.add_all([self.delete_action, self.cancel_build_action])

  import random

  from marshmallow import pprint

  from coprs.logic.actions_logic import ActionsLogic

  from coprs.logic.coprs_logic import CoprsLogic

  from coprs.logic.builds_logic import BuildsLogic

  import pytest

  import sqlalchemy

  from coprs.logic.users_logic import UsersLogic