rem stringlengths 0 322k | add stringlengths 0 2.05M | context stringlengths 8 228k |
|---|---|---|
return or_(*clauses) def getForReading(self, readingStr, fromReading, **options): | return strings def getForReading(self, readingStr, fromReading=None, **options): | def _getReadingClause(self, readingStr, fromReading, **options): decompositions = self._readingFactory.getDecompositions(readingStr, fromReading, **options) # convert all possible decompositions decompEntities = [] e = None for entities in decompositions: try: decompEntities.append( self._readingFactory.convertEntities... |
readingClause = self._getReadingClause(readingStr, fromReading, | if not fromReading: fromReading = self.READING dictionaryTable = self.db.tables[self.DICTIONARY_TABLE] readingStrings = self._getReadingStrings(readingStr, fromReading, | def getForReading(self, readingStr, fromReading, **options): # TODO support missing tones limit = options.pop('limit', None) orderBy = options.pop('orderBy', None) |
class CEDICTGR(CEDICT): | def getFor(self, searchStr, **options): def filterResult(headword, reading, translation): if searchStr == headword: return True elif fromReading and reading in readingStrings: return True else: return self.translationSearchStrategy.isMatch(searchStr, translation) limit = options.pop('limit', None) orderBy = options.po... | def getForReading(self, readingStr, fromReading, **options): # TODO support missing tones limit = options.pop('limit', None) orderBy = options.pop('orderBy', None) |
return value.split(':') | if not value: return [] else: return value.split(':') | def check_pathstring(option, opt, value): return value.split(':') |
parser.add_option("--attach", action="append", metavar="URL", dest="attach", default=defaults.get("attach", []), | parser.add_option("--attach", action="appendResetDefault", metavar="URL", dest="attach", default=defaults.get("attach", []), | def buildParser(self): usage = "%prog [options] [build | list]" description = self.DESCRIPTION version = """%%prog %s |
attachable.extend([('sqlite:///%s' % f) for f in glob.glob(os.path.join(name, "*.db"))]) | files = glob.glob(os.path.join(name, "*.db")) files.sort() attachable.extend([('sqlite:///%s' % f) for f in files]) | def _findAttachableDatabases(self, attachList): """ Returns URLs for databases that can be attached to a given database. """ attachable = [] for name in attachList: if '://' in name: # database url attachable.append(name) elif os.path.isabs(name): # path if not os.path.exists(name): continue attachable.extend([('sqlite... |
raise KeyError("Table '%s' not found in any database") | raise KeyError("Table '%s' not found in any database" % tableName) | def getTable(tableName): schema = self._findTable(tableName) if schema is not None: return Table(tableName, self.metadata, autoload=True, autoload_with=self.engine, schema=schema) |
class CommandLineBuilder: | class CommandLineBuilder(object): | def take_action(self, action, dest, opt, value, values, parser): if action == "extendResetDefault": if not hasattr(self, 'resetDefault'): self.resetDefault = set() if dest not in self.resetDefault: del values.ensure_value(dest, [])[:] self.resetDefault.add(dest) values.ensure_value(dest, []).extend(value) else: Option.... |
deprecatedGroups = ( (set(['fullDictionaries'] + self.BUILD_GROUPS['fullDictionaries'])) & set(buildGroupList)) | deprecatedGroups = self._getDeprecated() & set(buildGroupList) | def runBuild(self, buildGroupList, options): if not buildGroupList: return buildGroupList = set(buildGroupList) # by default fail if a table couldn't be built options['noFail'] = False if 'all' in buildGroupList or 'allAvail' in buildGroupList: if 'allAvail' in buildGroupList: if len(buildGroupList) == 1: # don't fail ... |
if not CommandLineBuilder().run(): | if not CommandLineBuilder(deprecated=['fullDictionaries']).run(): | def main(): if not CommandLineBuilder().run(): sys.exit(1) |
def getDefaultOptions(cls): """ Gets default options that always overwrite those specified in the build module. Boolean options of the L{DatabaseBuilder} can not be changed here as they are hardcoded in the given command line options. | def getConnectionConfigSettings(cls): """ Gets the connections settings from cjklib.conf. @rtype: dict @return: dictionary of connection options | def getDefaultOptions(cls): """ Gets default options that always overwrite those specified in the build module. Boolean options of the L{DatabaseBuilder} can not be changed here as they are hardcoded in the given command line options. """ options = {} # dataPath options['dataPath'] = ['.', getDataPath()] # prefer optio... |
options['dataPath'] = ['.', getDataPath()] options['prefer'] = cls.DB_PREFER_BUILDERS[:] | def getDefaultOptions(cls): """ Gets default options that always overwrite those specified in the build module. Boolean options of the L{DatabaseBuilder} can not be changed here as they are hardcoded in the given command line options. """ options = {} # dataPath options['dataPath'] = ['.', getDataPath()] # prefer optio... | |
options.update(cls.getBuilderConfigSettings()) | return options @classmethod def getDefaultOptions(cls, includeConfig=True): """ Gets default options that always overwrite those specified in the build module. Boolean options of the L{DatabaseBuilder} can not be changed here as they are hardcoded in the given command line options. """ options = {} options['dataPath'... | def getDefaultOptions(cls): """ Gets default options that always overwrite those specified in the build module. Boolean options of the L{DatabaseBuilder} can not be changed here as they are hardcoded in the given command line options. """ options = {} # dataPath options['dataPath'] = ['.', getDataPath()] # prefer optio... |
if not opts.ignoreConfig: options = self.getDefaultOptions() else: options = {} | options = self.getDefaultOptions( includeConfig=not opts.ignoreConfig) | def run(self): """ Runs the builder """ # parse command line parameters parser = self.buildParser() (opts, args) = parser.parse_args() |
if not self.wideBuild and redIndex >= int('20000', 16): | if not self.wideBuild and redIndex >= int('10000', 16): | def generator(self): """ Iterates over the Unihan entries. |
or ord(entry['ChineseCharacter']) < int('20000', 16): | or ord(entry['ChineseCharacter']) < int('10000', 16): | def generator(self): """Provides a pronunciation and a path to the audio file.""" entryList = [] xmlHandler = Kanjidic2Builder.XMLHandler(entryList, self.tagDict) |
or codePoint < int('20000', 16): | or codePoint < int('10000', 16): | def generator(self): """Provides one entry per variant and character.""" for entries in self.variantEntries: character = entries[0] for i, variantType in enumerate(self.typeList): variantInfo = entries[i+1] if variantInfo: # get proper regular expression for given variant info matchR, findR = self.VARIANT_REGEX_MAPPING... |
warn("malformed IDS for character '" + char \ + "'") | warn("malformed IDS for character %r" % char) | def generator(self): """Provides one entry per character, I{glyph} and locale subset.""" # Cjklib's stroke count method uses the stroke order information as # long as this table doesn't exist. strokeCountDict = self.cjk.getStrokeCountDict() for char, glyph in strokeCountDict.keys(): try: strokeCount = strokeCountDict... |
"malformed IDS for character '%s'" % char) | "malformed IDS for character %r" % char) | def getCharLayout(mainCharacterLayout, mainLayoutPosition, subCharLayout, subLayoutPosition): u""" Returns the character layout for the radical form within the component with layout subCharLayout itself belonging to a parent char with layout mainCharacterLayout. E.g. 鸺 can be decomposed into ⿰休鸟 and 休 can be furthermor... |
_dictionaryEntries = None def getDictionaryEntries(dictionary): global _dictionaryEntries if not _dictionaryEntries: db = dbconnector.getDBConnector() table = db.tables[dictionary] _dictionaryEntries = db.selectRows( select([table.c.HeadwordTraditional, table.c.HeadwordSimplified, table.c.Reading], distinct=True)\ .ord... | def checkCharacterReading(dictionary, readingName, readingOptions={}, | def getReadingOperator(readingName, readingOptions={}): global _readingOperator if not _readingOperator: readingFactory = ReadingFactory() _readingOperator = readingFactory.createReadingOperator(readingName, **readingOptions) return _readingOperator |
for entry in entryList: headwordTrad, headwordSimp, reading = entry if headwordTrad != headwordSimp: headword = headwordTrad + "'/'" + headwordSimp | for entry in iterDictionary(dictionary): if entry.HeadwordTraditional != entry.HeadwordSimplified: headword = "%s/%s" % (entry.HeadwordTraditional, entry.HeadwordSimplified) | def checkCharacterReading(entryList, readingName, readingOptions={}, ignoreFifthTone=False): for entry in entryList: headwordTrad, headwordSimp, reading = entry if headwordTrad != headwordSimp: headword = headwordTrad + "'/'" + headwordSimp else: headword = headwordTrad try: operator = getReadingOperator(readingName, ... |
headword = headwordTrad | headword = entry.HeadwordTraditional | def checkCharacterReading(entryList, readingName, readingOptions={}, ignoreFifthTone=False): for entry in entryList: headwordTrad, headwordSimp, reading = entry if headwordTrad != headwordSimp: headword = headwordTrad + "'/'" + headwordSimp else: headword = headwordTrad try: operator = getReadingOperator(readingName, ... |
entities = operator.decompose(reading) | entities = operator.decompose(entry.Reading) | def checkCharacterReading(entryList, readingName, readingOptions={}, ignoreFifthTone=False): for entry in entryList: headwordTrad, headwordSimp, reading = entry if headwordTrad != headwordSimp: headword = headwordTrad + "'/'" + headwordSimp else: headword = headwordTrad try: operator = getReadingOperator(readingName, ... |
print ("WARNING: can't parse line '" \ + headwordTrad + "', '" + headwordSimp + "', '" + reading \ + "'").encode(default_encoding) | print ("WARNING: can't parse line '%s', '%s', '%s'" % (entry.HeadwordTraditional, entry.HeadwordSimplified, entry.Reading)).encode(default_encoding) | def checkCharacterReading(entryList, readingName, readingOptions={}, ignoreFifthTone=False): for entry in entryList: headwordTrad, headwordSimp, reading = entry if headwordTrad != headwordSimp: headword = headwordTrad + "'/'" + headwordSimp else: headword = headwordTrad try: operator = getReadingOperator(readingName, ... |
if (len(entitiesFiltered) != len(headwordTrad)) \ or (len(entitiesFiltered) != len(headwordSimp)): print ("WARNING: can't parse line '" \ + headwordTrad + "', '" + headwordSimp + "', '" + reading \ + "'").encode(default_encoding) | if (len(entitiesFiltered) != len(entry.HeadwordTraditional)) \ or (len(entitiesFiltered) != len(entry.HeadwordSimplified)): print ("WARNING: can't parse line '%s', '%s', '%s'" % (entry.HeadwordTraditional, entry.HeadwordSimplified, entry.Reading)).encode(default_encoding) | def checkCharacterReading(entryList, readingName, readingOptions={}, ignoreFifthTone=False): for entry in entryList: headwordTrad, headwordSimp, reading = entry if headwordTrad != headwordSimp: headword = headwordTrad + "'/'" + headwordSimp else: headword = headwordTrad try: operator = getReadingOperator(readingName, ... |
if headwordTrad[i] != headwordSimp[i]: charList = [headwordTrad[i], headwordSimp[i]] | if entry.HeadwordTraditional[i] != entry.HeadwordSimplified[i]: charList = [entry.HeadwordTraditional[i], entry.HeadwordSimplified[i]] | def checkCharacterReading(entryList, readingName, readingOptions={}, ignoreFifthTone=False): for entry in entryList: headwordTrad, headwordSimp, reading = entry if headwordTrad != headwordSimp: headword = headwordTrad + "'/'" + headwordSimp else: headword = headwordTrad try: operator = getReadingOperator(readingName, ... |
charList = [headwordTrad[i]] | charList = [entry.HeadwordTraditional[i]] | def checkCharacterReading(entryList, readingName, readingOptions={}, ignoreFifthTone=False): for entry in entryList: headwordTrad, headwordSimp, reading = entry if headwordTrad != headwordSimp: headword = headwordTrad + "'/'" + headwordSimp else: headword = headwordTrad try: operator = getReadingOperator(readingName, ... |
if not hasReading(entity, readingList, readingName, ignoreFifthTone): | if readingList and not hasReading(entity, readingList, readingName, ignoreFifthTone): | def checkCharacterReading(entryList, readingName, readingOptions={}, ignoreFifthTone=False): for entry in entryList: headwordTrad, headwordSimp, reading = entry if headwordTrad != headwordSimp: headword = headwordTrad + "'/'" + headwordSimp else: headword = headwordTrad try: operator = getReadingOperator(readingName, ... |
if headwordTrad[i] != entity \ and (headwordTrad[i] not in NON_PINYIN_MAPPING \ or NON_PINYIN_MAPPING[headwordTrad[i]] != entity): | if entry.HeadwordTraditional[i] != entity \ and (entry.HeadwordTraditional[i] not in NON_PINYIN_MAPPING \ or NON_PINYIN_MAPPING[entry.HeadwordTraditional[i]] != entity): | def checkCharacterReading(entryList, readingName, readingOptions={}, ignoreFifthTone=False): for entry in entryList: headwordTrad, headwordSimp, reading = entry if headwordTrad != headwordSimp: headword = headwordTrad + "'/'" + headwordSimp else: headword = headwordTrad try: operator = getReadingOperator(readingName, ... |
+ headwordTrad[i] + "' to '" + entity \ | + entry.HeadwordTraditional[i] + "' to '" + entity \ | def checkCharacterReading(entryList, readingName, readingOptions={}, ignoreFifthTone=False): for entry in entryList: headwordTrad, headwordSimp, reading = entry if headwordTrad != headwordSimp: headword = headwordTrad + "'/'" + headwordSimp else: headword = headwordTrad try: operator = getReadingOperator(readingName, ... |
elif headwordSimp[i] != entity \ and (headwordSimp[i] not in NON_PINYIN_MAPPING \ or NON_PINYIN_MAPPING[headwordSimp[i]] != entity): | elif entry.HeadwordSimplified[i] != entity \ and (entry.HeadwordSimplified[i] not in NON_PINYIN_MAPPING \ or NON_PINYIN_MAPPING[entry.HeadwordSimplified[i]] != entity): | def checkCharacterReading(entryList, readingName, readingOptions={}, ignoreFifthTone=False): for entry in entryList: headwordTrad, headwordSimp, reading = entry if headwordTrad != headwordSimp: headword = headwordTrad + "'/'" + headwordSimp else: headword = headwordTrad try: operator = getReadingOperator(readingName, ... |
+ headwordSimp[i] + "' to '" + entity \ | + entry.HeadwordSimplified[i] + "' to '" + entity \ | def checkCharacterReading(entryList, readingName, readingOptions={}, ignoreFifthTone=False): for entry in entryList: headwordTrad, headwordSimp, reading = entry if headwordTrad != headwordSimp: headword = headwordTrad + "'/'" + headwordSimp else: headword = headwordTrad try: operator = getReadingOperator(readingName, ... |
def checkCharacterVariants(entryList): for entry in entryList: headwordTrad, headwordSimp, reading = entry if len(headwordTrad) != len(headwordSimp): print ("WARNING: different string length '" \ + headwordTrad + "', '" + headwordSimp + "', '" + reading \ + "'").encode(default_encoding) | def checkCharacterVariants(dictionary): for entry in iterDictionary(dictionary): if len(entry.HeadwordTraditional) != len(entry.HeadwordSimplified): print ("WARNING: different string length '%s', '%s', '%s'" % (entry.HeadwordTraditional, entry.HeadwordSimplified, entry.Reading)).encode(default_encoding) | def checkCharacterVariants(entryList): for entry in entryList: headwordTrad, headwordSimp, reading = entry if len(headwordTrad) != len(headwordSimp): print ("WARNING: different string length '" \ + headwordTrad + "', '" + headwordSimp + "', '" + reading \ + "'").encode(default_encoding) continue for idx, char in enume... |
for idx, char in enumerate(headwordTrad): | if entry.HeadwordTraditional == entry.HeadwordSimplified: continue for idx, char in enumerate(entry.HeadwordTraditional): | def checkCharacterVariants(entryList): for entry in entryList: headwordTrad, headwordSimp, reading = entry if len(headwordTrad) != len(headwordSimp): print ("WARNING: different string length '" \ + headwordTrad + "', '" + headwordSimp + "', '" + reading \ + "'").encode(default_encoding) continue for idx, char in enume... |
if headwordSimp[idx] not in mapping: if headwordTrad != headwordSimp: headword = headwordTrad + "'/'" + headwordSimp else: headword = headwordTrad | if entry.HeadwordSimplified[idx] not in mapping: headword = "%s/%s" % (entry.HeadwordTraditional, entry.HeadwordSimplified) | def checkCharacterVariants(entryList): for entry in entryList: headwordTrad, headwordSimp, reading = entry if len(headwordTrad) != len(headwordSimp): print ("WARNING: different string length '" \ + headwordTrad + "', '" + headwordSimp + "', '" + reading \ + "'").encode(default_encoding) continue for idx, char in enume... |
checkCharacterReading(getDictionaryEntries(dictionary), reading, | checkCharacterReading(dictionary, reading, | def main(): # parse command line parameters try: opts, args = getopt.getopt(sys.argv[1:], "w:rc", ["help", "pinyin", "character-variants", "set-dictionary=", "ignore-fifth"]) except getopt.GetoptError: # print help information and exit usage() sys.exit(2) # get default dictionary dictionaryDic = {} for dictionary in D... |
checkCharacterVariants(getDictionaryEntries(dictionary)) | checkCharacterVariants(dictionary) | def main(): # parse command line parameters try: opts, args = getopt.getopt(sys.argv[1:], "w:rc", ["help", "pinyin", "character-variants", "set-dictionary=", "ignore-fifth"]) except getopt.GetoptError: # print help information and exit usage() sys.exit(2) # get default dictionary dictionaryDic = {} for dictionary in D... |
entry.append(u'%s（%s）' % (entry[0], entry[1])) | entry.append(u'%s（%s）' % headwords) | def _unifyHeadwords(self, entry): entry = list(entry) if self.headword == 's': headwords = (entry[0], entry[1]) else: headwords = (entry[1], entry[0]) |
if character in [u'⿺', u'⿶']: | if (character == u'⿶' or (character == u'⿺' and type(subTree[index+1]) == type(()) and subTree[index+1][0] in u'辶廴乙')): | def getFromEntry(subTree, index=0): """ Goes through a single layer of a tree recursively. |
if not isinstance(data, basestring): | if hasattr(data, '__iter__'): | def _decode(self, data): """ Decodes a data row. |
if searchEntities[0] == '%': | elif searchEntities[0] == '%': | def _depthFirstSearch(searchEntities, entities): """ Depth first search comparing a list of reading entities with wildcards against reading entities from a result. """ if not searchEntities: if not entities: return True else: return False if searchEntities[0] == '%': if ReadingWildcardBase._depthFirstSearch(searchEntit... |
else: | elif entities: | def _depthFirstSearch(searchEntities, entities): """ Depth first search comparing a list of reading entities with wildcards against reading entities from a result. """ if not searchEntities: if not entities: return True else: return False if searchEntities[0] == '%': if ReadingWildcardBase._depthFirstSearch(searchEntit... |
elif searchEntities[0] == '_%' and entities: | else: return False elif not entities: return False elif searchEntities[0] == '_%': | def _depthFirstSearch(searchEntities, entities): """ Depth first search comparing a list of reading entities with wildcards against reading entities from a result. """ if not searchEntities: if not entities: return True else: return False if searchEntities[0] == '%': if ReadingWildcardBase._depthFirstSearch(searchEntit... |
elif entities and searchEntities[0] == entities[0]: | elif searchEntities[0] == entities[0]: | def _depthFirstSearch(searchEntities, entities): """ Depth first search comparing a list of reading entities with wildcards against reading entities from a result. """ if not searchEntities: if not entities: return True else: return False if searchEntities[0] == '%': if ReadingWildcardBase._depthFirstSearch(searchEntit... |
wildcardReadingStr = self._getWildcardString(readingStr) | wildcardReadingStr = self._getWildcardString(searchStr) | def getWhereClause(self, column, searchStr, **options): if self.hasWildcardCharacters(searchStr): wildcardReadingStr = self._getWildcardString(readingStr) return column.like(wildcardReadingStr, escape=self.escape) else: # simple routine is faster return ExactSearchStrategy.getWhereClause(self, column, searchStr) |
regex = self._getWildcardRegex(readingStr) | regex = self._getWildcardRegex(searchStr) | def getMatchFunction(self, searchStr, **options): if self.hasWildcardCharacters(searchStr): regex = self._getWildcardRegex(readingStr) return lambda reading: regex.search(reading) is not None else: # simple routine is faster return ExactSearchStrategy.getMatchFunction(self, searchStr) |
class SimpleWildcardReadingSearchStrategy(SimpleReadingSearchStrategy, WildcardBase): """ Simple reading search strategy with support for wildcards. Converts search string to the dictionary reading and separates entities by space. """ def __init__(self, **options): SimpleReadingSearchStrategy.__init__(self) WildcardBas... | class ReadingWildcardBase(WildcardBase): """ Wildcard search base class for readings. Provides wildcard conversion and matching of reading strings. """ def __init__(self): WildcardBase.__init__(self) param = {'esc': re.escape(self.escape), 'single': re.escape(self.singleCharacter), 'multiple': re.escape(self.multipleC... | def getMatchFunction(self, searchStr, **options): decompEntities = self._getReadings(searchStr, **options) |
param = {'esc': re.escape(self.escape), 'single': re.escape(self.singleCharacter), 'multiple': re.escape(self.multipleCharacters)} wildcardRegex = re.compile( r'( |\\{2}|\\?(?:%(single)s|%(multiple)s))' % param) wildcardForms = [] for entities in decompEntities: wildcardEntities = [] for entity in entities: if isRea... | if self._getWildcardFormsOptions != (searchStr, options): decompEntities = self._getReadings(searchStr, **options) self._wildcardForms = [] for entities in decompEntities: wildcardEntities = [] for entity in entities: if isReadingEntity(entity): wildcardEntities.append(entity) else: wildcardEntities.extend( self._tran... | def isReadingEntity(entity, cache={}): if entity not in cache: cache[entity] = self._readingFactory.isReadingEntity(entity, self._dictInstance.READING, **self._dictInstance.READING_OPTIONS) return cache[entity] |
def getWildcardReading(entities): entityList = [] for entity in entities: if entityList and entityList[-1] != '%' and entity != '%': entityList.append(' ') entityList.append(entity) return ''.join(entityList) | def getWildcardReading(entities): entityList = [] for entity in entities: # insert space to separate reading entities, but only if we are # not looking for a wildcard with a possibly empty match if entityList and entityList[-1] != '%' and entity != '%': entityList.append(' ') entityList.append(entity) return ''.join(... | |
decompEntities = self._getReadings(searchStr, **options) wildcardForms = self._getWildcardForms(decompEntities) wildcardReadings = map(getWildcardReading, wildcardForms) return or_(*[column.like(reading, escape=self.escape) for reading in wildcardReadings]) | return self._getWildcardWhereClause(column, searchStr, **options) | def getWildcardReading(entities): entityList = [] for entity in entities: # insert space to separate reading entities, but only if we are # not looking for a wildcard with a possibly empty match if entityList and entityList[-1] != '%' and entity != '%': entityList.append(' ') entityList.append(entity) return ''.join(... |
def getReadingEntities(reading): return reading.split(' ') def depthFirstSearch(searchEntities, entities): if not searchEntities: if not entities: return True else: return False if searchEntities[0] == '%': if depthFirstSearch(searchEntities[1:], entities): return True else: return depthFirstSearch(searchEntities, ... | def getReadingEntities(reading): # simple and efficient method for CEDICT type dictionaries return reading.split(' ') | |
decompEntities = self._getReadings(searchStr, **options) wildcardForms = self._getWildcardForms(decompEntities) return matchReadingEntities | return self._getWildcardMatchFunction(searchStr, **options) | def matchReadingEntities(reading): readingEntities = getReadingEntities(reading) |
def _getWildcardForms(self, searchStr, **options): | def _getTonalWildcardForms(self, searchStr, **options): | def _getWildcardForms(self, searchStr, **options): """Adds wildcards to account for missing tone information.""" wildcardEntities = [] for entities in self._getPlainForms(searchStr, **options): newEntities = [] for entity in entities: if not isinstance(entity, basestring): entity, plainEntity, tone = entity if tone is ... |
def _getTonalForms(self, searchStr, **options): | def _getAllTonalForms(self, searchStr, **options): | def _getTonalForms(self, searchStr, **options): """ Gets all tonal reading strings for decompositions with missing tone information. """ def getTonalEntity(plainEntity, tone, cache={}): key = (plainEntity, tone) if key not in cache: try: cache[key] = self._readingFactory.getTonalEntity( plainEntity, tone, self._dictIns... |
searchEntities = self._getWildcardForms(searchStr, **options) | searchEntities = self._getTonalWildcardForms(searchStr, **options) | def getWhereClause(self, column, searchStr, **options): # if reading is tonal and includes support for missing tones, handle if self._hasTonlessSupport(): if self._dictInstance.READING in self.READINGS_HAVE_TONE_APPENDED: # look for missing tone information and use wildcards, with # better performance # TODO that's n... |
searchEntities = self._getTonalForms(searchStr, **options) | searchEntities = self._getAllTonalForms(searchStr, **options) | def getWhereClause(self, column, searchStr, **options): # if reading is tonal and includes support for missing tones, handle if self._hasTonlessSupport(): if self._dictInstance.READING in self.READINGS_HAVE_TONE_APPENDED: # look for missing tone information and use wildcards, with # better performance # TODO that's n... |
searchEntities = self._getTonalForms(searchStr, **options) matchSet = [' '.join(entities) for entities in searchEntities] else: decompEntities = self._getReadings(searchStr, **options) matchSet = set([' '.join(entities) for entities in decompEntities]) | searchEntities = self._getAllTonalForms(searchStr, **options) else: searchEntities = self._getReadings(searchStr, **options) matchSet = set([' '.join(entities) for entities in searchEntities]) | def getMatchFunction(self, searchStr, **options): # if reading is tonal and includes support for missing tones, handle if self._hasTonlessSupport(): # look for missing tone information and generate all forms searchEntities = self._getTonalForms(searchStr, **options) |
decompositionEntries = re.findall('([^ ]+); (\d+)', decomp) | decompositionEntries = re.findall('([^ ,]+); (\d+)', decomp) | def decompositionEntryPreparator(entryList): columns = ['glyph', 'decomposition'] entryDict = dict(zip(columns, entryList)) character, glyphIndex = entryDict['glyph'].split('/', 1) decomp = entryDict.get('decomposition', '').strip('"') decompositionEntries = re.findall('([^ ]+); (\d+)', decomp) entries = [] for deco... |
entries.append((character, decomposition.replace('/', ' | entries.append((character, re.sub(r'(\D)/(\d+)', r'\1[\2]', decomposition), | def decompositionEntryPreparator(entryList): columns = ['glyph', 'decomposition'] entryDict = dict(zip(columns, entryList)) character, glyphIndex = entryDict['glyph'].split('/', 1) decomp = entryDict.get('decomposition', '').strip('"') decompositionEntries = re.findall('([^ ]+); (\d+)', decomp) entries = [] for deco... |
return [(character, entryDict['strokeorder'].strip('"'), glyphIndex)] | return [(character, entryDict['strokeorder'].strip('"'), glyphIndex, '')] | def strokeorderEntryPreparator(entryList): columns = ['glyph', 'strokeorder'] entryDict = dict(zip(columns, entryList)) character, glyphIndex = entryDict['glyph'].split('/', 1) if 'strokeorder' in entryDict: return [(character, entryDict['strokeorder'].strip('"'), glyphIndex)] else: return [] |
print ','.join(('"%s"' % cell) for cell in a) | print ','.join(('"%s"' % cell) for cell in a).encode('utf8') | def main(): if len(sys.argv) != 2: print """usage: python export.py DATA_SET |
joinTables[-1].c.ChineseCharacter \ | joinTables[0].c.ChineseCharacter \ | def getCharactersForEquivalentComponents(self, componentConstruct, resultIncludeRadicalForms=False, includeAllGlyphs=False): u""" Gets all characters that contain at least one component per list entry, sorted by stroke count if available. |
configuration = configuration or {} if isinstance(configuration, basestring): | if not configuration: configuration = {} elif isinstance(configuration, basestring): | def __init__(self, configuration): """ Constructs the DatabaseConnector object and connects to the database specified by the options given in databaseSettings. |
... d = CEDICT(readingSearchStrategy=TonelessReadingSearchStrategy()) | ... d = CEDICT(readingSearchStrategy=TonelessReadingSearchStrategy(), ... entryFactory=UnifiedHeadwordEntryFactory()) | >>> def search(string, reading=None): |
... print e.HeadwordSimplified, e.Reading, e.Translation | ... print e.Headword, e.Reading, e.Translation | >>> def search(string, reading=None): |
宁 níng /peaceful/rather/Ningxia (abbr.)/Nanjing (abbr.)/surname Ning/ | 宁（寧） níng /peaceful/rather/Ningxia (abbr.)/Nanjing (abbr.)/surname Ning/ @todo Fix: letter case | >>> def search(string, reading=None): |
class ExactTranslationSearchStrategy(object): """Basic translation based search strategy.""" | class ExactSearchStrategy(object): """Simple search strategy class.""" | def format(self, string): toReading = self.toReading or self.fromReading try: return self._readingFactory.convert(string, self.fromReading, toReading, sourceOptions=self.sourceOptions, targetOptions=self.targetOptions) except (exception.DecompositionError, exception.CompositionError, exception.ConversionError): return ... |
return column.like('%' + searchStr + '%') | return column == searchStr | def getWhereClause(self, column, searchStr): """ Returns a SQLAlchemy clause that is the necessary condition for a possible match. This clause is used in the database query. Results may then be further narrowed by L{getMatchFunction()}. |
Gets a function that returns C{True} if the entry's translation matches | Gets a function that returns C{True} if the entry's cell content matches | def getMatchFunction(self, searchStr): """ Gets a function that returns C{True} if the entry's translation matches the search string. |
matches from other SQL clauses might get included, that do not fulfill | matches from other SQL clauses might get included which do not fulfill | def getMatchFunction(self, searchStr): """ Gets a function that returns C{True} if the entry's translation matches the search string. |
class SimpleTranslationSearchStrategy(ExactTranslationSearchStrategy): | class WildcardTranslationSearchStrategy(SingleEntryTranslationSearchStrategy, WildcardBase): """Basic translation search strategy with support for wildcards.""" def _getWildcardRegex(self, searchStr): return re.compile('/' + self._prepareWildcardRegex(searchStr) + '/') def getWhereClause(self, column, searchStr): wild... | def getMatchFunction(self, searchStr): """ Gets a function that returns C{True} if the entry's translation matches the search string. |
class CEDICTTranslationSearchStrategy(ExactTranslationSearchStrategy): | class SimpleWildcardTranslationSearchStrategy( WildcardTranslationSearchStrategy, SimpleTranslationSearchStrategy): """ Simple translation search strategy with support for wildcards. Takes into account additions put in parentheses. """ def _getWildcardRegex(self, searchStr): regexStr = self._prepareWildcardRegex(sear... | def getMatchFunction(self, searchStr): # start with a slash '/', make sure any opening parenthesis is # closed and match search string. Finish with other content in # parantheses and a slash regex = re.compile('/' + '(\s+|\([^\)]+\))*' + re.escape(searchStr) + '(\s+|\([^\)]+\))*' + '/') |
class HanDeDictTranslationSearchStrategy(ExactTranslationSearchStrategy): | class CEDICTWildcardTranslationSearchStrategy( WildcardTranslationSearchStrategy, CEDICTTranslationSearchStrategy): """ CEDICT translation based search strategy with support for wildcards. Takes into account additions put in parentheses and appended information separated by a comma. """ def _getWildcardRegex(self, sear... | def getMatchFunction(self, searchStr): # start with a slash '/', make sure any opening parenthesis is # closed and match search string. Finish with other content in # parantheses and a slash regex = re.compile('/' + '(\s+|\([^\)]+\))*' + re.escape(searchStr) + '(\s+|\([^\)]+\))*' + '[/,]') |
class ExactReadingSearchStrategy(object): """Basic translation based search strategy.""" def getWhereClause(self, column, readingStr, fromReading, **options): """ Returns a SQLAlchemy clause that is the necessary condition for a possible match. This clause is used in the database query. Results may then be further narr... | class WildcardReadingSearchStrategy(ExactSearchStrategy, WildcardBase): """Basic reading search strategy with support for wildcards.""" def _getWildcardRegex(self, searchStr): return re.compile(self._prepareWildcardRegex(searchStr) + '$') def getWhereClause(self, column, searchStr, **options): if self.hasWildcardChara... | def getMatchFunction(self, searchStr): # start with a slash '/', make sure any opening parenthesis is # closed, end any other entry with a punctuation mark, and match # search string. Finish with other content in parantheses and # a slash or punctuation mark regex = re.compile('/((\([^\)]+\)|[^\(])+' + '(?!; Bsp.... |
def _getReadings(self, readingStr, fromReading, **options): if self._getReadingsOptions != (readingStr, fromReading, options): self._getReadingsOptions = (readingStr, fromReading, options) | if (not hasattr(self._dictInstance, 'READING') or not hasattr(self._dictInstance, 'READING_OPTIONS')): raise ValueError('Incompatible dictionary') def _getReadings(self, readingStr, **options): if self._getReadingsOptions != (readingStr, options): self._getReadingsOptions = (readingStr, options) fromReading = options... | def _getReadings(self, readingStr, fromReading, **options): if self._getReadingsOptions != (readingStr, fromReading, options): self._getReadingsOptions = (readingStr, fromReading, options) |
def getWhereClause(self, column, readingStr, fromReading, **options): decompEntities = self._getReadings(readingStr, fromReading, **options) | def getWhereClause(self, column, searchStr, **options): decompEntities = self._getReadings(searchStr, **options) | def getWhereClause(self, column, readingStr, fromReading, **options): decompEntities = self._getReadings(readingStr, fromReading, **options) |
class MixedReadingSearchStrategy(SimpleReadingSearchStrategy): """ Reading search strategy that extends L{SimpleReadingSearchStrategy} to allow intermixing of readings with single characters from the headword. """ def __init__(self): super(MixedReadingSearchStrategy, self).__init__() self._getReadingsSearchPairsOptions... | def getMatchFunction(self, searchStr, **options): decompEntities = self._getReadings(searchStr, **options) matchSet = set([' '.join(entities) for entities in decompEntities]) return lambda reading: reading in matchSet class SimpleWildcardReadingSearchStrategy(SimpleReadingSearchStrategy, WildcardBase): """ Simple r... | def getWhereClause(self, column, readingStr, fromReading, **options): decompEntities = self._getReadings(readingStr, fromReading, **options) |
if self._getReadingsSearchPairsOptions != (readingStr, fromReading, options): self._getReadingsSearchPairsOptions = (readingStr, fromReading, options) decompEntities = self._getReadings(readingStr, fromReading, **options) self._searchPairs = [] for entities in decompEntities: searchEntities = [] nonReadingEntityFoun... | param = {'esc': re.escape(self.escape), 'single': re.escape(self.singleCharacter), 'multiple': re.escape(self.multipleCharacters)} wildcardRegex = re.compile( r'( |\\{2}|\\?(?:%(single)s|%(multiple)s))' % param) wildcardForms = [] for entities in decompEntities: wildcardEntities = [] for entity in entities: if isRea... | def isReadingEntity(entity, cache={}): if entity not in cache: cache[entity] = self._readingFactory.isReadingEntity(entity, self._dictInstance.READING, **self._dictInstance.READING_OPTIONS) return cache[entity] |
headwordSearchEntities.append(headwordEntity) if readingEntity is None: readingSearchEntities.append('_%') else: readingSearchEntities.append(readingEntity) headwordClause = headwordColumn.like( ''.join(headwordSearchEntities)) readingClause = readingColumn.like(' '.join(readingSearchEntities)) clauses.append(and_(he... | for part in wildcardRegex.split(entity): if part == self.singleCharacter: wildcardEntities.append('_%') elif part == self.multipleCharacters: wildcardEntities.append('%') else: wildcardEntities.extend(part.strip()) wildcardForms.append(wildcardEntities) return wildcardForms def getWhereClause(self, column, searchStr... | def getWhereClauseMixed(self, headwordColumn, readingColumn, readingStr, fromReading, **options): |
def matchHeadwordReadingPair(headword, reading): | def depthFirstSearch(searchEntities, entities): if not searchEntities: if not entities: return True else: return False if searchEntities[0] == '%': if depthFirstSearch(searchEntities[1:], entities): return True else: return depthFirstSearch(searchEntities, entities[1:]) elif searchEntities[0] == '_%': return depthFi... | def matchHeadwordReadingPair(headword, reading): readingEntities = getReadingEntities(reading) |
for searchEntities in searchPairs: for idx, entryTuple in enumerate(searchEntities): headwordEntity, readingEntity = entryTuple if (headwordEntity is not None and headword[idx] != headwordEntity): break if (readingEntity is not None and readingEntities[idx] != readingEntity): break else: | for entities in wildcardForms: if depthFirstSearch(entities, readingEntities): | def matchHeadwordReadingPair(headword, reading): readingEntities = getReadingEntities(reading) |
searchPairs = self._getReadingsSearchPairs(readingStr, fromReading, **options) return matchHeadwordReadingPair | if self.hasWildcardCharacters(searchStr): decompEntities = self._getReadings(searchStr, **options) wildcardForms = self._getWildcardForms(decompEntities) return matchReadingEntities else: return SimpleReadingSearchStrategy.getMatchFunction(self, searchStr, **options) | def matchHeadwordReadingPair(headword, reading): readingEntities = getReadingEntities(reading) |
def getWhereClause(self, column, readingStr, fromReading, **options): | def getWhereClause(self, column, searchStr, **options): | def getWhereClause(self, column, readingStr, fromReading, **options): def getWildcardForms(decompEntities): """Adds wildcards to account for missing tone information.""" wildcardEntities = [] for entities in decompEntities: newEntities = [] for entity in entities: if self._readingFactory.isReadingEntity(entity, fromRea... |
decompEntities = self._getReadings(readingStr, fromReading, **options) | decompEntities = self._getReadings(searchStr, **options) fromReading = options.get('reading', self._dictInstance.READING) | def getWildcardForms(decompEntities): """Adds wildcards to account for missing tone information.""" wildcardEntities = [] for entities in decompEntities: newEntities = [] for entity in entities: if self._readingFactory.isReadingEntity(entity, fromReading, **options): plainEntity, tone \ = self._readingFactory.splitEnti... |
def getMatchFunction(self, readingStr, fromReading, **options): | def getMatchFunction(self, searchStr, **options): | def getMatchFunction(self, readingStr, fromReading, **options): def getTonalForms(decompEntities): """ Gets all tonal reading strings for decompositions with missing tone information. """ formsSet = set() for entities in decompEntities: newEntities = [] for entity in entities: entityList = [entity] if self._readingFact... |
decompEntities = self._getReadings(readingStr, fromReading, **options) | decompEntities = self._getReadings(searchStr, **options) fromReading = options.get('reading', self._dictInstance.READING) | def getTonalEntities(plainEntity): """Gets all tonal forms for a given plain entity.""" tonalEntities = [] tones = self._readingFactory.getTones( fromReading, **options) for tone in tones: try: tonalEntities.append(self._readingFactory.getTonalEntity( plainEntity, tone, fromReading, **options)) except exception.Invalid... |
def __init__(self, entryFactory=None, columnFormatStrategies=None, readingSearchStrategy=None, translationSearchStrategy=None, databaseUrl=None, dbConnectInst=None): | def __init__(self, **options): | def __init__(self, entryFactory=None, columnFormatStrategies=None, readingSearchStrategy=None, translationSearchStrategy=None, databaseUrl=None, dbConnectInst=None): """ Initialises the BaseDictionary instance. |
@type entryFactory: instance @param entryFactory: entry factory instance @type columnFormatStrategies: dict @param columnFormatStrategies: column formatting strategy instances @type readingSearchStrategy: instance @param readingSearchStrategy: reading search strategy instance @type translationSearchStrategy: instance @... | @keyword entryFactory: entry factory instance @keyword columnFormatStrategies: column formatting strategy instances @keyword headwordSearchStrategy: headword search strategy instance @keyword readingSearchStrategy: reading search strategy instance @keyword translationSearchStrategy: translation search strategy instance... | def __init__(self, entryFactory=None, columnFormatStrategies=None, readingSearchStrategy=None, translationSearchStrategy=None, databaseUrl=None, dbConnectInst=None): """ Initialises the BaseDictionary instance. |
@type dbConnectInst: instance @param dbConnectInst: instance of a L{DatabaseConnector} | @keyword dbConnectInst: instance of a L{DatabaseConnector} | def __init__(self, entryFactory=None, columnFormatStrategies=None, readingSearchStrategy=None, translationSearchStrategy=None, databaseUrl=None, dbConnectInst=None): """ Initialises the BaseDictionary instance. |
if dbConnectInst: self.db = dbConnectInst | if 'dbConnectInst' in options: self.db = options['dbConnectInst'] | def __init__(self, entryFactory=None, columnFormatStrategies=None, readingSearchStrategy=None, translationSearchStrategy=None, databaseUrl=None, dbConnectInst=None): """ Initialises the BaseDictionary instance. |
if entryFactory: self.entryFactory = entryFactory | if 'entryFactory' in options: self.entryFactory = options['entryFactory'] | def __init__(self, entryFactory=None, columnFormatStrategies=None, readingSearchStrategy=None, translationSearchStrategy=None, databaseUrl=None, dbConnectInst=None): """ Initialises the BaseDictionary instance. |
self.columnFormatStrategies = columnFormatStrategies or {} | self.columnFormatStrategies = options.get('columnFormatStrategies', {}) | def __init__(self, entryFactory=None, columnFormatStrategies=None, readingSearchStrategy=None, translationSearchStrategy=None, databaseUrl=None, dbConnectInst=None): """ Initialises the BaseDictionary instance. |
if readingSearchStrategy: self.readingSearchStrategy = readingSearchStrategy else: self.readingSearchStrategy = ExactReadingSearchStrategy() | if 'headwordSearchStrategy' in options: self.headwordSearchStrategy = options['headwordSearchStrategy'] else: self.headwordSearchStrategy = WildcardHeadwordSearchStrategy() """Strategy for searching readings.""" if hasattr(self.headwordSearchStrategy, 'setDictionaryInstance'): self.headwordSearchStrategy.setDictionaryI... | def __init__(self, entryFactory=None, columnFormatStrategies=None, readingSearchStrategy=None, translationSearchStrategy=None, databaseUrl=None, dbConnectInst=None): """ Initialises the BaseDictionary instance. |
if translationSearchStrategy: self.translationSearchStrategy = translationSearchStrategy else: self.translationSearchStrategy = ExactTranslationSearchStrategy() | self.mixedReadingSearchStrategy = options.get( 'mixedReadingSearchStrategy', None) """Strategy for mixed searching of headword/reading.""" if (self.mixedReadingSearchStrategy and hasattr(self.mixedReadingSearchStrategy, 'setDictionaryInstance')): self.mixedReadingSearchStrategy.setDictionaryInstance(self) if 'translat... | def __init__(self, entryFactory=None, columnFormatStrategies=None, readingSearchStrategy=None, translationSearchStrategy=None, databaseUrl=None, dbConnectInst=None): """ Initialises the BaseDictionary instance. |
def __init__(self, entryFactory=None, columnFormatStrategies=None, readingSearchStrategy=None, translationSearchStrategy=None, databaseUrl=None, dbConnectInst=None): if not entryFactory: entryFactory = NamedTupleFactory() if not translationSearchStrategy: translationSearchStrategy = SimpleTranslationSearchStrategy() s... | def __init__(self, **options): if 'entryFactory' not in options: options['entryFactory'] = NamedTupleFactory() if 'translationSearchStrategy' not in options: options['translationSearchStrategy'] \ = SimpleWildcardTranslationSearchStrategy() super(EDICTStyleDictionary, self).__init__(**options) | def __init__(self, entryFactory=None, columnFormatStrategies=None, readingSearchStrategy=None, translationSearchStrategy=None, databaseUrl=None, dbConnectInst=None): |
def _search(self, whereClause, filters, orderBy, limit): | def _search(self, whereClause, filters, limit, orderBy): | def _search(self, whereClause, filters, orderBy, limit): def _getFilterFunction(filterList): """Creates a function for filtering search results.""" def anyFunc(row): for itemsIdx, function in functionList: if function(*[row[idx] for idx in itemsIdx]): return True return False |
if orderBy is None: orderBy = [] | orderByCols = [] if orderBy is not None: if type(orderBy) != type([]): orderBy = [orderBy] try: orderByCols = [dictionaryTable.c[col] for col in orderBy] except KeyError: raise ValueError("Invalid 'ORDER BY' columns specified: '%s'" % "', '".join(orderBy)) | def anyFunc(row): for itemsIdx, function in functionList: if function(*[row[idx] for idx in itemsIdx]): return True return False |
whereClause, distinct=True).order_by(*orderBy).limit(limit)) | whereClause, distinct=True).order_by(*orderByCols).limit(limit)) | def anyFunc(row): for itemsIdx, function in functionList: if function(*[row[idx] for idx in itemsIdx]): return True return False |
filters = [(['Headword'], lambda headword: headword == headwordStr)] | def _getHeadwordSearch(self, headwordStr, **options): filters = [(['Headword'], lambda headword: headword == headwordStr)] | |
clauses = [dictionaryTable.c.Headword == headword] return clauses, filters | headwordClause = self.headwordSearchStrategy.getWhereClause( dictionaryTable.c.Headword, headwordStr) headwordMatchFunc = self.headwordSearchStrategy.getMatchFunction( headwordStr) return [headwordClause], [(['Headword'], headwordMatchFunc)] | def _getHeadwordSearch(self, headwordStr, **options): filters = [(['Headword'], lambda headword: headword == headwordStr)] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.