コード例 #1
0
 def index(self):
     db = Database()
     genreChart = []
     editeurChart = []
     genres = db.retrieve(Genre)
     editeurs = db.retrieve(Editeur)
     mangas = db.retrieve(Manga)
     for genre in genres:
         compteur = 0
         for manga in mangas:
             if manga.genre == genre.genre:
                 for tome in manga.tomes:
                     if tome.possede == True:
                         compteur += 1
         if compteur > 0:
             tuple = (genre.genre, compteur)
             genreChart.append(tuple)
     for editeur in editeurs:
         compteur = 0
         for manga in mangas:
             if manga.editeur == editeur.editeur:
                 for tome in manga.tomes:
                     if tome.possede == True:
                         compteur += 1
         if compteur > 0:
             tuple = (editeur.editeur, compteur)
             editeurChart.append(tuple)
     return _index.render_unicode(genres=genreChart, editeurs=editeurChart)
コード例 #2
0
 def tome_buy(self, id_manga, id_tome):
     db = Database()
     tome = db.retrieveTome(id_manga, id_tome)
     tome.a_acheter = False
     tome.possede = True
     db.update()
     raise cherrypy.HTTPRedirect('/collection/')
コード例 #3
0
 def tome_buy(self, id_manga, id_tome):
     db = Database()
     tome = db.retrieveTome(id_manga, id_tome)
     tome.a_acheter = False
     tome.possede = True
     db.update()
     raise cherrypy.HTTPRedirect('/collection/')
コード例 #4
0
 def index(self):
     db = Database()
     genreChart = []
     editeurChart = []
     genres = db.retrieve(Genre)
     editeurs = db.retrieve(Editeur)
     mangas = db.retrieve(Manga)
     for genre in genres:
         compteur = 0
         for manga in mangas:
             if manga.genre == genre.genre:
                 for tome in manga.tomes:
                     if tome.possede == True:
                         compteur += 1
         if compteur > 0:
             tuple = (genre.genre, compteur)
             genreChart.append(tuple)
     for editeur in editeurs:
         compteur = 0
         for manga in mangas:
             if manga.editeur == editeur.editeur:
                 for tome in manga.tomes:
                     if tome.possede == True:
                         compteur += 1
         if compteur >0:
             tuple = (editeur.editeur, compteur)
             editeurChart.append(tuple)
     return _index.render_unicode(genres = genreChart, editeurs = editeurChart)
コード例 #5
0
 def manga_add(self, titre, description, editeur, scenariste, dessinateur,
               statut, genre):
     manga = Manga(titre, description, editeur, scenariste, dessinateur,
                   statut, genre)
     db = Database()
     db.create(manga, Manga)
     raise cherrypy.HTTPRedirect('/manga/')
コード例 #6
0
 def manga_new(self):
     db = Database()
     return _manga_new.render_unicode(
         scenaristes=db.retrieve(Scenariste),
         dessinateurs=db.retrieve(Dessinateur),
         editeurs=db.retrieve(Editeur),
         genres=db.retrieve(Genre)
     )
コード例 #7
0
    def __init__(self, title, body, file_name='', table_name=''):
        self.title = title
        self.body = body
        self.keyword = [
        ]  # ini adalah keyword yang akan digunakan sebagai link
        self.table_name = table_name  # nama tabel untuk offline support

        self.conn = Database(file_name)
コード例 #8
0
 def search(self, query):
     db = Database()
     mangas, editeurs, scenaristes, dessinateurs, genres = db.search(query)
     return _search.render_unicode(mangas=mangas,
                                   editeurs=editeurs,
                                   scenaristes=scenaristes,
                                   dessinateurs=dessinateurs,
                                   genres=genres)
コード例 #9
0
 def shopping_list_comfirm(self):
     db = Database()
     tomes = db.retrieveTome()
     for tome in tomes:
         if tome.a_acheter == True:
             tome.a_acheter = False
             tome.possede = True
     db.update()
     raise cherrypy.HTTPRedirect('/')
