fix some typings

Author: hiaselhans

openglider/glider/parametric/table/attachment_points.py

@@ -10,7 +10,6 @@
 
 from openglider.glider.cell.attachment_point import CellAttachmentPoint
 from openglider.glider.cell.cell import Cell
-from openglider.glider.curve import GliderCurveType
 from openglider.glider.parametric.table.base import CellTable, Keyword, RibTable, dto
 from openglider.glider.parametric.table.base.parser import Parser
 from openglider.glider.rib.attachment_point import AttachmentPoint
@@ -25,7 +24,7 @@
 
 logger = logging.getLogger(__name__)
 
-class ATP(dto.DTO):
+class ATP(dto.DTO[AttachmentPoint]):
     name: str
     rib_pos: Percentage
     force: float | euklid.vector.Vector3D
@@ -92,7 +91,7 @@ class AttachmentPointTable(RibTable):
         #"AHP": ATP,
     }
 
-    def get_element(self, row: int, keyword: str, data: list[Any], resolvers: list[Parser]=None, rib: Rib=None, **kwargs: Any) -> AttachmentPoint:
+    def get_element(self, row: int, keyword: str, data: list[Any], resolvers: list[Parser] | None=None, rib: Rib | None=None, **kwargs: Any) -> AttachmentPoint:
         # rib_no, rib_pos, cell_pos, force, name, is_cell
         force = data[2]
 
@@ -123,7 +122,8 @@ def update_columns(keyword: str, data_length: int, force_position: int) -> None:
                         if name in forces:
                             force = forces[name]
                             try:
-                                if isinstance(force, float):
+                                # TODO: why?
+                                if isinstance(force, (float, int)):
                                     raise TypeError()
                                 column[row, force_position] = str(list(force))
                             except TypeError:
@@ -157,7 +157,7 @@ class CellAttachmentPointTable(CellTable):
         "ATPDIFF": Keyword([("name", str), ("cell_pos", float), ("rib_pos", float), ("force", Union[float, str]), ("offset", float)], target_cls=CellAttachmentPoint)
     }
 
-    def get_element(self, row: int, keyword: str, data: list[Any], resolvers: list[Parser], cell: Cell=None, **kwargs: Any) -> CellAttachmentPoint:
+    def get_element(self, row: int, keyword: str, data: list[Any], resolvers: list[Parser], cell: Cell | None=None, **kwargs: Any) -> CellAttachmentPoint: # type: ignore
         force = data[3]
 
         if isinstance(force, str):
