which is okay for all the dictionaries supported so far...
480716
public GenericDictionaryEntry parse(String entry) {
        String[] fields = parseLine(entry);

        String surface = fields[0];
        short leftId = Short.parseShort(fields[1]);
        short rightId = Short.parseShort(fields[2]);
        short wordCost = Short.parseShort(fields[3]);

        List<String> pos = new ArrayList<>();
        pos.addAll(Arrays.asList(fields).subList(4, 10));

        List<String> features = new ArrayList<>();
        features.addAll(Arrays.asList(fields).subList(10, fields.length));

        GenericDictionaryEntry dictionaryEntry = new GenericDictionaryEntry.Builder().surface(surface).leftId(leftId)
                        .rightId(rightId).wordCost(wordCost).pos(pos).features(features).build();

        return dictionaryEntry;
    }
1326324
def supported_operations(self):
        
        return tuple(op for op in backend.DIR_OPS if self._dir_ops & op)
974307
def build_annotation_dict_all_filter(annotations: Mapping[str, Iterable[str]]) -> EdgePredicate:
    
    if not annotations:
        return keep_edge_permissive

    @edge_predicate
    def annotation_dict_all_filter(edge_data: EdgeData) -> bool:
        """Check if the all of the annotations in the enclosed query match."""
        return _annotation_dict_all_filter(edge_data, query=annotations)

    return annotation_dict_all_filter
419088
def asDict(self):
        
        d = {}
        for k, v in self.items():
            d[k] = v
        return d
1056510
def _stable_dict_repr(strdict):
    """"""
    lines = []
    for key in sorted(strdict.keys()):
        lines.append("'%s': %s" % (key, rpr(strdict[key])))
    return "{%s}" % ", ".join(lines)
713639
def dictapply(d, fn):
    
    for k, v in d.items():
        if isinstance(v, dict):
            v = dictapply(v, fn)
        else:
            d[k] = fn(v)
    return d
112589
protected function updateDictionary()
    {
        // Change some terms
        $this->dictionary = array_replace(
            $this->dictionary,
            [
                'agency_code'   => 'Agência/Cod. Beneficiário',
                'date_process'  => 'Data do processameto',
                'doc_number_sh' => 'Nº do documento',
                'discount'      => '(-) Desconto/ Abatimento',
                'doc_value'     => 'Valor',
                'doc_valueU'    => 'Valor',
                'doc_value='    => '(=) Valor do documento',
                'fine'          => '(+) Mora/Multa',
                'guarantor'     => 'Sacador/Avalista: ',
                'instructions'  => 'Instruções',
                'kind'          => 'Espécie doc',
                'currency'      => 'Moeda',
            ]
        );

        // Make most terms upper case
        $keys = [
            'accept', 'addition', 'agency_code', 'amount', 'assignor',
            'bank_use', 'charged', 'client', 'currency', 'date_document',
            'date_due', 'date_process', 'deduction', 'demonstrative',
            'discount', 'doc_number_sh', 'doc_value', 'doc_value=',
            'doc_valueU', 'fine', 'guarantor', 'instructions', 'kind',
            'mech_auth', 'our_number', 'payment_place', 'wallet',
        ];
        foreach ($keys as $key) {
            $this->dictionary[$key] = mb_strtoupper($this->dictionary[$key]);
        }
    }
66363
def asDictionary(self):
        
        return {
            "type": "joinTable",
            "leftTableSource": self._leftTableSource,
            "rightTableSource": self._rightTableSource,
            "leftTableKey": self._leftTableKey,
            "rightTableKey": self._rightTableKey,
            "joinType": self._joinType
        }
819553
def allowed(self, method, _dict, allow):
        
        for key in _dict.keys():
            if key not in allow:
                raise LunrError("'%s' is not an argument for method '%s'"
                                % (key, method))
900386
def make_editions_dict(editions):
    
    d = {}
    nums = ['1', '2', '3', '4', '5', '6']
    num_counter = 0
    for k, date_dict in editions.items():
        d['edition%s' % nums[num_counter]] = k
        if date_dict['start'] is not None:
            d['start_e%s' % nums[num_counter]] = date_dict['start'].isoformat()
        if date_dict['end'] is not None:
            d['end_e%s' % nums[num_counter]] = date_dict['end'].isoformat()

        num_counter += 1

    return d
1039678
def simple_dict() -> Callable:
    

    def parse(dict_str: str):

        def _parse(value: str):
            if value == "True":
                return True
            if value == "False":
                return False
            if "." in value:
                return float(value)
            return int(value)

        _dict = dict()
        try:
            for entry in dict_str.split(","):
                key, value = entry.split(":")
                _dict[key] = _parse(value)
        except ValueError:
            raise argparse.ArgumentTypeError("Specify argument dictionary as key1:value1,key2:value2,..."
                                             " Supported types: bool, int, float.")
        return _dict

    return parse
139817
def valid_dict(d, keys=None):
    

    if keys is None:
        d_ = d
    else:
        d_ = itemfilter(lambda item: item[0] in keys, d)
        if len(d_) != len(keys):
            return False
    values = list(itervalues(d_))
    return False if None in values else True
3006
def p_Dictionary(p):
  
  p[0] = model.Dictionary(name=p[2], parent=p[3], members=p[5])
76957
function supports(feature) {
		var root = document.documentElement;
		var fixt = feature[0].toUpperCase() + feature.substring(1);
		return !["", "Webkit", "Moz", "O", "ms"].every(function(prefix) {
			return root.style[prefix ? prefix + fixt : feature] === undefined;
		});
	}
871477
def asDictionary(self):
        
        template = {"type" : self._type,
                    "mapLayerId" : self._mapLayerId}
        if not self._gdbVersion is None and\
           self._gdbVersion != "":
            template['gdbVersion'] = self._gdbVersion
        return template
681906
def _buildDict(self):
        '''
        
        '''
        lexDict = {}
        with io.open(self.islePath, "r", encoding='utf-8') as fd:
            wordList = [line.rstrip('\n') for line in fd]
        
        for row in wordList:
            word, pronunciation = row.split(" ", 1)
            word, extraInfo = word.split("(", 1)
            
            extraInfo = extraInfo.replace(")", "")
            extraInfoList = [segment for segment in extraInfo.split(",")
                             if ("_" not in segment and "+" not in segment and
                                 ':' not in segment and segment != '')]
            
            lexDict.setdefault(word, [])
            lexDict[word].append((pronunciation, extraInfoList))
        
        return lexDict
968107
def asDict(self):
        
        dct = super(RtiRegItem, self).asDict()
        dct['extensions'] = self.extensions
        return dct