def __init__(self):
        db = Database()
        try:
            db.createCSVForClustering() 
        except:
            print 'postoji'
        
        self.importCsvForClustering()
        #'remote_id', 'acousticness', 'danceability', 'energy', 'instrumentalness', 'track_key', 
        #'liveness', 'loudness', 'mode', 'popularity', 'speechiness', 'tempo', 'time_signature',
        #'valence', 'album_year'
        keys = self.data.columns[1:len(self.data.columns)]
        print keys
        #normalize data
        self.min_max_scaler = preprocessing.MinMaxScaler()
        print self.data[keys]
        scaledData = self.min_max_scaler.fit_transform(self.data[keys])
        scaledDf = pd.DataFrame(scaledData, columns=keys)

        scaledDf['remote_id'] = self.data['remote_id']
        self.data = scaledDf
        
        #declare supported algorithms 
        self.kmeans = KMeans(verbose=1, n_clusters=70)
        self.clf = tree.DecisionTreeClassifier()
        
        print 'finished constructor MachineLearning' 
def perform_clustering(algorithm=None):
    #init()
    global songs
    ml = MachineLearning()
    ml.createDataframe(songs)

    response = {}
    response['success'] = False
    response['algorithm'] = 'Clustering algorithm ' + algorithm + ' is not supported'
	
    if(algorithm.lower() == 'kmeans'.lower()):
        (response['success'], response['algorithm']) = ml.clusterKmeans(songs)
    if(response['success']):
        db = Database()
        db.saveClusters(songs)
        
    return jsonify(response)
Example #3
0
def main():
    options = Options()
    args = options.get_arguments()

    database = Database()

    manager = Manager(args, database)
    manager.run()
Example #4
0
 def get_retweet(self):
     result = Database().buscar_todos_tweet()
     for r in result:
         try:
             print(r["text"])
             print('\n')
         except Exception as e:
             pass
Example #5
0
    def __init__(self, client, args):
#    def __init__(self, db, client, args):
#        self.__db = db
        self.__client = client
        self.__args = args
        self.__userRepo = Db().Repositories[self.__args.username]
        #self.__userRepo = self.__db.Repositories[self.__args.username]
        self.__repo_name = os.path.basename(self.__args.path_dir_pj)
class GetAllNotesTest(TestCase):
    def setUp(self):
        self.database = Database("Test")

    def test_get_all_notes(self):
        # given
        title1 = "Title"
        content1 = "Content"
        title2 = "Title2"
        content2 = "Content2"
        self.database.create_note(title1, content1)
        self.database.create_note(title2, content2)
        # when
        result = self.database.get_all_notes()
        # then
        self.assertTrue(len(result) == 2)
        self.assertTrue(result[0].title_and_content_equals(title1, content1))
        self.assertTrue(result[1].title_and_content_equals(title2, content2))

    def test_with_empty_database(self):
        # given

        # when then
        with self.assertRaises(NoteNotFound):
            self.database.get_all_notes()

    def tearDown(self):
        self.database.close_connection()
Example #7
0
def remove_participant():
    room_id = request.form['room_id']
    user_id = request.form['user_id']

    if room_id and user_id:
        Database().remove_participant(room_id, user_id)
        return jsonify({'status': True})
    else:
        return jsonify({'status': False})
Example #8
0
    def get(self):
        if is_logged():
            rooms = Database().get_rooms()
            for room in rooms:
                room['board'] = arr_to_matrix(str_to_arr(room['board']))

            return {'status': True, 'rooms': rooms}
        else:
            return send_not_logged()
 def __init__(self, args):
     self.__args = args
     self.__first_date = None
     self.__last_date = None
     self.__date_span = None
     self.__date_format = "%Y-%m-%dT%H:%M:%SZ"
     self.__sum_repo_count = 0
     self.__sum_code_size = 0
     self.__repoDb = Db().Repositories[self.__args.username]
    def test_get_most_popular_cities_fetch_many_city_when_there_is_one(self):
        database = Database(':memory:')
        session = database.get_session()

        locations = []
        locations.append(Location(city='Sejny'))
        locations.append(Location(city='Sejny'))
        locations.append(Location(city='Sejny'))

        session.add_all(locations)
        session.commit()

        data_fetcher = DataFetcher(database)

        values, columns = data_fetcher.get_most_popular_cities(4)
        expected = [('Sejny', 3)]

        assert set(values) == set(expected)
    def test_get_most_popular_passwords_fetch_one(self):
        database = Database(':memory:')
        session = database.get_session()

        logins = []
        logins.append(Login(password='******'))
        logins.append(Login(password='******'))
        logins.append(Login(password='******'))

        session.add_all(logins)
        session.commit()

        data_fetcher = DataFetcher(database)

        values, columns = data_fetcher.get_most_popular_passwords(1)
        expected = [('tricky', 2)]

        assert set(values) == set(expected)
 def clusterKmeans(self, force):
     print 'Clustering'
     keys = self.data.columns[0:len(self.data.columns)-1]
     
     self.kmeans.fit(self.data[keys])
     
     labels = self.kmeans.labels_
     self.data['cluster'] = labels
     
     if(os.path.isfile('/Users/igor/songAtributesClustered.csv')):
         if(force):
             os.remove('/Users/igor/songAtributesClustered.csv')
             self.data.to_csv('/Users/igor/songAtributesClustered.csv', sep=',', encoding='utf-8')
     else:
         self.data.to_csv('/Users/igor/songAtributesClustered.csv', sep=',', encoding='utf-8')
     db = Database()
     for index, row in self.data.iterrows():
         db.saveCluster(remoteId=row['remote_id'], cluster=labels[index])    
     print 'Finished clustering'
     return (True, 'KMeans')
