wip

Author: ducky64

edg/abstract_parts/PartsTable.py

@@ -2,7 +2,7 @@
 
 import csv
 import itertools
-from typing import Generic, Type, overload, Union, Callable, List, Dict, Any, KeysView, Optional, OrderedDict, \
+from typing import Generic, Type, overload, Union, Callable, List, Dict, Any, KeysView, Optional, \
   cast, Tuple, Sequence, Protocol
 
 from typing_extensions import ParamSpec, TypeVar
@@ -83,7 +83,7 @@ def from_csv_files(cls, csv_names: List[str], encoding: str='utf-8') -> 'PartsTa
     return cls.from_dict_rows(dict_rows)
 
   @staticmethod
-  def from_dict_rows(*dict_rowss: Union[List[Dict[str, str]], List[OrderedDict[str, str]]]) -> 'PartsTable':
+  def from_dict_rows(*dict_rowss: Union[List[Dict[str, str]], List[Dict[str, str]]]) -> 'PartsTable':
     """Creates a parts table from dict rows, such as parsed by csv.DictReader.
     Checks to make sure all incoming rows are dense (have all cells)."""
     all_dict_rows = list(itertools.chain(*dict_rowss))

edg/abstract_parts/StandardFootprint.py

@@ -48,6 +48,6 @@ class HasStandardFootprint(Block):
   def standard_footprint(cls) -> Type[StandardFootprint[Self]]:
     """Returns the StandardFootprint class for this block"""
     if callable(cls._STANDARD_FOOTPRINT):
-      return cls._STANDARD_FOOTPRINT()
+      return cls._STANDARD_FOOTPRINT()  # type: ignore
     else:
       return cls._STANDARD_FOOTPRINT

edg/core/Array.py

@@ -3,7 +3,7 @@
 import itertools
 from abc import abstractmethod
 from typing import Generic, Any, Tuple, Type, Optional, Union, Iterable, overload, Hashable, List, \
-  ItemsView, Callable
+  ItemsView, Callable, Dict
 
 from deprecated import deprecated
 from typing_extensions import TypeVar
@@ -108,7 +108,7 @@ def __init__(self, tpe: VectorType) -> None:
     assert not tpe._is_bound()
     self._tpe = tpe
     self._elt_sample = tpe._bind(self)
-    self._elts: Optional[OrderedDict[str, VectorType]] = None  # concrete elements, for boundary ports
+    self._elts: Optional[Dict[str, VectorType]] = None  # concrete elements, for boundary ports
     self._elt_next_index = 0
     self._requests: List[Tuple[Optional[str], BasePort]] = []  # used to track request / request_vector for ref_map
 

edg/core/Builder.py

@@ -8,6 +8,8 @@
 
 if TYPE_CHECKING:
   from .Blocks import BaseBlock
+  from .Link import Link
+  from .HierarchyBlock import Block
 
 
 class Builder:
@@ -41,14 +43,23 @@ def get_enclosing_block(self) -> Optional[BaseBlock]:
   def get_curr_context(self) -> Optional[BaseBlock]:
     return self.get_enclosing_block()
 
+  @overload
+  def elaborate_toplevel(self, block: Block, *,
+                         is_generator: bool = False,
+                         generate_values: Iterable[Tuple[edgir.LocalPath, edgir.ValueLit]] = []) -> edgir.HierarchyBlock: ...
+  @overload
+  def elaborate_toplevel(self, block: Link, *,
+                         is_generator: bool = False,
+                         generate_values: Iterable[Tuple[edgir.LocalPath, edgir.ValueLit]] = []) -> edgir.Link: ...
+
   def elaborate_toplevel(self, block: BaseBlock, *,
                          is_generator: bool = False,
-                         generate_values: Iterable[Tuple[edgir.LocalPath, edgir.ValueLit]] = []) -> edgir.HierarchyBlock:
+                         generate_values: Iterable[Tuple[edgir.LocalPath, edgir.ValueLit]] = []) -> edgir.BlockLikeTypes:
     try:
       if is_generator:  # TODO this is kind of nasty =(
         from .Generator import GeneratorBlock
         assert isinstance(block, GeneratorBlock)