コード例 #10
0
 def shopping_list_comfirm(self):
     db = Database()
     tomes = db.retrieveTome()
     for tome in tomes:
         if tome.a_acheter == True:
             tome.a_acheter = False
             tome.possede = True
     db.update()
     raise cherrypy.HTTPRedirect('/')
コード例 #11
0
 def search(self, query):
     db = Database()
     mangas, editeurs, scenaristes, dessinateurs, genres = db.search(query)
     return _search.render_unicode(
         mangas=mangas,
         editeurs=editeurs,
         scenaristes=scenaristes,
         dessinateurs=dessinateurs,
         genres=genres
     )
コード例 #12
0
 def collection(self):
     db = Database()
     mangas = db.retrieve(Manga)
     total = 0
     for manga in mangas:
         for tome in manga.tomes:
             if tome.possede == True:
                 total += tome.prix
     total = ceil(total)
     return _collection.render_unicode(mangas=mangas, total=total)
コード例 #13
0
ファイル: app.py プロジェクト: mesti-sukses/summerly
 def anime(id):
     db = Database(db_name)
     title = db.read('anime_list', ['judul'],
                     ' WHERE id=' + str(id))[0][0]
     opinion = db.read('opinion_orientation',
                       ['feature_name', 'good', 'bad'],
                       ' WHERE id_anime=' + str(id))
     return render_template('opinion.html',
                            title=title,
                            opinions=opinion)
コード例 #14
0
 def collection(self):
     db = Database()
     mangas = db.retrieve(Manga)
     total = 0
     for manga in mangas:
         for tome in manga.tomes:
             if tome.possede == True:
                 total+= tome.prix
     total = ceil(total)
     return _collection.render_unicode(mangas=mangas, total=total)
コード例 #15
0
 def shopping_list(self):
     db = Database()
     mangas = db.retrieve(Manga)
     total = 0
     for manga in mangas:
         for tome in manga.tomes:
             if tome.a_acheter == True:
                 total += tome.prix
     total = ceil(total)
     return _shopping_list.render_unicode(mangas=mangas, total=total)
コード例 #16
0
 def shopping_list(self):
     db = Database()
     mangas = db.retrieve(Manga)
     total = 0
     for manga in mangas:
         for tome in manga.tomes:
             if tome.a_acheter == True:
                 total+= tome.prix
     total = ceil(total)
     return _shopping_list.render_unicode(mangas = mangas, total=total)
コード例 #17
0
ファイル: Web.py プロジェクト: johnlwhiteman/CoCoScatS
 def __run(api, *args):
     WebApi.checkAuthentication()
     Database.connect()
     argCnt = len(args)
     if argCnt < 1:
         result = api()
     elif argCnt == 1:
         result = api(args[0])
     Database.disconnect()
     bottle.response.content_type = "application/json"
     return json.dumps(result)
コード例 #18
0
 def manga_statut(self, id, statut):
     db = Database()
     manga = db.retrieve(Manga, Manga.id, id)
     print('######################## Statut : ', statut)
     if statut == 'ongoing':
         manga.statut = "En cours"
     if statut == 'complete':
         manga.statut = "Terminé"
     if statut == 'pause':
         manga.statut = "En pause"
     print('######################## Statut : ', manga.statut)
     db.update()
     raise cherrypy.HTTPRedirect('/manga/' + id + '/')
コード例 #19
0
 def manga_statut(self, id, statut):
     db = Database()
     manga = db.retrieve(Manga, Manga.id, id)
     print('######################## Statut : ',statut)
     if statut == 'ongoing':
         manga.statut = "En cours"
     if statut == 'complete':
         manga.statut = "Terminé"
     if statut == 'pause':
         manga.statut = "En pause"
     print('######################## Statut : ', manga.statut)
     db.update()
     raise cherrypy.HTTPRedirect('/manga/'+id+'/')
