emerge 0.5.0__py3-none-any.whl → 0.5.2__py3-none-any.whl

emerge/_emerge/geo/pcb.py

@@ -18,7 +18,6 @@
 from __future__ import annotations
 
 import numpy as np
-from scipy.optimize import root, fmin
 import gmsh
 
 from ..cs import CoordinateSystem, GCS, Axis
@@ -30,7 +29,7 @@ from .operations import change_coordinate_system
 from .pcb_tools.macro import parse_macro
 from .pcb_tools.calculator import PCBCalculator
 from loguru import logger
-from typing import Literal, Callable
+from typing import Literal, Callable, overload
 from dataclasses import dataclass
 import math
 
@@ -107,6 +106,10 @@ class RouteElement:
         self.direction: np.ndarray = None
         self.dirright: np.ndarray = None
     
+    @property
+    def xy(self) -> tuple[float, float]:
+        return self.x, self.y
+
     @property
     def nr(self) -> tuple[float,float]:
         return (self.x + self.dirright[0]*self.width/2, self.y + self.dirright[1]*self.width/2)
@@ -117,11 +120,11 @@ class RouteElement:
     
     @property
     def right(self) -> list[tuple[float, float]]:
-        pass
+        raise NotImplementedError()
 
     @property
     def left(self) -> list[tuple[float, float]]:
-        pass
+        raise NotImplementedError()
     
     def __eq__(self, other: RouteElement) -> bool:
         return approx(self.x, other.x) and approx(self.y, other.y) and (1-abs(np.sum(self.direction*other.direction)))<1e-8
@@ -158,7 +161,7 @@ class StripTurn(RouteElement):
                  direction: tuple[float, float],
                  angle: float,
                  corner_type: str = 'round',
-                 champher_distance: float = None):
+                 champher_distance: float | None = None):
         self.xold: float = x
         self.yold: float = y
         self.width: float = width
@@ -221,7 +224,8 @@ class StripTurn(RouteElement):
             y2 = yend - dist * self.direction[1]
 
             return [(x1, y1), (x2, y2), (xend, yend)]
-    
+        else:
+            raise RouteException(f'Trying to route a StripTurn with an unknown corner type: {self.corner_type}')
     @property
     def left(self) -> list[tuple[float, float]]:
         if self.angle < 0:
@@ -258,6 +262,8 @@ class StripTurn(RouteElement):
             y2 = yend - dist * self.direction[1]
 
             return [(xend, yend), (x2, y2), (x1, y1)]
+        else:
+            raise RouteException(f'Trying to route a StripTurn with an unknown corner type: {self.corner_type}')
  
 ############################################################
 #                    THE STRIP PATH CLASS                  #
@@ -316,7 +322,7 @@ class StripPath:
         return self
     
     def straight(self, distance: 
-                 float, width: float = None, 
+                 float, width: float | None = None, 
                  dx: float = 0, 
                  dy: float = 0) -> StripPath:
         """Add A straight section to the stripline.
@@ -381,7 +387,7 @@ class StripPath:
         return self
     
     def turn(self, angle: float, 
-             width: float = None, 
+             width: float | None = None, 
              corner_type: Literal['champher','square'] = 'champher') -> StripPath:
         """Adds a turn to the strip path.
 
@@ -419,13 +425,12 @@ class StripPath:
         Returns:
             StripPath: The current StripPath object.
         """
-        self.pcb.store(name, self.end.x, self.end.y)
         self.pcb.stored_striplines[name] = self.end
         return self
     
     def split(self, 
-              direction: tuple[float, float] = None,
-              width: float = None) -> StripPath:
+              direction: tuple[float, float]  | None= None,
+              width: float  | None= None) -> StripPath:
         """Split the current path in N new paths given by a new departure direction
 
         Args:
@@ -529,9 +534,9 @@ class StripPath:
             znew: float,
             radius: float,
             proceed: bool = True,
-            direction: tuple[float, float] = None,
-            width: float = None,
-            extra: float = None,
+            direction: tuple[float, float] | None = None,
+            width: float | None = None,
+            extra: float | None = None,
             segments: int = 6) -> StripPath:
         """Adds a via to the circuit
 
@@ -576,13 +581,13 @@ class StripPath:
         return self
 
     def jump(self, 
-             dx: float = None,
-             dy: float = None,
-             width: float = None,
-             direction: tuple[float, float] = None,
-             gap: float = None,
-             side: Literal['left','right'] = None,
-             reverse: float = None) -> StripPath:
+             dx: float | None = None,
+             dy: float | None = None,
+             width: float | None = None,
+             direction: tuple[float, float] | None = None,
+             gap: float | None = None,
+             side: Literal['left','right'] | None = None,
+             reverse: float | None = None) -> StripPath:
         """Add an unconnected jump to the currenet stripline.
 
         The last stripline path will be terminated and a new one will be started based on the 