Example #13
0
    def post(self):
        room_id = request.form['room_id']

        if is_logged():
            if room_id:
                Database().delete_room(room_id)
                return {'status': True}
            else:
                return send_invalid_form()
        else:
            return send_not_logged()
    def test_load_many_persons_data(self):
        database = Database(':memory:')
        session = database.get_session()
        database_loader = DatabaseLoader(database)

        persons = [self.get_person_data(), self.get_person_data()]
        database_loader.load_many_persons_data(persons)

        session.query()

        assert len(session.query(Location).all()) == 2
        assert len(session.query(Name).all()) == 2
        assert len(session.query(Login).all()) == 2
        assert len(session.query(DayOfBirth).all()) == 2
        assert len(session.query(Registered).all()) == 2
        assert len(session.query(ID).all()) == 2
        assert len(session.query(Person).all()) == 2
        assert len(session.query(TimeZone).all()) == 2
        assert len(session.query(Coordinates).all()) == 2
        assert len(session.query(Street).all()) == 2
Example #15
0
def cadastro():
    msg = ''

    if request.method == 'POST':
        username = request.form['username']
        password = request.form['password']

        if username and password:

            account = Database().get_user(username)

            if account:
                msg = "Nome de usuario já existente"
            else:
                Database().add_user(username, password)
                msg = 'Você se cadastrou com sucesso'
                return render_template('Login.html', error_msg=msg)
        else:
            msg = 'Digite todos os campos'

    return render_template('Cadastro.html', error_msg=msg)
Example #16
0
def send_message():
    room_id = request.form['room_id']
    message = request.form['message']

    if room_id and message:

        Database().send_message(room_id, session['id'], message)
        socketio.emit('nm', {'room_id': room_id})
        return jsonify({'status': True})

    else:
        return jsonify({'status': False})
    def test_get_average_age_botch(self, gender, expected):
        database = Database(':memory:')
        session = database.get_session()

        person_1 = Person(gender='female')
        dbo_1 = DayOfBirth(age=10)
        person_1.day_of_birth = [dbo_1]
        person_2 = Person(gender='male')
        dbo_2 = DayOfBirth(age=20)
        person_2.day_of_birth = [dbo_2]
        person_3 = Person(gender='male')
        dbo_3 = DayOfBirth(age=39)
        person_3.day_of_birth = [dbo_3]

        session.add_all([person_1, person_2, person_3])
        session.commit()

        data_fetcher = DataFetcher(database)

        values, columns = data_fetcher.get_average_age(gender)

        assert set(values) == set(expected)
Example #18
0
class GitHubOtpCreator:
    def __init__(self):
        self.__path_dir_this = os.path.abspath(
            os.path.dirname(os.path.dirname(__file__)))
        #        self.__path_dir_this = os.path.abspath(os.path.dirname(__file__))
        #        self.__db = Database(self.__path_dir_this)
        self.__db = Database()
        #        self.__db = Database()
        self.__db.Initialize()

    def Create(self):
        self.__totp = pyotp.TOTP(self.__GetUserSecret())
        #        print("otp = {0}".format(self.__totp.now()))
        web.log.Log.Log().Logger.info("otp = {0}".format(self.__totp.now()))
        pyperclip.copy(self.__totp.now())

    def __GetUserSecret(self):
        parser = argparse.ArgumentParser(
            description='GitHub Repository Uploader.', )
        parser.add_argument('-u', '--username', '--user')
        args = parser.parse_args()

        username = args.username
        if None is username:
            config = configparser.ConfigParser()
            config.read('./config.ini')
            if not ('GitHub' in config):
                raise Exception(
                    'ユーザ名が必要です。しかし起動引数にもconfig.iniにも存在しません。起動引数なら第一引数にユーザ名を渡してください。iniならGitHubセクションUserキーにユーザ名を指定してください。'
                )
            if not ('User' in config['GitHub']):
                raise Exception(
                    'ユーザ名が必要です。しかし起動引数にもconfig.iniにも存在しません。起動引数なら第一引数にユーザ名を渡してください。iniならGitHubセクションUserキーにユーザ名を指定してください。'
                )
            username = config['GitHub']['User']