コード例 #20
0
 def tome_add(self,
              manga_id,
              numero,
              date_parution,
              prix,
              couverture,
              date_achat=None,
              possede=None,
              lu=None,
              a_acheter=None):
     tome = Tome(manga_id, numero, date_parution, possede, lu, a_acheter,
                 float(prix), couverture, date_achat)
     db = Database()
     db.create(tome, Tome)
     raise cherrypy.HTTPRedirect('/')
コード例 #21
0
    def __init__(self, file_name, id_anime, feature=[]):
        self.feature_list = set(feature)  # Our feature list
        self.noun_list = [
        ]  # Our noun list use for transaction and mining the frequent feature
        self.id_anime = id_anime

        self.db = Database(file_name)  # Our databse interface
        data = self.db.read(self.table_name, self.column,
                            ' WHERE anime_id=' + id_anime)
        self.sentences = []

        # The review is consist a sentence class
        # You can look at the sentence class to see what can a sentence do include post tagging, tokenizing and so on
        for row in data:
            self.sentences.append(Sentence(row[0].lower(), 5114))
        self.feature_result = []
コード例 #22
0
        def feed(page):
            c = Crawler()
            c.set_url('https://fs.blog/blog/page/' + str(page))
            db = Database(db_name)

            # Ini method untuk mengambil artikel paling paru
            titles = c.get_feed()

            # Pengecekan apakah ada artikel yang sudah disimpan
            # Karena ketika artikel sudah disimpan, maka link akan mengarah ke web seite tersimpan saja
            title_status = {}
            for title in titles.keys():
                data = db.read('articles', ['id', 'title'],
                               ' WHERE title="' + title + '"')
                if len(data) > 0:
                    title_status[title] = data[0][0]
                else:
                    title_status[title] = titles[title]

            return render_template('feed.html',
                                   titles=titles,
                                   title_status=title_status,
                                   page=page)
コード例 #23
0
 def dessinateur_list(self):
     db = Database()
     dessinateurs = db.retrieve(Dessinateur)
     return _dessinateur_list.render_unicode(dessinateurs=dessinateurs)
コード例 #24
0
 def editeur_list(self):
     db = Database()
     editeurs = db.retrieve(Editeur)
     return _editeur_list.render_unicode(editeurs=editeurs)
コード例 #25
0
 def genre_add(self, genre):
     db = Database()
     g = Genre(genre)
     db.create(g, Genre)
     raise cherrypy.HTTPRedirect('/genre/')
コード例 #26
0
 def tome_read(self, id_manga, id_tome):
     db = Database()
     tome = db.retrieveTome(id_manga, id_tome)
     tome.lu = True
     db.update()
     raise cherrypy.HTTPRedirect('/')
コード例 #27
0
 def scenariste_add(self, scenariste):
     db = Database()
     s = Scenariste(scenariste)
     db.create(s,Scenariste)
     raise cherrypy.HTTPRedirect('/scenariste/')
コード例 #28
0
 def tome_new(self):
     db = Database()
     mangas = db.retrieve(Manga)
     return _tome_new.render_unicode(mangas = mangas)
コード例 #29
0
ファイル: app.py プロジェクト: mesti-sukses/summerly
 def index():
     db = Database(db_name)
     row = db.read('anime_list', ['id', 'judul'])
     return render_template('index.html', data_title=row)
コード例 #30
0
from datetime import datetime

from Core.Database import Database
from models import *

if __name__ == "__main__":
    db = Database()
    #db.loadManga("import")
    #db.loadTome("importTomes")
    boucle = True
    while (boucle):
        print("Mode console")
        print("1 - Create")
        print("2 - Delete")
        print("3 - Update")
        print("4 - Quitter")
        action = int(input("Saisir action ?"))
        if action == 1:
            print("Créer un objet")
            print("1 - Manga")
            print("2 - Tome")
            print("3 - Commentaire")
            action = int(input("Quel objet souhaitez vous créer"))
            if action == 1:
                titre = input("Titre ?")
                description = input("Description ?")
                editeur = input("Editeur ?")
                scenariste = input("Scenariste ?")
                dessinateur = input("Dessinateur ?")
                statut = input("Statut ?")
                genre = input("Genre ?")