@@ -630,8 +635,8 @@ class StripPath:
         return self.pcb.new(x, y, width, direction)
     
     def to(self, dest: tuple[float, float], 
-           arrival_dir: tuple[float, float] = None,
-           arrival_margin: float = None,
+           arrival_dir: tuple[float, float] | None = None,
+           arrival_margin: float  | None= None,
            angle_step: float = 90):
         """
         Extend the path from current end point to dest (x, y).
@@ -672,7 +677,7 @@ class StripPath:
         dt = max_t / 1000.0  # resolution of search
         found = False
         desired_q = None
-        cand_dx = cand_dy = 0.0
+        #cand_dx = cand_dy = 0.0
         
         while t <= max_t:
             # candidate intercept point
@@ -700,8 +705,8 @@ class StripPath:
             raise RuntimeError("Could not find an intercept angle matching quantization")
 
         # 1) Perform initial quantized turn
-        if abs(desired_q) > atol:
-            self.turn(-desired_q)
+        if abs(desired_q) > atol: # type: ignore
+            self.turn(-desired_q) # type: ignore
         x0 = self.end.x
         y0 = self.end.y
         # compute new heading vector after turn
@@ -752,7 +757,7 @@ class StripPath:
 
         return self
 
-    def macro(self, path: str, width: float = None, start_dir: tuple[float, float] = None) -> StripPath:
+    def macro(self, path: str, width: float | None = None, start_dir: tuple[float, float] | None = None) -> StripPath:
         r"""Parse an EMerge macro command string
 
         The start direction by default is the abslute current heading. If a specified heading is provided
@@ -803,7 +808,7 @@ class PCB:
     def __init__(self,
                  thickness: float,
                  unit: float = 0.001,
-                 cs: CoordinateSystem = None,
+                 cs: CoordinateSystem | None = None,
                  material: Material = AIR,
                  layers: int = 2,
                  ):
@@ -811,16 +816,16 @@ class PCB:
         self.thickness: float = thickness
         self._zs: np.ndarray = np.linspace(-self.thickness, 0, layers)
         self.material: Material = material
-        self.width: float = None
-        self.length: float = None
-        self.origin: np.ndarray = None
+        self.width: float | None = None
+        self.length: float | None = None
+        self.origin: np.ndarray = np.array([0.,0.,0.])
         self.paths: list[StripPath] = []
         self.polies: list[PCBPoly] = []
 
         self.lumped_ports: list[StripLine] = []
         self.lumped_elements: list[GeoPolygon] = []
 
-        self.unit = unit
+        self.unit: float = unit
 
         self.cs: CoordinateSystem = cs
         if self.cs is None:
@@ -864,7 +869,7 @@ class PCB:
         """
         return self._zs[layer-1]
     
-    def _get_z(self, element: RouteElement) -> float:
+    def _get_z(self, element: RouteElement) -> float :
         """Return the z-height of a given Route Element
 
         Args:
@@ -876,38 +881,23 @@ class PCB:
         for path in self.paths:
             if path._has(element):
                 return path.z
-        return None
-
-    def store(self, name: str, x: float, y:float):
-        """Store the x,y coordinate pair one label provided by name
+        raise RouteException('Requesting z-height of route element that is not contained in a path.')
 
-        Args:
-            name (str): The corodinate label name
-            x (float): The x-coordinate
-            y (float): The y-coordinate
-        """
-        self.stored_coords[name] = (x,y)
-
-    def load(self, name: str) -> tuple[float, float] | StripLine:
+    def load(self, name: str) -> StripLine:
         """Acquire the x,y, coordinate associated with the label name.
         
         Args:
             name (str): The name of the x,y coordinate
             
         """
-        if name in self.stored_striplines and name in self.stored_coords:
-            logger.warning(f'There is both a coordinate and stripline under the name {name}.')
-            return self.stored_striplines[name]
-        elif name in self.stored_striplines:
+        if name in self.stored_striplines:
             return self.stored_striplines[name]
-        elif name in self.stored_coords:
-            return self.stored_coords[name]
         else:
             raise ValueError(f'There is no stripline or coordinate under the name of {name}')
     
     def __call__(self, path_nr: int) -> StripPath:
         if path_nr >= len(self.paths):
