Permalink
Sep 5, 2014
Feb 1, 2020
Sep 5, 2014
May 17, 2019
May 17, 2019
May 17, 2019
Sep 5, 2014
Feb 1, 2020
Jan 15, 2018
Apr 3, 2019
Apr 3, 2019
Feb 1, 2020
Apr 3, 2019
Apr 3, 2019
Dec 13, 2018
Dec 21, 2018
Dec 21, 2018
Nov 6, 2019
Dec 21, 2018
Sep 5, 2014
Dec 10, 2018
Dec 10, 2018
Dec 10, 2018
Dec 10, 2018
Dec 21, 2018
Sep 5, 2014
Mar 7, 2018
Feb 26, 2018
Feb 1, 2020
Dec 21, 2018
Dec 21, 2018
Dec 21, 2018
Dec 21, 2018
Sep 5, 2014
Dec 10, 2018
Apr 18, 2020
Dec 10, 2018
Dec 10, 2018
Dec 10, 2018
Sep 5, 2014
Sep 5, 2014
Jul 31, 2018
Sep 5, 2014
Jul 31, 2018
Dec 10, 2018
Nov 2, 2018
Jul 31, 2018
Sep 5, 2014
Dec 10, 2018
Sep 5, 2014
Sep 5, 2014
Dec 10, 2018
Dec 21, 2018
Sep 5, 2014
Sep 5, 2014
Nov 28, 2018
Apr 18, 2020
Sep 5, 2014
May 27, 2018
Apr 18, 2020
Feb 1, 2020
Dec 21, 2018
Oct 24, 2018
Feb 3, 2018
Feb 1, 2020
Dec 21, 2018
Dec 21, 2018
Sep 5, 2014
Sep 5, 2014
Sep 5, 2014
Sep 5, 2014
Sep 5, 2014
Sep 5, 2014
Sep 5, 2014
Mar 7, 2018
Sep 5, 2014
Sep 5, 2014
Dec 21, 2018
Sep 5, 2014
Sep 5, 2014
Mar 7, 2018
Nov 9, 2015
May 17, 2019
Feb 26, 2018
Apr 3, 2019
May 17, 2019
Feb 26, 2018
Apr 3, 2019
Dec 13, 2018
Sep 5, 2014
Sep 5, 2014
Sep 5, 2014
Sep 5, 2014
Mar 7, 2018
Sep 5, 2014
Dec 21, 2018
Sep 5, 2014
Mar 7, 2018
Feb 26, 2018
Apr 14, 2019
Dec 13, 2018
Sep 5, 2014
Sep 5, 2014
May 17, 2019
Feb 26, 2018
Apr 3, 2019
Dec 1, 2018
Sep 5, 2014
Sep 5, 2014
Jun 28, 2018
Feb 1, 2020
Mar 7, 2018
Aug 2, 2018
Apr 18, 2020
Feb 26, 2018
Sep 5, 2014
Newer
100644
1021 lines (912 sloc)
30.1 KB
1
;(function($B){
2
3
/*
4
Implementation of Python dictionaries
5
6
We can't use Javascript's Map here, because the behaviour is not exactly the
7
same (eg with keys that are instances of classes with a __hash__ method...)
8
and because Map is much slower than regular Javascript objects.
9
10
A Python dictionary is implemented as a Javascript objects with these
11
attributes:
12
. $version: an integer with an initial value of 0, incremented at each
13
insertion
14
. $numeric_dict: for keys of type int
15
. $string_dict and $str_hash: for keys of type str
16
. $object_dict: for keys of other types
17
18
The value associated to a key in $numeric_dict and $string_dict is a pair
19
[value, rank] where "value" is the value associated with the key and "rank"
20
is the value of the dict attribute $version when the pair is inserted. This
21
is required to keep track of the insertion order, mandatory since Python 3.7.
22
23
For keys that are not str or int, their hash value is computed. Since several
34
35
var set_ops = ["eq", "add", "sub", "and", "or", "xor", "le", "lt", "ge", "gt"]
36
37
$B.make_view = function(name, set_like){
38
var klass = $B.make_class(name, function(items){
39
return {
40
__class__: klass,
41
__dict__: _b_.dict.$factory(),
42
counter: -1,
43
items: items,
44
len: items.length
45
}
46
})
47
48
if(set_like){
49
for(var i = 0, len = set_ops.length; i < len; i++){
50
var op = "__" + set_ops[i] + "__"
51
klass[op] = (function(op){
52
return function(self, other){
53
// compare set of items to other
54
return _b_.set[op](_b_.set.$factory(self),
55
_b_.set.$factory(other))
56
}
57
})(op)
58
}
59
}
60
klass.__iter__ = function(self){
61
var it = klass.$iterator.$factory(self.items)
62
it.len_func = self.len_func
63
return it
64
}
70
klass.__repr__ = function(self){
71
return klass.$infos.__name__ + '(' + _b_.repr(self.items) + ')'
72
}
73
75
return klass
76
}
77
78
// Special version of __next__ for iterators on dict keys / values / items.
79
// Checks that the dictionary size didn't change during iteration.
80
function dict_iterator_next(self){
81
if(self.len_func() != self.len){
82
throw RuntimeError.$factory("dictionary changed size during iteration")
83
}
84
self.counter++
85
if(self.counter < self.items.length){
86
return self.items[self.counter]
87
}
88
throw _b_.StopIteration.$factory("StopIteration")
89
}
90
100
}
101
102
dict.$to_obj = function(d){
103
// Function applied to dictionary that only have string keys,
104
// return a Javascript objects with the kays mapped to the value,
105
// excluding the insertion rank
106
var res = {}
107
for(var key in d.$string_dict){
108
res[key] = d.$string_dict[key][0]
109
}
110
return res
111
}
112
122
if(val === undefined){val = _b_.NotImplemented}
123
else if(val === null){val = $N}
127
}else{
128
for(var k in d.$numeric_dict){
129
items.push([parseFloat(k), d.$numeric_dict[k]])
130
}
134
for(var k in d.$object_dict){
135
d.$object_dict[k].forEach(function(item){
136
items.push(item)
137
})
138
}
139
// sort by insertion order
140
items.sort(function(a, b){
141
return a[1][1] - b[1][1]
142
})
143
items = items.map(function(item){return [item[0], item[1][0]]})
146
if(ix !== undefined){
147
return items.map(function(item){return item[ix]})
148
}else{
149
items.__class__ = _b_.tuple
150
return items.map(function(item){
151
item.__class__ = _b_.tuple; return item}
152
)
153
}
156
$B.dict_to_list = to_list // used in py_types.js
157
158
// Special version of __next__ for iterators on dict keys / values / items.
159
// Checks that the dictionary size didn't change during iteration.
160
function dict_iterator_next(self){
161
if(self.len_func() != self.len){
162
throw RuntimeError.$factory("dictionary changed size during iteration")
163
}
164
self.counter++
165
if(self.counter < self.items.length){
166
return self.items[self.counter]
178
si(left, _l[i][0], _l[i][1])
179
if(right.$version != right_version){
180
throw _b_.RuntimeError.$factory("dict mutated during update")
181
}
182
}
185
function rank(self, hash, key){
186
// Search if object key, with hash = hash(key), is in
187
// self.$object_dict
188
var pairs = self.$object_dict[hash]
189
if(pairs !== undefined){
190
for(var i = 0, len = pairs.length; i < len; i++){
191
if($B.rich_comp("__eq__", key, pairs[i][0])){
192
return i
193
}
194
}
195
}
196
return -1
197
}
198
207
var $ = $B.args("__contains__", 2, {self: null, key: null},
208
["self", "key"], arguments, {}, null, null),
211
if(self.$is_namespace){key = $B.to_alias(key)} // issue 1244
212
213
if(self.$jsobj){
214
return self.$jsobj[key] !== undefined
215
}
221
return self.$numeric_dict[key] !== undefined
222
}
223
224
var hash = _b_.hash(key)
225
if(self.$str_hash[hash] !== undefined &&
226
$B.rich_comp("__eq__", key, self.$str_hash[hash])){return true}
227
if(self.$numeric_dict[hash] !== undefined &&
228
$B.rich_comp("__eq__", key, hash)){return true}
229
return rank(self, hash, key) > -1
230
}
231
234
var $ = $B.args("__eq__", 2, {self: null, arg: null},
235
["self", "arg"], arguments, {}, null, null),
240
if(self.$jsobj[arg] === undefined){throw KeyError.$factory(arg)}
241
delete self.$jsobj[arg]
244
switch(typeof arg){
245
case "string":
246
if(self.$string_dict[arg] === undefined){
247
throw KeyError.$factory(_b_.str.$factory(arg))
248
}
249
delete self.$string_dict[arg]
250
delete self.$str_hash[str_hash(arg)]
253
case "number":
254
if(self.$numeric_dict[arg] === undefined){
255
throw KeyError.$factory(_b_.str.$factory(arg))
266
if((ix = rank(self, hash, arg)) > -1){
267
self.$object_dict[hash].splice(ix, 1)
268
}else{
269
throw KeyError.$factory(_b_.str.$factory(arg))
274
}
275
277
var $ = $B.args("__eq__", 2, {self: null, other: null},
278
["self", "other"], arguments, {}, null, null),
284
if(self.$jsobj){self = jsobj2dict(self.$jsobj)}
285
if(other.$jsobj){other = jsobj2dict(other.$jsobj)}
296
if(!$B.rich_comp("__eq__", other.$numeric_dict[k][0],
297
self.$numeric_dict[k][0])){
301
var pairs = other.$object_dict[k],
302
flag = false
303
for(var i = 0, len = pairs.length; i < len; i++){
304
if($B.rich_comp("__eq__", k, pairs[i][0]) &&
305
$B.rich_comp("__eq__", self.$numeric_dict[k],
306
pairs[i][1])){
307
flag = true
308
break
309
}
324
var pairs = self.$object_dict[hash]
325
// Get all (key, value) pairs in other that have the same hash
326
var other_pairs = []
327
if(other.$numeric_dict[hash] !== undefined){
328
other_pairs.push([hash, other.$numeric_dict[hash]])
329
}
331
other_pairs = other_pairs.concat(other.$object_dict[hash])
332
}
333
if(other_pairs.length == 0){
334
return false
335
}
336
for(var i = 0, len_i = pairs.length; i < len_i; i++){
337
var flag = false
338
var key = pairs[i][0],
340
for(var j = 0, len_j = other_pairs.length; j < len_j; j++){
341
if($B.rich_comp("__eq__", key, other_pairs[j][0]) &&
353
}
354
356
var $ = $B.args("__getitem__", 2, {self: null, arg: null},
357
["self", "arg"], arguments, {}, null, null),
365
if(self.$jsobj[arg] === undefined){
366
if(self.$jsobj.hasOwnProperty(arg)){
367
return undefined
368
}
369
throw _b_.KeyError.$factory(arg)
370
}
373
374
switch(typeof arg){
375
case "string":
376
if(self.$string_dict[arg] !== undefined){
384
break
385
}
386
387
// since the key is more complex use 'default' method of getting item
388
401
}
402
if(isinstance(arg, _b_.str)){
403
// string subclass
404
var res = self.$string_dict[arg.valueOf()]
426
}
427
429
455
if(first === undefined){return $N}
456
if(second === undefined){
457
if(first.__class__ === $B.JSObject){
458
self.$jsobj = first.js
459
return $N
460
}else if(first.$jsobj){
461
self.$jsobj = {}
462
for(var attr in first.$jsobj){
463
self.$jsobj[attr] = first.$jsobj[attr]
469
}
473
arguments, {}, "first", "second")
474
var args = $.first
475
if(args.length > 1){
476
throw _b_.TypeError.$factory("dict expected at most 1 argument" +
477
", got 2")
478
}else if(args.length == 1){
479
args = args[0]
480
if(args.__class__ === dict){
481
['$string_dict', '$str_hash', '$numeric_dict', '$object_dict'].
482
forEach(function(d){
483
for(key in args[d]){self[d][key] = args[d][key]}
484
})
488
var keys = $B.$getattr(args, "keys", null)
489
if(keys !== null){
490
var gi = $B.$getattr(args, "__getitem__", null)
491
if(gi !== null){
492
// has keys and __getitem__ : it's a mapping, iterate on
493
// keys and values
494
gi = $B.$call(gi)
495
var kiter = _b_.iter($B.$call(keys)())
496
while(true){
497
try{
498
var key = _b_.next(kiter),
499
value = gi(key)
500
dict.__setitem__(self, key, value)
501
}catch(err){
502
if(err.__class__ === _b_.StopIteration){
503
break
504
}
505
throw err
506
}
507
}
508
return $N
509
}
510
}
511
if(! Array.isArray(args)){
512
args = _b_.list.$factory(args)
513
}
514
// Form "dict([[key1, value1], [key2,value2], ...])"
516
}
520
switch(typeof attr){
521
case "string":
522
self.$string_dict[attr] = kw[attr]
523
self.$str_hash[str_hash(attr)] = attr
524
break
525
case "number":
526
self.$numeric_dict[attr] = kw[attr]
527
break
528
default:
529
si(self, attr, kw[attr])
530
break
531
}
534
}
535
538
}
539
548
for(var k in self.$numeric_dict){_count++}
549
for(var k in self.$string_dict){_count++}
550
for(var hash in self.$object_dict){
551
_count += self.$object_dict[hash].length
552
}
556
558
571
if(cls !== dict){
572
instance.__dict__ = _b_.dict.$factory()
573
}
574
return instance
587
try{
588
res.push(repr(item[0]) + ": " + repr(item[1]))
589
}catch(err){
590
console.log("error", item)
591
throw err
592
}
596
}
597
600
["self", "key", "value"], arguments, {}, null, null)
601
return dict.$setitem($.self, $.key, $.value)
602
}
607
// If key is a string, set:
608
// - $string_dict[key] = [value, order] where "order" is an auto-increment
609
// unique id to keep track of insertion order
610
// - $str_hash[hash(key)] to key
611
//
612
// If key is a number, set $numeric_dict[key] = value
613
//
614
// If key is another object, compute its hash value:
615
// - if the hash is a key of $str_hash, and key == $str_hash[hash],
616
// replace $string_dict[$str_hash[hash]] by value
617
// - if the hash is a key of $numeric_dict, and hash == key, replace
618
// $numeric_dict[hash] by value
619
// - if the hash is a key of $object_dict: $object_dict[hash] is a list
620
// of [k, v] pairs. If key is equal to one of the "k", replace the
621
// matching v by value. Otherwise, add [key, value] to the list
622
// - else set $object_dict[hash] = [[key, value]]
623
//
624
// In all cases, increment attribute $version, used to detect dictionary
627
// Parameter $hash is only set if this method is called by setdefault.
628
// In this case the hash of key has already been computed and we
629
// know that the key is not present in the dictionary, so it's no
630
// use computing hash(key) again, nor testing equality of keys
632
if(self.$from_js){
633
// dictionary created by method to_dict of JSObject instances
634
value = $B.pyobj2jsobj(value)
635
}
639
// If class attribute __init__ or __new__ are reset,
640
// the factory function has to change
641
self.$jsobj.$factory = $B.$instance_creator(self.$jsobj)
642
}
643
}else{
651
if(self.$string_dict === undefined){
652
console.log("pas de string dict", self, key, value)
653
}
654
self.$string_dict[key] = [value, self.$version]
681
// If $setitem is called from setdefault, don't test equality of key
682
// with any object
683
if($hash){
684
if(self.$object_dict[$hash] !== undefined){
688
}
689
self.$version++
690
return $N
691
}
692
var ix = rank(self, hash, key)
693
if(ix > -1){
694
// reset value
705
}
706
710
711
// add "reflected" methods
713
715
// Remove all items from the dictionary.
734
}
735
737
// Return a shallow copy of the dictionary
743
return res
744
}
745
748
var $ = $B.args("fromkeys", 3, {cls: null, keys: null, value: null},
749
["cls", "keys", "value"], arguments, {value: _b_.None}, null, null),
753
// class method
758
while(1){
759
try{
760
var key = _b_.next(keys_iter)
761
if(klass === dict){dict.$setitem(res, key, value)}
762
else{$B.$getattr(res, "__setitem__")(key, value)}
763
}catch(err){
765
return res
766
}
767
throw err
768
}
769
}
770
}
771
773
var $ = $B.args("get", 3, {self: null, key: null, _default: null},
774
["self", "key", "_default"], arguments, {_default: $N}, null, null)
777
catch(err){
778
if(_b_.isinstance(err, _b_.KeyError)){return $._default}
779
else{throw err}
780
}
781
}
782
783
var dict_items = $B.make_view("dict_items", true)
784
dict_items.$iterator = $B.make_iterator_class("dict_itemiterator")
788
var _len = arguments.length - 1,
789
_msg = "items() takes no arguments (" + _len + " given)"
792
var it = dict_items.$factory(to_list(self))
793
it.len_func = function(){return dict.__len__(self)}
794
return it
797
var dict_keys = $B.make_view("dict_keys", true)
798
dict_keys.$iterator = $B.make_iterator_class("dict_keyiterator")
802
var _len = arguments.length - 1,
803
_msg = "keys() takes no arguments (" + _len + " given)"
806
var it = dict_keys.$factory(to_list(self, 0))
807
it.len_func = function(){return dict.__len__(self)}
808
return it
813
var missing = {},
814
$ = $B.args("pop", 3, {self: null, key: null, _default: null},
815
["self", "key", "_default"], arguments, {_default: missing}, null, null),
820
try{
823
return res
824
}catch(err){
827
throw err
828
}
829
throw err
830
}
831
}
832
843
}
844
847
var $ = $B.args("setdefault", 3, {self: null, key: null, _default: null},
848
["self", "key", "_default"], arguments, {_default: $N}, null, null),
854
catch(err){
859
var hash = key.$hash
860
key.$hash = undefined
861
dict.$setitem(self, key, _default, hash)
862
return _default
863
}
864
}
865
868
var $ = $B.args("update", 1, {"self": null}, ["self"], arguments,
869
{}, "args", "kw"),
870
self = $.self,
871
args = $.args,
872
kw = $.kw
873
if(args.length > 0){
874
var o = args[0]
875
if(isinstance(o, dict)){
881
var _keys = _b_.list.$factory($B.$call($B.$getattr(o, "keys"))())
882
for(var i = 0, len = _keys.length; i < len; i++){
884
dict.$setitem(self, _keys[i], _value)
885
}
886
}else{
887
var it = _b_.iter(o),
888
i = 0
889
while(true){
890
try{
891
var item = _b_.next(it)
892
}catch(err){
893
if(err.__class__ === _b_.StopIteration){break}
894
throw err
895
}
896
try{
897
key_value = _b_.list.$factory(item)
898
}catch(err){
899
throw _b_.TypeError.$factory("cannot convert dictionary" +
900
" update sequence element #" + i + " to a sequence")
901
}
902
if(key_value.length !== 2){
903
throw _b_.ValueError.$factory("dictionary update " +
904
"sequence element #" + i + " has length " +
905
key_value.length + "; 2 is required")
906
}
907
dict.$setitem(self, key_value[0], key_value[1])
908
i++
911
}
915
}
916
917
var dict_values = $B.make_view("dict_values")
918
dict_values.$iterator = $B.make_iterator_class("dict_valueiterator")
922
var _len = arguments.length - 1,
923
_msg = "values() takes no arguments (" + _len + " given)"
926
var it = dict_values.$factory(to_list(self, 1))
927
it.len_func = function(){return dict.__len__(self)}
928
return it
933
var args = [res]
934
for(var i = 0, len = arguments.length; i < len ; i++){
935
args.push(arguments[i])
936
}
937
dict.__init__.apply(null, args)
938
return res
939
}
941
_b_.dict = dict
945
// This must be done after set_func_names, otherwise dict.fromkeys doesn't
946
// have the attribute $infos
947
dict.fromkeys = _b_.classmethod.$factory(dict.fromkeys)
948
953
// obj is a dictionary, with $string_dict table such that
954
// obj.$string_dict[key] = [value, rank]
955
// Transform it into an object with attribute $jsobj such that
956
// res.$jsobj[key] = value
957
var res = $B.obj_dict(dict.$to_obj(obj))
967
throw _b_.TypeError.$factory("'mappingproxy' object does not support " +
968
"item assignment")
971
for(var attr in dict){
972
if(mappingproxy[attr] !== undefined ||
973
["__class__", "__mro__", "__new__", "__init__", "__delitem__",
974
"clear", "fromkeys", "pop", "popitem", "setdefault",
975
"update"].indexOf(attr) > -1){
976
continue
977
}
978
if(typeof dict[attr] == "function"){
979
mappingproxy[attr] = (function(key){
980
return function(){
981
return dict[key].apply(null, arguments)
982
}
983
})(attr)
984
}else{
985
mappingproxy[attr] = dict[attr]
986
}
987
}
988
995
if(x[attr] === null){
996
d.$string_dict[attr] = [_b_.None, d.$version]
997
}else if(x[attr] === undefined){
1012
if(klass !== undefined && klass.$native){
1013
throw _b_.AttributeError.$factory(klass.__name__ +
1021
})(__BRYTHON__)