Permalink
Sep 5, 2014
Feb 1, 2020
Sep 5, 2014
Jul 21, 2020
Dec 28, 2020
Dec 28, 2020
Dec 28, 2020
May 17, 2019
Sep 5, 2014
Feb 1, 2020
Jan 15, 2018
Apr 3, 2019
Apr 3, 2019
Feb 1, 2020
Apr 3, 2019
Dec 13, 2018
Dec 21, 2018
Oct 5, 2020
Dec 21, 2018
Dec 21, 2018
Sep 5, 2014
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
Dec 10, 2018
Jan 29, 2021
Sep 5, 2014
Sep 5, 2014
May 29, 2021
Jul 30, 2020
Jul 14, 2020
Jul 31, 2018
Sep 5, 2014
Jul 31, 2018
Dec 10, 2018
Nov 2, 2018
Jul 31, 2018
Sep 5, 2014
Sep 5, 2014
Sep 5, 2014
Jun 11, 2020
Dec 10, 2018
Dec 21, 2018
Sep 5, 2014
Sep 5, 2014
Jun 11, 2020
May 4, 2021
Sep 5, 2014
Jun 11, 2020
May 27, 2018
Apr 18, 2020
Feb 1, 2020
Dec 21, 2018
Feb 3, 2018
Feb 1, 2020
Jul 4, 2020
Jul 4, 2020
Jul 30, 2020
Jul 30, 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
Mar 7, 2018
Sep 5, 2014
Sep 5, 2014
Dec 21, 2018
Sep 5, 2014
Sep 5, 2014
Mar 7, 2018
Jul 24, 2021
Nov 9, 2015
May 17, 2019
Feb 26, 2018
Jul 21, 2020
Dec 28, 2020
Feb 26, 2018
Dec 28, 2020
Dec 13, 2018
Sep 5, 2014
Sep 5, 2014
Sep 5, 2014
Sep 5, 2014
Mar 7, 2018
Jan 29, 2021
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
Dec 28, 2020
Dec 1, 2018
Sep 5, 2014
Sep 5, 2014
Jun 29, 2020
Jun 28, 2018
May 16, 2020
May 16, 2020
Feb 1, 2020
Mar 7, 2018
Aug 2, 2018
Sep 5, 2014
Newer
100644
1243 lines (1123 sloc)
36.4 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
32
33
var set_ops = ["eq", "le", "lt", "ge", "gt",
34
"sub", "rsub", "and", "or", "xor"]
35
36
// methods to compare non set-like views
37
function is_sublist(t1, t2){
38
// Return true if all elements of t1 are in t2
39
for(var i = 0, ilen = t1.length; i < ilen; i++){
40
var x = t1[i],
41
flag = false
42
for(var j = 0, jlen = t2.length; j < jlen; j++){
43
if($B.rich_comp("__eq__", x, t2[j])){
44
t2.splice(j, 1)
45
flag = true
46
break
47
}
48
}
49
if(! flag){
50
return false
51
}
52
}
53
return true
54
}
55
56
dict_view_op = {
57
__eq__: function(t1, t2){
58
return t1.length == t2.length && is_sublist(t1, t2)
59
},
60
__ne__: function(t1, t2){
61
return ! dict_view_op.__eq__(t1, t2)
62
},
63
__lt__: function(t1, t2){
64
return t1.length < t2.length && is_sublist(t1, t2)
65
},
66
__gt__: function(t1, t2){
67
return dict_view_op.__lt__(t2, t1)
68
},
69
__le__: function(t1, t2){
70
return t1.length <= t2.length && is_sublist(t1, t2)
71
},
72
__ge__: function(t1, t2){
73
return dict_view_op.__le__(t2, t1)
74
},
75
__and__: function(t1, t2){
76
var items = []
77
for(var i = 0, ilen = t1.length; i < ilen; i++){
78
var x = t1[i]
79
flag = false
80
for(var j = 0, jlen = t2.length; j < jlen; j++){
81
if($B.rich_comp("__eq__", x, t2[j])){
82
t2.splice(j, 1)
83
items.push(x)
84
break
85
}
86
}
87
}
88
return items
89
},
90
__or__: function(t1, t2){
91
var items = t1
92
for(var j = 0, jlen = t2.length; j < jlen; j++){
93
var y = t2[j],
94
flag = false
95
for(var i = 0, ilen = t1.length; i < ilen; i++){
96
if($B.rich_comp("__eq__", y, t1[i])){
97
t2.splice(j, 1)
98
flag = true
99
break
100
}
101
}
102
if(! flag){
103
items.push(y)
104
}
105
}
106
return items
107
}
124
for(var i = 0, len = set_ops.length; i < len; i++){
125
var op = "__" + set_ops[i] + "__"
126
klass[op] = (function(op){
127
return function(self, other){
128
// compare set of items to other
129
if(self.set_like){
130
return _b_.set[op](_b_.set.$factory(self),
131
_b_.set.$factory(other))
132
}else{
133
// Non-set like views can only be compared to
134
// instances of the same class
135
if(other.__class__ !== klass){
136
return false
138
var other_items = _b_.list.$factory(other)
139
return dict_view_op[op](self.items, other_items)
147
it.test_change = function(){
148
return self.dict.$version != self.dict_version
149
}
157
klass.__repr__ = function(self){
158
return klass.$infos.__name__ + '(' + _b_.repr(self.items) + ')'
159
}
160
175
}
176
177
dict.$to_obj = function(d){
178
// Function applied to dictionary that only have string keys,
179
// return a Javascript objects with the kays mapped to the value,
180
// excluding the insertion rank
181
var res = {}
182
for(var key in d.$string_dict){
183
res[key] = d.$string_dict[key][0]
184
}
185
return res
186
}
187
197
if(val === undefined){val = _b_.NotImplemented}
198
else if(val === null){val = $N}
203
for(var k in d.$numeric_dict){
204
items.push([parseFloat(k), d.$numeric_dict[k]])
205
}
211
for(var k in d.$object_dict){
212
d.$object_dict[k].forEach(function(item){
213
items.push(item)
214
})
215
}
217
// sort by insertion order
218
items.sort(function(a, b){
219
return a[1][1] - b[1][1]
220
})
221
items = items.map(function(item){return [item[0], item[1][0]]})
226
}else{
227
items.__class__ = _b_.tuple
228
return items.map(function(item){
229
item.__class__ = _b_.tuple; return item}
230
)
231
}
242
si(left, _l[i][0], _l[i][1])
243
if(right.$version != right_version){
244
throw _b_.RuntimeError.$factory("dict mutated during update")
245
}
246
}
249
function rank(self, hash, key){
250
// Search if object key, with hash = hash(key), is in
251
// self.$object_dict
252
var pairs = self.$object_dict[hash]
253
if(pairs !== undefined){
254
for(var i = 0, len = pairs.length; i < len; i++){
255
if($B.rich_comp("__eq__", key, pairs[i][0])){
256
return i
257
}
258
}
259
}
260
return -1
261
}
262
269
dict.__class_getitem__ = function(cls, item){
270
// PEP 585
271
// Set as a classmethod at the end of this script, after $B.set_func_names()
272
if(! Array.isArray(item)){
273
item = [item]
274
}
275
return $B.GenericAlias.$factory(cls, item)
276
}
277
279
var $ = $B.args("__contains__", 2, {self: null, key: null},
280
["self", "key"], arguments, {}, null, null),
292
return self.$numeric_dict[key] !== undefined
293
}
294
295
var hash = _b_.hash(key)
296
if(self.$str_hash[hash] !== undefined &&
305
}
306
309
var $ = $B.args("__eq__", 2, {self: null, arg: null},
310
["self", "arg"], arguments, {}, null, null),
319
switch(typeof arg){
320
case "string":
321
if(self.$string_dict[arg] === undefined){
341
if((ix = rank(self, hash, arg)) > -1){
342
self.$object_dict[hash].splice(ix, 1)
343
}else{
349
}
350
352
var $ = $B.args("__eq__", 2, {self: null, other: null},
353
["self", "other"], arguments, {}, null, null),
359
if(self.$jsobj){self = jsobj2dict(self.$jsobj)}
360
if(other.$jsobj){other = jsobj2dict(other.$jsobj)}
371
if(!$B.rich_comp("__eq__", other.$numeric_dict[k][0],
372
self.$numeric_dict[k][0])){
376
var pairs = other.$object_dict[k],
377
flag = false
378
for(var i = 0, len = pairs.length; i < len; i++){
379
if($B.rich_comp("__eq__", k, pairs[i][0]) &&
380
$B.rich_comp("__eq__", self.$numeric_dict[k],
381
pairs[i][1])){
382
flag = true
383
break
384
}
399
var pairs = self.$object_dict[hash]
400
// Get all (key, value) pairs in other that have the same hash
401
var other_pairs = []
402
if(other.$numeric_dict[hash] !== undefined){
403
other_pairs.push([hash, other.$numeric_dict[hash]])
404
}
406
other_pairs = other_pairs.concat(other.$object_dict[hash])
407
}
408
if(other_pairs.length == 0){
409
return false
410
}
411
for(var i = 0, len_i = pairs.length; i < len_i; i++){
412
var flag = false
413
var key = pairs[i][0],
415
for(var j = 0, len_j = other_pairs.length; j < len_j; j++){
416
if($B.rich_comp("__eq__", key, other_pairs[j][0]) &&
428
}
429
431
var $ = $B.args("__getitem__", 2, {self: null, arg: null},
432
["self", "arg"], arguments, {}, null, null),
462
break
463
}
464
465
// since the key is more complex use 'default' method of getting item
466
491
if(! ignore_missing){
492
if(self.__class__ !== dict && ! ignore_missing){
493
try{
506
}
507
509
516
if(item.length != 2){
517
throw _b_.ValueError.$factory("dictionary " +
518
`update sequence element #${i} has length 1; 2 is required`)
519
}
527
if(item[0] != 0 && item[0] != 1){
528
self.$numeric_dict[item[0]] = [item[1], self.$order++]
529
self.$version++
530
break
531
}
545
for(var key in first){
546
self.$string_dict[key] = [first[key], self.$order++]
547
}
548
return _b_.None
549
}else if(first.$jsobj){
550
self.$jsobj = {}
551
for(var attr in first.$jsobj){
552
self.$jsobj[attr] = first.$jsobj[attr]
558
}
562
arguments, {}, "first", "second")
563
var args = $.first
564
if(args.length > 1){
565
throw _b_.TypeError.$factory("dict expected at most 1 argument" +
566
", got 2")
567
}else if(args.length == 1){
568
args = args[0]
569
if(args.__class__ === dict){
570
['$string_dict', '$str_hash', '$numeric_dict', '$object_dict'].
571
forEach(function(d){
572
for(key in args[d]){self[d][key] = args[d][key]}
573
})
577
var keys = $B.$getattr(args, "keys", null)
578
if(keys !== null){
579
var gi = $B.$getattr(args, "__getitem__", null)
580
if(gi !== null){
581
// has keys and __getitem__ : it's a mapping, iterate on
582
// keys and values
583
gi = $B.$call(gi)
584
var kiter = _b_.iter($B.$call(keys)())
585
while(true){
586
try{
587
var key = _b_.next(kiter),
588
value = gi(key)
589
dict.__setitem__(self, key, value)
590
}catch(err){
591
if(err.__class__ === _b_.StopIteration){
592
break
593
}
594
throw err
595
}
596
}
597
return $N
598
}
599
}
600
if(! Array.isArray(args)){
601
args = _b_.list.$factory(args)
602
}
603
// Form "dict([[key1, value1], [key2,value2], ...])"
605
}
623
}
624
627
}
628
629
dict.__ior__ = function(self, other){
630
// PEP 584
631
dict.update(self, other)
632
return self
633
}
634
643
for(var k in self.$numeric_dict){_count++}
644
for(var k in self.$string_dict){_count++}
645
for(var hash in self.$object_dict){
646
_count += self.$object_dict[hash].length
647
}
651
653
673
dict.__or__ = function(self, other){
674
// PEP 584
675
if(! _b_.isinstance(other, dict)){
676
return _b_.NotImplemented
677
}
678
var res = dict.copy(self)
679
dict.update(res, other)
680
return res
681
}
682
683
function __newobj__(){
684
// __newobj__ is called with a generator as only argument
685
var $ = $B.args('__newobj__', 0, {}, [], arguments, {}, 'args', null),
686
args = $.args
687
var res = $B.empty_dict()
688
res.__class__ = args[0]
689
return res
690
}
691
692
dict.__reduce_ex__ = function(self, protocol){
693
return $B.fast_tuple([
694
__newobj__,
695
$B.fast_tuple([self.__class__]),
696
_b_.None,
697
_b_.None,
698
dict.items(self)])
699
}
700
720
}
721
722
dict.__ror__ = function(self, other){
723
// PEP 584
724
if(! _b_.isinstance(other, dict)){
725
return _b_.NotImplemented
726
}
727
var res = dict.copy(other)
728
dict.update(res, self)
729
return res
730
}
731
734
["self", "key", "value"], arguments, {}, null, null)
735
return dict.$setitem($.self, $.key, $.value)
736
}
741
// If key is a string, set:
742
// - $string_dict[key] = [value, order] where "order" is an auto-increment
743
// unique id to keep track of insertion order
744
// - $str_hash[hash(key)] to key
745
//
746
// If key is a number, set $numeric_dict[key] = value
747
//
748
// If key is another object, compute its hash value:
749
// - if the hash is a key of $str_hash, and key == $str_hash[hash],
750
// replace $string_dict[$str_hash[hash]] by value
751
// - if the hash is a key of $numeric_dict, and hash == key, replace
752
// $numeric_dict[hash] by value
753
// - if the hash is a key of $object_dict: $object_dict[hash] is a list
754
// of [k, v] pairs. If key is equal to one of the "k", replace the
755
// matching v by value. Otherwise, add [key, value] to the list
756
// - else set $object_dict[hash] = [[key, value]]
757
//
758
// In all cases, increment attribute $version, used to detect dictionary
761
// Parameter $hash is only set if this method is called by setdefault.
762
// In this case the hash of key has already been computed and we
763
// know that the key is not present in the dictionary, so it's no
764
// use computing hash(key) again, nor testing equality of keys
773
// If class attribute __init__ or __new__ are reset,
774
// the factory function has to change
775
self.$jsobj.$factory = $B.$instance_creator(self.$jsobj)
776
}
777
}else{
788
if(self.$string_dict === undefined){
789
console.log("pas de string dict", self, key, value)
790
}
791
if(self.$string_dict[key] !== undefined){
792
self.$string_dict[key][0] = value
793
}else{
794
self.$string_dict[key] = [value, self.$order++]
795
self.$str_hash[str_hash(key)] = key
796
self.$version++
797
}
800
if(self.$numeric_dict[key] !== undefined){
801
// existing key: preserve order
802
self.$numeric_dict[key][0] = value
803
}else{
804
// special case for 0 and 1 if True or False are keys
805
var done = false
806
if((key == 0 || key == 1) &&
807
self.$object_dict[key] !== undefined){
808
for(const item of self.$object_dict[key]){
809
if((key == 0 && item[0] === false) ||
810
(key == 1 && item[0] === true)){
811
// replace value
812
item[1][0] = value
813
done = true
814
}
815
}
816
}
817
if(! done){
818
// new key
819
self.$numeric_dict[key] = [value, self.$order++]
820
}
824
case "boolean":
825
// true replaces 1 and false replaces 0
826
var num = key ? 1 : 0
827
if(self.$numeric_dict[num] !== undefined){
828
var order = self.$numeric_dict[num][1] // preserve order
829
self.$numeric_dict[num] = [value, order]
830
return
831
}
832
if(self.$object_dict[num] !== undefined){
833
self.$object_dict[num].push([key, [value, self.$order++]])
834
}else{
835
self.$object_dict[num] = [[key, [value, self.$order++]]]
836
}
856
// If $setitem is called from setdefault, don't test equality of key
857
// with any object
858
if($hash){
859
if(self.$object_dict[$hash] !== undefined){
863
}
864
self.$version++
865
return $N
866
}
867
var ix = rank(self, hash, key)
868
if(ix > -1){
869
// reset value
880
}
881
882
// add "reflected" methods
884
886
// Remove all items from the dictionary.
906
}
907
909
// Return a shallow copy of the dictionary
915
return res
916
}
917
920
var $ = $B.args("fromkeys", 3, {cls: null, keys: null, value: null},
921
["cls", "keys", "value"], arguments, {value: _b_.None}, null, null),
925
// class method
930
while(1){
931
try{
932
var key = _b_.next(keys_iter)
933
if(klass === dict){dict.$setitem(res, key, value)}
934
else{$B.$getattr(res, "__setitem__")(key, value)}
935
}catch(err){
937
return res
938
}
939
throw err
940
}
941
}
942
}
943
945
var $ = $B.args("get", 3, {self: null, key: null, _default: null},
946
["self", "key", "_default"], arguments, {_default: $N}, null, null)
948
try{
949
// call $getitem with ignore_missign set to true
950
return dict.$getitem($.self, $.key, true)
951
}catch(err){
952
if(_b_.isinstance(err, _b_.KeyError)){return $._default}
953
else{throw err}
954
}
955
}
956
957
var dict_items = $B.make_view("dict_items", true)
958
dict_items.$iterator = $B.make_iterator_class("dict_itemiterator")
962
var _len = arguments.length - 1,
963
_msg = "items() takes no arguments (" + _len + " given)"
966
var items = to_list(self),
967
set_like = true
968
// Check if all values are hashable
969
for(var i = 0, len = items.length; i < len; i++){
970
try{
971
_b_.hash(items[i][1])
972
}catch(err){
973
set_like = false
974
break
975
}
976
}
977
var values = to_list(self)
978
var it = dict_items.$factory(self, values, set_like)
979
it.dict_version = self.$version
989
var _len = arguments.length - 1,
990
_msg = "keys() takes no arguments (" + _len + " given)"
993
var it = dict_keys.$factory(self, to_list(self, 0), true)
994
it.dict_version = self.$version
1000
var missing = {},
1001
$ = $B.args("pop", 3, {self: null, key: null, _default: null},
1002
["self", "key", "_default"], arguments, {_default: missing}, null, null),
1007
try{
1010
return res
1011
}catch(err){
1014
throw err
1015
}
1016
throw err
1017
}
1018
}
1019
1030
}
1031
1034
var $ = $B.args("setdefault", 3, {self: null, key: null, _default: null},
1035
["self", "key", "_default"], arguments, {_default: $N}, null, null),
1039
try{
1040
// Pass 3rd argument to dict.$getitem to avoid using __missing__
1041
// Cf. issue #1598
1042
return dict.$getitem(self, key, true)
1043
}catch(err){
1048
var hash = key.$hash
1049
key.$hash = undefined
1050
dict.$setitem(self, key, _default, hash)
1051
return _default
1052
}
1053
}
1054
1057
var $ = $B.args("update", 1, {"self": null}, ["self"], arguments,
1058
{}, "args", "kw"),
1059
self = $.self,
1060
args = $.args,
1061
kw = $.kw
1062
if(args.length > 0){
1063
var o = args[0]
1070
var _keys = _b_.list.$factory($B.$call($B.$getattr(o, "keys"))())
1071
for(var i = 0, len = _keys.length; i < len; i++){
1073
dict.$setitem(self, _keys[i], _value)
1074
}
1075
}else{
1076
var it = _b_.iter(o),
1077
i = 0
1078
while(true){
1079
try{
1080
var item = _b_.next(it)
1081
}catch(err){
1082
if(err.__class__ === _b_.StopIteration){break}
1083
throw err
1084
}
1085
try{
1086
key_value = _b_.list.$factory(item)
1087
}catch(err){
1088
throw _b_.TypeError.$factory("cannot convert dictionary" +
1089
" update sequence element #" + i + " to a sequence")
1090
}
1091
if(key_value.length !== 2){
1092
throw _b_.ValueError.$factory("dictionary update " +
1093
"sequence element #" + i + " has length " +
1094
key_value.length + "; 2 is required")
1095
}
1096
dict.$setitem(self, key_value[0], key_value[1])
1097
i++
1100
}
1104
}
1105
1106
var dict_values = $B.make_view("dict_values")
1107
dict_values.$iterator = $B.make_iterator_class("dict_valueiterator")
1111
var _len = arguments.length - 1,
1112
_msg = "values() takes no arguments (" + _len + " given)"
1116
var it = dict_values.$factory(self, values, false)
1117
it.dict_version = self.$version
1123
var args = [res]
1124
for(var i = 0, len = arguments.length; i < len ; i++){
1125
args.push(arguments[i])
1126
}
1127
dict.__init__.apply(null, args)
1128
return res
1129
}
1131
_b_.dict = dict
1137
$B.empty_dict = function(){
1138
return {
1139
__class__: dict,
1140
$numeric_dict : {},
1141
$object_dict : {},
1142
$string_dict : {},
1143
$str_hash: {},
1149
// This must be done after set_func_names, otherwise dict.fromkeys doesn't
1150
// have the attribute $infos
1151
dict.fromkeys = _b_.classmethod.$factory(dict.fromkeys)
1152
1153
$B.getset_descriptor = $B.make_class("getset_descriptor",
1154
function(klass, attr){
1155
return {
1156
__class__: $B.getset_descriptor,
1158
cls: klass,
1159
attr: attr
1160
}
1161
}
1162
)
1163
1164
$B.getset_descriptor.__repr__ = $B.getset_descriptor.__str__ = function(self){
1165
return `<attribute '${self.attr}' of '${self.cls.$infos.__name__}' objects>`
1166
}
1167
1168
$B.set_func_names($B.getset_descriptor, "builtins")
1169
1174
// obj is a dictionary, with $string_dict table such that
1175
// obj.$string_dict[key] = [value, rank]
1176
// Transform it into an object with attribute $jsobj such that
1177
// res.$jsobj[key] = value
1178
var res = $B.obj_dict(dict.$to_obj(obj))
1190
throw _b_.TypeError.$factory("'mappingproxy' object does not support " +
1191
"item assignment")
1194
for(var attr in dict){
1195
if(mappingproxy[attr] !== undefined ||
1196
["__class__", "__mro__", "__new__", "__init__", "__delitem__",
1197
"clear", "fromkeys", "pop", "popitem", "setdefault",
1198
"update"].indexOf(attr) > -1){
1199
continue
1200
}
1201
if(typeof dict[attr] == "function"){
1202
mappingproxy[attr] = (function(key){
1203
return function(){
1204
return dict[key].apply(null, arguments)
1205
}
1206
})(attr)
1207
}else{
1208
mappingproxy[attr] = dict[attr]
1209
}
1210
}
1211
1243
})(__BRYTHON__)