-            self.paths.append(StripPath())
+            self.paths.append(StripPath(self))
         return self.paths[path_nr]
     
     def determine_bounds(self, 
@@ -956,9 +946,9 @@ class PCB:
 
     def plane(self,
               z: float,
-              width: float = None,
-              height: float = None,
-              origin: tuple[float, float] = None,
+              width: float | None = None,
+              height: float | None = None,
+              origin: tuple[float, float] | None = None,
               alignment: Literal['corner','center'] = 'corner') -> GeoSurface:
         """Generates a generic rectangular plate in the XY grid.
         If no size is provided, it defaults to the entire PCB size assuming that the bounds are determined.
@@ -974,17 +964,22 @@ class PCB:
             GeoSurface: _description_
         """
         if width is None or height is None or origin is None:
+            if self.width is None or self.length is None or self.origin:
+                raise RouteException('Cannot define a plane with no possible definition of its size.')
             width = self.width
             height = self.length
             origin = (self.origin[0]*self.unit, self.origin[1]*self.unit)
-        origin = origin + (z*self.unit, )
+        
+        origin: tuple[float, ...] = origin + (z*self.unit, ) # type: ignore
 
         if alignment == 'center':
-            origin = (origin[0] - width*self.unit/2, origin[1]-height*self.unit/2, origin[2])
+            origin = (origin[0] - width*self.unit/2, 
+                                                        origin[1] - height*self.unit/2, 
+                                                        origin[2])
 
-        plane = Plate(origin, (width*self.unit, 0, 0), (0, height*self.unit, 0))
-        plane = change_coordinate_system(plane, self.cs)
-        return plane
+        plane = Plate(origin, (width*self.unit, 0, 0), (0, height*self.unit, 0)) # type: ignore
+        plane = change_coordinate_system(plane, self.cs) # type: ignore
+        return plane # type: ignore
     
     def gen_pcb(self, 
                 split_z: bool = True,
@@ -1004,7 +999,7 @@ class PCB:
                 if (z-zvalues_isolated[-1]) <= layer_tolerance:
                     continue
                 zvalues_isolated.append(z)
-            boxes = []
+            boxes: list[GeoVolume] = []
             for z1, z2 in zip(zvalues_isolated[:-1],zvalues_isolated[1:]):
                 h = z2-z1
                 box = Box(self.width*self.unit,
@@ -1015,8 +1010,8 @@ class PCB:
                 box = change_coordinate_system(box, self.cs)
                 boxes.append(box)
             if merge:
-                return GeoVolume.merged(boxes)
-            return boxes
+                return GeoVolume.merged(boxes) # type: ignore
+            return boxes # type: ignore
         
         box = Box(self.width*self.unit, 
                   self.length*self.unit, 
@@ -1024,7 +1019,7 @@ class PCB:
                   position=(x0,y0,z0-self.thickness*self.unit))
         box.material = self.material
         box = change_coordinate_system(box, self.cs)
-        return box
+        return box # type: ignore
 
     def gen_air(self, height: float) -> GeoVolume:
         """Generate the Air Block object
@@ -1041,7 +1036,7 @@ class PCB:
                   height*self.unit, 
                   position=(x0,y0,z0))
         box = change_coordinate_system(box, self.cs)
-        return box
+        return box # type: ignore
 
     def new(self, 
             x: float, 
@@ -1072,7 +1067,7 @@ class PCB:
         self.paths.append(path)  
         return path
     
-    def lumped_port(self, stripline: StripLine, z_ground: float = None) -> GeoPolygon:
+    def lumped_port(self, stripline: StripLine, z_ground: float | None = None) -> GeoPolygon:
         """Generate a lumped-port object to be created.
 
         Args:
@@ -1152,7 +1147,7 @@ class PCB:
 
         plate = Plate(np.array([x0,y0,z0])*self.unit, ax1, ax2)
         plate = change_coordinate_system(plate, self.cs)
-        return plate
+        return plate # type: ignore
 
     def generate_vias(self, merge=False) -> list[Cyllinder] | Cyllinder:
         """Generates the via objects.
@@ -1175,14 +1170,14 @@ class PCB:
             vias.append(cyl)
         if merge:
             
-            return GeoVolume.merged(vias)
+            return GeoVolume.merged(vias) # type: ignore
         return vias   
 
     def add_poly(self, 
                  xs: list[float],
                  ys: list[float],
                  z: float = 0,
-                 material: Material = COPPER):
+                 material: Material = COPPER) -> None:
         """Add a custom polygon to the PCB
 
         Args:
@@ -1210,6 +1205,12 @@ class PCB:
         poly = GeoPolygon([planetag,])
         return poly
     
+    @overload
+    def compile_paths(self, merge: Literal[True]) -> GeoSurface: ...
+    
+    @overload
+    def compile_paths(self, merge: Literal[False] = ...) -> list[GeoSurface]: ...
+
     def compile_paths(self, merge: bool = False) -> list[GeoPolygon] | GeoSurface:
         """Compiles the striplines and returns a list of polygons or asingle one.
 

emerge/_emerge/geo/pcb_tools/macro.py

@@ -25,8 +25,8 @@ def rotation_angle(a: tuple[float, float], b: tuple[float, float]) -> float:
 @dataclass
 class Instruction:
     instr: str
-    args: tuple[int]
-    kwargs: dict[str,float] = None
+    args: tuple[int | float, ...]
+    kwargs: dict[str,float] | None = None
 
     def __post_init__(self):
         if self.kwargs is None:
@@ -37,33 +37,34 @@ char_class = ''.join(re.escape(c) for c in symbols)
 
 pattern = re.compile(rf'([{char_class}])([\d\,\.\-]+)')
 
-def parse_macro(pathstring: str, width: int, direction: tuple[float, float]) -> list[Instruction]:
+def parse_macro(pathstring: str, width: int | float, direction: tuple[float, float]) -> list[Instruction]:
     instructions = pattern.findall(pathstring.replace(' ',''))
     
     oi = []
     for com, val in instructions:
         if ',' in val:
-            ival, width = [float(x) for x in val.split(',')]
+            val_list: list[float] = [float(x) for x in val.split(',')]
+            ival, width = val_list[0], val_list[1]
         else:
             ival = float(val)
         if com == '=':
-            oi.append(Instruction('straight',(ival,),{'width': width}))
+            oi.append(Instruction('straight',(ival,),{'width': width})) #type: ignore
         elif com == '>':
-            oi.append(Instruction('turn',(rotation_angle(direction,(1,0)),) ))
+            oi.append(Instruction('turn',(rotation_angle(direction, (1., 0.)),) ))
             oi.append(Instruction('straight',(ival,),{'width': width}))
-            direction = (1,0)
+            direction = (1. ,0. )
         elif com == '<':
-            oi.append(Instruction('turn',(rotation_angle(direction,(-1,0)),) ))
+            oi.append(Instruction('turn',(rotation_angle(direction, (-1., 0.)),) ))
             oi.append(Instruction('straight',(ival,),{'width': width}))
-            direction = (-1,0)
+            direction = (-1.,0.)
         elif com == 'v':
-            oi.append(Instruction('turn',(rotation_angle(direction,(0,-1)),) ))
+            oi.append(Instruction('turn',(rotation_angle(direction, (0.,-1.)),) ))
             oi.append(Instruction('straight',(ival,),{'width': width}))
-            direction = (0,-1)
+            direction = (0.,-1.)
         elif com == '^':
-            oi.append(Instruction('turn',(rotation_angle(direction,(0,1)),) ))
+            oi.append(Instruction('turn',(rotation_angle(direction, (0.,1.)),) ))
             oi.append(Instruction('straight',(ival,),{'width': width}))
-            direction = (0,1)
+            direction = (0.,1.)
         elif com == '\\':
             oi.append(Instruction('turn',(90,) ))
             oi.append(Instruction('straight',(ival,),{'width': width}))

emerge/_emerge/geo/pmlbox.py

@@ -106,7 +106,7 @@ def _add_pml_layer(center: tuple[float, float, float],
             plate = Plate(np.array([p0x-tW/2, p0y-tD/2, p0z-dz*thickness/2 + dz*(n+1)*thl]), ax1, ax2)
             planes.append(plate)
     
-    pml_box.material = Material(_neff=np.sqrt(material.er*material.ur), _fer=ermat, _fur=urmat)
+    pml_box.material = Material(_neff=np.sqrt(material.er*material.ur), _fer=ermat, _fur=urmat, color='#bbbbff', opacity=0.1)
     pml_box.max_meshsize = thickness/N_mesh_layers
     pml_box._embeddings = planes
     

emerge/_emerge/geometry.py

@@ -16,13 +16,15 @@
 # <https://www.gnu.org/licenses/>.
 
 from __future__ import annotations
-import gmsh
+import gmsh # type: ignore
 from .material import Material, AIR
-from .selection import FaceSelection, DomainSelection, EdgeSelection, PointSelection
+from .selection import FaceSelection, DomainSelection, EdgeSelection, PointSelection, Selection
 from loguru import logger
-from typing import Literal, Any
+from typing import Literal, Any, Iterable, TypeVar
 import numpy as np
 
+
+
 def _map_tags(tags: list[int], mapping: dict[int, list[int]]):
     new_tags = []
     for tag in tags:
@@ -48,12 +50,12 @@ class _GeometryManager:
         self.geometry_list: dict[str, list[GeoObject]] = dict()
         self.active: str = ''
 
-    def all_geometries(self, model: str = None) -> list[GeoObject]:
+    def all_geometries(self, model: str | None = None) -> list[GeoObject]:
         if model is None:
             model = self.active
         return [geo for geo in self.geometry_list[model] if geo._exists]
 
-    def submit_geometry(self, geo: GeoObject, model: str = None) -> None:
+    def submit_geometry(self, geo: GeoObject, model: str | None = None) -> None:
         if model is None:
             model = self.active
         self.geometry_list[model].append(geo)
@@ -135,7 +137,7 @@ class _FacePointer:
     def translate(self, dx, dy, dz):
         self.o = self.o + np.array([dx, dy, dz])
     
-    def mirror(self, c0: np.ndarray, pln: np.ndarray):
+    def mirror(self, c0: np.ndarray, pln: np.ndarray) -> None:
         """
         Reflect self.o and self.n across the plane passing through c0
         with normal pln.
@@ -205,9 +207,11 @@ class GeoObject:
     """A generalization of any OpenCASCADE entity described by a dimension and a set of tags.
     """
     dim: int = -1
-    def __init__(self):
+    def __init__(self, tags: list[int] | None = None):
+        if tags is None:
+            tags = []
         self.old_tags: list[int] = []
-        self.tags: list[int] = []
+        self.tags: list[int] = tags
         self.material: Material = AIR
         self.mesh_multiplier: float = 1.0
         self.max_meshsize: float = 1e9
@@ -225,7 +229,7 @@ class GeoObject:
         _GEOMANAGER.submit_geometry(self)
 
     @property
-    def color_rgb(self) -> tuple[int,int,int]:
+    def color_rgb(self) -> tuple[float, float, float]:
         return self.material.color_rgb
     
     @property
@@ -233,7 +237,7 @@ class GeoObject:
         return self.material.opacity
     
     @property
-    def select(self) -> FaceSelection | DomainSelection | EdgeSelection | None:
+    def select(self) -> Selection:
         '''Returns a corresponding Face/Domain or Edge Selection object'''
         if self.dim==1:
             return EdgeSelection(self.tags)
@@ -241,11 +245,14 @@ class GeoObject:
             return FaceSelection(self.tags)
         elif self.dim==3:
             return DomainSelection(self.tags)
+        else:
+            return Selection(self.tags)
     
     @staticmethod
-    def merged(objects: list[GeoObject]) -> list[GeoObject]:
+    def merged(objects: list[GeoPoint | GeoEdge | GeoSurface | GeoVolume | GeoObject]) -> list[GeoPoint | GeoEdge | GeoSurface | GeoVolume | GeoObject] | GeoPoint | GeoEdge | GeoSurface | GeoVolume | GeoObject:
         dim = objects[0].dim
         tags = []
+        out: GeoObject | None = None
         for obj in objects:
             tags.extend(obj.tags)
         if dim==2:
@@ -260,8 +267,8 @@ class GeoObject:
     def __repr__(self) -> str:
         return f'{self.__class__.__name__}({self.dim},{self.tags})'
 
-    def _data(self, *labels) -> tuple[Any]:
-        return tuple([self._aux_data.get(lab, None) for lab in labels])
+    def _data(self, *labels) -> tuple[Any | None, ...]:
+        return tuple([self._aux_data[lab] for lab in labels])
     
     def _add_face_pointer(self, 
                           name: str,
@@ -325,7 +332,7 @@ class GeoObject:
             self._tools.update(obj._tools)
         return self
     
-    def _face_tags(self, name: FaceNames, tool: GeoObject = None) -> list[int]:
+    def _face_tags(self, name: FaceNames, tool: GeoObject | None = None) -> list[int]:
         names = self._all_pointer_names
         if name not in names:
             raise ValueError(f'The face {name} does not exist in {self}')
@@ -380,7 +387,7 @@ class GeoObject:
         self._priority -= 1
         return self
 
-    def outside(self, *exclude: FaceNames, tags: list[int] = None) -> FaceSelection:
+    def outside(self, *exclude: FaceNames, tags: list[int] | None = None) -> FaceSelection:
         """Returns the complete set of outside faces.
 
         If implemented, it is possible to exclude a set of faces based on their name
@@ -394,7 +401,7 @@ class GeoObject:
         dimtags = gmsh.model.get_boundary(self.dimtags, True, False)
         return FaceSelection([t for d,t in dimtags if t not in tags])
     
-    def face(self, name: FaceNames, tool: GeoObject = None) -> FaceSelection:
+    def face(self, name: FaceNames, tool: GeoObject | None = None) -> FaceSelection:
         """Returns the FaceSelection for a given face name.
         
         The face name must be defined for the type of geometry.
@@ -422,7 +429,7 @@ class GeoObject:
             return FaceSelection([t[1] for t in tags])
         if self.dim == 2:
             return FaceSelection(self.tags)
-        if self.dim < 2:
+        else:
             raise ValueError('Can only generate faces for objects of dimension 2 or higher.')
 
     @staticmethod
@@ -443,12 +450,13 @@ class GeoVolume(GeoObject):
     '''GeoVolume is an interface to the GMSH CAD kernel. It does not represent EMerge
     specific geometry data.'''
     dim = 3
-    def __init__(self, tag: int | list[int]):
+    def __init__(self, tag: int | Iterable[int]):
         super().__init__()
-        if isinstance(tag, list):
-            self.tags: list[int] = tag
+        self.tags: list[int] = []
+        if isinstance(tag, Iterable):
+            self.tags = list(tag)
         else:
-            self.tags: list[int] = [tag,]
+            self.tags = [tag,]
 
     @property
     def select(self) -> DomainSelection:
@@ -463,10 +471,12 @@ class GeoPoint(GeoObject):
     
     def __init__(self, tag: int | list[int]):
         super().__init__()
-        if isinstance(tag, list):
-            self.tags: list[int] = tag
+
+        self.tags: list[int] = []
+        if isinstance(tag, Iterable):
+            self.tags = list(tag)
         else:
-            self.tags: list[int] = [tag,]
+            self.tags = [tag,]
 
 class GeoEdge(GeoObject):
     dim = 1
@@ -477,10 +487,11 @@ class GeoEdge(GeoObject):
     
     def __init__(self, tag: int | list[int]):
         super().__init__()
-        if isinstance(tag, list):
-            self.tags: list[int] = tag
+        self.tags: list[int] = []
+        if isinstance(tag, Iterable):
+            self.tags = list(tag)
         else:
-            self.tags: list[int] = [tag,]
+            self.tags = [tag,]
         
 
 class GeoSurface(GeoObject):
@@ -494,17 +505,20 @@ class GeoSurface(GeoObject):
     
     def __init__(self, tag: int | list[int]):
         super().__init__()
-        if isinstance(tag, list):
-            self.tags: list[int] = tag
+        self.tags: list[int] = []
+        if isinstance(tag, Iterable):
+            self.tags = list(tag)
         else:
-            self.tags: list[int] = [tag,]
+            self.tags = [tag,]
 
 class GeoPolygon(GeoSurface):
     
     def __init__(self,
                  tags: list[int]):
         super().__init__(tags)
-        self.points: list[int] = None
-        self.lines: list[int] = None
+        self.points: list[int] = []
+        self.lines: list[int] = []
 
     
+T = TypeVar('T', GeoVolume, GeoEdge, GeoPoint, GeoSurface)
+    

emerge/_emerge/logsettings.py

@@ -51,8 +51,8 @@ class LogController:
         logger.remove()
         self.std_handlers: list[int] = []
         self.file_handlers: list[int] = []
-        self.level: LLTYPE = 'INFO'
-        self.file_level: LLTYPE = 'INFO'
+        self.level: str = 'INFO'
+        self.file_level: str = 'INFO'
     
     def set_default(self):
         value = os.getenv("EMERGE_STD_LOGLEVEL", default="INFO")
@@ -68,7 +68,7 @@ class LogController:
         handler = {"sink": sys.stdout, 
                    "level": loglevel, 
                    "format": FORMAT_DICT.get(loglevel, INFO_FORMAT)}
-        logger.configure(handlers=[handler])
+        logger.configure(handlers=[handler]) # type: ignore
         self.level = loglevel
         os.environ["EMERGE_STD_LOGLEVEL"] = loglevel