コード例 #31
0
 def article(article_id):
     db = Database(db_name)
     data = db.read('articles', ['title', 'raw_article'],
                    ' WHERE id=' + str(article_id))
     return render_template('article.html', article=data)
コード例 #32
0
class Article:
    '''
		Class ini akan bertanggung jawab dengan text yang ada dalam artikel
	'''
    def __init__(self, title, body, file_name='', table_name=''):
        self.title = title
        self.body = body
        self.keyword = [
        ]  # ini adalah keyword yang akan digunakan sebagai link
        self.table_name = table_name  # nama tabel untuk offline support

        self.conn = Database(file_name)

    '''
		Untuk mengekstrack keyword kita menggunakan rake
	'''

    def extract_keyword(self):

        # Menggunakan beautiful soup untuk mengambil text dari artikel
        clean = self.get_clean_body()

        # Dnegan rake kita ekstract keyword
        r = Rake(min_length=1, max_length=1)
        r.extract_keywords_from_text(clean)
        self.keyword = r.get_ranked_phrases()

        # Debug di terminal untuk melihat jumlah keyword
        print('Keyword extracted with ' + str(len(self.keyword)) + ' words')

    # Menggunakan beautiful soup untuk mengambil teks
    def get_clean_body(self):
        return BeautifulSoup(self.body, 'lxml').text

    '''
		Keyword yang ada akan di bandingkand engan judul artikel di wikipedia kemudian akan di beri link
	'''

    def get_wiki(self):
        key = []

        # File bisa didapat di kaggles
        file = open('titles.txt')
        for line in file:
            key.append(line[:-1].lower())
        file.close()

        for i in self.keyword:
            if i not in key:
                self.keyword.remove(i)

        for k in self.keyword:
            self.body = self.body.replace(
                ' ' + k + ' ', ' <a href="https://en.wikipedia.org/wiki/' + k +
                '">' + k + '</a> ')

    def get_keyword(self):
        return self.keyword

    def get_title(self):
        return self.title

    def get_content(self):
        return self.body

    def clean_html(self):

        # Drop tag yang menyusahkan dari web
        td = TagDropper(['img', 'h4', 'svg', 'a', 'figure', 'div', 'path'])
        td.feed(self.body)

        self.body = td.get_text()

    '''
		For Database
	'''

    def save_article(self):
        self.save(['title', 'raw_article'], (self.title, self.body))
        self.commit()

    def save(self, column, data):
        self.conn.insert(self.table_name, column, data)

    def commit(self):
        self.conn.commit()
コード例 #33
0
 def index():
     db = Database(db_name)
     row = db.read('articles', ['id', 'title'])
     return render_template('index.html', data_title=row)
