skeleton sync
[idea/community.git] / python / helpers / python-skeletons / __builtin__.py
1 """Skeletons for Python 2 built-in symbols."""
2
3
4 from __future__ import unicode_literals
5 import sys
6
7
8 def abs(number):
9     """Return the absolute value of the argument.
10
11     :type number: T
12     :rtype: T | unknown
13     """
14     return number
15
16
17 def all(iterable):
18     """Return True if bool(x) is True for all values x in the iterable.
19
20     :type iterable: collections.Iterable
21     :rtype: bool
22     """
23     return False
24
25
26 def any(iterable):
27     """Return True if bool(x) is True for any x in the iterable.
28
29     :type iterable: collections.Iterable
30     :rtype: bool
31     """
32     return False
33
34
35 def bin(number):
36     """Return the binary representation of an integer or long integer.
37
38     :type number: numbers.Number
39     :rtype: bytes
40     """
41     return b''
42
43
44 def callable(object):
45     """Return whether the object is callable (i.e., some kind of function).
46     Note that classes are callable, as are instances with a __call__() method.
47
48     :rtype: bool
49     """
50     return False
51
52
53 def chr(i):
54     """Return a string of one character with ordinal i; 0 <= i < 256.
55
56     :type i: numbers.Integral
57     :rtype: bytes
58     """
59     return b''
60
61
62 def cmp(x, y):
63     """Return negative if x<y, zero if x==y, positive if x>y.
64
65     :rtype: int
66     """
67     return 0
68
69
70 def dir(object=None):
71     """If called without an argument, return the names in the current scope.
72     Else, return an alphabetized list of names comprising (some of) the
73     attributes of the given object, and of attributes reachable from it.
74
75     :rtype: list[string]
76     """
77     return []
78
79
80 def divmod(x, y):
81     """Return the tuple ((x-x%y)/y, x%y).
82
83     :type x: numbers.Number
84     :type y: numbers.Number
85     :rtype: (int | long | float | unknown, int | long | float | unknown)
86     """
87     return 0, 0
88
89
90 def filter(function_or_none, sequence):
91     """Return those items of sequence for which function(item) is true. If
92     function is None, return the items that are true. If sequence is a tuple
93     or string, return the same type, else return a list.
94
95     :type function_or_none: collections.Callable | None
96     :type sequence: T <= list[V] | collections.Iterable[V] | bytes | unicode
97     :rtype: T
98     """
99     return sequence
100
101
102 def getattr(object, name, default=None):
103     """Get a named attribute from an object; getattr(x, 'y') is equivalent to
104     x.y. When a default argument is given, it is returned when the attribute
105     doesn't exist; without it, an exception is raised in that case.
106
107     :type name: string
108     """
109     pass
110
111
112 def globals():
113     """Return the dictionary containing the current scope's global variables.
114
115     :rtype: dict[string, unknown]
116     """
117     return {}
118
119
120 def hasattr(object, name):
121     """Return whether the object has an attribute with the given name.
122
123     :type name: string
124     :rtype: bool
125     """
126     return False
127
128
129 def hash(object):
130     """Return a hash value for the object.
131
132     :rtype: int
133     """
134     return 0
135
136
137 def hex(number):
138     """Return the hexadecimal representation of an integer or long integer.
139
140     :type number: numbers.Integral
141     :rtype: bytes
142     """
143     return b''
144
145
146 def id(object):
147     """Return the identity of an object.
148
149     :rtype: int
150     """
151     return 0
152
153
154 def isinstance(object, class_or_type_or_tuple):
155     """Return whether an object is an instance of a class or of a subclass
156     thereof.
157
158     :rtype: bool
159     """
160     return False
161
162
163 def issubclass(C, B):
164     """Return whether class C is a subclass (i.e., a derived class) of class B.
165
166     :rtype: bool
167     """
168     return False
169
170
171 def iter(o, sentinel=None):
172     """Get an iterator from an object. In the first form, the argument must
173     supply its own iterator, or be a sequence. In the second form, the callable
174     is called until it returns the sentinel.
175
176     :type o: collections.Iterable[T] | (() -> object)
177     :type sentinel: object | None
178     :rtype: collections.Iterator[T]
179     """
180     return []
181
182
183 def len(object):
184     """Return the number of items of a sequence or mapping.
185
186     :type object: collections.Sized
187     :rtype: int
188     """
189     return 0
190
191
192 def locals():
193     """Update and return a dictionary containing the current scope's local
194     variables.
195
196     :rtype: dict[string, unknown]
197     """
198     return {}
199
200
201 def map(function, sequence, *sequence_1):
202     """Return a list of the results of applying the function to the items of
203     the argument sequence(s).
204
205     :type function: ((T) -> V) | None
206     :type sequence: collections.Iterable[T]
207     :rtype: list[V] | bytes | unicode
208     """
209     pass
210
211
212 def next(iterator, default=None):
213     """Return the next item from the iterator.
214
215     :type iterator: collections.Iterator[T]
216     :rtype: T
217     """
218     pass
219
220
221 def oct(number):
222     """Return the octal representation of an integer or long integer.
223
224     :type number: numbers.Integral
225     :rtype: bytes
226     """
227     return b''
228
229
230 def open(name, mode='r', buffering=-1, encoding=None, errors=None, newline=None,
231          closefd=None, opener=None):
232     """Open a file, returns a file object.
233
234     :type name: string
235     :type mode: string
236     :type buffering: numbers.Integral
237     :type encoding: string | None
238     :type errors: string | None
239     :rtype: file
240     """
241     return file()
242
243
244 def ord(c):
245     """Return the integer ordinal of a one-character string.
246
247     :type c: string
248     :rtype: int
249     """
250     return 0
251
252
253 def pow(x, y, z=None):
254     """With two arguments, equivalent to x**y. With three arguments,
255     equivalent to (x**y) % z, but may be more efficient (e.g. for longs).
256
257     :type x: numbers.Number
258     :type y: numbers.Number
259     :type z: numbers.Number | None
260     :rtype: int | long | float | complex
261     """
262     return 0
263
264
265 def range(start, stop=None, step=None):
266     """Return a list containing an arithmetic progression of integers.
267
268     :type start: numbers.Integral
269     :type stop: numbers.Integral | None
270     :type step: numbers.Integral | None
271     :rtype: list[int]
272     """
273     return []
274
275
276 def reduce(function, sequence, initial=None):
277     """Apply a function of two arguments cumulatively to the items of a
278     sequence, from left to right, so as to reduce the sequence to a single
279     value.
280
281     :type function: collections.Callable
282     :type sequence: collections.Iterable
283     :type initial: T
284     :rtype: T | unknown
285     """
286     return initial
287
288
289 def repr(object):
290     """
291     Return the canonical string representation of the object.
292
293     :rtype: bytes
294     """
295     return b''
296
297
298 def round(number, ndigits=None):
299     """Round a number to a given precision in decimal digits (default 0 digits).
300
301     :type number: object
302     :type ndigits: numbers.Integral | None
303     :rtype: float
304     """
305     return 0.0
306
307
308 class slice(object):
309     def __init__(self, start, stop=None, step=None):
310         """Create a slice object. This is used for extended slicing (e.g.
311         a[0:10:2]).
312
313         :type start: numbers.Integral
314         :type stop: numbers.Integral | None
315         :type step: numbers.Integral | None
316         """
317         pass
318
319
320 def unichr(i):
321     """Return the Unicode string of one character whose Unicode code is the
322     integer i.
323
324     :type i: numbers.Integral
325     :rtype: unicode
326     """
327     return ''
328
329
330 def vars(object=None):
331     """Without arguments, equivalent to locals(). With an argument, equivalent
332     to object.__dict__.
333
334     :rtype: dict[string, unknown]
335     """
336     return {}
337
338
339 def zip(*iterables):
340     """This function returns a list of tuples, where the i-th tuple contains
341     the i-th element from each of the argument sequences or iterables.
342
343     :rtype: list[tuple]
344     """
345     return []
346
347
348 class object:
349     """ The most base type."""
350
351     @staticmethod
352     def __new__(cls, *more):
353         """Create a new object.
354
355         :type cls: T
356         :rtype: T
357         """
358         pass
359
360
361 class type(object):
362     """Type of object."""
363
364     def __instancecheck__(cls, instance):
365         """Return true if instance should be considered a (direct or indirect)
366         instance of class.
367         """
368         return False
369
370     def __subclasscheck__(cls, subclass):
371         """Return true if subclass should be considered a (direct or indirect)
372         subclass of class.
373         """
374         return False
375
376
377 class enumerate(object):
378     """enumerate object."""
379
380     def __init__(self, iterable, start=0):
381         """Create an enumerate object.
382
383         :type iterable: collections.Iterable[T]
384         :type start: numbers.Integral
385         :rtype: enumerate[T]
386         """
387         pass
388
389     def next(self):
390         """Return the next value, or raise StopIteration.
391
392         :rtype: (int, T)
393         """
394         pass
395
396     def __iter__(self):
397         """x.__iter__() <==> iter(x).
398
399         :rtype: collections.Iterator[(int, T)]
400         """
401         return self
402
403
404 class xrange(object):
405     """xrange object."""
406
407     def __init__(self, start, stop=None, step=None):
408         """Create an xrange object.
409
410         :type start: numbers.Integral
411         :type stop: numbers.Integral | None
412         :type step: numbers.Integral | None
413         :rtype: xrange[int]
414         """
415         pass
416
417
418 class int(object):
419     """Integer numeric type."""
420
421     def __init__(self, x=None, base=10):
422         """Convert a number or string x to an integer, or return 0 if no
423         arguments are given.
424
425         :type x: object
426         :type base: numbers.Integral
427         """
428         pass
429
430     def __eq__(self, y):
431         return False
432
433     def __ne__(self, y):
434         return False
435
436     def __lt__(self, y):
437         return False
438
439     def __gt__(self, y):
440         return False
441
442     def __le__(self, y):
443         return False
444
445     def __ge__(self, y):
446         return False
447
448     def __add__(self, y):
449         """Sum of x and y.
450
451         :type y: numbers.Number
452         :rtype: int
453         """
454         return 0
455
456     def __sub__(self, y):
457         """Difference of x and y.
458
459         :type y: numbers.Number
460         :rtype: int
461         """
462         return 0
463
464     def __mul__(self, y):
465         """Product of x and y.
466
467         :type y: numbers.Number
468         :rtype: int
469         """
470         return 0
471
472     def __floordiv__(self, y):
473         """Floored quotient of x and y.
474
475         :type y: numbers.Number
476         :rtype: int
477         """
478         return 0
479
480     def __mod__(self, y):
481         """Remainder of x / y.
482
483         :type y: numbers.Number
484         :rtype: int
485         """
486         return 0
487
488     def __pow__(self, y, modulo=None):
489         """x to the power y.
490
491         :type y: numbers.Number
492         :type modulo: numbers.Integral | None
493         :rtype: int
494         """
495         return 0
496
497     def __lshift__(self, n):
498         """x shifted left by n bits.
499
500         :type n: numbers.Integral
501         :rtype: int
502         """
503         return 0
504
505     def __rshift__(self, n):
506         """x shifted right by n bits.
507
508         :type n: numbers.Integral
509         :rtype: int
510         """
511         return 0
512
513     def __and__(self, y):
514         """Bitwise and of x and y.
515
516         :type y: numbers.Integral
517         :rtype: int
518         """
519         return 0
520
521     def __or__(self, y):
522         """Bitwise or of x and y.
523
524         :type y: numbers.Integral
525         :rtype: int
526         """
527         return 0
528
529     def __xor__(self, y):
530         """Bitwise exclusive or of x and y.
531
532         :type y: numbers.Integral
533         :rtype: int
534         """
535         return 0
536
537     def __div__(self, y):
538         """Quotient of x and y.
539
540         :type y: numbers.Number
541         :rtype: int
542         """
543         return 0
544
545     def __truediv__(self, y):
546         """Quotient of x and y.
547
548         :type y: numbers.Number
549         :rtype: int
550         """
551         return 0
552
553     def __radd__(self, y):
554         """Sum of y and x.
555
556         :type y: numbers.Number
557         :rtype: int
558         """
559         return 0
560
561     def __rsub__(self, y):
562         """Difference of y and x.
563
564         :type y: numbers.Number
565         :rtype: int
566         """
567         return 0
568
569     def __rmul__(self, y):
570         """Product of y and x.
571
572         :type y: numbers.Number
573         :rtype: int
574         """
575         return 0
576
577     def __rfloordiv__(self, y):
578         """Floored quotient of y and x.
579
580         :type y: numbers.Number
581         :rtype: int
582         """
583         return 0
584
585     def __rmod__(self, y):
586         """Remainder of y / x.
587
588         :type y: numbers.Number
589         :rtype: int
590         """
591         return 0
592
593     def __rpow__(self, y):
594         """x to the power y.
595
596         :type y: numbers.Number
597         :rtype: int
598         """
599         return 0
600
601     def __rlshift__(self, y):
602         """y shifted left by x bits.
603
604         :type y: numbers.Integral
605         :rtype: int
606         """
607         return 0
608
609     def __rrshift__(self, y):
610         """y shifted right by n bits.
611
612         :type y: numbers.Integral
613         :rtype: int
614         """
615         return 0
616
617     def __rand__(self, y):
618         """Bitwise and of y and x.
619
620         :type y: numbers.Integral
621         :rtype: int
622         """
623         return 0
624
625     def __ror__(self, y):
626         """Bitwise or of y and x.
627
628         :type y: numbers.Integral
629         :rtype: int
630         """
631         return 0
632
633     def __rxor__(self, y):
634         """Bitwise exclusive or of y and x.
635
636         :type y: numbers.Integral
637         :rtype: int
638         """
639         return 0
640
641     def __rdiv__(self, y):
642         """Quotient of y and x.
643
644         :type y: numbers.Number
645         :rtype: int
646         """
647         return 0
648
649     def __rtruediv__(self, y):
650         """Quotient of y and x.
651
652         :type y: numbers.Number
653         :rtype: int
654         """
655         return 0
656
657     def __pos__(self):
658         """x unchanged.
659
660         :rtype: int
661         """
662         return 0
663
664     def __neg__(self):
665         """x negated.
666
667         :rtype: int
668         """
669         return 0
670
671     def __invert__(self):
672         """The bits of x inverted.
673
674         :rtype: int
675         """
676         return 0
677
678
679 class long(object):
680     """Long integer numeric type."""
681
682     def __init__(self, x=None, base=10):
683         """Convert a number or string x to a long integer, or return 0 if
684         no arguments are given.
685
686         :type x: object
687         :type base: numbers.Integral
688         """
689         pass
690
691     def __add__(self, y):
692         """Sum of x and y.
693
694         :type y: numbers.Number
695         :rtype: long
696         """
697         return 0
698
699     def __sub__(self, y):
700         """Difference of x and y.
701
702         :type y: numbers.Number
703         :rtype: long
704         """
705         return 0
706
707     def __mul__(self, y):
708         """Product of x and y.
709
710         :type y: numbers.Number
711         :rtype: long
712         """
713         return 0
714
715     def __floordiv__(self, y):
716         """Floored quotient of x and y.
717
718         :type y: numbers.Number
719         :rtype: long
720         """
721         return 0
722
723     def __mod__(self, y):
724         """Remainder of x / y.
725
726         :type y: numbers.Number
727         :rtype: long
728         """
729         return 0
730
731     def __pow__(self, y, modulo=None):
732         """x to the power y.
733
734         :type y: numbers.Number
735         :type modulo: numbers.Integral | None
736         :rtype: long
737         """
738         return 0
739
740     def __lshift__(self, n):
741         """x shifted left by n bits.
742
743          :type n: numbers.Integral
744          :rtype: long
745          """
746         return 0
747
748     def __rshift__(self, n):
749         """x shifted right by n bits.
750
751          :type n: numbers.Integral
752          :rtype: long
753          """
754         return 0
755
756     def __and__(self, y):
757         """Bitwise and of x and y.
758
759         :type y: numbers.Integral
760         :rtype: long
761         """
762         return 0
763
764     def __or__(self, y):
765         """Bitwise or of x and y.
766
767         :type y: numbers.Integral
768         :rtype: long
769         """
770         return 0
771
772     def __xor__(self, y):
773         """Bitwise exclusive or of x and y.
774
775         :type y: numbers.Integral
776         :rtype: long
777         """
778         return 0
779
780     def __div__(self, y):
781         """Quotient of x and y.
782
783         :type y: numbers.Number
784         :rtype: long
785         """
786         return 0
787
788     def __truediv__(self, y):
789         """Quotient of x and y.
790
791         :type y: numbers.Number
792         :rtype: long
793         """
794         return 0
795
796     def __radd__(self, y):
797         """Sum of y and x.
798
799         :type y: numbers.Number
800         :rtype: long
801         """
802         return 0
803
804     def __rsub__(self, y):
805         """Difference of y and x.
806
807         :type y: numbers.Number
808         :rtype: long
809         """
810         return 0
811
812     def __rmul__(self, y):
813         """Product of y and x.
814
815         :type y: numbers.Number
816         :rtype: long
817         """
818         return 0
819
820     def __rfloordiv__(self, y):
821         """Floored quotient of y and x.
822
823         :type y: numbers.Number
824         :rtype: long
825         """
826         return 0
827
828     def __rmod__(self, y):
829         """Remainder of y / x.
830
831         :type y: numbers.Number
832         :rtype: long
833         """
834         return 0
835
836     def __rpow__(self, y):
837         """x to the power y.
838
839         :type y: numbers.Number
840         :rtype: long
841         """
842         return 0
843
844     def __rlshift__(self, y):
845         """y shifted left by x bits.
846
847          :type y: numbers.Integral
848          :rtype: long
849          """
850         return 0
851
852     def __rrshift__(self, y):
853         """y shifted right by n bits.
854
855          :type y: numbers.Integral
856          :rtype: long
857          """
858         return 0
859
860     def __rand__(self, y):
861         """Bitwise and of y and x.
862
863         :type y: numbers.Integral
864         :rtype: long
865         """
866         return 0
867
868     def __ror__(self, y):
869         """Bitwise or of y and x.
870
871         :type y: numbers.Integral
872         :rtype: long
873         """
874         return 0
875
876     def __rxor__(self, y):
877         """Bitwise exclusive or of y and x.
878
879         :type y: numbers.Integral
880         :rtype: long
881         """
882         return 0
883
884     def __rdiv__(self, y):
885         """Quotient of y and x.
886
887         :type y: numbers.Number
888         :rtype: long
889         """
890         return 0
891
892     def __rtruediv__(self, y):
893         """Quotient of y and x.
894
895         :type y: numbers.Number
896         :rtype: long
897         """
898         return 0
899
900     def __pos__(self):
901         """x unchanged.
902
903         :rtype: long
904         """
905         return 0
906
907     def __neg__(self):
908         """x negated.
909
910         :rtype: long
911         """
912         return 0
913
914     def __invert__(self):
915         """The bits of x inverted.
916
917         :rtype: long
918         """
919         return 0
920
921
922 class float(object):
923     """Floating point numeric type."""
924
925     def __init__(self, x=None):
926         """Convert a string or a number to floating point.
927
928         :type x: object
929         """
930         pass
931
932     def __add__(self, y):
933         """Sum of x and y.
934
935         :type y: numbers.Number
936         :rtype: float
937         """
938         return 0.0
939
940     def __sub__(self, y):
941         """Difference of x and y.
942
943         :type y: numbers.Number
944         :rtype: float
945         """
946         return 0.0
947
948     def __mul__(self, y):
949         """Product of x and y.
950
951         :type y: numbers.Number
952         :rtype: float
953         """
954         return 0.0
955
956     def __floordiv__(self, y):
957         """Floored quotient of x and y.
958
959         :type y: numbers.Number
960         :rtype: float
961         """
962         return 0.0
963
964     def __mod__(self, y):
965         """Remainder of x / y.
966
967         :type y: numbers.Number
968         :rtype: float
969         """
970         return 0.0
971
972     def __pow__(self, y):
973         """x to the power y.
974
975         :type y: numbers.Number
976         :rtype: float
977         """
978         return 0.0
979
980     def __div__(self, y):
981         """Quotient of x and y.
982
983         :type y: numbers.Number
984         :rtype: float
985         """
986         return 0.0
987
988     def __truediv__(self, y):
989         """Quotient of x and y.
990
991         :type y: numbers.Number
992         :rtype: float
993         """
994         return 0.0
995
996     def __radd__(self, y):
997         """Sum of y and x.
998
999         :type y: numbers.Number
1000         :rtype: float
1001         """
1002         return 0.0
1003
1004     def __rsub__(self, y):
1005         """Difference of y and x.
1006
1007         :type y: numbers.Number
1008         :rtype: float
1009         """
1010         return 0.0
1011
1012     def __rmul__(self, y):
1013         """Product of y and x.
1014
1015         :type y: numbers.Number
1016         :rtype: float
1017         """
1018         return 0.0
1019
1020     def __rfloordiv__(self, y):
1021         """Floored quotient of y and x.
1022
1023         :type y: numbers.Number
1024         :rtype: float
1025         """
1026         return 0.0
1027
1028     def __rmod__(self, y):
1029         """Remainder of y / x.
1030
1031         :type y: numbers.Number
1032         :rtype: float
1033         """
1034         return 0.0
1035
1036     def __rpow__(self, y):
1037         """x to the power y.
1038
1039         :type y: numbers.Number
1040         :rtype: float
1041         """
1042         return 0.0
1043
1044     def __rdiv__(self, y):
1045         """Quotient of y and x.
1046
1047         :type y: numbers.Number
1048         :rtype: float
1049         """
1050         return 0.0
1051
1052     def __rtruediv__(self, y):
1053         """Quotient of y and x.
1054
1055         :type y: numbers.Number
1056         :rtype: float
1057         """
1058         return 0.0
1059
1060     def __pos__(self):
1061         """x unchanged.
1062
1063         :rtype: float
1064         """
1065         return 0.0
1066
1067     def __neg__(self):
1068         """x negated.
1069
1070         :rtype: float
1071         """
1072         return 0.0
1073
1074
1075 class complex(object):
1076     """Complex numeric type."""
1077
1078     def __init__(self, real=None, imag=None):
1079         """Create a complex number with the value real + imag*j or convert a
1080         string or number to a complex number.
1081
1082         :type real: object
1083         :type imag: object
1084         """
1085         pass
1086
1087     def __add__(self, y):
1088         """Sum of x and y.
1089
1090         :type y: numbers.Number
1091         :rtype: complex
1092         """
1093         return 0j
1094
1095     def __sub__(self, y):
1096         """Difference of x and y.
1097
1098         :type y: numbers.Number
1099         :rtype: complex
1100         """
1101         return 0j
1102
1103     def __mul__(self, y):
1104         """Product of x and y.
1105
1106         :type y: numbers.Number
1107         :rtype: complex
1108         """
1109         return 0j
1110
1111     def __floordiv__(self, y):
1112         """Floored quotient of x and y.
1113
1114         :type y: numbers.Number
1115         :rtype: complex
1116         """
1117         return 0j
1118
1119     def __mod__(self, y):
1120         """Remainder of x / y.
1121
1122         :type y: numbers.Number
1123         :rtype: complex
1124         """
1125         return 0j
1126
1127     def __pow__(self, y):
1128         """x to the power y.
1129
1130         :type y: numbers.Number
1131         :rtype: complex
1132         """
1133         return 0j
1134
1135     def __div__(self, y):
1136         """Quotient of x and y.
1137
1138         :type y: numbers.Number
1139         :rtype: complex
1140         """
1141         return 0j
1142
1143     def __truediv__(self, y):
1144         """Quotient of x and y.
1145
1146         :type y: numbers.Number
1147         :rtype: complex
1148         """
1149         return 0j
1150
1151     def __radd__(self, y):
1152         """Sum of y and x.
1153
1154         :type y: numbers.Number
1155         :rtype: complex
1156         """
1157         return 0j
1158
1159     def __rsub__(self, y):
1160         """Difference of y and x.
1161
1162         :type y: numbers.Number
1163         :rtype: complex
1164         """
1165         return 0j
1166
1167     def __rmul__(self, y):
1168         """Product of y and x.
1169
1170         :type y: numbers.Number
1171         :rtype: complex
1172         """
1173         return 0j
1174
1175     def __rfloordiv__(self, y):
1176         """Floored quotient of y and x.
1177
1178         :type y: numbers.Number
1179         :rtype: complex
1180         """
1181         return 0j
1182
1183     def __rmod__(self, y):
1184         """Remainder of y / x.
1185
1186         :type y: numbers.Number
1187         :rtype: complex
1188         """
1189         return 0j
1190
1191     def __rpow__(self, y):
1192         """x to the power y.
1193
1194         :type y: numbers.Number
1195         :rtype: complex
1196         """
1197         return 0j
1198
1199     def __rdiv__(self, y):
1200         """Quotient of y and x.
1201
1202         :type y: numbers.Number
1203         :rtype: complex
1204         """
1205         return 0j
1206
1207     def __rtruediv__(self, y):
1208         """Quotient of y and x.
1209
1210         :type y: numbers.Number
1211         :rtype: complex
1212         """
1213         return 0j
1214
1215     def __pos__(self):
1216         """x unchanged.
1217
1218         :rtype: complex
1219         """
1220         return 0j
1221
1222     def __neg__(self):
1223         """x negated.
1224
1225         :rtype: complex
1226         """
1227         return 0j
1228
1229
1230 class str(basestring):
1231     """String object."""
1232
1233     def __init__(self, object=''):
1234         """Construct an immutable string.
1235
1236         :type object: object
1237         """
1238         pass
1239
1240     def __add__(self, y):
1241         """The concatenation of x and y.
1242
1243         :type y: string
1244         :rtype: string
1245         """
1246         return b''
1247
1248     def __mul__(self, n):
1249         """n shallow copies of x concatenated.
1250
1251         :type n: numbers.Integral
1252         :rtype: str
1253         """
1254         return b''
1255
1256     def __mod__(self, y):
1257         """x % y.
1258
1259         :rtype: string
1260         """
1261         return b''
1262
1263     def __rmul__(self, n):
1264         """n shallow copies of x concatenated.
1265
1266         :type n: numbers.Integral
1267         :rtype: str
1268         """
1269         return b''
1270
1271     def __getitem__(self, y):
1272         """y-th item of x, origin 0.
1273
1274         :type y: numbers.Integral
1275         :rtype: str
1276         """
1277         return b''
1278
1279     def __iter__(self):
1280         """Iterator over bytes.
1281
1282         :rtype: collections.Iterator[str]
1283         """
1284         return []
1285
1286     def capitalize(self):
1287         """Return a copy of the string with its first character capitalized
1288         and the rest lowercased.
1289
1290         :rtype: str
1291         """
1292         return b''
1293
1294     def center(self, width, fillchar=' '):
1295         """Return centered in a string of length width.
1296
1297         :type width: numbers.Integral
1298         :type fillchar: str
1299         :rtype: str
1300         """
1301         return b''
1302
1303     def count(self, sub, start=None, end=None):
1304         """Return the number of non-overlapping occurrences of substring
1305         sub in the range [start, end].
1306
1307         :type sub: string
1308         :type start: numbers.Integral | None
1309         :type end: numbers.Integral | None
1310         :rtype: int
1311         """
1312         return 0
1313
1314     def decode(self, encoding='utf-8', errors='strict'):
1315         """Return a string decoded from the given bytes.
1316
1317         :type encoding: string
1318         :type errors: string
1319         :rtype: unicode
1320         """
1321         return ''
1322
1323     def encode(self, encoding='utf-8', errors='strict'):
1324         """Return an encoded version of the string as a bytes object.
1325
1326         :type encoding: string
1327         :type errors: string
1328         :rtype: str
1329         """
1330         return b''
1331
1332     def endswith(self, suffix, start=None, end=None):
1333         """Return True if the string ends with the specified suffix,
1334         otherwise return False.
1335
1336         :type suffix: string | tuple
1337         :type start: numbers.Integral | None
1338         :type end: numbers.Integral | None
1339         :rtype: bool
1340         """
1341         return False
1342
1343     def find(self, sub, start=None, end=None):
1344         """Return the lowest index in the string where substring sub is
1345         found, such that sub is contained in the slice s[start:end].
1346
1347         :type sub: string
1348         :type start: numbers.Integral | None
1349         :type end: numbers.Integral | none
1350         :rtype: int
1351         """
1352         return 0
1353
1354     def format(self, *args, **kwargs):
1355         """Perform a string formatting operation.
1356
1357         :rtype: string
1358         """
1359         return ''
1360
1361     def index(self, sub, start=None, end=None):
1362         """Like find(), but raise ValueError when the substring is not
1363         found.
1364
1365         :type sub: string
1366         :type start: numbers.Integral | None
1367         :type end: numbers.Integral | none
1368         :rtype: int
1369         """
1370         return 0
1371
1372     def isalnum(self):
1373         """Return true if all characters in the string are alphanumeric and
1374         there is at least one character, false otherwise.
1375
1376         :rtype: bool
1377         """
1378         return False
1379
1380     def isalpha(self):
1381         """Return true if all characters in the string are alphabetic and there
1382         is at least one character, false otherwise.
1383
1384         :rtype: bool
1385         """
1386         return False
1387
1388     def isdigit(self):
1389         """Return true if all characters in the string are digits and there
1390         is at least one character, false otherwise.
1391
1392         :rtype: bool
1393         """
1394         return False
1395
1396     def islower(self):
1397         """Return true if all cased characters in the string are lowercase
1398         and there is at least one cased character, false otherwise.
1399
1400         :rtype: bool
1401         """
1402         return False
1403
1404     def isspace(self):
1405         """Return true if there are only whitespace characters in the
1406         string and there is at least one character, false otherwise.
1407
1408         :rtype: bool
1409         """
1410         return False
1411
1412     def istitle(self):
1413         """Return true if the string is a titlecased string and there is at
1414         least one character, for example uppercase characters may only
1415         follow uncased characters and lowercase characters only cased ones.
1416
1417         :rtype: bool
1418         """
1419         return False
1420
1421     def isupper(self):
1422         """Return true if all cased characters in the string are uppercase
1423         and there is at least one cased character, false otherwise.
1424
1425         :rtype: bool
1426         """
1427         return False
1428
1429     def join(self, iterable):
1430         """Return a string which is the concatenation of the strings in the
1431         iterable.
1432
1433         :type iterable: collections.Iterable[string]
1434         :rtype: string
1435         """
1436         return ''
1437
1438     def ljust(self, width, fillchar=' '):
1439         """Return the string left justified in a string of length width.
1440         Padding is done using the specified fillchar (default is a space).
1441
1442         :type width: numbers.Integral
1443         :type fillchar: str
1444         :rtype: str
1445         """
1446         return b''
1447
1448     def lower(self):
1449         """Return a copy of the string with all the cased characters
1450         converted to lowercase.
1451
1452         :rtype: str
1453         """
1454         return b''
1455
1456     def lstrip(self, chars=None):
1457         """Return a copy of the string with leading characters removed.
1458
1459         :type chars: string | None
1460         :rtype: str
1461         """
1462         return b''
1463
1464     def partition(self, sep):
1465         """Split the string at the first occurrence of sep, and return a
1466         3-tuple containing the part before the separator, the separator
1467         itself, and the part after the separator.
1468
1469         :type sep: string
1470         :rtype: (str, str, str)
1471         """
1472         return b'', b'', b''
1473
1474     def replace(self, old, new, count=-1):
1475         """Return a copy of the string with all occurrences of substring
1476         old replaced by new.
1477
1478         :type old: string
1479         :type new: string
1480         :type count: numbers.Integral
1481         :rtype: string
1482         """
1483         return ''
1484
1485     def rfind(self, sub, start=None, end=None):
1486         """Return the highest index in the string where substring sub is
1487         found, such that sub is contained within s[start:end].
1488
1489         :type sub: string
1490         :type start: numbers.Integral | None
1491         :type end: numbers.Integral | none
1492         :rtype: int
1493         """
1494         return 0
1495
1496     def rindex(self, sub, start=None, end=None):
1497         """Like rfind(), but raise ValueError when the substring is not
1498         found.
1499
1500         :type sub: string
1501         :type start: numbers.Integral | None
1502         :type end: numbers.Integral | none
1503         :rtype: int
1504         """
1505         return 0
1506
1507     def rjust(self, width, fillchar=' '):
1508         """Return the string right justified in a string of length width.
1509         Padding is done using the specified fillchar (default is a space).
1510
1511         :type width: numbers.Integral
1512         :type fillchar: string
1513         :rtype: string
1514         """
1515         return ''
1516
1517     def rpartition(self, sep):
1518         """Split the string at the last occurrence of sep, and return a
1519         3-tuple containing the part before the separator, the separator
1520         itself, and the part after the separator.
1521
1522         :type sep: string
1523         :rtype: (str, str, str)
1524         """
1525         return b'', b'', b''
1526
1527     def rsplit(self, sep=None, maxsplit=-1):
1528         """Return a list of the words in the string, using sep as the
1529         delimiter string.
1530
1531         :type sep: string | None
1532         :type maxsplit: numbers.Integral
1533         :rtype: list[str]
1534         """
1535         return []
1536
1537     def rstrip(self, chars=None):
1538         """Return a copy of the string with trailing characters removed.
1539
1540         :type chars: string | None
1541         :rtype: str
1542         """
1543         return b''
1544
1545     def split(self, sep=None, maxsplit=-1):
1546         """Return a list of the words in the string, using sep as the
1547         delimiter string.
1548
1549         :type sep: string | None
1550         :type maxsplit: numbers.Integral
1551         :rtype: list[str]
1552         """
1553         return []
1554
1555     def splitlines(self, keepends=False):
1556         """Return a list of the lines in the string, breaking at line
1557         boundaries.
1558
1559         :type keepends: bool
1560         :rtype: list[str]
1561         """
1562         return []
1563
1564     def startswith(self, prefix, start=None, end=None):
1565         """Return True if string starts with the prefix, otherwise return
1566         False.
1567
1568         :type prefix: string | tuple
1569         :type start: numbers.Integral | None
1570         :type end: numbers.Integral | None
1571         :rtype: bool
1572         """
1573         return False
1574
1575     def strip(self, chars=None):
1576         """Return a copy of the string with the leading and trailing
1577         characters removed.
1578
1579         :type chars: string | None
1580         :rtype: str
1581         """
1582         return b''
1583
1584     def swapcase(self):
1585         """Return a copy of the string with uppercase characters converted
1586         to lowercase and vice versa.
1587
1588         :rtype: str
1589         """
1590         return b''
1591
1592     def title(self):
1593         """Return a titlecased version of the string where words start with
1594         an uppercase character and the remaining characters are lowercase.
1595
1596         :rtype: str
1597         """
1598         return b''
1599
1600     def upper(self):
1601         """Return a copy of the string with all the cased characters
1602         converted to uppercase.
1603
1604         :rtype: str
1605         """
1606         return b''
1607
1608     def zfill(self, width):
1609         """Return the numeric string left filled with zeros in a string of
1610         length width.
1611
1612         :type width: numbers.Integral
1613         :rtype: str
1614         """
1615         return b''
1616
1617
1618 class unicode(basestring):
1619     """Unicode string object."""
1620
1621     def __init__(self, object='', encoding='utf-8', errors='strict'):
1622         """Construct an immutable Unicode string.
1623
1624         :type object: object
1625         :type encoding: string
1626         :type errors: string
1627         """
1628         pass
1629
1630     def __add__(self, y):
1631         """The concatenation of x and y.
1632
1633         :type y: string
1634         :rtype: unicode
1635         """
1636         return ''
1637
1638     def __mul__(self, n):
1639         """n shallow copies of x concatenated.
1640
1641         :type n: numbers.Integral
1642         :rtype: unicode
1643         """
1644         return ''
1645
1646     def __mod__(self, y):
1647         """x % y.
1648
1649         :rtype: unicode
1650         """
1651         return ''
1652
1653     def __rmul__(self, n):
1654         """n shallow copies of x concatenated.
1655
1656         :type n: numbers.Integral
1657         :rtype: unicode
1658         """
1659         return ''
1660
1661     def __getitem__(self, y):
1662         """y-th item of x, origin 0.
1663
1664         :type y: numbers.Integral
1665         :rtype: unicode
1666         """
1667         return ''
1668
1669     def __iter__(self):
1670         """Iterator over bytes.
1671
1672         :rtype: collections.Iterator[unicode]
1673         """
1674         return []
1675
1676     def capitalize(self):
1677         """Return a copy of the string with its first character capitalized
1678         and the rest lowercased.
1679
1680         :rtype: unicode
1681         """
1682         return ''
1683
1684     def center(self, width, fillchar=' '):
1685         """Return centered in a string of length width.
1686
1687         :type width: numbers.Integral
1688         :type fillchar: string
1689         :rtype: unicode
1690         """
1691         return ''
1692
1693     def count(self, sub, start=None, end=None):
1694         """Return the number of non-overlapping occurrences of substring
1695         sub in the range [start, end].
1696
1697         :type sub: string
1698         :type start: numbers.Integral | None
1699         :type end: numbers.Integral | None
1700         :rtype: int
1701         """
1702         return 0
1703
1704     def decode(self, encoding='utf-8', errors='strict'):
1705         """Return a string decoded from the given bytes.
1706
1707         :type encoding: string
1708         :type errors: string
1709         :rtype: unicode
1710         """
1711         return ''
1712
1713     def encode(self, encoding='utf-8', errors='strict'):
1714         """Return an encoded version of the string as a bytes object.
1715
1716         :type encoding: string
1717         :type errors: string
1718         :rtype: bytes
1719         """
1720         return b''
1721
1722     def endswith(self, suffix, start=None, end=None):
1723         """Return True if the string ends with the specified suffix,
1724         otherwise return False.
1725
1726         :type suffix: string | tuple
1727         :type start: numbers.Integral | None
1728         :type end: numbers.Integral | None
1729         :rtype: bool
1730         """
1731         return False
1732
1733     def find(self, sub, start=None, end=None):
1734         """Return the lowest index in the string where substring sub is
1735         found, such that sub is contained in the slice s[start:end].
1736
1737         :type sub: string
1738         :type start: numbers.Integral | None
1739         :type end: numbers.Integral | none
1740         :rtype: int
1741         """
1742         return 0
1743
1744     def format(self, *args, **kwargs):
1745         """Perform a string formatting operation.
1746
1747         :rtype: unicode
1748         """
1749         return ''
1750
1751     def index(self, sub, start=None, end=None):
1752         """Like find(), but raise ValueError when the substring is not
1753         found.
1754
1755         :type sub: string
1756         :type start: numbers.Integral | None
1757         :type end: numbers.Integral | none
1758         :rtype: int
1759         """
1760         return 0
1761
1762     def isalnum(self):
1763         """Return true if all characters in the string are alphanumeric and
1764         there is at least one character, false otherwise.
1765
1766         :rtype: bool
1767         """
1768         return False
1769
1770     def isalpha(self):
1771         """Return true if all characters in the string are alphabetic and there
1772         is at least one character, false otherwise.
1773
1774         :rtype: bool
1775         """
1776         return False
1777
1778     def isdigit(self):
1779         """Return true if all characters in the string are digits and there
1780         is at least one character, false otherwise.
1781
1782         :rtype: bool
1783         """
1784         return False
1785
1786     def islower(self):
1787         """Return true if all cased characters in the string are lowercase
1788         and there is at least one cased character, false otherwise.
1789
1790         :rtype: bool
1791         """
1792         return False
1793
1794     def isspace(self):
1795         """Return true if there are only whitespace characters in the
1796         string and there is at least one character, false otherwise.
1797
1798         :rtype: bool
1799         """
1800         return False
1801
1802     def istitle(self):
1803         """Return true if the string is a titlecased string and there is at
1804         least one character, for example uppercase characters may only
1805         follow uncased characters and lowercase characters only cased ones.
1806
1807         :rtype: bool
1808         """
1809         return False
1810
1811     def isupper(self):
1812         """Return true if all cased characters in the string are uppercase
1813         and there is at least one cased character, false otherwise.
1814
1815         :rtype: bool
1816         """
1817         return False
1818
1819     def join(self, iterable):
1820         """Return a string which is the concatenation of the strings in the
1821         iterable.
1822
1823         :type iterable: collections.Iterable[string]
1824         :rtype: unicode
1825         """
1826         return ''
1827
1828     def ljust(self, width, fillchar=' '):
1829         """Return the string left justified in a string of length width.
1830         Padding is done using the specified fillchar (default is a space).
1831
1832         :type width: numbers.Integral
1833         :type fillchar: string
1834         :rtype: unicode
1835         """
1836         return ''
1837
1838     def lower(self):
1839         """Return a copy of the string with all the cased characters
1840         converted to lowercase.
1841
1842         :rtype: unicode
1843         """
1844         return ''
1845
1846     def lstrip(self, chars=None):
1847         """Return a copy of the string with leading characters removed.
1848
1849         :type chars: string | None
1850         :rtype: unicode
1851         """
1852         return ''
1853
1854     def partition(self, sep):
1855         """Split the string at the first occurrence of sep, and return a
1856         3-tuple containing the part before the separator, the separator
1857         itself, and the part after the separator.
1858
1859         :type sep: string
1860         :rtype: (unicode, unicode, unicode)
1861         """
1862         return '', '', ''
1863
1864     def replace(self, old, new, count=-1):
1865         """Return a copy of the string with all occurrences of substring
1866         old replaced by new.
1867
1868         :type old: string
1869         :type new: string
1870         :type count: numbers.Integral
1871         :rtype: unicode
1872         """
1873         return ''
1874
1875     def rfind(self, sub, start=None, end=None):
1876         """Return the highest index in the string where substring sub is
1877         found, such that sub is contained within s[start:end].
1878
1879         :type sub: string
1880         :type start: numbers.Integral | None
1881         :type end: numbers.Integral | none
1882         :rtype: int
1883         """
1884         return 0
1885
1886     def rindex(self, sub, start=None, end=None):
1887         """Like rfind(), but raise ValueError when the substring is not
1888         found.
1889
1890         :type sub: string
1891         :type start: numbers.Integral | None
1892         :type end: numbers.Integral | none
1893         :rtype: int
1894         """
1895         return 0
1896
1897     def rjust(self, width, fillchar=' '):
1898         """Return the string right justified in a string of length width.
1899         Padding is done using the specified fillchar (default is a space).
1900
1901         :type width: numbers.Integral
1902         :type fillchar: string
1903         :rtype: unicode
1904         """
1905         return ''
1906
1907     def rpartition(self, sep):
1908         """Split the string at the last occurrence of sep, and return a
1909         3-tuple containing the part before the separator, the separator
1910         itself, and the part after the separator.
1911
1912         :type sep: string
1913         :rtype: (unicode, unicode, unicode)
1914         """
1915         return '', '', ''
1916
1917     def rsplit(self, sep=None, maxsplit=-1):
1918         """Return a list of the words in the string, using sep as the
1919         delimiter string.
1920
1921         :type sep: string | None
1922         :type maxsplit: numbers.Integral
1923         :rtype: list[unicode]
1924         """
1925         return []
1926
1927     def rstrip(self, chars=None):
1928         """Return a copy of the string with trailing characters removed.
1929
1930         :type chars: string | None
1931         :rtype: unicode
1932         """
1933         return ''
1934
1935     def split(self, sep=None, maxsplit=-1):
1936         """Return a list of the words in the string, using sep as the
1937         delimiter string.
1938
1939         :type sep: string | None
1940         :type maxsplit: numbers.Integral
1941         :rtype: list[unicode]
1942         """
1943         return []
1944
1945     def splitlines(self, keepends=False):
1946         """Return a list of the lines in the string, breaking at line
1947         boundaries.
1948
1949         :type keepends: bool
1950         :rtype: list[unicode]
1951         """
1952         return []
1953
1954     def startswith(self, prefix, start=None, end=None):
1955         """Return True if string starts with the prefix, otherwise return
1956         False.
1957
1958         :type prefix: string | tuple
1959         :type start: numbers.Integral | None
1960         :type end: numbers.Integral | None
1961         :rtype: bool
1962         """
1963         return False
1964
1965     def strip(self, chars=None):
1966         """Return a copy of the string with the leading and trailing
1967         characters removed.
1968
1969         :type chars: string | None
1970         :rtype: unicode
1971         """
1972         return ''
1973
1974     def swapcase(self):
1975         """Return a copy of the string with uppercase characters converted
1976         to lowercase and vice versa.
1977
1978         :rtype: unicode
1979         """
1980         return ''
1981
1982     def title(self):
1983         """Return a titlecased version of the string where words start with
1984         an uppercase character and the remaining characters are lowercase.
1985
1986         :rtype: unicode
1987         """
1988         return ''
1989
1990     def upper(self):
1991         """Return a copy of the string with all the cased characters
1992         converted to uppercase.
1993
1994         :rtype: unicode
1995         """
1996         return ''
1997
1998     def zfill(self, width):
1999         """Return the numeric string left filled with zeros in a string of
2000         length width.
2001
2002         :type width: numbers.Integral
2003         :rtype: unicode
2004         """
2005         return ''
2006
2007
2008 class list(object):
2009     """List object."""
2010
2011     def __init__(self, iterable=None):
2012         """Create a list object.
2013
2014         :type iterable: collections.Iterable[T]
2015         :rtype: list[T]
2016         """
2017         pass
2018
2019     def __add__(self, y):
2020         """The concatenation of x and y.
2021
2022         :type y: list[T]
2023         :rtype: list[T]
2024         """
2025         return []
2026
2027     def __mul__(self, n):
2028         """n shallow copies of x concatenated.
2029
2030         :type n: numbers.Integral
2031         :rtype: list[T]
2032         """
2033         return []
2034
2035     def __rmul__(self, n):
2036         """n shallow copies of x concatenated.
2037
2038         :type n: numbers.Integral
2039         :rtype: list[T]
2040         """
2041         return []
2042
2043     def __iter__(self):
2044         """
2045         :rtype: collections.Iterator[T]
2046         """
2047         return []
2048
2049     def __getitem__(self, y):
2050         """y-th item of x, origin 0.
2051
2052         :type y: numbers.Integral
2053         :rtype: T
2054         """
2055         pass
2056
2057     def __setitem__(self, i, y):
2058         """Item i is replaced by y.
2059
2060         :type i: numbers.Integral
2061         :type y: T
2062         :rtype: None
2063         """
2064         pass
2065
2066     def __delitem__(self, i):
2067         """Remove i-th item.
2068
2069         :type i: numbers.Integral
2070         :rtype: None
2071         """
2072         pass
2073
2074     def append(self, x):
2075         """Appends x to the end of the sequence.
2076
2077         :type x: T
2078         :rtype: None
2079         """
2080         pass
2081
2082     def extend(self, t):
2083         """Extends the sequence with the contents of t.
2084
2085         :type t: collections.Iterable[T]
2086         :rtype: None
2087         """
2088         pass
2089
2090     def count(self, x):
2091         """Total number of occurrences of x in the sequence.
2092
2093         :type x: T
2094         :rtype: int
2095         """
2096         return 0
2097
2098     def index(self, x, i=None, j=None):
2099         """Index of the first occurrence of x in the sequence.
2100
2101         :type x: T
2102         :type i: numbers.Integral | None
2103         :type j: numbers.Integral | none
2104         :rtype: int
2105         """
2106         return 0
2107
2108     def insert(self, i, x):
2109         """Inserts x into the sequence at the index given by i.
2110
2111         :type i: numbers.Number
2112         :type x: T
2113         :rtype: None
2114         """
2115         pass
2116
2117     def pop(self, i=-1):
2118         """Retrieves the item at i and also removes it from the sequence.
2119
2120         :type i: numbers.Number
2121         :rtype: T
2122         """
2123         pass
2124
2125     def remove(self, x):
2126         """Remove the first item x from the sequence.
2127
2128         :type x: T
2129         :rtype: None
2130         """
2131         pass
2132
2133     def sort(self, cmp=None, key=None, reverse=False):
2134         """Sort the items of the sequence in place.
2135
2136         :type cmp: ((T, T) -> int) | None
2137         :type key: ((T) -> object) | None
2138         :type reverse: bool
2139         :rtype: None
2140         """
2141         pass
2142
2143
2144 class tuple(object):
2145     """Tuple object."""
2146
2147     def __add__(self, y):
2148         """The concatenation of x and y.
2149
2150         :type y: tuple
2151         :rtype: tuple
2152         """
2153         pass
2154
2155     def __mul__(self, n):
2156         """n shallow copies of x concatenated.
2157
2158         :type n: numbers.Integral
2159         :rtype: tuple
2160         """
2161         pass
2162
2163     def __rmul__(self, n):
2164         """n shallow copies of x concatenated.
2165
2166         :type n: numbers.Integral
2167         :rtype: tuple
2168         """
2169         pass
2170
2171     def __getitem__(self, y):
2172         """y-th item of x, origin 0.
2173
2174         :type y: numbers.Integral
2175         :rtype: object | unknown
2176         """
2177         pass
2178
2179     def count(self, x):
2180         """Total number of occurrences of x in the sequence.
2181
2182         :type x: object
2183         :rtype: int
2184         """
2185         return 0
2186
2187     def index(self, x, i=None, j=None):
2188         """Index of the first occurrence of x in the sequence.
2189
2190         :type x: object
2191         :type i: numbers.Integral | None
2192         :type j: numbers.Integral | none
2193         :rtype: int
2194         """
2195         return 0
2196
2197
2198 class dict(object):
2199     """Dictionary object."""
2200
2201     def __init__(self, iterable=None, **kwargs):
2202         """Create a dictionary object.
2203
2204         :type iterable: collections.Iterable[(T, V)]
2205         :rtype: dict[T, V]
2206         """
2207         pass
2208
2209     def __iter__(self):
2210         """
2211         :rtype: collections.Iterator[T]
2212         """
2213         pass
2214
2215     def __len__(self):
2216         """Return the number of items in the dictionary d.
2217
2218         :rtype: int
2219         """
2220         return 0
2221
2222     def __getitem__(self, key):
2223         """Return the item of d with key key.
2224
2225         :type key: T
2226         :rtype: V
2227         """
2228         pass
2229
2230     def __setitem__(self, key, value):
2231         """Set d[key] to value.
2232
2233         :type key: T
2234         :type value: V
2235         :rtype: None
2236         """
2237         pass
2238
2239     def __delitem__(self, key):
2240         """Remove d[key] from d.
2241
2242         :type key: T
2243         :rtype: None
2244         """
2245         pass
2246
2247     def copy(self):
2248         """Return a shallow copy of the dictionary.
2249
2250         :rtype: dict[T, V]
2251         """
2252         return self
2253
2254     @staticmethod
2255     def fromkeys(seq, value=None):
2256         """Create a new dictionary with keys from seq and values set to value.
2257
2258         :type seq: collections.Iterable[T]
2259         :type value: V
2260         :rtype: dict[T, V]
2261         """
2262         return {}
2263
2264     def get(self, key, default=None):
2265         """Return the value for key if key is in the dictionary, else default.
2266
2267         :type key: T
2268         :type default: V | None
2269         :rtype: V
2270         """
2271         pass
2272
2273     def has_key(self, key):
2274         """Return True if d has a key key, else False.
2275
2276         :type key: T
2277         :rtype: bool
2278         """
2279         return False
2280
2281     def items(self):
2282         """Return a copy of the dictionary's list of (key, value) pairs.
2283
2284         :rtype: list[(T, V)]
2285         """
2286         return []
2287
2288     def iteritems(self):
2289         """Return an iterator over the dictionary's (key, value) pairs.
2290
2291         :rtype: collections.Iterable[(T, V)]
2292         """
2293         return []
2294
2295     def iterkeys(self):
2296         """Return an iterator over the dictionary's keys.
2297
2298         :rtype: collections.Iterable[T]
2299         """
2300         return []
2301
2302     def itervalues(self):
2303         """Return an iterator over the dictionary's values.
2304
2305         :rtype: collections.Iterable[V]
2306         """
2307         return []
2308
2309     def keys(self):
2310         """Return a copy of the dictionary's list of keys.
2311
2312         :rtype: list[T]
2313         """
2314         return []
2315
2316     def pop(self, key, default=None):
2317         """If key is in the dictionary, remove it and return its value, else
2318         return default.
2319
2320         :type key: T
2321         :type default: V | None
2322         :rtype: V
2323         """
2324         pass
2325
2326     def popitem(self):
2327         """Remove and return an arbitrary (key, value) pair from the
2328         dictionary.
2329
2330         :rtype: (T, V)
2331         """
2332         pass
2333
2334     def setdefault(self, key, default=None):
2335         """If key is in the dictionary, return its value.
2336
2337         :type key: T
2338         :type default: V | None
2339         :rtype: V
2340         """
2341         pass
2342
2343     def update(self, other=None, **kwargs):
2344         """Update the dictionary with the key/value pairs from other,
2345         overwriting existing keys.
2346
2347         :type other: dict[T, V] | collections.Iterable[(T, V)]
2348         :rtype: None
2349         """
2350         pass
2351
2352     def values():
2353         """Return a copy of the dictionary's list of values.
2354
2355         :rtype: list[V]
2356         """
2357         return []
2358
2359
2360 class file(object):
2361     """File object."""
2362
2363     def __init__(self, name, mode='r', buffering=-1):
2364         """Create a file object.
2365
2366         :type name: string
2367         :type mode: string
2368         :type buffering: numbers.Integral
2369         """
2370         self.name = name
2371         self.mode = mode
2372
2373     def fileno(self):
2374         """Return the integer "file descriptor" that is used by the
2375         underlying implementation to request I/O operations from the
2376         operating system.
2377
2378         :rtype: int
2379         """
2380         return 0
2381
2382     def isatty(self):
2383         """Return True if the file is connected to a tty(-like) device,
2384         else False.
2385
2386         :rtype: bool
2387         """
2388         return False
2389
2390     def next(self):
2391         """Returns the next input line.
2392
2393         :rtype: bytes
2394         """
2395         return ''
2396
2397     def read(self, size=-1):
2398         """Read at most size bytes from the file (less if the read hits EOF
2399         before obtaining size bytes).
2400
2401         :type size: numbers.Integral
2402         :rtype: bytes
2403         """
2404         return ''
2405
2406     def readline(self, size=-1):
2407         """Read one entire line from the file.
2408
2409         :type size: numbers.Integral
2410         :rtype: bytes
2411         """
2412         return ''
2413
2414     def readlines(self, sizehint=-1):
2415         """Read until EOF using readline() and return a list containing the
2416         lines thus read.
2417
2418         :type sizehint: numbers.Integral
2419         :rtype: list[bytes]
2420         """
2421         return []
2422
2423     def xreadlines(self):
2424         """This method returns the same thing as iter(f).
2425
2426         :rtype: collections.Iterable[bytes]
2427         """
2428         return []
2429
2430     def seek(self, offset, whence=0):
2431         """Set the file's current position, like stdio's fseek().
2432
2433         :type offset: numbers.Integral
2434         :type whence: numbers.Integral
2435         :rtype: None
2436         """
2437         pass
2438
2439     def tell(self):
2440         """Return the file's current position, like stdio's ftell().
2441
2442         :rtype: int
2443         """
2444         return 0
2445
2446     def truncate(self, size=-1):
2447         """Truncate the file's size.
2448
2449         :type size: numbers.Integral
2450         :rtype: None
2451         """
2452         pass
2453
2454     def write(self, str):
2455         """"Write a string to the file.
2456
2457         :type str: bytes
2458         :rtype: None
2459         """
2460         pass
2461
2462     def writelines(self, sequence):
2463         """Write a sequence of strings to the file.
2464
2465         :type sequence: collections.Iterable[bytes]
2466         :rtype: None
2467         """
2468         pass
2469
2470
2471 class __generator(object):
2472     """A mock class representing the generator function type."""
2473     def __init__(self):
2474         """Create a generator object.
2475
2476         :rtype: __generator[T, U, V]
2477         """
2478         self.gi_code = None
2479         self.gi_frame = None
2480         self.gi_running = 0
2481
2482     def __iter__(self):
2483         """Defined to support iteration over container.
2484
2485         :rtype: collections.Iterator[T]
2486         """
2487         pass
2488
2489     def next(self):
2490         """Return the next item from the container.
2491
2492         :rtype: T
2493         """
2494         pass
2495
2496     def close(self):
2497         """Raises new GeneratorExit exception inside the generator to
2498         terminate the iteration.
2499
2500         :rtype: None
2501         """
2502         pass
2503
2504     def send(self, value):
2505         """Resumes the generator and "sends" a value that becomes the
2506         result of the current yield-expression.
2507
2508         :type value: U
2509         :rtype: None
2510         """
2511         pass
2512
2513     def throw(self, type, value=None, traceback=None):
2514         """Used to raise an exception inside the generator.
2515
2516         :rtype: None
2517         """
2518         pass
2519
2520
2521 class __function(object):
2522     """A mock class representing function type."""
2523
2524     def __init__(self):
2525         self.__name__ = ''
2526         self.__doc__ = ''
2527         self.__dict__ = ''
2528         self.__module__ = ''
2529
2530         self.func_defaults = {}
2531         self.func_globals = {}
2532         self.func_closure = None
2533         self.func_code = None
2534         self.func_name = ''
2535         self.func_doc = ''
2536         self.func_dict = ''
2537
2538         if sys.version_info >= (2, 6):
2539             self.__defaults__ = {}
2540             self.__globals__ = {}
2541             self.__closure__ = None
2542             self.__code__ = None
2543
2544
2545 class __method(object):
2546     """A mock class representing method type (both bound and unbound)."""
2547
2548     def __init__(self):
2549         self.im_class = None
2550         self.im_self = None
2551         self.im_func = None
2552
2553         if sys.version_info >= (2, 6):
2554             self.__func__ = None
2555             self.__self__ = None