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
Oct 19, 2021
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
Oct 19, 2021
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
Oct 19, 2021
Oct 18, 2021
Oct 18, 2021
Oct 19, 2021
Oct 19, 2021
Oct 18, 2021
Oct 19, 2021
Oct 18, 2021
Oct 19, 2021
Sep 5, 2014
Newer
100644
1402 lines (1265 sloc)
40.6 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
198
if(val === undefined){val = _b_.NotImplemented}
199
else if(val === null){val = $N}
204
for(var k in d.$numeric_dict){
205
items.push([parseFloat(k), d.$numeric_dict[k]])
206
}
212
for(var k in d.$object_dict){
213
d.$object_dict[k].forEach(function(item){
214
items.push(item)
215
})
216
}
218
// sort by insertion order
219
items.sort(function(a, b){
220
return a[1][1] - b[1][1]
221
})
222
items = items.map(function(item){return [item[0], item[1][0]]})
227
}else{
228
items.__class__ = _b_.tuple
229
return items.map(function(item){
230
item.__class__ = _b_.tuple; return item}
231
)
232
}
243
si(left, _l[i][0], _l[i][1])
244
if(right.$version != right_version){
245
throw _b_.RuntimeError.$factory("dict mutated during update")
246
}
247
}
250
function rank(self, hash, key){
251
// Search if object key, with hash = hash(key), is in
252
// self.$object_dict
253
var pairs = self.$object_dict[hash]
254
if(pairs !== undefined){
255
for(var i = 0, len = pairs.length; i < len; i++){
256
if($B.rich_comp("__eq__", key, pairs[i][0])){
257
return i
258
}
259
}
260
}
261
return -1
262
}
263
270
dict.__class_getitem__ = function(cls, item){
271
// PEP 585
272
// Set as a classmethod at the end of this script, after $B.set_func_names()
273
if(! Array.isArray(item)){
274
item = [item]
275
}
276
return $B.GenericAlias.$factory(cls, item)
277
}
278
280
var $ = $B.args("__contains__", 2, {self: null, key: null},
281
["self", "key"], arguments, {}, null, null),
293
return self.$numeric_dict[key] !== undefined
294
}
295
296
var hash = _b_.hash(key)
297
if(self.$str_hash[hash] !== undefined &&
306
}
307
310
var $ = $B.args("__eq__", 2, {self: null, arg: null},
311
["self", "arg"], arguments, {}, null, null),
320
switch(typeof arg){
321
case "string":
322
if(self.$string_dict[arg] === undefined){
342
if((ix = rank(self, hash, arg)) > -1){
343
self.$object_dict[hash].splice(ix, 1)
344
}else{
350
}
351
353
var $ = $B.args("__eq__", 2, {self: null, other: null},
354
["self", "other"], arguments, {}, null, null),
360
if(self.$jsobj){self = jsobj2dict(self.$jsobj)}
361
if(other.$jsobj){other = jsobj2dict(other.$jsobj)}
372
if(!$B.rich_comp("__eq__", other.$numeric_dict[k][0],
373
self.$numeric_dict[k][0])){
377
var pairs = other.$object_dict[k],
378
flag = false
379
for(var i = 0, len = pairs.length; i < len; i++){
380
if($B.rich_comp("__eq__", k, pairs[i][0]) &&
381
$B.rich_comp("__eq__", self.$numeric_dict[k],
382
pairs[i][1])){
383
flag = true
384
break
385
}
400
var pairs = self.$object_dict[hash]
401
// Get all (key, value) pairs in other that have the same hash
402
var other_pairs = []
403
if(other.$numeric_dict[hash] !== undefined){
404
other_pairs.push([hash, other.$numeric_dict[hash]])
405
}
407
other_pairs = other_pairs.concat(other.$object_dict[hash])
408
}
409
if(other_pairs.length == 0){
410
return false
411
}
412
for(var i = 0, len_i = pairs.length; i < len_i; i++){
413
var flag = false
414
var key = pairs[i][0],
416
for(var j = 0, len_j = other_pairs.length; j < len_j; j++){
417
if($B.rich_comp("__eq__", key, other_pairs[j][0]) &&
429
}
430
432
var $ = $B.args("__getitem__", 2, {self: null, arg: null},
433
["self", "arg"], arguments, {}, null, null),
442
if(self.$exclude && self.$exclude(arg)){
443
throw _b_.KeyError.$factory(arg)
444
}
466
break
467
}
468
469
// since the key is more complex use 'default' method of getting item
470
495
if(! ignore_missing){
496
if(self.__class__ !== dict && ! ignore_missing){
497
try{
510
}
511
513
520
if(item.length != 2){
521
throw _b_.ValueError.$factory("dictionary " +
522
`update sequence element #${i} has length 1; 2 is required`)
523
}
531
if(item[0] != 0 && item[0] != 1){
532
self.$numeric_dict[item[0]] = [item[1], self.$order++]
533
self.$version++
534
break
535
}
549
for(var key in first){
550
self.$string_dict[key] = [first[key], self.$order++]
551
}
552
return _b_.None
553
}else if(first.$jsobj){
554
self.$jsobj = {}
555
for(var attr in first.$jsobj){
556
self.$jsobj[attr] = first.$jsobj[attr]
562
}
566
arguments, {}, "first", "second")
567
var args = $.first
568
if(args.length > 1){
569
throw _b_.TypeError.$factory("dict expected at most 1 argument" +
570
", got 2")
571
}else if(args.length == 1){
572
args = args[0]
573
if(args.__class__ === dict){
574
['$string_dict', '$str_hash', '$numeric_dict', '$object_dict'].
575
forEach(function(d){
576
for(key in args[d]){self[d][key] = args[d][key]}
577
})
581
var keys = $B.$getattr(args, "keys", null)
582
if(keys !== null){
583
var gi = $B.$getattr(args, "__getitem__", null)
584
if(gi !== null){
585
// has keys and __getitem__ : it's a mapping, iterate on
586
// keys and values
587
gi = $B.$call(gi)
588
var kiter = _b_.iter($B.$call(keys)())
589
while(true){
590
try{
591
var key = _b_.next(kiter),
592
value = gi(key)
593
dict.__setitem__(self, key, value)
594
}catch(err){
595
if(err.__class__ === _b_.StopIteration){
596
break
597
}
598
throw err
599
}
600
}
601
return $N
602
}
603
}
604
if(! Array.isArray(args)){
605
args = _b_.list.$factory(args)
606
}
607
// Form "dict([[key1, value1], [key2,value2], ...])"
609
}
627
}
628
631
}
632
633
dict.__ior__ = function(self, other){
634
// PEP 584
635
dict.update(self, other)
636
return self
637
}
638
643
for(var attr in self.$jsobj){
644
if(attr.charAt(0) != "$" &&
645
((! self.$exclude) || ! self.$exclude(attr))){
646
_count++
647
}
648
}
652
for(var k in self.$numeric_dict){_count++}
653
for(var k in self.$string_dict){_count++}
654
for(var hash in self.$object_dict){
655
_count += self.$object_dict[hash].length
656
}
660
664
684
dict.__or__ = function(self, other){
685
// PEP 584
686
if(! _b_.isinstance(other, dict)){
687
return _b_.NotImplemented
688
}
689
var res = dict.copy(self)
690
dict.update(res, other)
691
return res
692
}
693
694
function __newobj__(){
695
// __newobj__ is called with a generator as only argument
696
var $ = $B.args('__newobj__', 0, {}, [], arguments, {}, 'args', null),
697
args = $.args
698
var res = $B.empty_dict()
699
res.__class__ = args[0]
700
return res
701
}
702
703
dict.__reduce_ex__ = function(self, protocol){
704
return $B.fast_tuple([
705
__newobj__,
706
$B.fast_tuple([self.__class__]),
707
_b_.None,
708
_b_.None,
709
dict.items(self)])
710
}
711
731
}
732
733
dict.__ror__ = function(self, other){
734
// PEP 584
735
if(! _b_.isinstance(other, dict)){
736
return _b_.NotImplemented
737
}
738
var res = dict.copy(other)
739
dict.update(res, self)
740
return res
741
}
742
745
["self", "key", "value"], arguments, {}, null, null)
746
return dict.$setitem($.self, $.key, $.value)
747
}
752
// If key is a string, set:
753
// - $string_dict[key] = [value, order] where "order" is an auto-increment
754
// unique id to keep track of insertion order
755
// - $str_hash[hash(key)] to key
756
//
757
// If key is a number, set $numeric_dict[key] = value
758
//
759
// If key is another object, compute its hash value:
760
// - if the hash is a key of $str_hash, and key == $str_hash[hash],
761
// replace $string_dict[$str_hash[hash]] by value
762
// - if the hash is a key of $numeric_dict, and hash == key, replace
763
// $numeric_dict[hash] by value
764
// - if the hash is a key of $object_dict: $object_dict[hash] is a list
765
// of [k, v] pairs. If key is equal to one of the "k", replace the
766
// matching v by value. Otherwise, add [key, value] to the list
767
// - else set $object_dict[hash] = [[key, value]]
768
//
769
// In all cases, increment attribute $version, used to detect dictionary
772
// Parameter $hash is only set if this method is called by setdefault.
773
// In this case the hash of key has already been computed and we
774
// know that the key is not present in the dictionary, so it's no
775
// use computing hash(key) again, nor testing equality of keys
784
// If class attribute __init__ or __new__ are reset,
785
// the factory function has to change
786
self.$jsobj.$factory = $B.$instance_creator(self.$jsobj)
787
}
788
}else{
799
if(self.$string_dict === undefined){
800
console.log("pas de string dict", self, key, value)
801
}
802
if(self.$string_dict[key] !== undefined){
803
self.$string_dict[key][0] = value
804
}else{
805
self.$string_dict[key] = [value, self.$order++]
806
self.$str_hash[str_hash(key)] = key
807
self.$version++
808
}
811
if(self.$numeric_dict[key] !== undefined){
812
// existing key: preserve order
813
self.$numeric_dict[key][0] = value
814
}else{
815
// special case for 0 and 1 if True or False are keys
816
var done = false
817
if((key == 0 || key == 1) &&
818
self.$object_dict[key] !== undefined){
819
for(const item of self.$object_dict[key]){
820
if((key == 0 && item[0] === false) ||
821
(key == 1 && item[0] === true)){
822
// replace value
823
item[1][0] = value
824
done = true
825
}
826
}
827
}
828
if(! done){
829
// new key
830
self.$numeric_dict[key] = [value, self.$order++]
831
}
835
case "boolean":
836
// true replaces 1 and false replaces 0
837
var num = key ? 1 : 0
838
if(self.$numeric_dict[num] !== undefined){
839
var order = self.$numeric_dict[num][1] // preserve order
840
self.$numeric_dict[num] = [value, order]
841
return
842
}
843
if(self.$object_dict[num] !== undefined){
844
self.$object_dict[num].push([key, [value, self.$order++]])
845
}else{
846
self.$object_dict[num] = [[key, [value, self.$order++]]]
847
}
867
// If $setitem is called from setdefault, don't test equality of key
868
// with any object
869
if($hash){
870
if(self.$object_dict[$hash] !== undefined){
874
}
875
self.$version++
876
return $N
877
}
878
var ix = rank(self, hash, key)
879
if(ix > -1){
880
// reset value
891
}
892
893
// add "reflected" methods
895
897
// Remove all items from the dictionary.
917
}
918
920
// Return a shallow copy of the dictionary
926
return res
927
}
928
931
var $ = $B.args("fromkeys", 3, {cls: null, keys: null, value: null},
932
["cls", "keys", "value"], arguments, {value: _b_.None}, null, null),
936
// class method
941
while(1){
942
try{
943
var key = _b_.next(keys_iter)
944
if(klass === dict){dict.$setitem(res, key, value)}
945
else{$B.$getattr(res, "__setitem__")(key, value)}
946
}catch(err){
948
return res
949
}
950
throw err
951
}
952
}
953
}
954
956
var $ = $B.args("get", 3, {self: null, key: null, _default: null},
957
["self", "key", "_default"], arguments, {_default: $N}, null, null)
959
try{
960
// call $getitem with ignore_missign set to true
961
return dict.$getitem($.self, $.key, true)
962
}catch(err){
963
if(_b_.isinstance(err, _b_.KeyError)){return $._default}
964
else{throw err}
965
}
966
}
967
968
var dict_items = $B.make_view("dict_items", true)
969
dict_items.$iterator = $B.make_iterator_class("dict_itemiterator")
973
var _len = arguments.length - 1,
974
_msg = "items() takes no arguments (" + _len + " given)"
977
var items = to_list(self),
978
set_like = true
979
// Check if all values are hashable
980
for(var i = 0, len = items.length; i < len; i++){
981
try{
982
_b_.hash(items[i][1])
983
}catch(err){
984
set_like = false
985
break
986
}
987
}
988
var values = to_list(self)
989
var it = dict_items.$factory(self, values, set_like)
990
it.dict_version = self.$version
1000
var _len = arguments.length - 1,
1001
_msg = "keys() takes no arguments (" + _len + " given)"
1004
var it = dict_keys.$factory(self, to_list(self, 0), true)
1005
it.dict_version = self.$version
1011
var missing = {},
1012
$ = $B.args("pop", 3, {self: null, key: null, _default: null},
1013
["self", "key", "_default"], arguments, {_default: missing}, null, null),
1018
try{
1021
return res
1022
}catch(err){
1025
throw err
1026
}
1027
throw err
1028
}
1029
}
1030
1041
}
1042
1045
var $ = $B.args("setdefault", 3, {self: null, key: null, _default: null},
1046
["self", "key", "_default"], arguments, {_default: $N}, null, null),
1050
try{
1051
// Pass 3rd argument to dict.$getitem to avoid using __missing__
1052
// Cf. issue #1598
1053
return dict.$getitem(self, key, true)
1054
}catch(err){
1059
var hash = key.$hash
1060
key.$hash = undefined
1061
dict.$setitem(self, key, _default, hash)
1062
return _default
1063
}
1064
}
1065
1068
var $ = $B.args("update", 1, {"self": null}, ["self"], arguments,
1069
{}, "args", "kw"),
1070
self = $.self,
1071
args = $.args,
1072
kw = $.kw
1073
if(args.length > 0){
1074
var o = args[0]
1081
var _keys = _b_.list.$factory($B.$call($B.$getattr(o, "keys"))())
1082
for(var i = 0, len = _keys.length; i < len; i++){
1084
dict.$setitem(self, _keys[i], _value)
1085
}
1086
}else{
1087
var it = _b_.iter(o),
1088
i = 0
1089
while(true){
1090
try{
1091
var item = _b_.next(it)
1092
}catch(err){
1093
if(err.__class__ === _b_.StopIteration){break}
1094
throw err
1095
}
1096
try{
1097
key_value = _b_.list.$factory(item)
1098
}catch(err){
1099
throw _b_.TypeError.$factory("cannot convert dictionary" +
1100
" update sequence element #" + i + " to a sequence")
1101
}
1102
if(key_value.length !== 2){
1103
throw _b_.ValueError.$factory("dictionary update " +
1104
"sequence element #" + i + " has length " +
1105
key_value.length + "; 2 is required")
1106
}
1107
dict.$setitem(self, key_value[0], key_value[1])
1108
i++
1111
}
1115
}
1116
1117
var dict_values = $B.make_view("dict_values")
1118
dict_values.$iterator = $B.make_iterator_class("dict_valueiterator")
1122
var _len = arguments.length - 1,
1123
_msg = "values() takes no arguments (" + _len + " given)"
1127
var it = dict_values.$factory(self, values, false)
1128
it.dict_version = self.$version
1134
var args = [res]
1135
for(var i = 0, len = arguments.length; i < len ; i++){
1136
args.push(arguments[i])
1137
}
1138
dict.__init__.apply(null, args)
1139
return res
1140
}
1142
_b_.dict = dict
1148
$B.empty_dict = function(){
1149
return {
1150
__class__: dict,
1151
$numeric_dict : {},
1152
$object_dict : {},
1153
$string_dict : {},
1154
$str_hash: {},
1160
// This must be done after set_func_names, otherwise dict.fromkeys doesn't
1161
// have the attribute $infos
1162
dict.fromkeys = _b_.classmethod.$factory(dict.fromkeys)
1163
1164
$B.getset_descriptor = $B.make_class("getset_descriptor",
1165
function(klass, attr){
1166
return {
1167
__class__: $B.getset_descriptor,
1169
cls: klass,
1170
attr: attr
1171
}
1172
}
1173
)
1174
1175
$B.getset_descriptor.__repr__ = $B.getset_descriptor.__str__ = function(self){
1176
return `<attribute '${self.attr}' of '${self.cls.$infos.__name__}' objects>`
1177
}
1178
1179
$B.set_func_names($B.getset_descriptor, "builtins")
1180
1185
// obj is a dictionary, with $string_dict table such that
1186
// obj.$string_dict[key] = [value, rank]
1187
// Transform it into an object with attribute $jsobj such that
1188
// res.$jsobj[key] = value
1189
var res = $B.obj_dict(dict.$to_obj(obj))
1201
throw _b_.TypeError.$factory("'mappingproxy' object does not support " +
1202
"item assignment")
1205
for(var attr in dict){
1206
if(mappingproxy[attr] !== undefined ||
1207
["__class__", "__mro__", "__new__", "__init__", "__delitem__",
1208
"clear", "fromkeys", "pop", "popitem", "setdefault",
1209
"update"].indexOf(attr) > -1){
1210
continue
1211
}
1212
if(typeof dict[attr] == "function"){
1213
mappingproxy[attr] = (function(key){
1214
return function(){
1215
return dict[key].apply(null, arguments)
1216
}
1217
})(attr)
1218
}else{
1219
mappingproxy[attr] = dict[attr]
1220
}
1221
}
1222
1225
function jsobj2dict(x, exclude){
1226
exclude = exclude || function(){return false}
1255
// Wrapper around a JS object to handle it as a Python dictionary.
1256
// Some keys of the original object can be ignored by passing
1257
// the filtering function exclude().
1258
// Supports adding new keys.
1259
1260
var jsobj_as_pydict = $B.jsobj_as_pydict = $B.make_class('jsobj_as_pydict',
1261
function(jsobj, exclude){
1262
return {
1263
__class__: jsobj_as_pydict,
1264
obj: jsobj,
1265
exclude: exclude ? exclude : function(){return false},
1266
new_keys: []
1267
}
1268
}
1269
)
1270
1271
jsobj_as_pydict.__contains__ = function(self, key){
1272
if(self.new_keys.indexOf(key) > -1){
1273
return true
1274
}
1275
return ! (self.exclude(key) || self.obj[key] === undefined)
1276
}
1277
1278
jsobj_as_pydict.__delitem__ = function(self, key){
1279
jsobj_as_pydict.__getitem__(self, key) // raises KeyError if not present
1280
delete self.obj[key]
1281
var ix = self.new_keys.indexOf(key)
1282
if(ix > -1){
1283
self.new_keys.splice(ix, 1)
1284
}
1285
}
1286
1287
jsobj_as_pydict.__eq__ = function(self, other){
1288
if(other.__class__ !== jsobj_as_pydict){
1289
return _b_.NotImplemented
1290
}
1291
// create true Python dicts with the items in self and other
1292
var self1 = $B.empty_dict()
1293
other1 = $B.empty_dict()
1294
1295
dict.__init__(self1, jsobj_as_pydict.items(self))
1296
dict.__init__(other1, jsobj_as_pydict.items(other))
1297
1298
// Compare true Python dicts
1299
return dict.__eq__(self1, other1)
1300
}
1301
1302
jsobj_as_pydict.__getitem__ = function(self, key){
1303
if(jsobj_as_pydict.__contains__(self, key)){
1304
return self.obj[key]
1305
}
1306
throw _b_.KeyError.$factory(key)
1307
}
1308
1309
jsobj_as_pydict.__iter__ = function(self){
1310
return _b_.iter(jsobj_as_pydict.keys(self))
1311
}
1312
1313
jsobj_as_pydict.__len__ = function(self){
1314
var len = 0
1315
for(var key in self.obj){
1316
if(! self.exclude(key)){
1317
len++
1318
}
1319
}
1320
return len + self.new_keys.length
1321
}
1322
1323
jsobj_as_pydict.__repr__ = function(self){
1324
if($B.repr.enter(self)){
1325
return "{...}"
1326
}
1327
var res = [],
1328
items = _b_.list.$factory(jsobj_as_pydict.items(self))
1329
for(var item of items){
1330
res.push(_b_.repr(item[0]) + ": " + _b_.repr(item[1]))
1331
}
1332
$B.repr.leave(self)
1333
return "{" + res.join(", ") + "}"
1334
}
1335
1336
jsobj_as_pydict.__setitem__ = function(self, key, value){
1337
if(self.exclude(key) && self.new_keys.indexOf(key) == -1){
1338
self.new_keys.push(key)
1339
}
1340
self.obj[key] = value
1341
}
1342
1343
jsobj_as_pydict.get = function(self, key, _default){
1344
_default = _default === undefined ? _b_.None : _default
1345
if(self.exclude(key) || self.obj[key] === undefined){
1346
return _default
1347
}
1348
return self.obj[key]
1349
}
1350
1351
jsobj_as_pydict.items = function(self){
1353
for(var key in self.obj){
1354
if(self.exclude(key) && self.new_keys.indexOf(key) == -1){
1355
continue
1356
}
1357
items.push($B.fast_tuple([key, self.obj[key]]))
1358
}
1359
var set_like = true
1360
// Check if all values are hashable
1361
for(var item of items){
1362
try{
1363
_b_.hash(item[1])
1364
}catch(err){
1365
set_like = false
1366
break
1367
}
1369
var it = dict_items.$factory(self, items, set_like)
1370
it.dict_version = self.$version
1371
return it
1372
}
1373
1374
jsobj_as_pydict.keys = function(self){
1375
var lst = []
1376
for(var key in self.obj){
1377
if(self.exclude(key) && self.new_keys.indexOf(key) == -1){
1378
continue
1379
}
1380
lst.push(key)
1381
}
1382
var it = dict_keys.$factory(self, lst, true)
1383
it.dict_version = self.$version
1384
return it
1389
for(var key in self.obj){
1390
if(self.exclude(key) && self.new_keys.indexOf(key) == -1){
1391
continue
1392
}
1395
var it = dict_values.$factory(self, values, false)
1396
it.dict_version = self.$version
1397
return it
1402
})(__BRYTHON__)