コード例 #34
0
class Review:
    # First config for read
    column = ['sentences']  # column
    table_name = 'sentences'  # table name
    '''
		This class provide interface to extract the feature and get the opinion text. This is our main process
	'''
    def __init__(self, file_name, id_anime, feature=[]):
        self.feature_list = set(feature)  # Our feature list
        self.noun_list = [
        ]  # Our noun list use for transaction and mining the frequent feature
        self.id_anime = id_anime

        self.db = Database(file_name)  # Our databse interface
        data = self.db.read(self.table_name, self.column,
                            ' WHERE anime_id=' + id_anime)
        self.sentences = []

        # The review is consist a sentence class
        # You can look at the sentence class to see what can a sentence do include post tagging, tokenizing and so on
        for row in data:
            self.sentences.append(Sentence(row[0].lower(), 5114))
        self.feature_result = []

    '''
		This method provide an interface to extract the feature list. The process is like this

		- Use the post tagging to find the noun or a feature candidate.
		- Save to the noun list
		- Use assosiation mining to find the frequent feature
		- Save to the feature list
	'''

    def extract_feature_list(self):

        if len(self.feature_list) == 0:
            # Get the noun for each sentences
            for sentence in self.sentences:

                for word in sentence.tagged:
                    if word[1] == 'NN':
                        sentence.noun.append(word[0])

                # If the sentences didn't countain noun, it's just a dump sentences
                if len(sentence.noun) > 0:
                    sentence.opinion = True
                    self.noun_list.append(sentence.noun)
                else:
                    sentence.opinion = False

            # Use apriori method to mine the feature
            association_rules = apriori(self.noun_list,
                                        min_support=0.001,
                                        min_confidence=0,
                                        min_lift=3,
                                        min_length=2)
            association_results = list(association_rules)

            features = []

            for item in association_results:
                pair = item[0]
                items = [x for x in pair]
                self.feature_list.add(items[0])

    '''
		After mine the feature list we mine the opinion about that feature.

		- First, we get the adjective that most nearby to the noun
		- We categorize them with positive or negative with wordnet
	'''

    def extract_feature_opinion(self):

        # List all the feature and make them the key to the dictionary
        feature_count = {}
        for feature in self.feature_list:
            feature_count[feature] = []

        # Find all feature and opinion in all sentences
        for sentence in self.sentences:

            if sentence.opinion == True:
                all_words = len(sentence.tagged)
                for i, j in enumerate(sentence.tagged):

                    # Find the nearby adjective forward or backward
                    if j[1] == 'NN' and j[0] in self.feature_list:
                        count_forward = i
                        count_backward = i
                        while count_forward < all_words and sentence.tagged[
                                count_forward][1] != 'JJ':
                            count_forward += 1
                        while count_backward >= 0 and sentence.tagged[
                                count_backward][1] != 'JJ':
                            count_backward -= 1

                        count = -1
                        if count_forward < all_words and count_backward >= 0:
                            if (count_forward - i > i - count_backward):
                                count = count_backward
                            else:
                                count = count_forward

                        if count_backward < 0:
                            count = count_forward
                        if count_forward >= all_words:
                            count = count_backward
                        if count_forward >= all_words and count_backward < 0:
                            count = -1
                        if count != -1:
                            feature_count[j[0]].append(
                                sentence.tagged[count][0])

        # Make the feature class that contain the feature count of positive opinion and negative opinion
        for i in feature_count.keys():
            self.feature_result.append(
                Feature(self.db, i, feature_count[i], self.id_anime))

        # Use wordnet to mine the opinion orientation
        Feature.OrientationPrediction(Feature.all_adj, Feature.seed)
        # print(Feature.seed)

    def get_summary(self):
        self.extract_feature_list()
        self.extract_feature_opinion()
        res = {}
        for i in self.feature_result:
            i.save()
            res[i.feature] = (i.good, i.bad)
        return res

    # Save method
    def save(self):
        for feature in self.feature_result:
            feature.save()

    # Close database
    def close_db(self):
        self.db.close()
コード例 #35
0
 def test_DeleteInvalidType(self):
     db = Database("../mangas.sqlite3")
     self.assertRaises(BadTypeException, db.delete, "blop", Manga)
     self.assertRaises(BadTypeException, db.delete, 1, Manga)
     self.assertRaises(BadTypeException, db.delete, None, Manga)
     self.assertRaises(BadTypeException, db.delete, False, Manga)
コード例 #36
0
 def genre_list(self):
     db = Database()
     genres = db.retrieve(Genre)
     return _genre_list.render_unicode(genres=genres)
コード例 #37
0
ファイル: Cocoscats.py プロジェクト: johnlwhiteman/CoCoScatS
 def __initializeDatabase(self):
     Database.setName(self.cfg["Database"]["Name"])
     if Text.isTrue(self.cfg["Database"]["Rebuild"]):
         Database.drop()
     if not Database.exists():
         Database.create(True)
コード例 #38
0
 def genre_list(self):
     db = Database()
     genres = db.retrieve(Genre)
     return _genre_list.render_unicode(genres=genres)
コード例 #39
0
 def getTranslatorContentFromDatabase(self):
     return Database.getTranslatorContent(self.getProjectID())
コード例 #40
0
 def scenariste_list(self):
     db = Database()
     scenaristes = db.retrieve(Scenariste)
     return _scenariste_list.render_unicode(scenaristes=scenaristes)
