dotfiles

My dotfiles
git clone https://git.neuralcrash.com/dotfiles.git
Log | Files | Refs

main.py (4873B)

      1 #!/usr/bin/python
      2 # coding: utf8
      3 from aqt import mw
      4 from aqt.utils import showInfo
      5 from aqt.qt import *
      6 import importlib
      7 
      8 from anki.hooks import addHook
      9 
     10 from shinmeikai_definitions import config, shinmeikai, jpParser
     11 
     12 conf = config.Config()
     13 
     14 # Importing mecab from Japanese Support or MIA Japanese Support
     15 try:
     16     reading = importlib.import_module('278530045.reading')
     17     mecab = reading.MecabController()
     18 except: # If MIA Japanese Support Plugin is not Installed
     19     reading = importlib.import_module(conf.japaneseSupportPluginFolderName+'.reading')
     20     mecab = reading.mecab
     21 
     22 mecab.setup()
     23 
     24 #ANKI SPECIFIC
     25 def generateDefinitions(selectedNotes):
     26     global mecab
     27     mw.checkpoint("Shinmeikai Definitions")
     28     mw.progress.start()
     29     for currentSelectedNote in selectedNotes:
     30         note = mw.col.getNote(currentSelectedNote)
     31 
     32         if conf.enableKanjiKeywords:
     33             rtkKeywords = None
     34             for field in conf.kanjiSrcField:
     35                 if field in note:
     36                     srcTxt = mw.col.media.strip(note[field])
     37                     if jpParser.stringContainsKanji(srcTxt):
     38                         rtkKeywords = jpParser.getRTKKeyword(srcTxt)
     39             if rtkKeywords != None:
     40                 for field in conf.kanjiDstField:
     41                     if field in note:
     42                         if not note[field]:
     43                             note[field] = rtkKeywords
     44 
     45         src = None
     46         for field in conf.defSrcField:
     47             if field in note:
     48                 src = field
     49                 break
     50         if not src:
     51             continue
     52 
     53         dst = None
     54         for field in conf.defDstField:#dstFields:
     55             if field in note:
     56                 dst = field
     57                 break
     58         if not dst:
     59             continue
     60 
     61         # already contains data, skip
     62         if note[dst]:
     63             continue
     64 
     65         srcTxt = mw.col.media.strip(note[src])
     66         if not srcTxt.strip():
     67             continue
     68 
     69         try:
     70             definition = getCompleteDefinitionsForWord(srcTxt)
     71             #definition.decode('unicode-escape')
     72             #definition.encode('utf-8')
     73             #encodedDef = definition.encode('utf8')
     74             '''
     75             temp
     76             '''
     77             #note[dst] = shinmeikai.getDefsOfWord(srcTxt, conf)
     78             note[dst] = definition
     79             #note[dst] = shinmeikai.testEncodingFunction()
     80 
     81 
     82             #note[dst] = srcTxt#mecab.reading(srcTxt)
     83         except Exception as e:
     84             mecab = None
     85             raise
     86         note.flush()
     87     mw.progress.finish()
     88     mw.reset()
     89 
     90 def setupMenu(browser):
     91     action = QAction("Bulk Add Shinmeikai Definitions", browser)
     92     action.triggered.connect(lambda: generateDefinitions(browser.selectedNotes()))
     93     browser.form.menuEdit.addSeparator()
     94     browser.form.menuEdit.addAction(action)
     95 
     96 addHook("browser.setupMenus", setupMenu)
     97 
     98 #NON ANKI SPECIFIC
     99 def getCompleteDefinitionsForWord(targetWord):
    100     defs = shinmeikai.getDefsOfWord(targetWord, conf)
    101     sortedDefs = sortDefinitions(defs)
    102     optimallySelectedDefs = removeOverflowDefinitions(sortedDefs)
    103     formatedDef = defListToString(optimallySelectedDefs)
    104     if formatedDef == None:
    105         return "";
    106     if conf.addFuriganaToDef:
    107         formatedDef = mecab.reading(formatedDef)
    108     completeDefinitions = correctSpacing(formatedDef)
    109     return completeDefinitions
    110 
    111 def sortDefinitions(defList):
    112     #print(defList)
    113     sortedSubDefList = sorted(defList, key=lambda y : y[1])
    114     return sortedSubDefList
    115 
    116 def removeOverflowDefinitions(defList):
    117     numOfDefs = len(defList)
    118     desiredNumOfDef = conf.maxNumberOfDefs
    119     if numOfDefs > desiredNumOfDef:
    120             for x in range(0, numOfDefs - desiredNumOfDef):
    121                 del defList[-1] #Remove last element
    122     return defList
    123 
    124 def defListToString(defList):
    125     formatedDef = ""
    126     for x in defList:
    127         formatedDef += x[0] + "<div></div>"
    128     return formatedDef.replace(r"[", "TEMPSPACING") #Prevent pitch accent to not display as furigana
    129 
    130 def correctSpacing(definition):
    131     returnDef = definition.replace("\\n", "<div></div>")
    132     returnDef = returnDef.replace("\\ n", "<div></div>")
    133     returnDef = returnDef.replace("TEMPSPACING", " [")
    134     returnDef = returnDef.replace("[ ", "[")
    135     return returnDef
    136 
    137 ###TESTS
    138 def test():
    139     defs = shinmeikai.getDefsOfWord(sys.argv[1], conf)
    140     #print(defs)
    141     sortedDefs = sortDefinitions(defs)
    142     #print(sortedDefs)
    143     optimallySelectedDefs = removeOverflowDefinitions(sortedDefs)
    144     #print(optimallySelectedDefs)
    145     formatedDef = defListToString(optimallySelectedDefs)
    146     #print(formatedDef)
    147     if conf.addFuriganaToDef:
    148         formatedDef = mecab.reading(formatedDef)
    149     #print(formatedDef)
    150     return formatedDef
    151     #print("Searching for...\nKanji: "+sys.argv[2]+".\nHira: "+sys.argv[1]+".")
    152     #print(jpParser.getWordFreq(sys.argv[1], sys.argv[2]))
    153 #test()