#        print("username = {0}".format(username))
        web.log.Log.Log().Logger.info("username = {0}".format(username))
        account = self.__db.Accounts['Accounts'].find_one(Username=username)
        if None is account:
            raise Exception(
                'ユーザ {0} はDBのAccountsテーブルに存在しません。登録してから再度実行してください。'.format(
                    username))
        twofactor = self.__db.Accounts['TwoFactors'].find_one(
            AccountId=account['Id'])
        if None is twofactor:
            raise Exception(
                'ユーザ {0} はDBのTwoFactorsテーブルに存在しません。登録してから再度実行してください。'.format(
                    username))
        return twofactor['Secret']
Example #19
0
    def post(self):
        room_id = request.form['room_id']
        message = request.form['message']

        if is_logged():
            user_id = session['id']
            if room_id and message:
                Database().add_message(user_id, room_id, message)
                socket.emit("newMessage", {'room_id': room_id})
                return {'status': True}
            else:
                return send_invalid_form()
        else:
            return send_not_logged()
Example #20
0
    def post(self):
        username = request.form['username']
        password = request.form['password']

        if username and password:
            password = hash_string(password)
            user = Database().get_user(username, password)
            if user:
                session['logged_in'] = True
                session['id'] = user['id']
                return {'status': True}
            else:
                return {'status': False, 'message': "user not find"}
        else:
            return send_invalid_form()
Example #21
0
    def post(self):
        username = request.form['username']
        password = request.form['password']
        icon = request.form['icon']

        if username and password and icon:
            if not check_existent_username(username):
                password = hash_string(password)
                id = Database().create_user(username, password, icon)
                session['logged_in'] = True
                session['id'] = id
                return {'status': True}
            else:
                return {'status': False, 'message': 'user alredy exist'}
        else:
            return send_invalid_form()
Example #22
0
    def __init__(self, host, port):
        self.database = Database()

        self.server = Server(host, port, self.database)
        t = threading.Thread(target=self.server.launch)
        t.daemon = True
        print("Launching server...")
        t.start()
        print("Launching GUI...")
        self.currentRobot = None
        self.interface = Interface(self.database, self.currentRobot)
        self.screen = self.interface.screen
        self.binding()
        self.button_map = self.set_up_buttons()
        self.interface.set_button_map(self.button_map)
        self.screen.mainloop()
Example #23
0
class CreateNoteTest(TestCase):
    def setUp(self):
        self.database = Database("Test")

    def test_create_note_and_check_quantity(self):
        # given
        title = "Title"
        content = "Content"
        # when
        self.database.create_note(title, content)
        result = self.database.query_executor.execute(
            'Select count(*) from Notes')
        # then
        self.assertEqual(1, result[0])

    def test_create_note_and_check_content(self):
        # given
        title = "Title"
        content = "content"
        version = 1
        deleted = False
        # when
        self.database.create_note(title, content)
        result = self.database.query_executor.execute('Select * from Notes')
        # then
        self.assertEqual(title, result[0])
        self.assertEqual(content, result[1])
        self.assertEqual(version, result[4])
        self.assertEqual(deleted, result[5])

    def test_create_note_and_check_in_note_version(self):
        # given
        title = "Title"
        content = "content"
        # when
        self.database.create_note(title, content)
        result = self.database.query_executor.execute(
            'Select * from Note_version')
        # then
        self.assertEqual(title, result[1])
        self.assertEqual(content, result[2])

    def tearDown(self):
        self.database.close_connection()
Example #24
0
    def post(self):
        room_id = request.form['room_id']
        password = request.form['password']
        if is_logged():
            user_id = session['id']
            if room_id and password:
                password = hash_string(password)

                status = Database().add_user_in_room(room_id, password,
                                                     user_id)

                socket.emit('enter', {'room_id': room_id})

                return status
            else:
                return send_invalid_form()
        else:
            return send_not_logged()