コード例 #41
0
 def getOutputContentDB(self):
     return Database.getOutputContent(self.getProjectID())
コード例 #42
0
 def tome_detail(self, id_manga, id_tome):
     db = Database()
     tome = db.retrieveTome(id_manga,id_tome)
     return _tome_detail.render_unicode(tome = tome)
コード例 #43
0
 def no_category(self):
     db = Database()
     mangas = db.retrieve(Manga)
     return _no_category.render_unicode(mangas = mangas)
コード例 #44
0
 def tome_delete(self, id_manga, id_tome):
     db = Database()
     tome = db.retrieveTome(id_manga, id_tome)
     db.deleteTome(tome)
     raise cherrypy.HTTPRedirect('/')
コード例 #45
0
 def manga_list(self):
     db = Database()
     mangas = db.retrieve((Manga))
     return _manga_list.render_unicode(mangas=mangas)
コード例 #46
0
 def tome_cart(self, id_manga, id_tome):
     db = Database()
     tome = db.retrieveTome(id_manga, id_tome)
     tome.a_acheter = True
     db.update()
     raise cherrypy.HTTPRedirect('/shopping_list/')
コード例 #47
0
 def manga_detail(self, id):
     db = Database()
     manga = db.retrieve(Manga, Manga.id, id)
     commentaire = db.retrieve(Commentaire, Commentaire.id, manga.id)
     return _manga_detail.render_unicode(manga = manga, commentaire=commentaire)
コード例 #48
0
 def tome_add(self, manga_id, numero, date_parution, prix, couverture, date_achat=None, possede=None, lu=None,
              a_acheter=None):
     tome = Tome(manga_id, numero, date_parution, possede, lu, a_acheter, float(prix), couverture, date_achat)
     db = Database()
     db.create(tome,Tome)
     raise cherrypy.HTTPRedirect('/')
コード例 #49
0
 def manga_delete(self, id):
     db = Database()
     manga = db.retrieve(Manga, Manga.id, id)
     db.delete(manga, Manga)
     raise cherrypy.HTTPRedirect('/')
コード例 #50
0
 def dessinateur_add(self, dessinateur):
     db = Database()
     d = Dessinateur(dessinateur)
     db.create(d, Dessinateur)
     raise cherrypy.HTTPRedirect('/dessinateur/')
コード例 #51
0
 def manga_add(self, titre, description, editeur, scenariste, dessinateur, statut, genre):
     manga = Manga(titre, description, editeur, scenariste, dessinateur, statut, genre)
     db = Database()
     db.create(manga, Manga)
     raise cherrypy.HTTPRedirect('/manga/')
コード例 #52
0
 def editeur_add(self, editeur):
     db = Database()
     e = Editeur(editeur)
     db.create(e, Editeur)
     raise cherrypy.HTTPRedirect('/editeur/')
コード例 #53
0
 def getAnalyzerContentDB(self):
     return Database.getAnalyzerContent(self.getProjectID())
コード例 #54
0
 def genre_add(self, genre):
     db = Database()
     g = Genre(genre)
     db.create(g, Genre)
     raise cherrypy.HTTPRedirect('/genre/')
コード例 #55
0
 def add_commentaire(self, commentaire, titre, id):
     db = Database()
     commentaire = Commentaire(commentaire, titre, id)
     db.create(commentaire, Commentaire)
     raise cherrypy.HTTPRedirect('/manga/' + id + '/')
コード例 #56
0
 def add_commentaire(self,commentaire, titre, id):
     db = Database()
     commentaire = Commentaire(commentaire, titre, id)
     db.create(commentaire, Commentaire)
     raise cherrypy.HTTPRedirect('/manga/'+id+'/')
コード例 #57
0
ファイル: Web.py プロジェクト: johnlwhiteman/CoCoScatS
 def __exists(projectID):
     WebApi.checkAuthentication()
     Database.connect()
     result = Database.checkProjectExists(projectID)
     Database.disconnect()
     return result
