Permalink
Sep 5, 2014
Sep 5, 2014
Feb 26, 2018
Sep 5, 2014
Sep 5, 2014
Dec 31, 2014
Feb 3, 2018
Dec 31, 2014
Feb 3, 2018
Jan 15, 2018
Feb 26, 2018
Dec 31, 2014
Feb 26, 2018
Feb 26, 2018
May 29, 2017
Feb 26, 2018
Feb 26, 2018
Nov 21, 2015
Nov 21, 2015
Sep 5, 2014
Feb 26, 2018
Sep 5, 2014
Feb 26, 2018
Feb 26, 2018
Feb 26, 2018
Sep 5, 2014
Feb 26, 2018
Feb 26, 2018
May 28, 2016
Sep 5, 2014
Sep 5, 2014
Feb 26, 2018
Feb 26, 2018
Feb 26, 2018
Feb 26, 2018
Sep 5, 2014
Sep 5, 2014
Feb 26, 2018
Feb 26, 2018
Sep 5, 2014
Sep 5, 2014
Sep 5, 2014
Feb 26, 2018
Sep 5, 2014
Sep 5, 2014
Feb 26, 2018
Feb 9, 2018
Sep 5, 2014
Feb 26, 2018
Sep 5, 2014
Feb 3, 2018
Feb 26, 2018
Feb 26, 2018
May 28, 2016
Sep 5, 2014
Sep 5, 2014
Sep 5, 2014
Sep 5, 2014
Feb 26, 2018
Feb 26, 2018
Oct 30, 2017
Sep 5, 2014
Sep 5, 2014
Sep 5, 2014
Sep 5, 2014
Sep 5, 2014
Feb 26, 2018
Sep 5, 2014
Sep 5, 2014
Sep 5, 2014
Feb 26, 2018
Nov 9, 2015
Feb 26, 2018
Feb 26, 2018
Feb 26, 2018
Sep 5, 2014
Sep 5, 2014
Sep 5, 2014
Sep 5, 2014
Feb 26, 2018
Sep 5, 2014
Feb 26, 2018
Sep 5, 2014
Feb 26, 2018
Sep 5, 2014
Sep 5, 2014
Feb 26, 2018
Nov 21, 2015
Feb 26, 2018
Feb 26, 2018
Jun 10, 2016
Feb 26, 2018
Feb 3, 2018
Sep 5, 2014
Sep 5, 2014
Sep 5, 2014
Feb 11, 2018
Dec 31, 2014
Feb 12, 2018
Feb 10, 2018
Feb 26, 2018
Sep 5, 2014
Newer
100644
815 lines (700 sloc)
22.5 KB
1
;(function($B){
2
8
9
// dictionary
10
function $DictClass($keys,$values){
11
this.iter = null
15
var setitem = dict.__setitem__,
16
i = $keys.length
17
while(i--){setitem($keys[i], $values[i])}
24
__name__ : 'dict',
27
}
28
29
var $key_iterator = function(d) {
30
this.d = d
31
this.current = 0
32
this.iter = new $item_generator(d)
33
}
34
$key_iterator.prototype.length = function(){return this.iter.items.length}
35
$key_iterator.prototype.next = function(){return this.iter.next()[0]}
36
37
var $value_iterator = function(d) {
38
this.d = d
39
this.current = 0
40
this.iter = new $item_generator(d)
41
}
42
$value_iterator.prototype.length = function(){return this.iter.items.length}
43
$value_iterator.prototype.next = function(){return this.iter.next()[1]}
54
if(val === undefined){val = _b_.NotImplemented}
55
else if(val === null){val = $N}
56
this.items.push([attr, val])
62
var items = []
63
for(var k in d.$numeric_dict){
64
items.push([parseFloat(k), d.$numeric_dict[k]])
82
}
83
84
var $item_iterator = function(d) {
85
this.d = d
86
this.current = 0
87
this.iter = new $item_generator(d)
88
}
89
$item_iterator.prototype.length = function(){return this.iter.items.length}
90
$item_iterator.prototype.next = function(){
91
return _b_.tuple.$factory(this.iter.next())
92
}
94
var $copy_dict = function(left, right){
95
var _l = new $item_generator(right).as_list(),
96
si = dict.__setitem__,
97
i = _l.length
98
while(i--){si(left, _l[i][0], _l[i][1])}
101
function toSet(items){
102
// Build a set from the iteration on items
103
var res = []
104
while(true){
105
try{res.push(items.next())}
106
catch(err){break}
107
}
118
__iter__: function(){items.iter.i = 0; return res},
119
__len__: function(){return items.length()},
120
__next__: function(){
136
var $ = $B.args('__bool__', 1, {self: null}, ['self'],
137
arguments, {}, null, null)
163
// If the key is an object, its hash must be in the dict keys but the
164
// key itself must compare equal to the key associated with the hash
165
// For instance :
166
//
167
// class X:
168
// def __hash__(self): return hash('u')
170
// a = {'u': 'a', X(): 'b'}
171
// assert set(a.values())=={'a', 'b'}
172
// assert not X() in a
176
}
177
191
case 'string':
192
if(self.$string_dict[arg] === undefined){
193
throw KeyError.$factory(_b_.str.$factory(arg))
194
}
195
delete self.$string_dict[arg]
196
delete self.$str_hash[str_hash(arg)]
197
return $N
198
case 'number':
199
if(self.$numeric_dict[arg] === undefined){
200
throw KeyError.$factory(_b_.str.$factory(arg))
201
}
202
delete self.$numeric_dict[arg]
203
return $N
215
}
216
225
if(self.$jsobj){self = jsobj2dict(self.$jsobj)}
226
if(other.$jsobj){other = jsobj2dict(other.$jsobj)}
230
if((self.$numeric_dict.length != other.$numeric_dict.length) ||
231
(self.$string_dict.length != other.$string_dict.length) ||
232
(self.$object_dict.length != other.$object_dict.length)){
233
return false
248
if(!$B.rich_comp("__eq__", other.$object_dict[k][1],
249
self.$object_dict[k][1])){
256
}
257
265
if(!self.$jsobj.hasOwnProperty(arg)){
266
throw _b_.KeyError.$factory(str.$factory(arg))
267
}else if(self.$jsobj[arg] === undefined){
268
return _b_.NotImplemented
269
}else if(self.$jsobj[arg] === null){return $N}
274
switch(typeof arg){
275
case 'string':
276
if(self.$string_dict[arg] !== undefined){
277
return self.$string_dict[arg]
278
}
279
break
280
case 'number':
281
if(self.$numeric_dict[arg] !== undefined){
282
return self.$numeric_dict[arg]
283
}
302
// An object with the same hash is already stored
303
// Lookup should fail if equality raises an exception
304
_eq(self.$object_dict[_key][0])
314
}
315
317
319
var args = []
320
for(var i = 1; i < arguments.length; i++){args.push(arguments[i])}
321
322
switch(args.length){
323
case 0:
324
return
325
case 1:
326
var obj = args[0]
327
if(Array.isArray(obj)){
328
var i = obj.length,
329
si = dict.__setitem__
330
while(i-- > 0){si(self, obj[i-1][0], obj[i-1][1])}
331
return $N
332
}else if(obj.$nat === undefined && isinstance(obj, dict)){
333
$copy_dict(self, obj)
334
return $N
335
}
337
if(obj.__class__ === $B.JSObject){
338
// convert a JSObject into a Python dictionary
340
// Attribute $jsobj is used to update the original JS object
341
// when the dictionary is modified
342
self.$jsobj = obj.js
343
return $N
344
}
345
}
347
var $ns = $B.args('dict', 0, {}, [], args, {}, 'args', 'kw'),
348
args = $ns['args'],
349
kw = $ns['kw']
355
}
357
// format dict([(k1,v1),(k2,v2)...])
360
var src = args[0],
361
i = src.length - 1,
362
si = dict.__setitem__
363
while(i-- > 0){si(self, src[i - 1][0], src[i - 1][1])}
369
var elt = next(iterable),
370
key = getattr(elt, '__getitem__')(0),
371
value = getattr(elt,'__getitem__')(1)
380
}
381
}
385
}
386
387
var $dict_iterator = $B.$iterator_class('dict iterator')
390
}
391
400
for (var k in self.$numeric_dict){_count++}
401
for (var k in self.$string_dict){_count++}
402
for (var k in self.$object_dict){_count+= self.$object_dict[k].length}
406
408
410
if(cls === undefined){
411
throw _b_.TypeError.$factory('int.__new__(): not enough arguments')
412
}
415
$numeric_dict : {},
416
$object_dict : {},
417
$string_dict : {},
418
$str_hash: {}
419
}
420
}
421
430
}
431
}
432
439
items.forEach(function(item){
440
if((!self.$jsobj && item[1] === self) ||
441
(self.$jsobj && item[1] === self.$jsobj)){
442
res.push(repr(item[0]) + ': {...}')
452
}
453
464
self.$jsobj[key] = $B.pyobj2jsobj(value)
465
if(key=="__init__" || key=="__new__"){
466
// If class attribute __init__ or __new__ are reset,
467
// the factory function has to change
468
self.$jsobj.$factory = $B.$instance_creator(self.$jsobj)
469
}
470
}else{
476
switch(typeof key){
477
case 'string':
478
self.$string_dict[key] = value
479
self.$str_hash[str_hash(key)] = key
480
return $N
481
case 'number':
482
self.$numeric_dict[key] = value
483
return $N
488
var _key = hash(key),
489
_eq = function(other){return $B.rich_comp("__eq__", key, other)}
503
// An object with the same hash is already stored
504
// Lookup should fail if equality raises an exception
505
_eq(self.$object_dict[_key][0])
506
}
507
self.$object_dict[_key] = [key, value]
509
}
510
512
513
// add "reflected" methods
515
517
// Remove all items from the dictionary.
518
var $ = $B.args('clear', 1, {self: null}, ['self'], arguments, {},
519
null, null),
522
self.$numeric_dict = {}
523
self.$string_dict = {}
524
self.$str_hash = {}
525
self.$object_dict = {}
527
if(self.$jsobj){
528
for(var attr in self.$jsobj){
529
if(attr.charAt(0) !== '$' && attr !== "__class__"){
530
delete self.$jsobj[attr]
531
}
532
}
533
}
535
}
536
538
// Return a shallow copy of the dictionary
544
return res
545
}
546
554
// class method
560
while(1){
561
try{
562
var key = _b_.next(keys_iter)
563
if(klass === dict){dict.__setitem__(res, key, value)}
564
else{_b_.getattr(res, "__setitem__")(key, value)}
565
}catch(err){
568
return res
569
}
570
throw err
571
}
572
}
573
}
575
577
var $ = $B.args('get', 3, {self: null, key: null, _default: null},
578
['self', 'key', '_default'], arguments, {_default: $N}, null, null)
581
catch(err){
582
if(_b_.isinstance(err, _b_.KeyError)){return $._default}
583
else{throw err}
584
}
585
}
586
587
var $dict_itemsDict = $B.$iterator_class('dict_items')
588
591
var _len = arguments.length - 1,
592
_msg = "items() takes no arguments (" + _len + " given)"
602
var _len = arguments.length - 1,
603
_msg = "keys() takes no arguments (" + _len + " given)"
611
var $ = $B.args('pop', 3, {self: null, key: null, _default: null},
612
['self', 'key', '_default'], arguments, {_default: $N}, null, null),
613
self = $.self,
614
key = $.key,
615
_default = $._default
617
try{
620
return res
621
}catch(err){
624
throw err
625
}
626
throw err
627
}
628
}
629
642
}
643
646
var $ = $B.args('setdefault', 3, {self: null, key: null, _default: null},
647
['self', 'key', '_default'], arguments, {_default: $N}, null, null),
648
self = $.self,
649
key = $.key,
650
_default = $._default
653
catch(err){
654
if(_default === undefined){_default = $N}
655
dict.__setitem__(self, key, _default)
656
return _default
657
}
658
}
659
662
var $ = $B.args('update', 1, {'self': null}, ['self'], arguments,
663
{}, 'args', 'kw'),
664
self = $.self,
665
args = $.args,
666
kw = $.kw
667
668
if(args.length > 0){
669
var o = args[0]
670
if(isinstance(o, dict)){
671
if(o.$jsobj){o = jsobj2dict(o)}
672
$copy_dict(self, o)
673
}else if(hasattr(o, '__getitem__') && hasattr(o, 'keys')){
674
var _keys = _b_.list.$factory(getattr(o, 'keys')()),
675
si = dict.__setitem__,
676
i = _keys.length
677
while(i--){
678
var _value = getattr(o, '__getitem__')(_keys[i])
679
si(self, _keys[i], _value)
680
}
681
}
682
}
685
}
686
691
var _len = arguments.length - 1,
692
_msg = "values() takes no arguments (" + _len + " given)"
694
}
695
return $iterator_wrapper(new $value_iterator(self), $dict_valuesDict)
696
}
697
712
var i = -1,
713
stop = args.length - 1,
714
si = dict.__setitem__
715
while(i++ < stop){
716
var item = args[i]
719
res.$string_dict[item[0]] = item[1]
720
res.$str_hash[str_hash(item[0])] = item[0]
721
break
724
break
725
default:
726
si(res, item[0], item[1])
727
break
728
}
729
}
730
return res
735
switch(typeof attr){
736
case 'string':
737
res.$string_dict[attr] = kw[attr]
738
res.$str_hash[str_hash(attr)] = attr
739
break
740
case 'number':
741
res.$numeric_dict[attr] = kw[attr]
742
break
743
default:
744
si(res, attr, kw[attr])
745
break
749
}else if(args.$jsobj){
750
res.$jsobj = {}
751
for(var attr in args.$jsobj){res.$jsobj[attr] = args.$jsobj[attr]}
752
return res
756
// apply __init__ with arguments of dict()
758
return res
759
}
761
_b_.dict = dict
767
$B.$dict_length = dict.__len__
768
$B.$dict_getitem = dict.__getitem__
769
$B.$dict_get = dict.get
770
$B.$dict_set = dict.__setitem__
771
$B.$dict_contains = dict.__contains__
772
$B.$dict_items = function(d) { return new $item_generator(d).as_list() }
773
$B.$copy_dict = $copy_dict // copy from right to left
778
var mappingproxy = $B.make_class("mappingproxy",
779
function(obj){
780
var res = obj_dict(obj)
781
res.__class__ = mappingproxy
782
return res
783
}
784
)
787
throw _b_.TypeError.$factory("'mappingproxy' object does not support item assignment")
807
if(klass !== undefined && klass.$native){
808
throw _b_.AttributeError.$factory(klass.__name__ +
815
})(__BRYTHON__)