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
Nov 6, 2019
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
Jan 29, 2021
Dec 28, 2020
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
Apr 18, 2020
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
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
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
Mar 16, 2021
Sep 5, 2014
Newer
100644
1239 lines (1118 sloc)
36.3 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
33
34
var set_ops = ["eq", "le", "lt", "ge", "gt",
35
"sub", "rsub", "and", "or", "xor"]
36
37
// methods to compare non set-like views
38
function is_sublist(t1, t2){
39
// Return true if all elements of t1 are in t2
40
for(var i = 0, ilen = t1.length; i < ilen; i++){
41
var x = t1[i],
42
flag = false
43
for(var j = 0, jlen = t2.length; j < jlen; j++){
44
if($B.rich_comp("__eq__", x, t2[j])){
45
t2.splice(j, 1)
46
flag = true
47
break
48
}
49
}
50
if(! flag){
51
return false
52
}
53
}
54
return true
55
}
56
57
dict_view_op = {
58
__eq__: function(t1, t2){
59
return t1.length == t2.length && is_sublist(t1, t2)
60
},
61
__ne__: function(t1, t2){
62
return ! dict_view_op.__eq__(t1, t2)
63
},
64
__lt__: function(t1, t2){
65
return t1.length < t2.length && is_sublist(t1, t2)
66
},
67
__gt__: function(t1, t2){
68
return dict_view_op.__lt__(t2, t1)
69
},
70
__le__: function(t1, t2){
71
return t1.length <= t2.length && is_sublist(t1, t2)
72
},
73
__ge__: function(t1, t2){
74
return dict_view_op.__le__(t2, t1)
75
},
76
__and__: function(t1, t2){
77
var items = []
78
for(var i = 0, ilen = t1.length; i < ilen; i++){
79
var x = t1[i]
80
flag = false
81
for(var j = 0, jlen = t2.length; j < jlen; j++){
82
if($B.rich_comp("__eq__", x, t2[j])){
83
t2.splice(j, 1)
84
items.push(x)
85
break
86
}
87
}
88
}
89
return items
90
},
91
__or__: function(t1, t2){
92
var items = t1
93
for(var j = 0, jlen = t2.length; j < jlen; j++){
94
var y = t2[j],
95
flag = false
96
for(var i = 0, ilen = t1.length; i < ilen; i++){
97
if($B.rich_comp("__eq__", y, t1[i])){
98
t2.splice(j, 1)
99
flag = true
100
break
101
}
102
}
103
if(! flag){
104
items.push(y)
105
}
106
}
107
return items
108
}
125
for(var i = 0, len = set_ops.length; i < len; i++){
126
var op = "__" + set_ops[i] + "__"
127
klass[op] = (function(op){
128
return function(self, other){
129
// compare set of items to other
130
if(self.set_like){
131
return _b_.set[op](_b_.set.$factory(self),
132
_b_.set.$factory(other))
133
}else{
134
// Non-set like views can only be compared to
135
// instances of the same class
136
if(other.__class__ !== klass){
137
return false
139
var other_items = _b_.list.$factory(other)
140
return dict_view_op[op](self.items, other_items)
148
it.test_change = function(){
149
return self.dict.$version != self.dict_version
150
}
158
klass.__repr__ = function(self){
159
return klass.$infos.__name__ + '(' + _b_.repr(self.items) + ')'
160
}
161
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
280
var $ = $B.args("__contains__", 2, {self: null, key: null},
281
["self", "key"], arguments, {}, null, null),
284
if(self.$is_namespace){key = $B.to_alias(key)} // issue 1244
285
286
if(self.$jsobj){
287
return self.$jsobj[key] !== undefined
288
}
294
return self.$numeric_dict[key] !== undefined
295
}
296
297
var hash = _b_.hash(key)
298
if(self.$str_hash[hash] !== undefined &&
299
$B.rich_comp("__eq__", key, self.$str_hash[hash])){return true}
300
if(self.$numeric_dict[hash] !== undefined &&
301
$B.rich_comp("__eq__", key, hash)){return true}
302
return rank(self, hash, key) > -1
303
}
304
307
var $ = $B.args("__eq__", 2, {self: null, arg: null},
308
["self", "arg"], arguments, {}, null, null),
317
switch(typeof arg){
318
case "string":
319
if(self.$string_dict[arg] === undefined){
339
if((ix = rank(self, hash, arg)) > -1){
340
self.$object_dict[hash].splice(ix, 1)
341
}else{
347
}
348
350
var $ = $B.args("__eq__", 2, {self: null, other: null},
351
["self", "other"], arguments, {}, null, null),
357
if(self.$jsobj){self = jsobj2dict(self.$jsobj)}
358
if(other.$jsobj){other = jsobj2dict(other.$jsobj)}
369
if(!$B.rich_comp("__eq__", other.$numeric_dict[k][0],
370
self.$numeric_dict[k][0])){
374
var pairs = other.$object_dict[k],
375
flag = false
376
for(var i = 0, len = pairs.length; i < len; i++){
377
if($B.rich_comp("__eq__", k, pairs[i][0]) &&
378
$B.rich_comp("__eq__", self.$numeric_dict[k],
379
pairs[i][1])){
380
flag = true
381
break
382
}
397
var pairs = self.$object_dict[hash]
398
// Get all (key, value) pairs in other that have the same hash
399
var other_pairs = []
400
if(other.$numeric_dict[hash] !== undefined){
401
other_pairs.push([hash, other.$numeric_dict[hash]])
402
}
404
other_pairs = other_pairs.concat(other.$object_dict[hash])
405
}
406
if(other_pairs.length == 0){
407
return false
408
}
409
for(var i = 0, len_i = pairs.length; i < len_i; i++){
410
var flag = false
411
var key = pairs[i][0],
413
for(var j = 0, len_j = other_pairs.length; j < len_j; j++){
414
if($B.rich_comp("__eq__", key, other_pairs[j][0]) &&
426
}
427
429
var $ = $B.args("__getitem__", 2, {self: null, arg: null},
430
["self", "arg"], arguments, {}, null, null),
438
dict.$getitem = function(self, arg, ignore_missing){
439
// ignore_missing is only set in dict.setdefault
452
var x = self.$string_dict[arg]
453
if(x !== undefined){
454
$B.string_count++
455
return x[0]
463
break
464
}
465
466
// since the key is more complex use 'default' method of getting item
467
492
if(! ignore_missing){
493
if(self.__class__ !== dict && ! ignore_missing){
494
try{
495
var missing_method = getattr(self.__class__, "__missing__",
496
_b_.None)
497
}catch(err){
498
console.log(err)
507
}
508
510
517
if(item.length != 2){
518
throw _b_.ValueError.$factory("dictionary " +
519
`update sequence element #${i} has length 1; 2 is required`)
520
}
528
if(item[0] != 0 && item[0] != 1){
529
self.$numeric_dict[item[0]] = [item[1], self.$order++]
530
self.$version++
531
break
532
}
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
711
try{
712
res.push(repr(item[0]) + ": " + repr(item[1]))
713
}catch(err){
714
throw err
715
}
719
}
720
721
dict.__ror__ = function(self, other){
722
// PEP 584
723
if(! _b_.isinstance(other, dict)){
724
return _b_.NotImplemented
725
}
726
var res = dict.copy(other)
727
dict.update(res, self)
728
return res
729
}
730
733
["self", "key", "value"], arguments, {}, null, null)
734
return dict.$setitem($.self, $.key, $.value)
735
}
740
// If key is a string, set:
741
// - $string_dict[key] = [value, order] where "order" is an auto-increment
742
// unique id to keep track of insertion order
743
// - $str_hash[hash(key)] to key
744
//
745
// If key is a number, set $numeric_dict[key] = value
746
//
747
// If key is another object, compute its hash value:
748
// - if the hash is a key of $str_hash, and key == $str_hash[hash],
749
// replace $string_dict[$str_hash[hash]] by value
750
// - if the hash is a key of $numeric_dict, and hash == key, replace
751
// $numeric_dict[hash] by value
752
// - if the hash is a key of $object_dict: $object_dict[hash] is a list
753
// of [k, v] pairs. If key is equal to one of the "k", replace the
754
// matching v by value. Otherwise, add [key, value] to the list
755
// - else set $object_dict[hash] = [[key, value]]
756
//
757
// In all cases, increment attribute $version, used to detect dictionary
760
// Parameter $hash is only set if this method is called by setdefault.
761
// In this case the hash of key has already been computed and we
762
// know that the key is not present in the dictionary, so it's no
763
// use computing hash(key) again, nor testing equality of keys
772
// If class attribute __init__ or __new__ are reset,
773
// the factory function has to change
774
self.$jsobj.$factory = $B.$instance_creator(self.$jsobj)
775
}
776
}else{
784
if(self.$string_dict === undefined){
785
console.log("pas de string dict", self, key, value)
786
}
787
if(self.$string_dict[key] !== undefined){
788
self.$string_dict[key][0] = value
789
}else{
790
self.$string_dict[key] = [value, self.$order++]
791
self.$str_hash[str_hash(key)] = key
792
self.$version++
793
}
796
if(self.$numeric_dict[key] !== undefined){
797
// existing key: preserve order
798
self.$numeric_dict[key][0] = value
799
}else{
800
// special case for 0 and 1 if True or False are keys
801
var done = false
802
if((key == 0 || key == 1) &&
803
self.$object_dict[key] !== undefined){
804
for(const item of self.$object_dict[key]){
805
if((key == 0 && item[0] === false) ||
806
(key == 1 && item[0] === true)){
807
// replace value
808
item[1][0] = value
809
done = true
810
}
811
}
812
}
813
if(! done){
814
// new key
815
self.$numeric_dict[key] = [value, self.$order++]
816
}
820
case "boolean":
821
// true replaces 1 and false replaces 0
822
var num = key ? 1 : 0
823
if(self.$numeric_dict[num] !== undefined){
824
var order = self.$numeric_dict[num][1] // preserve order
825
self.$numeric_dict[num] = [value, order]
826
return
827
}
828
if(self.$object_dict[num] !== undefined){
829
self.$object_dict[num].push([key, [value, self.$order++]])
830
}else{
831
self.$object_dict[num] = [[key, [value, self.$order++]]]
832
}
852
// If $setitem is called from setdefault, don't test equality of key
853
// with any object
854
if($hash){
855
if(self.$object_dict[$hash] !== undefined){
859
}
860
self.$version++
861
return $N
862
}
863
var ix = rank(self, hash, key)
864
if(ix > -1){
865
// reset value
876
}
877
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)
949
catch(err){
950
if(_b_.isinstance(err, _b_.KeyError)){return $._default}
951
else{throw err}
952
}
953
}
954
955
var dict_items = $B.make_view("dict_items", true)
956
dict_items.$iterator = $B.make_iterator_class("dict_itemiterator")
960
var _len = arguments.length - 1,
961
_msg = "items() takes no arguments (" + _len + " given)"
964
var items = to_list(self),
965
set_like = true
966
// Check if all values are hashable
967
for(var i = 0, len = items.length; i < len; i++){
968
try{
969
_b_.hash(items[i][1])
970
}catch(err){
971
set_like = false
972
break
973
}
974
}
975
var values = to_list(self)
976
var it = dict_items.$factory(self, values, set_like)
977
it.dict_version = self.$version
987
var _len = arguments.length - 1,
988
_msg = "keys() takes no arguments (" + _len + " given)"
991
var it = dict_keys.$factory(self, to_list(self, 0), true)
992
it.dict_version = self.$version
998
var missing = {},
999
$ = $B.args("pop", 3, {self: null, key: null, _default: null},
1000
["self", "key", "_default"], arguments, {_default: missing}, null, null),
1005
try{
1008
return res
1009
}catch(err){
1012
throw err
1013
}
1014
throw err
1015
}
1016
}
1017
1028
}
1029
1032
var $ = $B.args("setdefault", 3, {self: null, key: null, _default: null},
1033
["self", "key", "_default"], arguments, {_default: $N}, null, null),
1037
try{
1038
// Pass 3rd argument to dict.$getitem to avoid using __missing__
1039
// Cf. issue #1598
1040
return dict.$getitem(self, key, true)
1041
}catch(err){
1046
var hash = key.$hash
1047
key.$hash = undefined
1048
dict.$setitem(self, key, _default, hash)
1049
return _default
1050
}
1051
}
1052
1055
var $ = $B.args("update", 1, {"self": null}, ["self"], arguments,
1056
{}, "args", "kw"),
1057
self = $.self,
1058
args = $.args,
1059
kw = $.kw
1060
if(args.length > 0){
1061
var o = args[0]
1068
var _keys = _b_.list.$factory($B.$call($B.$getattr(o, "keys"))())
1069
for(var i = 0, len = _keys.length; i < len; i++){
1071
dict.$setitem(self, _keys[i], _value)
1072
}
1073
}else{
1074
var it = _b_.iter(o),
1075
i = 0
1076
while(true){
1077
try{
1078
var item = _b_.next(it)
1079
}catch(err){
1080
if(err.__class__ === _b_.StopIteration){break}
1081
throw err
1082
}
1083
try{
1084
key_value = _b_.list.$factory(item)
1085
}catch(err){
1086
throw _b_.TypeError.$factory("cannot convert dictionary" +
1087
" update sequence element #" + i + " to a sequence")
1088
}
1089
if(key_value.length !== 2){
1090
throw _b_.ValueError.$factory("dictionary update " +
1091
"sequence element #" + i + " has length " +
1092
key_value.length + "; 2 is required")
1093
}
1094
dict.$setitem(self, key_value[0], key_value[1])
1095
i++
1098
}
1102
}
1103
1104
var dict_values = $B.make_view("dict_values")
1105
dict_values.$iterator = $B.make_iterator_class("dict_valueiterator")
1109
var _len = arguments.length - 1,
1110
_msg = "values() takes no arguments (" + _len + " given)"
1114
var it = dict_values.$factory(self, values, false)
1115
it.dict_version = self.$version
1121
var args = [res]
1122
for(var i = 0, len = arguments.length; i < len ; i++){
1123
args.push(arguments[i])
1124
}
1125
dict.__init__.apply(null, args)
1126
return res
1127
}
1129
_b_.dict = dict
1135
$B.empty_dict = function(){
1136
return {
1137
__class__: dict,
1138
$numeric_dict : {},
1139
$object_dict : {},
1140
$string_dict : {},
1141
$str_hash: {},
1147
// This must be done after set_func_names, otherwise dict.fromkeys doesn't
1148
// have the attribute $infos
1149
dict.fromkeys = _b_.classmethod.$factory(dict.fromkeys)
1150
1151
$B.getset_descriptor = $B.make_class("getset_descriptor",
1152
function(klass, attr){
1153
return {
1154
__class__: $B.getset_descriptor,
1156
cls: klass,
1157
attr: attr
1158
}
1159
}
1160
)
1161
1162
$B.getset_descriptor.__repr__ = $B.getset_descriptor.__str__ = function(self){
1163
return `<attribute '${self.attr}' of '${self.cls.$infos.__name__}' objects>`
1164
}
1165
1166
$B.set_func_names($B.getset_descriptor, "builtins")
1167
1172
// obj is a dictionary, with $string_dict table such that
1173
// obj.$string_dict[key] = [value, rank]
1174
// Transform it into an object with attribute $jsobj such that
1175
// res.$jsobj[key] = value
1176
var res = $B.obj_dict(dict.$to_obj(obj))
1186
throw _b_.TypeError.$factory("'mappingproxy' object does not support " +
1187
"item assignment")
1190
for(var attr in dict){
1191
if(mappingproxy[attr] !== undefined ||
1192
["__class__", "__mro__", "__new__", "__init__", "__delitem__",
1193
"clear", "fromkeys", "pop", "popitem", "setdefault",
1194
"update"].indexOf(attr) > -1){
1195
continue
1196
}
1197
if(typeof dict[attr] == "function"){
1198
mappingproxy[attr] = (function(key){
1199
return function(){
1200
return dict[key].apply(null, arguments)
1201
}
1202
})(attr)
1203
}else{
1204
mappingproxy[attr] = dict[attr]
1205
}
1206
}
1207
1231
throw _b_.AttributeError.$factory("'" + $B.class_name(obj) +
1232
"' object has no attribute '__dict__'")}
1239
})(__BRYTHON__)