def getTest():
    reload(sys)
    sys.setdefaultencoding( "utf-8" )
    question=models.WordQuize.query.order_by(func.random()).limit(20)
    results=[]
    results2=[]
    results3=[]
    #result={'user_id': 2,'s':1}
    #{'id':+q.id,'question':+q.question,"option:":+q.option}
    for q in question:
        result={'id':q.id,'question':q.question,'option':q.option}
        results.append(result)
    question = models.ConfuseQuize.query.order_by(func.random()).limit(20)
    for q in question:
        result = {'id': q.id, 'question': q.question, 'option': q.option}
        results3.append(result)
    question=models.PhraseQuize.query.order_by(func.random()).limit(20)
    for q in question:
        result={'id':q.id,'question':q.question,'option':q.option}
        results2.append(result)
    json_result = {'result':results,'result2':results2, 'result3':results3}#json.dumps(json_result)
    print results
    print results2
    print results3
    return json.dumps(json_result,ensure_ascii=False)

def get_request():
    """
    @return: a random request guarantied to be locked and unique
    """
    session = database.get_session()
    me = Host.by_name(socket.gethostname(), session)
    if me.region is not None:
        # noinspection PyComparisonWithNone,PyPep8
        query = session.query(HashRequest).join(HashRequest.host).join(Host.region).filter(
            and_(HashRequest.locked == False, HashRequest.server != None,
                 Region.id == me.region.id)).order_by(func.random()).with_for_update()
    else:
        # noinspection PyComparisonWithNone,PyPep8
        query = session.query(HashRequest).join(HashRequest.host).filter(
            and_(HashRequest.locked == False, HashRequest.server != None,
                 HashRequest.host == me)).order_by(func.random()).with_for_update()
    try:
        request = query.first()
        if request is None:
            return None
        request.locked = True
        session.commit()
        return request
    except Exception as error:
        session.rollback()
        raise error

    finally:
        session.close()

 def random(self):
     engine = str(db.engine)
     if 'postgresql' in engine:
         # Postgres
         return Session.query(self).order_by(func.random()).first()
     elif 'mysql' in engine:
         # MySQL
         return Session.query(self).order_by(func.rand()).first()
     elif 'sqlite' in engine:
         # sqlite
         return Session.query(self).order_by(func.random()).first()

    def test_generic_random(self):
        assert func.random().type == sqltypes.NULLTYPE
        assert isinstance(func.random(type_=Integer).type, Integer)

        for ret, dialect in [
            ('random()', sqlite.dialect()),
            ('random()', postgresql.dialect()),
            ('rand()', mysql.dialect()),
            ('random()', oracle.dialect())
        ]:
            self.assert_compile(func.random(), ret, dialect=dialect)

    def index(self, **kw):
#        items = DBSession.query(Item).all()
#        my_page = Page(items, page = int(kw.get("page", 1)), url = lambda page:"%s?page=%d" % (self.request.path, page))
#        self.render("index.html", my_page = my_page)
        items = DBSession.query(Item).all()[:9]
        try:
            show_case1 = DBSession.query(Item).order_by(func.random()).all()[:4]
            show_case2 = DBSession.query(Item).order_by(func.random()).all()[:4]
        except:
            show_case1 = DBSession.query(Item).order_by(func.rand()).all()[:4]
            show_case2 = DBSession.query(Item).order_by(func.rand()).all()[:4]
        self.render("index.html", items = items, show_case1 = show_case1, show_case2 = show_case2)

