VT, Any, Union, Type, TypeVar, get_type_hints, no_type_check, ) try: from typing import OrderedDict except ImportError: # Python < 3.7.2 compatibility; see # https://github.com/python/cpython/commit/68b56d0 import collections from typing import _alias OrderedDict = _alias(collections.OrderedDict, (KT, VT)) import pydantic from pydantic import DictError, Extra, ValidationError from pydantic.class_validators import make_generic_validator class Resource(str, Enum): """Enumeration of SDMX REST API endpoints. ====================== ================================================ :class:`Enum` member :mod:`pandasdmx.model` class ====================== ================================================ ``categoryscheme`` :class:`CategoryScheme \ <pandasdmx.model.CategoryScheme>` ``codelist`` :class:`Codelist \
# OrderedDict was introduced in 3.7.2 and deprecated in 3.9 if sys.version_info < (3, 7): class OrderedDict(collections.OrderedDict, MutableMapping[KT, VT], extra=collections.OrderedDict): __slots__ = () def __new__(cls, *args, **kwargs): # noqa: ANN002,ANN003,ANN204 if _geqv(cls, OrderedDict): return collections.OrderedDict(*args, **kwargs) return _generic_new(collections.OrderedDict, cls, *args, **kwargs) elif sys.version_info < (3, 7, 2): # For whatever reason, pylint can crash if we access collections.OrderedDict directly here from collections import OrderedDict as OrderedDict_collections OrderedDict = _alias(OrderedDict_collections, (KT, VT)) elif sys.version_info < (3, 9): # Whatever Wing uses to underline problematic code thinks typing.OrderedDict doesn't exist OrderedDict = typing.OrderedDict # noqa: TYP006 else: OrderedDict = collections.OrderedDict # Protocol was introduced in 3.8. # _Protocol is an internal type we can use as a shim for < 3.8 if sys.version_info < (3, 8): from typing import _Protocol as Protocol # pylint: disable=E0611 else: from typing import Protocol # AbstractSet -> Set # defaultdict -> DefaultDict
from collections import ChainMap, defaultdict from itertools import combinations, count from typing import Dict, Tuple, NamedTuple, FrozenSet, _alias, KT, VT, List import typing from cytoolz import first, memoize, last import pyaoc2019.utils as U from string import ascii_lowercase, ascii_uppercase __author__ = 'acushner' from pyaoc2019.colors.tile_utils import RC, a_star MyDict = _alias(dict, (KT, VT), inst=False) class my_dict(dict): def __sub__(self, keys): return my_dict((k, self[k]) for k in self.keys() - keys) class Maze(NamedTuple): key_pos: MyDict[str, RC] door_pos: MyDict[str, RC] walls: FrozenSet[RC] start: RC shape_lr: RC @classmethod def from_data(cls, data):
return g(f(x)) return functor(fog) def effect(x): return f(x) return {'map': map, 'effect': effect} class functor(object): def __init__(self, f: Callable): self.f = f def map(self, g: Callable) -> 'functor': def fog(x: Any) -> Any: return g(self.f(x)) return functor(fog) def __call__(self, x: Any = None) -> Any: return self.f(x) def combine(self, _functor: 'functor', x: Any = None) -> 'Functor': return _functor.map(self.f) @classmethod def of(cls, x: Any) -> 'functor': def f(_: Any) -> Any: return x return functor(f) Functor = _alias(functor, T, inst=False)
from collections import deque from enum import Enum from typing import Any, Optional, Sequence, Tuple, Union from wcwidth import wcwidth from . import ansi, constants, utils # This is needed for compatibility with early versions of Python 3.5 prior to 3.5.4 try: from typing import Deque except ImportError: import typing # noinspection PyProtectedMember, PyUnresolvedReferences Deque = typing._alias(deque, typing.T) # Constants EMPTY = '' SPACE = ' ' class HorizontalAlignment(Enum): """Horizontal alignment of text in a cell""" LEFT = 1 CENTER = 2 RIGHT = 3 class VerticalAlignment(Enum): """Vertical alignment of text in a cell"""
import typing class interface: pass ROP = typing._alias(object, typing.T, inst = False) class rop_impl_base: pass interface_rop_types = {} # interface type -> interface rop type inv_interface_rop_types = {} # interface rop type -> interface type def register_interface_rop_type(interface_type, interface_rop_type): interface_rop_types[interface_type] = interface_rop_type inv_interface_rop_types[interface_rop_type] = interface_type def get_interface_rop_type(interface_type): return interface_rop_types[interface_type] def get_interface_type(interface_rop_type): return inv_interface_rop_types[interface_rop_type] method_defs = {} # method signature -> method def def register_method_def(method_signature, method_def): method_defs[method_signature] = method_def def get_method_def(method_signature): return method_defs[method_signature]
def __iter__(self): return self._counter.__iter__() def __len__(self): return self._counter.__len__() def __hash__(self): return hash((FrozenCounter, frozenset(self._counter.items()))) @raise_frozen_error() def __setitem__(self, *args, **kwargs): pass if sys.version_info >= (3, 7): from typing import _alias, T_co, FrozenSet TFrozenCounter = _alias(FrozenCounter, T_co, inst=False) elif sys.version_info >= (3, 6): from typing import Dict, T, _generic_new class TFrozenCounter(FrozenCounter, Dict[T, int], extra=FrozenCounter): __slots__ = () def __new__(cls, *args, **kwds): if cls._gorg is FrozenCounter: return FrozenCounter(*args, **kwds) return _generic_new(FrozenCounter, cls, *args, **kwds)
import numpy as np from abc import ABC, abstractmethod from typing import _alias, T, Tuple Np2dArray = _alias(np.ndarray, T, inst=False) class GridLayer(ABC): def __init__(self, can_move_through: bool = False, pushable: bool = False): self.can_move_through = can_move_through self.pushable = pushable layers = [] @abstractmethod def show(self, density: Np2dArray[int]) -> Np2dArray[str]: pass class GridManager: def __init__(self): self.width = 100 self.height = 50 from dungeon_generator import generate_dungeon dungeon_res = generate_dungeon(self.width, self.height, num_rooms=5, room_min=5, room_max=20) self.layers = { Layer(): density