コード例 #58
0
ファイル: Cocoscats.py プロジェクト: johnlwhiteman/CoCoScatS
    def updateDatabase(self):
        #Database.connect()
        #projects = Database.getProject("MyProjectID")
        #print(projects)
        #Database.disconnect()
        #sys.exit()
        if not Text.isTrue(self.cfg["Database"]["Enable"]):
            Msg.showWarning("Database is NOT enabled in {0}".format(
                self.cfgPath))
            return
        Database.connect()
        Database.setDebug(Text.toTrueOrFalse(self.cfg["Database"]["Debug"]))
        with Database.ORM.db_session:
            records = Database.Table.Project.get(ID=self.getProjectID())
            if records is not None:
                records.delete()
                Database.commit()

            projectTable = Database.Table.Project(
                ID=self.getProjectID(),
                Title=Database.sanitize(self.cfg["Title"]),
                Description=Database.sanitize(self.cfg["Description"]),
                DateTime=self.frameworkParams["dateTime"],
                Workflow=self.cfg["Workflow"])

            inputTable = Database.Table.Input(
                ProjectID=projectTable,
                Content=Database.sanitize(
                    File.getContent(self.frameworkParams["inputPath"])),
                Source=Database.sanitize(
                    self.cfg["Workflow"]["Input"]["Source"]),
                PluginName=Database.sanitize(
                    self.cfg["Workflow"]["Input"]["Plugin"]),
                PluginMethod=Database.sanitize(
                    self.cfg["Workflow"]["Input"]["Method"]),
                Plugin=self.cfg["Workflow"]["Input"])

            analyzerTable = Database.Table.Analyzer(
                ProjectID=projectTable,
                Content=Database.sanitize(
                    File.getContent(self.frameworkParams["analyzerPath"])),
                PluginName=Database.sanitize(
                    self.cfg["Workflow"]["Analyzer"]["Plugin"]),
                PluginMethod=Database.sanitize(
                    self.cfg["Workflow"]["Analyzer"]["Method"]),
                Plugin=self.cfg["Workflow"]["Analyzer"])

            content = Database.sanitize(
                File.getContent(self.frameworkParams["translatorPath"]))
            translatorTable = Database.Table.Translator(
                ProjectID=projectTable,
                Content=content,
                ContentParsed=Result.parseTranslatorContent(content),
                PluginName=Database.sanitize(
                    self.cfg["Workflow"]["Translator"]["Plugin"]),
                PluginMethod=Database.sanitize(
                    self.cfg["Workflow"]["Translator"]["Method"]),
                Plugin=self.cfg["Workflow"]["Translator"])

            outputTable = Database.Table.Output(
                ProjectID=projectTable,
                Content=Database.sanitize(
                    File.getContent(self.frameworkParams["outputPath"])),
                Target=Database.sanitize(
                    self.cfg["Workflow"]["Output"]["Target"]),
                PluginName=Database.sanitize(
                    self.cfg["Workflow"]["Output"]["Plugin"]),
                PluginMethod=Database.sanitize(
                    self.cfg["Workflow"]["Output"]["Method"]),
                Plugin=self.cfg["Workflow"]["Output"])

        Database.disconnect()
コード例 #59
0
from datetime import datetime

from Core.Database import Database
from models import *

if __name__ == "__main__":
    db = Database()
    #db.loadManga("import")
    #db.loadTome("importTomes")
    boucle = True
    while(boucle):
        print("Mode console")
        print("1 - Create")
        print("2 - Delete")
        print("3 - Update")
        print("4 - Quitter")
        action = int(input("Saisir action ?"))
        if action == 1:
            print("Créer un objet")
            print("1 - Manga")
            print("2 - Tome")
            print("3 - Commentaire")
            action = int(input("Quel objet souhaitez vous créer"))
            if action == 1:
                titre = input("Titre ?")
                description = input("Description ?")
                editeur = input("Editeur ?")
                scenariste = input("Scenariste ?")
                dessinateur = input("Dessinateur ?")
                statut = input("Statut ?")
                genre = input("Genre ?")