def birdie_view(request):
    dbsession = DBSession()
    userid = authenticated_userid(request)
    user = dbsession.query(User).filter_by(userid=userid).first()
    follows = dbsession.query(Follower).filter(Follower.follower == user.id)
    follows = follows.order_by(Follower.follows.asc()).limit(10)
    followers = dbsession.query(Follower).filter(Follower.follows == user.id)
    followers = followers.order_by(Follower.follower.asc()).limit(10)
    chirpers = [follow.follows for follow in follows]
    chirpers.append(user.id)
    chirps = dbsession.query(Chirp).filter(Chirp.author_id.in_(chirpers))
    chirps = chirps.order_by(Chirp.timestamp.desc()).limit(30)
    whomtofollow = dbsession.query(User).order_by(func.random()).limit(10)
    return {
        "app_url": request.application_url,
        "static_url": request.static_url,
        "userid": userid,
        "user": user,
        "elapsed": get_elapsed,
        "follows": follows,
        "followers": followers,
        "user_chirps": False,
        "whomtofollow": whomtofollow,
        "chirps": chirps,
    }

def get_representative_nodes():
    """Get elements with a reasonable distribution of node counts."""

    step = 1000
    start = 0
    stop = 60000
    limit = 50
    record_names = ['name', 'gridcode', 'node_count']

    ranges = []
    to_process = []

    s = Session()

    while start < stop:
        ranges.append([start, start + step])
        start += step

    for ctr, select_range in enumerate(ranges):
        log.debug(select_range)
        q = s.query(VectorProcessingUnit.name, Catchment.gridcode, Catchment.node_count).join(Catchment)
        q = q.filter(Catchment.node_count >= select_range[0]).filter(Catchment.node_count < select_range[1])
        q = q.order_by(func.random()).limit(limit)

        for idx, record in enumerate(q):
            to_process.append(dict(zip(record_names, record)))

    s.close()

    return to_process

    def rand(self, sender, *, orig_only=False):
        ''' A random tweet from someone.

        Example::

            /rand j
                a random tweet from j

        :param str sender: single sender
        :param bool orig_only: original tweets only
        :return: `Resp` object
        :rtype: Resp
        '''
        sender = self._to_sender(sender)
        assert len(sender) == 1, "so many people"
        sender = sender[0]
        cond = Tweet.user_id == int(sender)
        if orig_only:
            cond = cond & (Tweet.type == 'tweet')
        one = self.session.query(Tweet).filter(cond)\
                          .order_by(func.random()).first()
        if one is None:
            return Resp(message="nothing indexed")
        cmd = '/randt' if orig_only else '/rand'
        keyboard = {"keyboard": [[cmd + ' ' + sender], ['/end']],
                    "selective": True, "resize_keyboard": True}
        return Resp(message=self.fmt.format_rand(one),
                    keyboard=keyboard, markdown=True)

    def get_random_mapobject_subset(self, mapobject_type_name, n):
        '''Selects a random subset of mapobjects.

        Parameters
        ----------
        mapobject_type_name: str
            name of the selected
            :class:`MapobjectType <tmlib.models.mapobject.MapobjectType>`
        n: int
            number of mapobjects that should be selected at random

        Returns
        -------
        Tuple[int]
            IDs of selected mapobject
        '''
        with tm.utils.ExperimentSession(self.experiment_id) as session:
            mapobject_type = session.query(tm.MapobjectType.id).\
                filter_by(name=mapobject_type_name).\
                one()
            mapobjects = session.query(tm.Mapobject.id).\
                filter_by(mapobject_type_id=mapobject_type.id).\
                order_by(func.random()).\
                limit(n).\
                all()
            return [m.id for m in mapobjects]

 def meet_character(cls, character):
     """ Get monster for character.
     """
     return cls.query.filter(
         cls.level >= character.level - 2,
         cls.level <= character.level + 2
     ).order_by(func.random()).first()