@@ -171,7 +171,8 @@ def get_element(self, row: int, keyword: str, data: list[Any], resolvers: list[P
         if len(data) > 4:
             offset = resolvers[row].parse(data[4])
 
-            node.offset = offset
+            if offset is not None:
+                node.offset = Length(offset)
 
         return node
 

openglider/glider/parametric/table/base/dto.py

@@ -37,22 +37,22 @@ def from_value(cls, value: TupleType) -> Self:
     @pydantic.model_validator(mode="before")
     @classmethod
     def _validate(cls, v: Any) -> dict[str, Any] | Self:
-        if isinstance(v, tuple) and len(v) == 2:
-            return {
-                "first": v[0],
-                "second": v[1]
-            }
-        else:
-            return {
-                "first": v,
-                "second": v
-            }
-
+        if isinstance(v, tuple):
+            v_tuple = typing.cast(tuple[Any, Any], v)
+            if len(v_tuple) == 2:
+                return {
+                    "first": v_tuple[0],
+                    "second": v_tuple[1]
+                }
+        return {
+            "first": v,
+            "second": v
+        }
 class SingleCellTuple(CellTuple[TupleType], Generic[TupleType]):
     index_offset: ClassVar[tuple[int, int]] = (0, 0)
 
 
-_type_cache: dict[type[DTO], list[tuple[str, str]]] = {}
+_type_cache: dict[type[DTO[Any]], list[tuple[str, str]]] = {}
 
 class DTO(BaseModel, Generic[ReturnType], abc.ABC):
     model_config = pydantic.ConfigDict(
@@ -66,12 +66,12 @@ def get_object(self) -> ReturnType:
         raise NotImplementedError
 
     @staticmethod
-    def _get_type_string(type_: type | None) -> str:
+    def _get_type_string(type_: type | types.UnionType | None) -> str:
         assert type_ is not None
 
         if isinstance(type_, types.UnionType):
-            names = []
-            for subtype in type_.__args__:
+            names: list[str] = []
+            for subtype in typing.get_args(type_):
                 names.append(subtype.__name__)
 
             return " | ".join(names)
@@ -87,10 +87,10 @@ def _get_type_string(type_: type | None) -> str:
             return type_.__name__
 
     @staticmethod
-    def _is_cell_tuple(type: Any) -> CellTuple | None:
+    def check_is_cell_tuple(type_: Any) -> type[CellTuple[Any]] | None:
         try:
-            if issubclass(type, CellTuple):
-                return type
+            if isinstance(type_, type) and issubclass(type_, CellTuple):
+                return typing.cast(type[CellTuple[Any]], type_)
         except TypeError:
             pass
 
@@ -99,12 +99,12 @@ def _is_cell_tuple(type: Any) -> CellTuple | None:
     @classmethod
     def describe(cls) -> list[tuple[str, str]]:
         if cls not in _type_cache:
-            result = []
+            result: list[tuple[str, str]] = []
             for field_name, field in cls.model_fields.items():
-                is_cell_tuple = cls._is_cell_tuple(field.annotation)
+                is_cell_tuple = cls.check_is_cell_tuple(field.annotation)
 
                 if is_cell_tuple:
-                    inner_type = is_cell_tuple.__fields__["first"].annotation
+                    inner_type = is_cell_tuple.model_fields["first"].annotation
                     inner_type_str = cls._get_type_string(inner_type)
 
                     if sum(is_cell_tuple.index_offset) > 0:

openglider/glider/parametric/table/base/table.py

@@ -1,6 +1,5 @@
 import enum
 import logging
-import sys
 import typing
 from typing import Any, Generic, TypeVar
 
@@ -24,10 +23,10 @@ class TableType(enum.Enum):
 
 class ElementTable(Generic[ElementType]):
     table_type: TableType = TableType.general
-    keywords: dict[str, Keyword] = {}
-    dtos: dict[str, type[DTO]] = {}
+    keywords: dict[str, Keyword[Any]] = {}
+    dtos: dict[str, type[DTO[Any]]] = {}
 
-    def __init__(self, table: Table=None, migrate_header: bool=False):
+    def __init__(self, table: Table | None=None, migrate_header: bool=False):
         self.table = Table()
         if table is not None:
             if migrate_header:
@@ -36,18 +35,17 @@ def __init__(self, table: Table=None, migrate_header: bool=False):
             else:
                 _table = table
 
-            if _table is not None:
-                def add_data(keyword: str, data_length: int) -> None:
-                    for column in self.get_columns(_table, keyword, data_length):
-                        self.table.append_right(column)
+            def add_data(keyword: str, data_length: int) -> None:
+                for column in self.get_columns(_table, keyword, data_length):
+                    self.table.append_right(column)
 
-                for keyword in self.keywords:
-                    data_length = self.keywords[keyword].attribute_length
-                    add_data(keyword, data_length)
+            for keyword in self.keywords:
+                data_length = self.keywords[keyword].attribute_length
+                add_data(keyword, data_length)
 
-                for dto in self.dtos:
-                    data_length = self.dtos[dto].column_length()
-                    add_data(dto, data_length)
+            for dto in self.dtos:
+                data_length = self.dtos[dto].column_length()
+                add_data(dto, data_length)
 
     def __json__(self) -> dict[str, Any]:
         return {
@@ -56,7 +54,7 @@ def __json__(self) -> dict[str, Any]:
 
     @classmethod
     def get_columns(cls, table: Table, keyword: str, data_length: int) -> list[Table]:
-        columns = []
+        columns: list[Table] = []
         column = 0
 
         if keyword in cls.keywords:
@@ -69,6 +67,8 @@ def get_columns(cls, table: Table, keyword: str, data_length: int) -> list[Table
             header[0, 0] = keyword
             for i, (field_name, field_type) in enumerate(types):
                 header[1, i] = f"{field_name}: {field_type}"
+        else:
+            raise ValueError(f"unknown keyword {keyword}")
 
         while column < table.num_columns:
             if table[0, column] == keyword:
@@ -85,7 +85,7 @@ def get_columns(cls, table: Table, keyword: str, data_length: int) -> list[Table
 
     def get(self, row_no: int, keywords: list[str] | None=None, **kwargs: Any) -> list[ElementType]:
         row_no += 2  # skip header line
-        elements = []
+        elements: list[ElementType] = []
 
         for keyword in list(self.keywords.keys()) + list(self.dtos.keys()):
             if keyword in self.keywords:
@@ -136,14 +136,14 @@ def get_one(self, row_no: int, keywords: list[str] | None=None, **kwargs: Any) -
 
         return None
 
-    def _prepare_dto_data(self, row: int, dto: type[DTO], data: list[Any], resolvers: list[Parser]) -> dict[str, Any]:
+    def _prepare_dto_data(self, row: int, dto: type[DTO[Any]], data: list[Any], resolvers: list[Parser]) -> dict[str, Any]:
         fields = dto.model_fields.items()
 
         dct: dict[str, Any] = {}
         index = 0
 
         for field_name, field in fields:
-            if tuple_type := dto._is_cell_tuple(field.annotation):
+            if tuple_type := dto.check_is_cell_tuple(field.annotation):
                 offset1, offset2 = tuple_type.index_offset
                 dct[field_name] = (
                     resolvers[row].parse(data[index+offset1]),
@@ -176,11 +176,11 @@ def get_element(self, row: int, keyword: str, data: list[typing.Any], **kwargs:
             raise ValueError()
 
     def _repr_html_(self) -> str:
-        return self.table._repr_html_()
+        return self.table._repr_html_() # type: ignore
 
 
-class CellTable(ElementTable):
+class CellTable(ElementTable[Any]):
     table_type = TableType.cell
 
-class RibTable(ElementTable):
+class RibTable(ElementTable[Any]):
     table_type = TableType.rib

openglider/glider/rib/attachment_point.py

@@ -29,7 +29,7 @@ class RoundReinforcement(BaseModel):
     def get_3d(self, rib: Rib, num_points: int=10) -> list[euklid.vector.PolyLine3D]:
         # create circle with center on the point
         polygons = self.get_flattened(rib, num_points=num_points)
-        aligned_polygons = []
+        aligned_polygons: list[euklid.vector.PolyLine3D] = []
         for polygon in polygons:
 
             aligned_polygons.append(rib.align_all(polygon, scale=False))
@@ -61,7 +61,7 @@ class AttachmentPoint(Node):
     protoloops: int = 0
     protoloop_distance: Percentage | Length = Percentage("2%")
 
-    re_name: ClassVar[re.Pattern] = re.compile(r"^(?P<n>[0-9]+_)?([A-Za-z]+)([0-9]+)")
+    re_name: ClassVar[re.Pattern[Any]] = re.compile(r"^(?P<n>[0-9]+_)?([A-Za-z]+)([0-9]+)")
 
     def __repr__(self) -> str:
         return f"<{self.__class__.__name__}: '{self.name}' ({self.rib_pos})>"
@@ -76,7 +76,7 @@ def __json__(self) -> dict[str, Any]:
         }
 
     @classmethod
-    def __from_json__(self, **data: Any) -> AttachmentPoint:
+    def __from_json__(cls, **data: Any) -> AttachmentPoint:
         data["force"] = euklid.vector.Vector3D(data["force"])
         return AttachmentPoint(**data)
 
@@ -88,7 +88,7 @@ def get_x_values(self, rib: Rib) -> list[float]:
 
         if self.protoloops:
             hull = rib.get_hull()
-            ik_start = hull.get_ik(self.rib_pos)
+            ik_start = hull.get_ik(self.rib_pos.si)
 
             for i in range(self.protoloops):
                 diff = (i+1) * self.protoloop_distance
@@ -104,11 +104,9 @@ def get_x_values(self, rib: Rib) -> list[float]:
 
         return positions
 
-    @classmethod
-    def calculate_force_rib_aligned(self, rib: Rib, force: float | None=None) -> euklid.vector.Vector3D:
-        if force is None:
-            force = self.force.length()
-        return rib.rotation_matrix.apply([0, force, 0])
+    @staticmethod
+    def calculate_force_rib_aligned(rib: Rib, force: float) -> euklid.vector.Vector3D:
+        return rib.rotation_matrix.apply(euklid.vector.Vector3D([0, force, 0]))
 
     def get_position(self, rib: Rib) -> euklid.vector.Vector3D:
         hull = rib.get_hull()

openglider/lines/lineset.py

@@ -6,7 +6,7 @@
 import math
 import os
 import re
-from typing import TYPE_CHECKING, Any, TypeAlias, TypeVar
+from typing import TYPE_CHECKING, Any, TypeAlias
 from collections.abc import Callable
 from functools import cmp_to_key
 
@@ -58,8 +58,7 @@ def get_length(self) -> float:
         return length
 
 
-T = TypeVar('T')
-LineTreePart: TypeAlias = tuple[Line, list[T]]
+LineTreePart: TypeAlias = tuple[Line, list["LineTreePart"]]
 
 class LineSet:
     """
@@ -69,7 +68,7 @@ class LineSet:
     knot_corrections = KnotCorrections.read_csv(os.path.join(os.path.dirname(__file__), "knots.csv"))
     mat: SagMatrix
 
-    def __init__(self, lines: list[Line], v_inf: euklid.vector.Vector3D=None):
+    def __init__(self, lines: list[Line], v_inf: euklid.vector.Vector3D | None=None):
         self._v_inf = v_inf or euklid.vector.Vector3D([0,0,0])
         self.lines = lines or []
 
@@ -101,7 +100,7 @@ def __json__(self) -> dict[str, Any]:
 
     @classmethod
     def __from_json__(cls, lines: list[dict[str, Any]], nodes: list[Node], v_inf: euklid.vector.Vector3D) -> LineSet:
-        lines_new = []
+        lines_new: list[Line] = []
         for line in lines:
             if isinstance(line["upper_node"], int):
                 line["upper_node"] = nodes[line["upper_node"]]
@@ -137,8 +136,9 @@ def uppermost_lines(self) -> list[Line]:
 
     @property
     def nodes(self) -> list[Node]:
-        nodes = set()
+        nodes: set[Node] = set()
         for line in self.lines:
+            # Collect unique Node instances from each line
             nodes.add(line.upper_node)
             nodes.add(line.lower_node)
         return list(nodes)
@@ -207,7 +207,7 @@ def recursive_count_floors(node: Node) -> int:
 
         return {n: recursive_count_floors(n) for n in self.lower_attachment_points}
 
-    def get_lines_by_floor(self, target_floor: int=0, node: Node=None, en_style: bool=True) -> list[Line]:
+    def get_lines_by_floor(self, target_floor: int=0, node: Node | None=None, en_style: bool=True) -> list[Line]:
         """
         starting from node: walk up "target_floor" floors and return all the lines.
 
@@ -229,8 +229,8 @@ def recursive_level(node: Node, current_level: int) -> list[Line]:
 
         return recursive_level(node, 0)
 
-    def get_floor_strength(self, node: Node=None) -> list[float]:
-        strength_list = []
+    def get_floor_strength(self, node: Node | None=None) -> list[float]:
+        strength_list: list[float] = []
         node =  node or self.get_main_attachment_point()
         for i in range(self.floors[node]):
             lines = self.get_lines_by_floor(i, node, en_style=True)
@@ -637,7 +637,7 @@ def sort_lines(self, lines: list[Line] | None=None, x_factor: float=10., by_name
             matches = {line.name: re_name.match(line.name) for line in lines_new}
 
             if all(matches.values()):
-                line_values = {}
+                line_values: dict[str, tuple[float, int, int]] = {}
                 for name, match in matches.items():
                     if match is None:
                         raise ValueError(f"this is unreachable")
@@ -888,15 +888,15 @@ def get_checklength(line: Line, upper_lines: Any) -> list[tuple[str, float]]:
             if not len(upper_lines):
                 return [(line.upper_node.name, line_length)]
             else:
-                lengths = []
+                lengths: list[tuple[str, float]] = []
                 for upper in upper_lines:
                     lengths += get_checklength(*upper)
 
                 return [
                     (name, length + line_length) for name, length in lengths
                 ]
 
-        checklength_values = []
+        checklength_values: list[tuple[str, float]] = []
         for line, upper_line in self.create_tree():
             checklength_values += get_checklength(line, upper_line)