java-api 17.25.0__py2-none-any.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (46) hide show
  1. java/__init__.py +0 -0
  2. java/awt/__init__.py +265 -0
  3. java/awt/event/__init__.py +184 -0
  4. java/awt/geom/__init__.py +116 -0
  5. java/awt/image/__init__.py +14 -0
  6. java/awt/print/__init__.py +93 -0
  7. java/beans/__init__.py +38 -0
  8. java/io/__init__.py +442 -0
  9. java/lang/__init__.py +868 -0
  10. java/lang/reflect/__init__.py +9 -0
  11. java/math/__init__.py +93 -0
  12. java/net/__init__.py +504 -0
  13. java/net/http/__init__.py +15 -0
  14. java/nio/__init__.py +667 -0
  15. java/nio/channels/__init__.py +352 -0
  16. java/nio/charset/__init__.py +146 -0
  17. java/nio/file/__init__.py +728 -0
  18. java/nio/file/attribute/__init__.py +141 -0
  19. java/org/__init__.py +0 -0
  20. java/org/jdesktop/__init__.py +0 -0
  21. java/org/jdesktop/core/__init__.py +0 -0
  22. java/org/jdesktop/core/animation/__init__.py +0 -0
  23. java/org/jdesktop/core/animation/timing/__init__.py +17 -0
  24. java/security/__init__.py +27 -0
  25. java/text/__init__.py +543 -0
  26. java/time/__init__.py +575 -0
  27. java/time/chrono/__init__.py +319 -0
  28. java/time/format/__init__.py +72 -0
  29. java/time/temporal/__init__.py +353 -0
  30. java/util/__init__.py +1479 -0
  31. java/util/concurrent/__init__.py +147 -0
  32. java/util/function/__init__.py +131 -0
  33. java/util/regex/__init__.py +197 -0
  34. java/util/stream/__init__.py +128 -0
  35. java_api-17.25.0.dist-info/LICENSE +21 -0
  36. java_api-17.25.0.dist-info/METADATA +150 -0
  37. java_api-17.25.0.dist-info/RECORD +46 -0
  38. java_api-17.25.0.dist-info/WHEEL +5 -0
  39. java_api-17.25.0.dist-info/top_level.txt +2 -0
  40. javax/__init__.py +0 -0
  41. javax/security/__init__.py +0 -0
  42. javax/security/auth/__init__.py +14 -0
  43. javax/swing/__init__.py +483 -0
  44. javax/swing/event/__init__.py +43 -0
  45. javax/swing/plaf/__init__.py +28 -0
  46. javax/swing/text/__init__.py +19 -0