def load_projects():
    """Takes 'n' the user specifies and returns n projects from the cluster."""
    number = request.form.get("number")
    print number
    cluster_id = request.form.get("id")
    print cluster_id
    #returns n random projects in chosen cluster
    cluster_query = modelsession.query(model.Cluster).filter(
                    model.Cluster.cluster_num==cluster_id).order_by(
                    func.random()).limit(number).all()
    print len(cluster_query)
    projects = []
    #loops through projects in cluster_query to create a list of the project objs.
    for item in cluster_query:
        proj_id = item.project_id
        proj_id = '"'+proj_id+'"'
        print proj_id
        query = modelsession.query(model.Project).filter(
                model.Project.id==proj_id).first()
        projects.append(query)
    print projects
    #creates a json object to pass to javascript
    json_list = []
    for i in range(len(projects)):
        json_list.append({"id": projects[i].id,
                        "title": projects[i].title, 
                        "location": projects[i].school.city + ", " + 
                                    projects[i].school.state,
                        "grade": projects[i].grade_level,
                        "needs": projects[i].fulfillment_trailer})
    results = json.dumps(json_list)
    return results

    def get(self):
        sort = request.args.get('sort')
        role = request.args.get('role')
        require = request.args.get('require')
        limit = request.args.get('limit')

        if sort == 'random':
            users = User.query.order_by(func.random())
        else:
            users = User.query.order_by(desc(User.first_name))

        if role:
            roles = role.split(',')
            users = users.filter(User.role.in_(roles))
        if require:
            # Return only users that have attributes that are lists with at least one element
            # example, if require = 'host-applications', only return users with at least one host application
            requires = require.split(',')
            requires = [getattr(User, lisp_to_snake(require)).any() for require in requires]
            users = User.query.filter(*requires)

        if limit:
            limit = int(limit)
            users = users[:limit]
        else:
            users = users.all()

        #print(row2dict(users[0]))
        tmp = [row2dict(user) for user in users]
        users = {'users': tmp}
        return users

    def update_scores(self, model, chunksize=10000):

        # update node scores
        waypoint_nodes = (
            self.session.query(
                Node,
                ST_X(cast(Node.loc, Geometry)),
                ST_Y(cast(Node.loc, Geometry)))
                .filter(Node.num_ways != 0)
                .order_by(func.random()))   # random order

        # process nodes in chunks for memory efficiency.
        # note: normalization of scores is done per chunk, which should be a
        # reasonable approximation to global normalization when the chunks are
        # large since the query specifies random ordering
        for chunk in _grouper(chunksize, waypoint_nodes):
            nodes, x, y = zip(*chunk)
            X = np.vstack((x, y)).T
            scores = model.score_samples(X)
            for node, score in zip(nodes, scores):
                node.score = score

        # update cumulative scores
        sq = (
            self.session.query(
                Waypoint.id.label('id'),
                func.sum(Node.score).over(
                    partition_by=Waypoint.way_id,
                    order_by=Waypoint.idx).label('cscore'))
                .join(Node)
                .subquery())

        (self.session.query(Waypoint)
             .filter(Waypoint.id == sq.c.id)
             .update({Waypoint.cscore: sq.c.cscore}))

def cmd(send, msg, args):
    """Returns a random line from $nick.

    Syntax: {command} (--channel <channel>) (nick)

    """
    parser = arguments.ArgParser(args['config'])
    parser.add_argument('--channel', action=arguments.ChanParser)
    parser.add_argument('nick', nargs='*')
    try:
        cmdargs = parser.parse_args(msg)
    except arguments.ArgumentException as e:
        send(str(e))
        return
    quote = args['db'].query(Log.msg, Log.source)
    nick = ' '.join(cmdargs.nick) if cmdargs.nick else ""
    if nick:
        quote = quote.filter(Log.source == nick)
    else:
        quote = quote.filter(Log.source != args['botnick'])
    target = cmdargs.channels[0] if hasattr(cmdargs, 'channels') else args['config']['core']['channel']
    quote = quote.filter(or_(Log.type == 'pubmsg', Log.type == 'privmsg', Log.type == 'action'), Log.target == target,
                         func.length(Log.msg) > 5).order_by(func.random()).first()
    if quote:
        send("%s -- %s" % quote)
    elif nick:
        send("%s isn't very quotable." % nick)
    else:
        send("Nobody is very quotable :(")

