_abcoll.py (12360B)
1 #Embedded file name: C:\BuildAgent\work\20d73f1b24eed06e\eve\release\V24.01\carbon\common\stdlib\_abcoll.py 2 from abc import ABCMeta, abstractmethod 3 import sys 4 __all__ = ['Hashable', 5 'Iterable', 6 'Iterator', 7 'Sized', 8 'Container', 9 'Callable', 10 'Set', 11 'MutableSet', 12 'Mapping', 13 'MutableMapping', 14 'MappingView', 15 'KeysView', 16 'ItemsView', 17 'ValuesView', 18 'Sequence', 19 'MutableSequence'] 20 21 def _hasattr(C, attr): 22 try: 23 return any((attr in B.__dict__ for B in C.__mro__)) 24 except AttributeError: 25 return hasattr(C, attr) 26 27 28 class Hashable: 29 __metaclass__ = ABCMeta 30 31 @abstractmethod 32 def __hash__(self): 33 return 0 34 35 @classmethod 36 def __subclasshook__(cls, C): 37 if cls is Hashable: 38 try: 39 for B in C.__mro__: 40 if '__hash__' in B.__dict__: 41 if B.__dict__['__hash__']: 42 return True 43 break 44 45 except AttributeError: 46 if getattr(C, '__hash__', None): 47 return True 48 49 return NotImplemented 50 51 52 class Iterable: 53 __metaclass__ = ABCMeta 54 55 @abstractmethod 56 def __iter__(self): 57 while False: 58 yield 59 60 @classmethod 61 def __subclasshook__(cls, C): 62 if cls is Iterable: 63 if _hasattr(C, '__iter__'): 64 return True 65 return NotImplemented 66 67 68 Iterable.register(str) 69 70 class Iterator(Iterable): 71 72 @abstractmethod 73 def next(self): 74 raise StopIteration 75 76 def __iter__(self): 77 return self 78 79 @classmethod 80 def __subclasshook__(cls, C): 81 if cls is Iterator: 82 if _hasattr(C, 'next'): 83 return True 84 return NotImplemented 85 86 87 class Sized: 88 __metaclass__ = ABCMeta 89 90 @abstractmethod 91 def __len__(self): 92 return 0 93 94 @classmethod 95 def __subclasshook__(cls, C): 96 if cls is Sized: 97 if _hasattr(C, '__len__'): 98 return True 99 return NotImplemented 100 101 102 class Container: 103 __metaclass__ = ABCMeta 104 105 @abstractmethod 106 def __contains__(self, x): 107 return False 108 109 @classmethod 110 def __subclasshook__(cls, C): 111 if cls is Container: 112 if _hasattr(C, '__contains__'): 113 return True 114 return NotImplemented 115 116 117 class Callable: 118 __metaclass__ = ABCMeta 119 120 @abstractmethod 121 def __call__(self, *args, **kwds): 122 return False 123 124 @classmethod 125 def __subclasshook__(cls, C): 126 if cls is Callable: 127 if _hasattr(C, '__call__'): 128 return True 129 return NotImplemented 130 131 132 class Set(Sized, Iterable, Container): 133 134 def __le__(self, other): 135 if not isinstance(other, Set): 136 return NotImplemented 137 if len(self) > len(other): 138 return False 139 for elem in self: 140 if elem not in other: 141 return False 142 143 return True 144 145 def __lt__(self, other): 146 if not isinstance(other, Set): 147 return NotImplemented 148 return len(self) < len(other) and self.__le__(other) 149 150 def __gt__(self, other): 151 if not isinstance(other, Set): 152 return NotImplemented 153 return other < self 154 155 def __ge__(self, other): 156 if not isinstance(other, Set): 157 return NotImplemented 158 return other <= self 159 160 def __eq__(self, other): 161 if not isinstance(other, Set): 162 return NotImplemented 163 return len(self) == len(other) and self.__le__(other) 164 165 def __ne__(self, other): 166 return not self == other 167 168 @classmethod 169 def _from_iterable(cls, it): 170 return cls(it) 171 172 def __and__(self, other): 173 if not isinstance(other, Iterable): 174 return NotImplemented 175 return self._from_iterable((value for value in other if value in self)) 176 177 def isdisjoint(self, other): 178 for value in other: 179 if value in self: 180 return False 181 182 return True 183 184 def __or__(self, other): 185 if not isinstance(other, Iterable): 186 return NotImplemented 187 chain = (e for s in (self, other) for e in s) 188 return self._from_iterable(chain) 189 190 def __sub__(self, other): 191 if not isinstance(other, Set): 192 if not isinstance(other, Iterable): 193 return NotImplemented 194 other = self._from_iterable(other) 195 return self._from_iterable((value for value in self if value not in other)) 196 197 def __xor__(self, other): 198 if not isinstance(other, Set): 199 if not isinstance(other, Iterable): 200 return NotImplemented 201 other = self._from_iterable(other) 202 return self - other | other - self 203 204 __hash__ = None 205 206 def _hash(self): 207 MAX = sys.maxint 208 MASK = 2 * MAX + 1 209 n = len(self) 210 h = 1927868237 * (n + 1) 211 h &= MASK 212 for x in self: 213 hx = hash(x) 214 h ^= (hx ^ hx << 16 ^ 89869747) * 3644798167L 215 h &= MASK 216 217 h = h * 69069 + 907133923 218 h &= MASK 219 if h > MAX: 220 h -= MASK + 1 221 if h == -1: 222 h = 590923713 223 return h 224 225 226 Set.register(frozenset) 227 228 class MutableSet(Set): 229 230 @abstractmethod 231 def add(self, value): 232 raise NotImplementedError 233 234 @abstractmethod 235 def discard(self, value): 236 raise NotImplementedError 237 238 def remove(self, value): 239 if value not in self: 240 raise KeyError(value) 241 self.discard(value) 242 243 def pop(self): 244 it = iter(self) 245 try: 246 value = next(it) 247 except StopIteration: 248 raise KeyError 249 250 self.discard(value) 251 return value 252 253 def clear(self): 254 try: 255 while True: 256 self.pop() 257 258 except KeyError: 259 pass 260 261 def __ior__(self, it): 262 for value in it: 263 self.add(value) 264 265 return self 266 267 def __iand__(self, it): 268 for value in self - it: 269 self.discard(value) 270 271 return self 272 273 def __ixor__(self, it): 274 if it is self: 275 self.clear() 276 else: 277 if not isinstance(it, Set): 278 it = self._from_iterable(it) 279 for value in it: 280 if value in self: 281 self.discard(value) 282 else: 283 self.add(value) 284 285 return self 286 287 def __isub__(self, it): 288 if it is self: 289 self.clear() 290 else: 291 for value in it: 292 self.discard(value) 293 294 return self 295 296 297 MutableSet.register(set) 298 299 class Mapping(Sized, Iterable, Container): 300 301 @abstractmethod 302 def __getitem__(self, key): 303 raise KeyError 304 305 def get(self, key, default = None): 306 try: 307 return self[key] 308 except KeyError: 309 return default 310 311 def __contains__(self, key): 312 try: 313 self[key] 314 except KeyError: 315 return False 316 317 return True 318 319 def iterkeys(self): 320 return iter(self) 321 322 def itervalues(self): 323 for key in self: 324 yield self[key] 325 326 def iteritems(self): 327 for key in self: 328 yield (key, self[key]) 329 330 def keys(self): 331 return list(self) 332 333 def items(self): 334 return [ (key, self[key]) for key in self ] 335 336 def values(self): 337 return [ self[key] for key in self ] 338 339 __hash__ = None 340 341 def __eq__(self, other): 342 if not isinstance(other, Mapping): 343 return NotImplemented 344 return dict(self.items()) == dict(other.items()) 345 346 def __ne__(self, other): 347 return not self == other 348 349 350 class MappingView(Sized): 351 352 def __init__(self, mapping): 353 self._mapping = mapping 354 355 def __len__(self): 356 return len(self._mapping) 357 358 def __repr__(self): 359 return '{0.__class__.__name__}({0._mapping!r})'.format(self) 360 361 362 class KeysView(MappingView, Set): 363 364 @classmethod 365 def _from_iterable(self, it): 366 return set(it) 367 368 def __contains__(self, key): 369 return key in self._mapping 370 371 def __iter__(self): 372 for key in self._mapping: 373 yield key 374 375 376 class ItemsView(MappingView, Set): 377 378 @classmethod 379 def _from_iterable(self, it): 380 return set(it) 381 382 def __contains__(self, item): 383 key, value = item 384 try: 385 v = self._mapping[key] 386 except KeyError: 387 return False 388 389 return v == value 390 391 def __iter__(self): 392 for key in self._mapping: 393 yield (key, self._mapping[key]) 394 395 396 class ValuesView(MappingView): 397 398 def __contains__(self, value): 399 for key in self._mapping: 400 if value == self._mapping[key]: 401 return True 402 403 return False 404 405 def __iter__(self): 406 for key in self._mapping: 407 yield self._mapping[key] 408 409 410 class MutableMapping(Mapping): 411 412 @abstractmethod 413 def __setitem__(self, key, value): 414 raise KeyError 415 416 @abstractmethod 417 def __delitem__(self, key): 418 raise KeyError 419 420 __marker = object() 421 422 def pop(self, key, default = __marker): 423 try: 424 value = self[key] 425 except KeyError: 426 if default is self.__marker: 427 raise 428 return default 429 430 del self[key] 431 return value 432 433 def popitem(self): 434 try: 435 key = next(iter(self)) 436 except StopIteration: 437 raise KeyError 438 439 value = self[key] 440 del self[key] 441 return (key, value) 442 443 def clear(self): 444 try: 445 while True: 446 self.popitem() 447 448 except KeyError: 449 pass 450 451 def update(*args, **kwds): 452 if len(args) > 2: 453 raise TypeError('update() takes at most 2 positional arguments ({} given)'.format(len(args))) 454 elif not args: 455 raise TypeError('update() takes at least 1 argument (0 given)') 456 self = args[0] 457 other = args[1] if len(args) >= 2 else () 458 if isinstance(other, Mapping): 459 for key in other: 460 self[key] = other[key] 461 462 elif hasattr(other, 'keys'): 463 for key in other.keys(): 464 self[key] = other[key] 465 466 else: 467 for key, value in other: 468 self[key] = value 469 470 for key, value in kwds.items(): 471 self[key] = value 472 473 def setdefault(self, key, default = None): 474 try: 475 return self[key] 476 except KeyError: 477 self[key] = default 478 479 return default 480 481 482 MutableMapping.register(dict) 483 484 class Sequence(Sized, Iterable, Container): 485 486 @abstractmethod 487 def __getitem__(self, index): 488 raise IndexError 489 490 def __iter__(self): 491 i = 0 492 try: 493 while True: 494 v = self[i] 495 yield v 496 i += 1 497 498 except IndexError: 499 return 500 501 def __contains__(self, value): 502 for v in self: 503 if v == value: 504 return True 505 506 return False 507 508 def __reversed__(self): 509 for i in reversed(range(len(self))): 510 yield self[i] 511 512 def index(self, value): 513 for i, v in enumerate(self): 514 if v == value: 515 return i 516 517 raise ValueError 518 519 def count(self, value): 520 return sum((1 for v in self if v == value)) 521 522 523 Sequence.register(tuple) 524 Sequence.register(basestring) 525 Sequence.register(buffer) 526 Sequence.register(xrange) 527 528 class MutableSequence(Sequence): 529 530 @abstractmethod 531 def __setitem__(self, index, value): 532 raise IndexError 533 534 @abstractmethod 535 def __delitem__(self, index): 536 raise IndexError 537 538 @abstractmethod 539 def insert(self, index, value): 540 raise IndexError 541 542 def append(self, value): 543 self.insert(len(self), value) 544 545 def reverse(self): 546 n = len(self) 547 for i in range(n // 2): 548 self[i], self[n - i - 1] = self[n - i - 1], self[i] 549 550 def extend(self, values): 551 for v in values: 552 self.append(v) 553 554 def pop(self, index = -1): 555 v = self[index] 556 del self[index] 557 return v 558 559 def remove(self, value): 560 del self[self.index(value)] 561 562 def __iadd__(self, values): 563 self.extend(values) 564 return self 565 566 567 MutableSequence.register(list)