Example #25
0
    def realizar_pesquisa(self, query="", result_type="mixed", lang="pt", count=100):
        """
        Método responsável por realizar a pesquisa no tweepy por tweets
        """

        # criando a query para pesquisa no tweepy
        public_tweets = self.__api.search(query,
                                          lang=lang,
                                          result_type=result_type,
                                          count=count)
        # percorrendo os resultados
        for tweet in public_tweets:
            try:  # tenta salvar os dados
                Database().salvar_tweets_discurso_odio(tweet._json)
            except tweepy.RateLimitError:  # caso o limite de consultas tenha sido alcançado
                print('[*] Pausando o tweepy por 1 minuto')
                time.sleep(60)
            except tweepy.error.TweepError:  # caso ocorra algum erro no tweepy
                print("[*] Falha ao executar o comando no tweepy, saindo...")
Example #26
0
    def post(self):
        name = request.form['name']
        password = request.form['password']
        board_size = request.form['board_size']

        if not board_size:
            board_size = 8

        if is_logged():
            user_id = session['id']
            if name and password:
                password = hash_string(password)
                board = arr_to_str(create_board(board_size))
                id = Database().create_room(name, password, board, user_id)
                return {'status': True, 'room_id': id}
            else:
                return send_invalid_form()
        else:
            return send_not_logged()
Example #27
0
    def post(self):
        room_id = request.form['room_id']

        if is_logged():
            user_id = session['id']
            if room_id:
                room = Database().get_room(room_id)
                room['board'] = arr_to_matrix(str_to_arr(room['board']))

                # Auto reverse the board for the second player
                if user_id == room['user2_id']:
                    room['board'] = room['board'][::-1]

                del room['password']

                return {'status': True, 'room': room}
            else:
                return send_invalid_form()
        else:
            return send_not_logged()
Example #28
0
def getAnimeList(q, page=0, rows_per_page=10):
    anisearch = AnimeInfo(Database(SqliteDriver('/var/www/data/anime.db')))
    searchid = anisearch.getId(q)
    if searchid == None:
        return None
    recs = anisearch.getscoredlist(searchid)[page * rows_per_page:page *
                                             rows_per_page + rows_per_page]

    AnimeList = []
    ids = []
    for (id, similarity) in recs:
        info = anisearch.info(id)
        if info is None: continue

        ids.append(str(id))
        info['similarity'] = similarity
        info['url'] = "go.py?search=%s&titles=%s&selected=%s" % (
            searchid, ",".join(ids), id)
        AnimeList.append(info)

    return AnimeList
Example #29
0
def login():
    msg = ''
    if request.method == 'POST':
        username = request.form['username']
        password = request.form['password']

        if username and password:

            account = Database().get_user(username, password)

            if account:
                session['loggedin'] = True
                session['id'] = account['id']
                session['username'] = account['username']

                return redirect(url_for('chat'))
            else:
                msg = "Usuario não encontrado"
        else:
            msg = "Digite todos os campos"

    return render_template('Login.html', error_msg=msg)
class GetNoteByIdTest(TestCase):
    def setUp(self):
        self.database = Database("Test")

    def test_get_note_by_id(self):
        # given
        self.database.create_note("Title", "Content")
        # when
        note = self.database.get_note_by_id(1)
        # then
        self.assertEqual(note.title, "Title")
        self.assertEqual(note.content, "Content")

    def test_no_note_like_this(self):
        # given

        # when then
        with self.assertRaises(NoteNotFound):
            self.database.get_note_by_id(2)

    def tearDown(self):
        self.database.close_connection()
Example #31
0
    def post(self):
        row = request.form['row']
        col = request.form['col']
        room_id = request.form['room_id']

        if is_logged():
            user_id = session['id']
            if row and col and room_id:
                row = int(row)
                col = int(col)
                room = Database().get_room(room_id)
                if user_id != room['user1_id'] and user_id != room['user2_id']:
                    return {'status': False, 'message': "you"}

                board: list = arr_to_matrix(str_to_arr(room['board']))

                if user_id == room['user2_id']:
                    board = board[::-1]

                if board[row][col] == 0:
                    return {
                        'status': False,
                        'message': "You don't select a piece"
                    }

                movements = check_valid_movement(row, col, board)

                session['piece_selected'] = {'col': col, 'row': row}
                session['movements'] = movements

                return {'status': True, 'movements': movements}

            else:
                return send_invalid_form()
        else:
            return send_not_logged()
from database.Database import Database
from database.StatisticsDao import StatisticsDao
from data.PreferenceCalculator import PreferenceCaculator
from data.DataHandler import DataHandler
from database.PointsUpdater import PointsUpdater

