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