-        elaborated = block._generated_def_to_proto(generate_values)
+        elaborated: edgir.BlockLikeTypes = block._generated_def_to_proto(generate_values)
       else:  # TODO check is a GeneratorBlock w/o circular imports?
         elaborated = block._elaborated_def_to_proto()
 

edg/core/Core.py

@@ -16,7 +16,7 @@ def __init__(self, anon_prefix: Optional[str]=None) -> None:
     self.anon_prefix = anon_prefix
     self.container: Dict[str, ElementType] = {}
     self.names = IdentityDict[ElementType, str]()  # TODO unify w/ container?
-    self.keys_list: List = []
+    self.keys_list: List[str] = []
     self.closed = False
 
   def register(self, item: ElementType) -> ElementType:
@@ -80,7 +80,7 @@ def name_of(self, elt: ElementType) -> Optional[str]:
 
 class SubElementManager:
   def __init__(self) -> None:
-    self.dicts: List[Tuple[Union[Type, Tuple[Type, ...]], SubElementDict]] = []
+    self.dicts: List[Tuple[Union[Type[Any], Tuple[Type[Any], ...]], SubElementDict[Any]]] = []
     self.aliases = IdentityDict[Any, Any]()
 
   def new_dict(self, filter_type: Union[Type[ElementType], Tuple[Type[ElementType], ...]],
@@ -274,7 +274,7 @@ def _get_bases_of(cls, base_type: Type[BaseType]) -> Tuple[List[Type[BaseType]],
     superclasses order is not defined (but MRO in current practice).
 
     mypy currently does not allow passing in abstract types, so generally calls to this need type: ignore."""
-    direct_bases: Set[Type] = set()
+    direct_bases: Set[Type[HasMetadata]] = set()
     def process_direct_base(bcls: Type[HasMetadata.BaseType]) -> None:
       if not issubclass(bcls, base_type):
         return  # ignore above base_type

edg/core/Generator.py

@@ -52,7 +52,7 @@ def get(self, param: ConstraintExpr[WrappedType, Any]) -> WrappedType:
   # Generator dependency data
   #
   class GeneratorRecord(NamedTuple):
-    fn: Callable
+    fn: Callable[..., None]
     req_params: Tuple[ConstraintExpr, ...]  # all required params for generator to fire
     fn_args: Tuple[ConstraintExpr, ...]  # params to unpack for the generator function
 

edg/core/HdlUserExceptions.py

@@ -12,7 +12,7 @@ def __init__(self, exc: str, resolution: str = ""):
 
 class EdgTypeError(EdslUserError):
   """Argument of the wrong type passed into a EDG core function."""
-  def __init__(self, item_desc: str, object: Any, expected_type: Union[Type, Tuple[Type, ...]]):
+  def __init__(self, item_desc: str, object: Any, expected_type: Union[Type[Any], Tuple[Type[Any], ...]]):
     if isinstance(expected_type, tuple):
       expected_type_str = '/'.join([t.__name__ for t in expected_type])
     else:

edg/core/HierarchyBlock.py

@@ -288,7 +288,8 @@ def __init__(self) -> None:
     super().__init__()
 
     if hasattr(self, '_init_params'):  # used to propagate params generated in the metaclass __init__ hook
-      for param_name, param in cast(Dict, self._init_params).items():
+      self._init_params: Dict[str, ConstraintExpr]
+      for param_name, param in self._init_params.items():
         self._parameters.register(param)
         self.manager.add_element(param_name, param)
       delattr(self, '_init_params')
@@ -320,6 +321,7 @@ def _build_ref_map(self, ref_map: Refable.RefMapType, prefix: edgir.LocalPath, *
 
   def _populate_def_proto_block_base(self, pb: edgir.BlockLikeTypes) -> None:
     super()._populate_def_proto_block_base(pb)
+    assert isinstance(pb, edgir.HierarchyBlock)
 
     # generate param defaults
     for param_name, param in self._parameters.items():

edg/core/Ports.py

@@ -16,6 +16,7 @@
 
 if TYPE_CHECKING:
   from .Blocks import BaseBlock
+  from .Link import Link
   from .PortBlocks import PortBridge, PortAdapter