dbHandler = Database("../../../database/merged.sqlite")
dao = StatisticsDao(dbHandler)
calculator = PreferenceCaculator()
updater = PointsUpdater(dbHandler)
dataHandler = DataHandler(calculator, updater)

for p in ["Ruck", "Forward", "Defender", "Midfielder"]:
    data = dao.getByPosition(position=p, minGames=0)
    for d in data:
        dataHandler.handle(d, p)
    dbHandler.commit()

# TODO: How to calculate value?
dbHandler.close()
Example #33
0
#!/usr/bin/env python
# -*- coding: utf-8 -*-

print "Content-Type: text/html\n\n"
import json
import cgi
import sys

from database.Database import Database
from database.SqliteDriver import SqliteDriver

q = str(cgi.FieldStorage().getvalue("q"))

if q: 
    con = Database(SqliteDriver('data/anime.db'))
    results = []
    res=con.execute('''
       select rowid, titles from anime where titles like ? limit 15
    ''', ('%' + q + '%',)).fetchall()
    for row in res:
        results.append({
            "value": (row[1].split(';|;')[0]), 
            "info": ("%s, %s" % (row[1].split(';|;')[1], row[1].split(';|;')[2]) )
        })
    print json.dumps({"results": results})


Example #34
0
from database.Database import Database
from database.SqliteDriver import SqliteDriver

con = Database(SqliteDriver('../../data/anime.db'))

res = con.execute("SELECT rowid, tags FROM anime").fetchall()
for row in res:
    rowid = row[0]
    tags = row[1].split(';|;')
    
    for tag in tags:
        if tag == '': continue
        print tag
        (count, tag_name) = tag.split(':')

        con.execute("""
            INSERT INTO tags
            (anime_id, tag_name, count) VALUES
            (?, ?, ?)
            """, (rowid, tag_name, count))


con.commit()

from database.Database import Database
from instagram_util.InstaUtil import InstaUtil

dbAPI = Database()

for project in dbAPI.get_projects():
    account = None
    try:
        account = dbAPI.get_next_insta_user_to_unfollow(project.project_id)
        insta_util = InstaUtil(project.insta_config)
        insta_util.unfollow(account.user_id)
    except Exception as e:
        print(e)
    finally:
        if account is not None:
            dbAPI.record_insta_unfollow(account)
Example #36
0
 def setUp(self):
     self.database = Database("Test")
def suggest_similar():
    print 'Suggest similar'
    
    if request.json:
         #get song name
        data = request.json # will be 
        songName =  data.get("songName")
        
        global ml
        response = {}
        response['success'] = False
        response['message'] = 'Oops, something went wrong. We couldn\'t find song: ' + songName

       
        #get song
        services = Services()
        s = services.getSongBySongName(songName)
        #print 'trazena pesam: \n' + s.toString()
        
        if(s != None):
            #classify and save cluster
            db = Database()
            persistedSong = db.getSongByRemoteId(s.remoteId)

            if(persistedSong == None):
                print 'Pesma nije bila u bazi'
                s.id = db.insertSongs([s])[0]
                s = ml.classifyDecisionTreeClassifier(s)

                print 'Dodeljen klaster: ' + str(s.cluster)
                db.saveCluster(s.remoteId, s.cluster)
            else:
                print 'Pesma je bila u bazi'
                s.cluster = persistedSong.cluster
                s.id = persistedSong.id
            
            #get songs from same cluster
            songsFromCluster = db.getSongsFromSameCluster(s)
        
            criteriaKey = data.get("criteriaKey")
            criteriaValue = data.get("criteriaValue")
            featureWeights = data.get("featureWeights")
            print "feature weights"
            print featureWeights
            if criteriaKey=="year" and criteriaValue!=None:
                years = criteriaValue.split("-")
                suggestedSong = ml.getSimilarSongFromYearRange(songsFromCluster, s, int(years[0]), int(years[1]))
                #return "not supported yet"
            elif(criteriaKey =="genre" and criteriaValue!=None):
                suggestedSong = ml.getSimilarSongFromGenre(songsFromCluster, s, criteriaValue)
            else:
                suggestedSong = ml.getSimilarSong(songsFromCluster, s, featureWeights)
            if suggestedSong == None:
                response['message'] = "Oops, something went wrong. We couldn't find a recommendation. "
                return jsonify(response)
            response['success'] = True
            response['request_song'] = s.toDictionary()
            response['suggested_song'] = suggestedSong.toDictionary()
            response['message'] = 'Suggestion successful'
            print response
        return jsonify(response)
    response = {}
    response['success'] = False
    response['message'] = 'Bad request.'
    return jsonify(response)