java/util/__init__.py ADDED
@@ -0,0 +1,1479 @@
1
+ """Contains the collections framework, legacy collection classes, event
2
+ model, date and time facilities, internationalization, and miscellaneous
3
+ utility classes (a string tokenizer, a random-number generator, and a
4
+ bit array).
5
+ """
6
+
7
+ from __future__ import print_function
8
+
9
+ __all__ = [
10
+ "AbstractCollection",
11
+ "AbstractList",
12
+ "AbstractMap",
13
+ "ArrayList",
14
+ "Arrays",
15
+ "Base64",
16
+ "Calendar",
17
+ "Collection",
18
+ "Comparator",
19
+ "ConcurrentModificationException",
20
+ "Currency",
21
+ "Date",
22
+ "Dictionary",
23
+ "Enumeration",
24
+ "EventObject",
25
+ "GregorianCalendar",
26
+ "HashMap",
27
+ "Hashtable",
28
+ "Iterator",
29
+ "ListIterator",
30
+ "Locale",
31
+ "Map",
32
+ "Properties",
33
+ "Spliterator",
34
+ "Stream",
35
+ "TimeZone",
36
+ "UUID",
37
+ ]
38
+
39
+ from typing import (
40
+ TYPE_CHECKING,
41
+ Any,
42
+ Dict,
43
+ Iterable,
44
+ List,
45
+ Mapping,
46
+ Optional,
47
+ Set,
48
+ Union,
49
+ )
50
+
51
+ from java.lang import Class, Object, RuntimeException, Throwable
52
+ from java.util.function import (
53
+ BiFunction,
54
+ Consumer,
55
+ Function,
56
+ Predicate,
57
+ Supplier,
58
+ ToDoubleFunction,
59
+ ToIntFunction,
60
+ ToLongFunction,
61
+ )
62
+
63
+ if TYPE_CHECKING:
64
+ from java.io import InputStream, OutputStream
65
+ from java.nio import ByteBuffer
66
+ from java.time import Instant, ZonedDateTime, ZoneId
67
+
68
+
69
+ class Collection(object):
70
+
71
+ def add(self, e):
72
+ # type: (Any) -> bool
73
+ raise NotImplementedError
74
+
75
+ def addAll(self, c):
76
+ # type: (Collection) -> bool
77
+ raise NotImplementedError
78
+
79
+ def clear(self):
80
+ # type: () -> None
81
+ raise NotImplementedError
82
+
83
+ def contains(self, o):
84
+ # type: (Object) -> bool
85
+ raise NotImplementedError
86
+
87
+ def containsAll(self, c):
88
+ # type: (Collection) -> bool
89
+ raise NotImplementedError
90
+
91
+ def equals(self, o):
92
+ # type: (Object) -> bool
93
+ raise NotImplementedError
94
+
95
+ def forEach(self, action):
96
+ # type: (Consumer) -> None
97
+ pass
98
+
99
+ def hashCode(self):
100
+ # type: () -> int
101
+ raise NotImplementedError
102
+
103
+ def isEmpty(self):
104
+ # type: () -> bool
105
+ raise NotImplementedError
106
+
107
+ def iterator(self):
108
+ # type: () -> Iterator
109
+ raise NotImplementedError
110
+
111
+ def parallelStream(self):
112
+ # type: () -> Stream
113
+ pass
114
+
115
+ def remove(self, o):
116
+ # type: (Object) -> bool
117
+ raise NotImplementedError
118
+
119
+ def removeAll(self, c):
120
+ # type: (Collection) -> bool
121
+ raise NotImplementedError
122
+
123
+ def removeIf(self, filter):
124
+ # type: (Predicate) -> bool
125
+ return True
126
+
127
+ def retainAll(self, v):
128
+ # type: (Collection) -> bool
129
+ raise NotImplementedError
130
+
131
+ def size(self):
132
+ # type: () -> int
133
+ raise NotImplementedError
134
+
135
+ def spliterator(self):
136
+ # type: () -> Spliterator
137
+ pass
138
+
139
+ def stream(self):
140
+ # type: () -> Stream
141
+ pass
142
+
143
+ def toArray(self, arg=None):
144
+ # type: (Optional[Any]) -> List[Object]
145
+ pass
146
+
147
+ def __getitem__(self, key):
148
+ # type: (Union[int, Any]) -> Any
149
+ pass
150
+
151
+ def __len__(self):
152
+ # type: () -> int
153
+ pass
154
+
155
+
156
+ class Comparator(object):
157
+ def compare(self, o1, o2):
158
+ # type: (Any, Any) -> int
159
+ raise NotImplementedError
160
+
161
+ @staticmethod
162
+ def comparing(keyExtractor, keyComparator):
163
+ # type: (Function, Comparator) -> Comparator
164
+ pass
165
+
166
+ @staticmethod
167
+ def comparingDouble(keyExtractor):
168
+ # type: (ToDoubleFunction) -> Comparator
169
+ pass
170
+
171
+ @staticmethod
172
+ def comparingInt(keyExtractor):
173
+ # type: (ToIntFunction) -> Comparator
174
+ pass
175
+
176
+ @staticmethod
177
+ def comparingLong(keyExtractor):
178
+ # type: (ToLongFunction) -> Comparator
179
+ pass
180
+
181
+ def equals(self, obj):
182
+ # type: (Object) -> bool
183
+ raise NotImplementedError
184
+
185
+ @staticmethod
186
+ def naturalOrder():
187
+ # type: () -> Comparator
188
+ pass
189
+
190
+ @staticmethod
191
+ def nullsFirst(comparator):
192
+ # type: (Comparator) -> Comparator
193
+ pass
194
+
195
+ @staticmethod
196
+ def nullsLast(comparator):
197
+ # type: (Comparator) -> Comparator
198
+ pass
199
+
200
+ def reversed(self):
201
+ # type: () -> Comparator
202
+ pass
203
+
204
+ @staticmethod
205
+ def reverseOrder():
206
+ # type: () -> Comparator
207
+ pass
208
+
209
+ def thenComparing(self, *args):
210
+ # type: (*Any) -> Comparator
211
+ pass
212
+
213
+ def thenComparingDouble(self, keyExtractor):
214
+ # type: (ToDoubleFunction) -> Comparator
215
+ pass
216
+
217
+ def thenComparingInt(self, keyExtractor):
218
+ # type: (ToIntFunction) -> Comparator
219
+ pass
220
+
221
+ def thenComparingLong(self, keyExtractor):
222
+ # type: (ToLongFunction) -> Comparator
223
+ pass
224
+
225
+
226
+ class Enumeration(object):
227
+ def asIterator(self):
228
+ # type: () -> Iterator
229
+ pass
230
+
231
+ def hasMoreElements(self):
232
+ # type: () -> bool
233
+ raise NotImplementedError
234
+
235
+ def nextElement(self):
236
+ # type: () -> Any
237
+ raise NotImplementedError
238
+
239
+
240
+ class Iterator(object):
241
+ def forEachRemaining(self, action):
242
+ # type: (Consumer) -> None
243
+ pass
244
+
245
+ def hasNext(self):
246
+ # type: () -> bool
247
+ raise NotImplementedError
248
+
249
+ def next(self):
250
+ # type: () -> Any
251
+ raise NotImplementedError
252
+
253
+ def remove(self):
254
+ # type: () -> bool
255
+ return True
256
+
257
+
258
+ class ListIterator(Iterator):
259
+ def add(self, e):
260
+ # type: (Any) -> None
261
+ raise NotImplementedError
262
+
263
+ def hasNext(self):
264
+ # type: () -> bool
265
+ raise NotImplementedError
266
+
267
+ def hasPrevious(self):
268
+ # type: () -> bool
269
+ raise NotImplementedError
270
+
271
+ def next(self):
272
+ # type: () -> Any
273
+ raise NotImplementedError
274
+
275
+ def nextIndex(self):
276
+ # type: () -> int
277
+ raise NotImplementedError
278
+
279
+ def previous(self):
280
+ # type: () -> Any
281
+ raise NotImplementedError
282
+
283
+ def previousIndex(self):
284
+ # type: () -> int
285
+ raise NotImplementedError
286
+
287
+ def set(self, e):
288
+ # type: (Any) -> None
289
+ raise NotImplementedError
290
+
291
+
292
+ class Map(object):
293
+
294
+ class Entry(object):
295
+ @staticmethod
296
+ def comparingByKey(cmp=None):
297
+ # type: (Optional[Comparator]) -> Any
298
+ pass
299
+
300
+ @staticmethod
301
+ def comparingByValue(cmp=None):
302
+ # type: (Optional[Comparator]) -> Any
303
+ pass
304
+
305
+ def getKey(self):
306
+ # type: () -> Any
307
+ raise NotImplementedError
308
+
309
+ def getValue(self):
310
+ # type: () -> Any
311
+ raise NotImplementedError
312
+
313
+ def hashCode(self):
314
+ # type: () -> int
315
+ raise NotImplementedError
316
+
317
+ def setValue(self, value):
318
+ # type: (Any) -> Any
319
+ raise NotImplementedError
320
+
321
+ def clear(self):
322
+ # type: () -> None
323
+ raise NotImplementedError
324
+
325
+ def compute(self, key, remappingFuntion):
326
+ # type: (Any, BiFunction) -> Any
327
+ pass
328
+
329
+ def computeIfAbsent(self, key, mappingFuntion):
330
+ # type: (Any, BiFunction) -> Any
331
+ pass
332
+
333
+ def computeIfPresent(self, key, remappingFuntion):
334
+ # type: (Any, BiFunction) -> Any
335
+ pass
336
+
337
+ def containsKey(self, key):
338
+ # type: (Object) -> bool
339
+ raise NotImplementedError
340
+
341
+ def containsValue(self, value):
342
+ # type: (Object) -> bool
343
+ raise NotImplementedError
344
+
345
+ @staticmethod
346
+ def copyOf(map):
347
+ # type: (Map) -> Map
348
+ pass
349
+
350
+ @staticmethod
351
+ def entry(k, v):
352
+ # type: (Any, Any) -> Map.Entry
353
+ pass
354
+
355
+ def entrySet(self):
356
+ # type: () -> Set[Map.Entry]
357
+ raise NotImplementedError
358
+
359
+ def forEach(self, action):
360
+ # type: (BiFunction) -> None
361
+ pass
362
+
363
+ def get(self, key):
364
+ # type: (Object) -> Any
365
+ raise NotImplementedError
366
+
367
+ def getOrDefault(self, key, defaultValue):
368
+ # type: (Object, Any) -> Any
369
+ pass
370
+
371
+ def isEmpty(self):
372
+ # type: () -> bool
373
+ raise NotImplementedError
374
+
375
+ def keySet(self):
376
+ # type: () -> Set[Any]
377
+ raise NotImplementedError
378
+
379
+ def merge(self, key, value, remappingFunction):
380
+ # type: (Any, Any, BiFunction) -> Any
381
+ pass
382
+
383
+ @staticmethod
384
+ def of(*args):
385
+ # type: (*Any) -> Map
386
+ pass
387
+
388
+ @staticmethod
389
+ def ofEntries(*entries):
390
+ # type: (*Map.Entry) -> Map
391
+ pass
392
+
393
+ def put(self, key, value):
394
+ # type: (Any, Any) -> Any
395
+ raise NotImplementedError
396
+
397
+ def putAll(self, m):
398
+ # type: (Mapping[Any, Any]) -> None
399
+ raise NotImplementedError
400
+
401
+ def putIfAbsent(self, key, value):
402
+ # type: (Any, Any) -> Any
403
+ pass
404
+
405
+ def remove(self, key):
406
+ # type: (Object) -> Any
407
+ pass
408
+
409
+ def replace(self, *args):
410
+ # type: (*Any) -> Union[Any, bool]
411
+ pass
412
+
413
+ def replaceAll(self, function):
414
+ # type: (BiFunction) -> None
415
+ pass
416
+
417
+ def size(self):
418
+ # type: () -> int
419
+ raise NotImplementedError
420
+
421
+ def values(self):
422
+ # type: () -> Collection
423
+ raise NotImplementedError
424
+
425
+
426
+ class Spliterator(object):
427
+ CONCURRENT = None # type: int
428
+ DISTINCT = None # type: int
429
+ IMMUTABLE = None # type: int
430
+ NONNULL = None # type: int
431
+ ORDERED = None # type: int
432
+ SIZED = None # type: int
433
+ SORTED = None # type: int
434
+ SUBSIZED = None # type: int
435
+
436
+ def characteristics(self):
437
+ # type: () -> int
438
+ raise NotImplementedError
439
+
440
+ def estimateSize(self):
441
+ # type: () -> long
442
+ raise NotImplementedError
443
+
444
+ def forEachRemaining(self, action):
445
+ # type: (Consumer) -> None
446
+ pass
447
+
448
+ def getComparator(self):
449
+ # type: () -> Comparator
450
+ pass
451
+
452
+ def getExactSizeIfKnown(self):
453
+ # type: () -> long
454
+ pass
455
+
456
+ def hasCharacteristics(self, characteristics):
457
+ # type: (int) -> bool
458
+ return True
459
+
460
+ def tryAdvance(self, action):
461
+ # type: (Consumer) -> bool
462
+ raise NotImplementedError
463
+
464
+ def trySplit(self):
465
+ # type: () -> Spliterator
466
+ raise NotImplementedError
467
+
468
+
469
+ class Stream(object):
470
+
471
+ class Builder(Consumer):
472
+ def accept(self, t):
473
+ # type: (Any) -> None
474
+ raise NotImplementedError
475
+
476
+ def add(self, t):
477
+ # type: (Any) -> Stream.Builder
478
+ pass
479
+
480
+ def build(self):
481
+ # type: () -> Stream
482
+ raise NotImplementedError
483
+
484
+ @staticmethod
485
+ def builder():
486
+ # type: () -> Builder
487
+ pass
488
+
489
+ @staticmethod
490
+ def concat(a, b):
491
+ # type: (Stream, Stream) -> Stream
492
+ pass
493
+
494
+ @staticmethod
495
+ def empty():
496
+ # type: () -> Stream
497
+ pass
498
+
499
+ @staticmethod
500
+ def generate(s):
501
+ # type: (Supplier) -> Stream
502
+ pass
503
+
504
+ @staticmethod
505
+ def iterate(*args):
506
+ # type: (*Any) -> Stream
507
+ pass
508
+
509
+ @staticmethod
510
+ def of(*args):
511
+ # type: (*Any) -> Stream
512
+ pass
513
+
514
+ @staticmethod
515
+ def ofNullable(t):
516
+ # type: (Any) -> Stream
517
+ pass
518
+
519
+
520
+ class Arrays(Object):
521
+ @staticmethod
522
+ def asList(a):
523
+ # type: (Any) -> List[Any]
524
+ pass
525
+
526
+ @staticmethod
527
+ def binarySearch(*args, **kwargs):
528
+ # type: (*Any, **Any) -> int
529
+ pass
530
+
531
+ @staticmethod
532
+ def compare(*args, **kwargs):
533
+ # type: (*Any, **Any) -> int
534
+ pass
535
+
536
+ @staticmethod
537
+ def compareUnsigned(*args, **kwargs):
538
+ # type: (*Any, **Any) -> int
539
+ pass
540
+
541
+ @staticmethod
542
+ def copyOf(original, newLength, newType=None):
543
+ # type: (List[Any], int, Optional[Class]) -> List[Any]
544
+ pass
545
+
546
+ @staticmethod
547
+ def copyOfRange(original, from_, to, newType=None):
548
+ # type: (List[Any], int, int, Optional[Class]) -> List[Any]
549
+ pass
550
+
551
+ @staticmethod
552
+ def deepEquals(a1, a2):
553
+ # type: (List[Object], List[Object]) -> bool
554
+ return True
555
+
556
+ @staticmethod
557
+ def equals(*args, **kwargs):
558
+ # type: (*Any, **Any) -> bool
559
+ return True
560
+
561
+ @staticmethod
562
+ def fill(a, *args):
563
+ # type: (List[Any], *Any) -> None
564
+ pass
565
+
566
+ @staticmethod
567
+ def mismatch(*args, **kwargs):
568
+ # type: (*Any, **Any) -> int
569
+ pass
570
+
571
+ @staticmethod
572
+ def parallelPrefix(*args, **kwargs):
573
+ # type: (*Any, **Any) -> None
574
+ pass
575
+
576
+ @staticmethod
577
+ def parallelSetAll(*args, **kwargs):
578
+ # type: (*Any, **Any) -> None
579
+ pass
580
+
581
+ @staticmethod
582
+ def parallelSort(*args, **kwargs):
583
+ # type: (*Any, **Any) -> None
584
+ pass
585
+
586
+ @staticmethod
587
+ def setAll(*args, **kwargs):
588
+ # type: (*Any, **Any) -> None
589
+ pass
590
+
591
+ @staticmethod
592
+ def sort(*args, **kwargs):
593
+ # type: (*Any, **Any) -> None
594
+ pass
595
+
596
+ @staticmethod
597
+ def spliterator(
598
+ array, # type: Iterable[Any]
599
+ startInclusive=None, # type: Optional[int]
600
+ endExclusive=None, # type: Optional[int]
601
+ ):
602
+ # type: (...) -> Spliterator
603
+ pass
604
+
605
+ @staticmethod
606
+ def stream(array, startInclusive=None, endExclusive=None):
607
+ # type: (Iterable[Any], Optional[int], Optional[int]) -> Stream
608
+ pass
609
+
610
+
611
+ class AbstractCollection(Object, Collection):
612
+ def add(self, e):
613
+ # type: (Any) -> bool
614
+ return True
615
+
616
+ def addAll(self, c):
617
+ # type: (Collection) -> bool
618
+ return True
619
+
620
+ def clear(self):
621
+ # type: () -> None
622
+ pass
623
+
624
+ def contains(self, o):
625
+ # type: (Object) -> bool
626
+ return True
627
+
628
+ def containsAll(self, c):
629
+ # type: (Collection) -> bool
630
+ return True
631
+
632
+ def isEmpty(self):
633
+ # type: () -> bool
634
+ return True
635
+
636
+ def iterator(self):
637
+ # type: () -> Iterator
638
+ pass
639
+
640
+ def remove(self, o):
641
+ # type: (Object) -> bool
642
+ return True
643
+
644
+ def removeAll(self, c):
645
+ # type: (Collection) -> bool
646
+ return True
647
+
648
+ def retainAll(self, v):
649
+ # type: (Collection) -> bool
650
+ return True
651
+
652
+ def size(self):
653
+ # type: () -> int
654
+ pass
655
+
656
+
657
+ class AbstractList(AbstractCollection):
658
+ def indexOf(self, o):
659
+ # type: (Object) -> int
660
+ pass
661
+
662
+ def lastIndexOf(self, o):
663
+ # type: (Object) -> int
664
+ pass
665
+
666
+ def listIterator(self, index=None):
667
+ # type: (Optional[int]) -> ListIterator
668
+ pass
669
+
670
+ def set(self, index, element):
671
+ # type: (int, Any) -> Any
672
+ pass
673
+
674
+ def subList(self, fromIndex, toIndex):
675
+ # type: (int, int) -> List[Any]
676
+ pass
677
+
678
+
679
+ class AbstractMap(Object, Map):
680
+ def clear(self):
681
+ # type: () -> None
682
+ pass
683
+
684
+ def containsKey(self, key):
685
+ # type: (Object) -> bool
686
+ return True
687
+
688
+ def containsValue(self, value):
689
+ # type: (Object) -> bool
690
+ return True
691
+
692
+ def entrySet(self):
693
+ # type: () -> Set[Map.Entry]
694
+ raise NotImplementedError
695
+
696
+ def get(self, key):
697
+ # type: (Object) -> Any
698
+ pass
699
+
700
+ def isEmpty(self):
701
+ # type: () -> bool
702
+ return True
703
+
704
+ def keySet(self):
705
+ # type: () -> Set[Any]
706
+ pass
707
+
708
+ def put(self, key, value):
709
+ # type: (Any, Any) -> Any
710
+ pass
711
+
712
+ def putAll(self, m):
713
+ # type: (Mapping[Any, Any]) -> None
714
+ pass
715
+
716
+ def remove(self, key):
717
+ # type: (Object) -> Any
718
+ pass
719
+
720
+ def size(self):
721
+ # type: () -> int
722
+ pass
723
+
724
+ def values(self):
725
+ # type: () -> Collection
726
+ pass
727
+
728
+
729
+ class ArrayList(AbstractList):
730
+ def __init__(self, *args):
731
+ # type: (*Any) -> None
732
+ super(ArrayList, self).__init__()
733
+ print(args)
734
+
735
+ def ensureCapacity(self, minCapacity):
736
+ # type: (int) -> None
737
+ pass
738
+
739
+ def get(self, index):
740
+ # type: (int) -> Any
741
+ pass
742
+
743
+ def trimToSize(self):
744
+ # type: () -> None
745
+ pass
746
+
747
+
748
+ class Base64(Object):
749
+ class Decoder(Object):
750
+ def decode(
751
+ self,
752
+ arg, # type: Union[str, unicode, ByteBuffer, List[int]]
753
+ dst=None, # type: Optional[List[int]]
754
+ ):
755
+ # type: (...) -> Union[ByteBuffer, int, List[int]]
756
+ pass
757
+
758
+ def wrap(self, is_):
759
+ # type: (InputStream) -> InputStream
760
+ pass
761
+
762
+ class Encoder(Object):
763
+ def encode(
764
+ self,
765
+ arg, # type: Union[ByteBuffer, List[int]]
766
+ dst=None, # type: Optional[List[int]]
767
+ ):
768
+ # type: (...) -> Union[ByteBuffer, int, List[int]]
769
+ pass
770
+
771
+ def encodeToString(self, src):
772
+ # type: (List[int]) -> Union[str, unicode]
773
+ pass
774
+
775
+ def withoutPadding(self):
776
+ # type: () -> Base64.Encoder
777
+ pass
778
+
779
+ def wrap(self, os):
780
+ # type: (OutputStream) -> OutputStream
781
+ pass
782
+
783
+ @staticmethod
784
+ def getDecoder():
785
+ # type: () -> Base64.Decoder
786
+ pass
787
+
788
+ @staticmethod
789
+ def getEncoder():
790
+ # type: () -> Base64.Encoder
791
+ pass
792
+
793
+ @staticmethod
794
+ def getMimeDecoder():
795
+ # type: () -> Base64.Decoder
796
+ pass
797
+
798
+ @staticmethod
799
+ def getMimeEncoder(lineLength=None, lineSeparator=None):
800
+ # type: (Optional[int], Optional[List[int]]) -> Base64.Encoder
801
+ pass
802
+
803
+ @staticmethod
804
+ def getUrlDecoder():
805
+ # type: () -> Base64.Decoder
806
+ pass
807
+
808
+ @staticmethod
809
+ def getUrlEncoder():
810
+ # type: () -> Base64.Encoder
811
+ pass
812
+
813
+
814
+ class Calendar(Object):
815
+ ALL_STYLES = None # type: int
816
+ AM = None # type: int
817
+ AM_PM = None # type: int
818
+ APRIL = None # type: int
819
+ AUGUST = None # type: int
820
+ DATE = None # type: int
821
+ DAY_OF_MONTH = None # type: int
822
+ DAY_OF_WEEK = None # type: int
823
+ DAY_OF_WEEK_IN_MONTH = None # type: int
824
+ DAY_OF_YEAR = None # type: int
825
+ DECEMBER = None # type: int
826
+ DST_OFFSET = None # type: int
827
+ ERA = None # type: int
828
+ FEBRUARY = None # type: int
829
+ FIELD_COUNT = None # type: int
830
+ FRIDAY = None # type: int
831
+ HOUR = None # type: int
832
+ HOUR_OF_DAY = None # type: int
833
+ JANUARY = None # type: int
834
+ JULY = None # type: int
835
+ JUNE = None # type: int
836
+ LONG = None # type: int
837
+ LONG_FORMAT = None # type: int
838
+ LONG_STANDALONE = None # type: int
839
+ MARCH = None # type: int
840
+ MAY = None # type: int
841
+ MILLISECOND = None # type: int
842
+ MINUTE = None # type: int
843
+ MONDAY = None # type: int
844
+ MONTH = None # type: int
845
+ NARROW_FORMAT = None # type: int
846
+ NARROW_STANDALONE = None # type: int
847
+ NOVEMBER = None # type: int
848
+ OCTOBER = None # type: int
849
+ PM = None # type: int
850
+ SATURDAY = None # type: int
851
+ SECOND = None # type: int
852
+ SEPTEMBER = None # type: int
853
+ SHORT = None # type: int
854
+ SHORT_FORMAT = None # type: int
855
+ SHORT_STANDALONE = None # type: int
856
+ SUNDAY = None # type: int
857
+ THURSDAY = None # type: int
858
+ TUESDAY = None # type: int
859
+ UNDECIMBER = None # type: int
860
+ WEDNESDAY = None # type: int
861
+ WEEK_OF_MONTH = None # type: int
862
+ WEEK_OF_YEAR = None # type: int
863
+ YEAR = None # type: int
864
+ ZONE_OFFSET = None # type: int
865
+
866
+ def add(self, field, amount):
867
+ # type: (int, int) -> None
868
+ pass
869
+
870
+ def after(self, when):
871
+ # type: (Object) -> bool
872
+ return True
873
+
874
+ def before(self, when):
875
+ # type: (Object) -> bool
876
+ return True
877
+
878
+ def clear(self, field=None):
879
+ # type: (Optional[int]) -> None
880
+ pass
881
+
882
+ def clone(self):
883
+ # type: () -> Object
884
+ pass
885
+
886
+ def compareTo(self, anotherCalendar):
887
+ # type: (Calendar) -> int
888
+ pass
889
+
890
+ def get(self, field):
891
+ # type: (int) -> int
892
+ pass
893
+
894
+ def getActualMaximum(self, field):
895
+ # type: (int) -> int
896
+ pass
897
+
898
+ def getActualMinimum(self, field):
899
+ # type: (int) -> int
900
+ pass
901
+
902
+ @staticmethod
903
+ def getAvailableCalendarTypes():
904
+ # type: () -> Set[Union[str, unicode]]
905
+ pass
906
+
907
+ @staticmethod
908
+ def getAvailableLocales():
909
+ # type: () -> List[Locale]
910
+ pass
911
+
912
+ def getCalendarType(self):
913
+ # type: () -> Union[str, unicode]
914
+ pass
915
+
916
+ def getDisplayName(self, field, style, locale):
917
+ # type: (int, int, Locale) -> Union[str, unicode]
918
+ pass
919
+
920
+ def getDisplayNames(self, field, style, locale):
921
+ # type: (int, int, Locale) -> Dict[Union[str, unicode], int]
922
+ pass
923
+
924
+ def getFirstDayOfWeek(self):
925
+ # type: () -> int
926
+ pass
927
+
928
+ def getGreatestMinimum(self, field):
929
+ # type: (int) -> int
930
+ pass
931
+
932
+ @staticmethod
933
+ def getInstance(*args):
934
+ # type: (*Any) -> Calendar
935
+ pass
936
+
937
+ def getLeastMaximum(self, field):
938
+ # type: (int) -> int
939
+ pass
940
+
941
+ def getMaximum(self, field):
942
+ # type: (int) -> int
943
+ pass
944
+
945
+ def getMinimalDaysInFirstWeek(self):
946
+ # type: () -> int
947
+ pass
948
+
949
+ def getMinimum(self, field):
950
+ # type: (int) -> int
951
+ pass
952
+
953
+ def getTime(self):
954
+ # type: () -> Date
955
+ pass
956
+
957
+ def getTimeInMillis(self):
958
+ # type: () -> long
959
+ pass
960
+
961
+ def getTimeZone(self):
962
+ # type: () -> TimeZone
963
+ pass
964
+
965
+ def getWeeksInWeekYear(self):
966
+ # type: () -> int
967
+ pass
968
+
969
+ def getWeekYear(self):
970
+ # type: () -> int
971
+ pass
972
+
973
+ def isLenient(self):
974
+ # type: () -> bool
975
+ return True
976
+
977
+ def isSet(self, field):
978
+ # type: (int) -> bool
979
+ return True
980
+
981
+ def isWeekDateSUpported(self):
982
+ # type: () -> bool
983
+ return True
984
+
985
+ def roll(self, field, amount):
986
+ # type: (int, int) -> None
987
+ pass
988
+
989
+ def set(self, *args):
990
+ # type: (*int) -> None
991
+ pass
992
+
993
+ def setFirstDayOfWeek(self, value):
994
+ # type: (int) -> None
995
+ pass
996
+
997
+ def setLenient(self, lenient):
998
+ # type: (bool) -> None
999
+ pass
1000
+
1001
+ def setMinimalDaysInFirstWeek(self, value):
1002
+ # type: (int) -> None
1003
+ pass
1004
+
1005
+ def setTime(self, date):
1006
+ # type: (Date) -> None
1007
+ pass
1008
+
1009
+ def setTimeInMillis(self, millis):
1010
+ # type: (long) -> None
1011
+ pass
1012
+
1013
+ def setTimeZone(self, value):
1014
+ # type: (TimeZone) -> None
1015
+ pass
1016
+
1017
+ def setWeekDate(self, weekYear, weekOfYear, dayOfWeek):
1018
+ # type: (int, int, int) -> None
1019
+ pass
1020
+
1021
+ def toInstant(self):
1022
+ # type: () -> Instant
1023
+ pass
1024
+
1025
+
1026
+ class ConcurrentModificationException(RuntimeException):
1027
+ def __init__(self, message=None, cause=None):
1028
+ # type: (Optional[str], Optional[Throwable]) -> None
1029
+ super(ConcurrentModificationException, self).__init__(message, cause)
1030
+
1031
+
1032
+ class Currency(Object):
1033
+ @staticmethod
1034
+ def getAvailableCurrencies():
1035
+ # type: () -> Set[Currency]
1036
+ pass
1037
+
1038
+ def getCurrencyCode(self):
1039
+ # type: () -> Union[str, unicode]
1040
+ pass
1041
+
1042
+ def getDisplayName(self, locale=None):
1043
+ # type: (Optional[Locale]) -> Union[str, unicode]
1044
+ pass
1045
+
1046
+ @staticmethod
1047
+ def getInstance(arg):
1048
+ # type: (Union[str, unicode, Locale]) -> Currency
1049
+ pass
1050
+
1051
+ def getNumericCode(self):
1052
+ # type: () -> int
1053
+ pass
1054
+
1055
+ def getNumericCodeAsString(self):
1056
+ # type: () -> Union[str, unicode]
1057
+ pass
1058
+
1059
+ def getSymbol(self, locale=None):
1060
+ # type: (Optional[Locale]) -> Union[str, unicode]
1061
+ pass
1062
+
1063
+
1064
+ class Date(Object):
1065
+ """The class Date represents a specific instant in time, with
1066
+ millisecond precision.
1067
+ """
1068
+
1069
+ def __init__(self, date=None):
1070
+ # type: (Optional[long]) -> None
1071
+ super(Date, self).__init__()
1072
+ self._date = date
1073
+
1074
+ def after(self, when):
1075
+ # type: (Date) -> bool
1076
+ return True
1077
+
1078
+ def before(self, when):
1079
+ # type: (Date) -> bool
1080
+ return True
1081
+
1082
+ def compareTo(self, anotherDate):
1083
+ # type: (Date) -> int
1084
+ pass
1085
+
1086
+ def getTime(self):
1087
+ # type: () -> long
1088
+ pass
1089
+
1090
+ def setTime(self, time):
1091
+ # type: (long) -> None
1092
+ pass
1093
+
1094
+
1095
+ class Dictionary(Object):
1096
+ def __init__(self):
1097
+ # type: () -> None
1098
+ super(Dictionary, self).__init__()
1099
+
1100
+ def elements(self):
1101
+ # type: () -> Enumeration
1102
+ raise NotImplementedError
1103
+
1104
+ def get(self, key):
1105
+ # type: (Object) -> Any
1106
+ raise NotImplementedError
1107
+
1108
+ def isEmpty(self):
1109
+ # type: () -> bool
1110
+ raise NotImplementedError
1111
+
1112
+ def keys(self):
1113
+ # type: () -> Enumeration
1114
+ raise NotImplementedError
1115
+
1116
+ def put(self, key, value):
1117
+ # type: (Any, Any) -> Any
1118
+ raise NotImplementedError
1119
+
1120
+ def remove(self, key):
1121
+ # type: (Object) -> Any
1122
+ raise NotImplementedError
1123
+
1124
+ def size(self):
1125
+ # type: () -> int
1126
+ raise NotImplementedError
1127
+
1128
+
1129
+ class EventObject(Object):
1130
+ """The root class from which all event state objects shall be
1131
+ derived.
1132
+
1133
+ All Events are constructed with a reference to the object, the
1134
+ "source", that is logically deemed to be the object upon which the
1135
+ Event in question initially occurred upon.
1136
+ """
1137
+
1138
+ _source = None # type: Object
1139
+
1140
+ def __init__(self, source):
1141
+ # type: (Object) -> None
1142
+ super(EventObject, self).__init__()
1143
+ self._source = source
1144
+
1145
+ def getSource(self):
1146
+ # type: () -> Object
1147
+ return self._source
1148
+
1149
+
1150
+ class GregorianCalendar(Calendar):
1151
+ AD = None # type: int
1152
+ BC = None # type: int
1153
+
1154
+ def __init__(self, *args):
1155
+ # type: (*Any) -> None
1156
+ super(GregorianCalendar, self).__init__()
1157
+ print(args)
1158
+
1159
+ def getGregorianChange(self):
1160
+ # type: () -> Date
1161
+ pass
1162
+
1163
+ def isLeapYear(self, year):
1164
+ # type: (int) -> bool
1165
+ return True
1166
+
1167
+ def setGregorianChange(self, date):
1168
+ # type: (Date) -> None
1169
+ pass
1170
+
1171
+ def toZonedDatetime(self):
1172
+ # type: () -> ZonedDateTime
1173
+ pass
1174
+
1175
+
1176
+ class HashMap(AbstractMap, Map):
1177
+ def __init__(self, *args):
1178
+ # type: (*Any) -> None
1179
+ super(HashMap, self).__init__()
1180
+ print(args)
1181
+
1182
+ def entrySet(self):
1183
+ # type: () -> Set[Map.Entry]
1184
+ pass
1185
+
1186
+
1187
+ class Hashtable(Dictionary, Map):
1188
+ def __init__(self, *args):
1189
+ # type: (*Any) -> None
1190
+ super(Hashtable, self).__init__()
1191
+ print(args)
1192
+
1193
+ def clear(self):
1194
+ # type: () -> None
1195
+ pass
1196
+
1197
+ def clone(self):
1198
+ # type: () -> Object
1199
+ pass
1200
+
1201
+ def contains(self, value):
1202
+ # type: (Object) -> bool
1203
+ return True
1204
+
1205
+ def containsKey(self, key):
1206
+ # type: (Object) -> bool
1207
+ return True
1208
+
1209
+ def containsValue(self, value):
1210
+ # type: (Object) -> bool
1211
+ return True
1212
+
1213
+ def elements(self):
1214
+ # type: () -> Enumeration
1215
+ pass
1216
+
1217
+ def entrySet(self):
1218
+ # type: () -> Set[Map.Entry]
1219
+ pass
1220
+
1221
+ def get(self, key):
1222
+ # type: (Object) -> Any
1223
+ pass
1224
+
1225
+ def isEmpty(self):
1226
+ # type: () -> bool
1227
+ return True
1228
+
1229
+ def keySet(self):
1230
+ # type: () -> Set[Any]
1231
+ pass
1232
+
1233
+ def keys(self):
1234
+ # type: () -> Enumeration
1235
+ pass
1236
+
1237
+ def put(self, key, value):
1238
+ # type: (Any, Any) -> Any
1239
+ pass
1240
+
1241
+ def putAll(self, m):
1242
+ # type: (Mapping[Any, Any]) -> None
1243
+ pass
1244
+
1245
+ def remove(self, key):
1246
+ # type: (Object) -> Any
1247
+ pass
1248
+
1249
+ def size(self):
1250
+ # type: () -> int
1251
+ pass
1252
+
1253
+ def values(self):
1254
+ # type: () -> Collection
1255
+ pass
1256
+
1257
+
1258
+ class Locale(Object):
1259
+ """A Locale object represents a specific geographical, political, or
1260
+ cultural region.
1261
+
1262
+ An operation that requires a Locale to perform its task is called
1263
+ locale-sensitive and uses the Locale to tailor information for the
1264
+ user. For example, displaying a number is a locale-sensitive
1265
+ operation; the number should be formatted according to the customs
1266
+ and conventions of the user's native country, region, or culture.
1267
+ """
1268
+
1269
+ country = None # type: Optional[str]
1270
+ language = None # type: str
1271
+ variant = None # type: Optional[str]
1272
+
1273
+ # Class attribute constants
1274
+ CANADA = None # type: Locale
1275
+ CANADA_FRENCH = None # type: Locale
1276
+ CHINA = None # type: Locale
1277
+ CHINESE = None # type: Locale
1278
+ ENGLISH = None # type: Locale
1279
+ FRANCE = None # type: Locale
1280
+ FRENCH = None # type: Locale
1281
+ GERMAN = None # type: Locale
1282
+ GERMANY = None # type: Locale
1283
+ ITALIAN = None # type: Locale
1284
+ ITALY = None # type: Locale
1285
+ JAPAN = None # type: Locale
1286
+ JAPANESE = None # type: Locale
1287
+ KOREA = None # type: Locale
1288
+ KOREAN = None # type: Locale
1289
+ PRC = None # type: Locale
1290
+ SIMPLIFIED_CHINESE = None # type: Locale
1291
+ TAIWAN = None # type: Locale
1292
+ TRADITIONAL_CHINESE = None # type: Locale
1293
+ UK = None # type: Locale
1294
+ US = None # type: Locale
1295
+
1296
+ def __init__(self, language, country=None, variant=None):
1297
+ # type: (str, Optional[str], Optional[str]) -> None
1298
+ super(Locale, self).__init__()
1299
+ self.language = language
1300
+ self.country = country
1301
+ self.variant = variant
1302
+
1303
+ def __str__(self):
1304
+ # type: () -> str
1305
+ ret = self.language
1306
+ if self.country:
1307
+ ret += "_{}".format(self.country)
1308
+ if self.variant:
1309
+ ret += "_{}".format(self.variant)
1310
+ return ret
1311
+
1312
+ def __repr__(self):
1313
+ # type: () -> str
1314
+ return "{!r}".format(self.__str__())
1315
+
1316
+
1317
+ Locale.CANADA = Locale("en", "CA")
1318
+ Locale.CANADA_FRENCH = Locale("fr", "CA")
1319
+ Locale.CHINA = Locale("zh", "CN")
1320
+ Locale.CHINESE = Locale("zh")
1321
+ Locale.ENGLISH = Locale("en")
1322
+ Locale.FRANCE = Locale("fr", "FR")
1323
+ Locale.FRENCH = Locale("fr")
1324
+ Locale.GERMAN = Locale("de")
1325
+ Locale.GERMANY = Locale("de", "DE")
1326
+ Locale.ITALIAN = Locale("it")
1327
+ Locale.ITALY = Locale("it", "IT")
1328
+ Locale.JAPAN = Locale("ja", "JP")
1329
+ Locale.JAPANESE = Locale("ja")
1330
+ Locale.KOREA = Locale("ko", "KR")
1331
+ Locale.KOREAN = Locale("ko")
1332
+ Locale.PRC = Locale("zh", "CN")
1333
+ Locale.SIMPLIFIED_CHINESE = Locale("zh", "CN")
1334
+ Locale.TAIWAN = Locale("zh", "TW")
1335
+ Locale.TRADITIONAL_CHINESE = Locale("zh", "TW")
1336
+ Locale.UK = Locale("en", "GB")
1337
+ Locale.US = Locale("en", "US")
1338
+
1339
+
1340
+ class Properties(Hashtable):
1341
+ def __init__(self, *args):
1342
+ # type: (*Any) -> None
1343
+ super(Properties, self).__init__()
1344
+
1345
+
1346
+ class TimeZone(Object):
1347
+ LONG = None # type: int
1348
+ SHORT = None # type: int
1349
+
1350
+ def __init__(self):
1351
+ # type: () -> None
1352
+ super(TimeZone, self).__init__()
1353
+
1354
+ def clone(self):
1355
+ # type: () -> Object
1356
+ pass
1357
+
1358
+ @staticmethod
1359
+ def getAvailableIDs(rawOffset=None):
1360
+ # type: (Optional[int]) -> List[Union[str, unicode]]
1361
+ pass
1362
+
1363
+ @staticmethod
1364
+ def getDefault():
1365
+ # type: () -> TimeZone
1366
+ pass
1367
+
1368
+ def getDisplayName(self, *args):
1369
+ # type: (*Any) -> Union[str, unicode]
1370
+ pass
1371
+
1372
+ def getDSTSavings(self):
1373
+ # type: () -> int
1374
+ pass
1375
+
1376
+ def getID(self):
1377
+ # type: () -> Union[str, unicode]
1378
+ pass
1379
+
1380
+ def getOffset(self, *args):
1381
+ # type: (*Any) -> int
1382
+ pass
1383
+
1384
+ def getRawOffset(self):
1385
+ # type: () -> int
1386
+ raise NotImplementedError
1387
+
1388
+ @staticmethod
1389
+ def getTimeZone(arg):
1390
+ # type: (Union[str, unicode, ZoneId]) -> TimeZone
1391
+ pass
1392
+
1393
+ def hasSameRules(self, other):
1394
+ # type: (TimeZone) -> bool
1395
+ return True
1396
+
1397
+ def isDaylightTime(self, date):
1398
+ # type: (Date) -> bool
1399
+ raise NotImplementedError
1400
+
1401
+ def observesDaylightTime(self):
1402
+ # type: () -> bool
1403
+ return True
1404
+
1405
+ @staticmethod
1406
+ def setDefault(zone):
1407
+ # type: (TimeZone) -> None
1408
+ pass
1409
+
1410
+ def setID(self, ID):
1411
+ # type: (Union[str, unicode]) -> None
1412
+ pass
1413
+
1414
+ def setRawOffset(self, offsetMillis):
1415
+ # type: (int) -> None
1416
+ raise NotImplementedError
1417
+
1418
+ def toZoneId(self):
1419
+ # type: () -> ZoneId
1420
+ pass
1421
+
1422
+ def useDaylightTime(self):
1423
+ # type: () -> bool
1424
+ raise NotImplementedError
1425
+
1426
+
1427
+ class UUID(Object):
1428
+ def __init__(self, mostSigBits, leastSigBits):
1429
+ # type: (long, long) -> None
1430
+ super(UUID, self).__init__()
1431
+ self._leastSigbits = leastSigBits
1432
+ self._mostSigBits = mostSigBits
1433
+
1434
+ def clockSequence(self):
1435
+ # type: () -> int
1436
+ pass
1437
+
1438
+ def compareTo(self, val):
1439
+ # type: (UUID) -> int
1440
+ pass
1441
+
1442
+ @staticmethod
1443
+ def fromString(name):
1444
+ # type: (Union[str, unicode]) -> UUID
1445
+ pass
1446
+
1447
+ def getLeastSignificantBits(self):
1448
+ # type: () -> long
1449
+ return self._leastSigbits
1450
+
1451
+ def getMostSignificantBits(self):
1452
+ # type: () -> long
1453
+ return self._mostSigBits
1454
+
1455
+ @staticmethod
1456
+ def nameUUIDFromBytes(name):
1457
+ # type: (bytearray) -> UUID
1458
+ pass
1459
+
1460
+ def node(self):
1461
+ # type: () -> long
1462
+ pass
1463
+
1464
+ @staticmethod
1465
+ def randomUUID():
1466
+ # type: () -> UUID
1467
+ pass
1468
+
1469
+ def timestamp(self):
1470
+ # type: () -> long
1471
+ pass
1472
+
1473
+ def variant(self):
1474
+ # type: () -> int
1475
+ pass
1476
+
1477
+ def version(self):
1478
+ # type: () -> int
1479
+ pass