def get_question_bytag(tag_name,limit):
    """

    :param tag_name:
    :return:
    """
    print(tag_name)
    max_questions=20
    tag = models.Tag.query.filter_by(tag_name=tag_name).first()
    if tag:
        try:
            limit = int(limit)
        except Exception as e:
            pass
        if isinstance(limit,int):
            if limit > max_questions or limit <=0:
                limit=max_questions
            questions = tag.quest.order_by(func.random()).limit(limit).all()
        elif limit=='all':
            questions = tag.quest.all()
        else:
            questions = []
        if len(questions)==1:
            r = questions[0].to_dict()
        else:
            r = [q.to_dict() for q in questions]
    else:
        r = []
    return make_response(jsonify({"result":r}), 200)

 def find(self):
     recipe = session.query(Recipe).filter(Recipe.done == False).order_by(func.random()).first()
     if not recipe:
         abort(500, message="Every recipe was done. Nice.")
     recipe.done = True
     session.commit()
     return recipe

  def random(self, n_instances=1, dialect=None):
    """Returns random model instances.

    :param n_instances: the number of instances to return
    :type n_instances: int
    :param dialect: the engine dialect (the implementation of random differs
      between MySQL and SQLite among others). By default will look up on the
      query for the dialect used. If no random function is available for the 
      chosen dialect, the fallback implementation uses total row count to 
      generate random offsets.
    :type dialect: str
    :rtype: model instances
    
    """
    if dialect is None:
      dialect = self.session.get_bind().dialect.name
    if dialect == 'mysql':
      instances = self.order_by(func.rand()).limit(n_instances).all()
    elif dialect in ['sqlite', 'postgresql']:
      instances = self.order_by(func.random()).limit(n_instances).all()
    else: # fallback implementation
      count = self.count()
      instances = [
        self.offset(randint(0, count - 1)).first()
        for _ in range(n_instances)
      ]
    if len(instances) == 1:
      return instances[0]
    return instances

def index(request):
    project_ids = [
        r[0]
        for r in (
            request.db.query(Project.id)
            .order_by(Project.zscore.desc().nullslast(), func.random())
            .limit(5)
            .all()
        )
    ]
    release_a = aliased(
        Release,
        request.db.query(Release)
        .distinct(Release.project_id)
        .filter(Release.project_id.in_(project_ids))
        .order_by(
            Release.project_id,
            Release.is_prerelease.nullslast(),
            Release._pypi_ordering.desc(),
        )
        .subquery(),
    )
    trending_projects = (
        request.db.query(release_a)
        .options(joinedload(release_a.project))
        .order_by(func.array_idx(project_ids, release_a.project_id))
        .all()
    )

    latest_releases = (
        request.db.query(Release)
        .options(joinedload(Release.project))
        .order_by(Release.created.desc())
        .limit(5)
        .all()
    )

    counts = dict(
        request.db.query(RowCount.table_name, RowCount.count)
        .filter(
            RowCount.table_name.in_(
                [
                    Project.__tablename__,
                    Release.__tablename__,
                    File.__tablename__,
                    User.__tablename__,
                ]
            )
        )
        .all()
    )

    return {
        "latest_releases": latest_releases,
        "trending_projects": trending_projects,
        "num_projects": counts.get(Project.__tablename__, 0),
        "num_releases": counts.get(Release.__tablename__, 0),
        "num_files": counts.get(File.__tablename__, 0),
        "num_users": counts.get(User.__tablename__, 0),
    }

    def coverage(self):
        image = self.images.filter_by(is_coverage=True)
        if image.count() == 0:
            image = self.images.order_by(func.random()).limit(1)

        image = image.first()
        return image and {'url': image.url, 'id': image.id} or None

 def get_quote(cls, id=None):
     try:
         if id is None:
             return meta.session.query(cls).order_by(func.random()).limit(1).one()
         return meta.session.query(cls).get(id)
     except:
         meta.session.rollback()
         raise