Refactor type hints and improve documentation in machine controller

Signed-off-by: Michael Brunner <brunner@cadwork.swiss>

Author: Brunner246

src/bim_controller/__init__.pyi

@@ -42,12 +42,12 @@ def get_ifc2x3_element_type(element_id: int) -> ifc_2x3_element_type:
     """
 
 
-def set_ifc2x3_element_type(element_i_ds: List[int], element_type: element_type) -> None:
+def set_ifc2x3_element_type(element_i_ds: List[int], ifc_type: ifc_2x3_element_type) -> None:
     """set ifc2x3 element type
 
     Parameters:
         element_i_ds: element_i_ds
-        element_type: element_type
+        ifc_type: element_type
 
     Returns:
         None

src/cadwork/point_3d.pyi

@@ -8,61 +8,146 @@ class point_3d:
             y (float): The y-coordinate of the point.
             z (float): The z-coordinate of the point.
         """
-        self.x = x
-        self.y = y
-        self.z = z
 
-    def dot(self, p: 'point_3d') -> float:
-        """dot
+    def __add__(self, other: 'point_3d') -> 'point_3d':
+        """
+        Add two points component-wise.
 
-        Parameters:
-            p: p
+        Returns:
+            point_3d: The sum of two points.
+        """
+
+    def __sub__(self, other: 'point_3d') -> 'point_3d':
+        """
+        Subtract two points component-wise.
 
         Returns:
-            float
+            point_3d: The difference of two points.
         """
 
-    def cross(self, p: 'point_3d') -> 'point_3d':
-        """cross
+    def __mul__(self, other: float) -> 'point_3d':
+        """
+        Multiply point by a scalar.
 
-        Parameters:
-            p: p
+        Returns:
+            point_3d: The scaled point.
+        """
+
+    def __rmul__(self, other: float) -> 'point_3d':
+        """
+        Multiply point by a scalar (right-hand side).
 
         Returns:
-            'point_3d'
+            point_3d: The scaled point.
         """
 
-    def magnitude(self) -> float:
-        """magnitude
+    def __truediv__(self, other: float) -> 'point_3d':
+        """
+        Divide point by a scalar.
 
         Returns:
-            float
+            point_3d: The scaled point.
         """
 
-    def normalized(self) -> 'point_3d':
-        """normalized
+    def __iadd__(self, other: 'point_3d') -> 'point_3d':
+        """
+        In-place addition of another point.
 
         Returns:
-            'point_3d'
+            point_3d: The updated point.
         """
 
-    def distance(self, p: 'point_3d') -> float:
-        """distance
+    def __isub__(self, other: 'point_3d') -> 'point_3d':
+        """
+        In-place subtraction of another point.
 
-        Parameters:
-            p: p
+        Returns:
+            point_3d: The updated point.
+        """
+
+    def __imul__(self, other: float) -> 'point_3d':
+        """
+        In-place multiplication by a scalar.
 
         Returns:
-            float
+            point_3d: The updated point.
         """
 
-    def invert(self) -> 'point_3d':
-        """invert
+    def __itruediv__(self, other: float) -> 'point_3d':
+        """
+        In-place division by a scalar.
 
         Returns:
-            'point_3d'
+            point_3d: The updated point.
+        """
+
+    def __neg__(self) -> 'point_3d':
         """
+        Negate the point (component-wise).
 
+        Returns:
+            point_3d: The negated point.
+        """
+
+    def __eq__(self, other: object) -> bool:
+        """
+        Check if two points are equal.
+
+        Returns:
+            bool: True if equal, False otherwise.
+        """
+
+    def __ne__(self, other: object) -> bool:
+        """
+        Check if two points are not equal.
+
+        Returns:
+            bool: True if not equal, False otherwise.
+        """
+
+    def __getitem__(self, index: int) -> float:
+        """
+        Get coordinate by index (0: x, 1: y, 2: z).
+
+        Returns:
+            float: The coordinate value.
+        Raises:
+            IndexError: If index is out of range.
+        """
+
+    def __setitem__(self, index: int, value: float) -> None:
+        """
+        Set coordinate by index (0: x, 1: y, 2: z).
+
+        Raises:
+            IndexError: If index is out of range.
+        """
+
+    def __repr__(self) -> str:
+        """
+        Return the string representation of the point.
+
+        Returns:
+            str: The string representation.
+        """
+
+    def dot(self, p: 'point_3d') -> float:
+        """Dot product with another point."""
+
+    def cross(self, p: 'point_3d') -> 'point_3d':
+        """Cross product with another point."""
+
+    def magnitude(self) -> float:
+        """Return the magnitude of the point vector."""
+
+    def normalized(self) -> 'point_3d':
+        """Return the normalized (unit) vector."""
+
+    def distance(self, p: 'point_3d') -> float:
+        """Euclidean distance to another point."""
+
+    def invert(self) -> 'point_3d':
+        """Return the inverted point (negated coordinates)."""
     def __sub__(self, other: 'point_3d') -> 'point_3d':
         """sub
 

src/element_controller/__init__.pyi

@@ -2131,7 +2131,7 @@ def map_elements(elements: List[int], map_query: element_map_query) -> Dict[str,
         elements: elements
         map_query: map_query
 
-    Example:
+    Examples:
         >>> import cadwork
         >>> import element_controller as ec
         >>> your_map_query = cadwork.element_map_query()
@@ -2153,9 +2153,9 @@ def cast_ray_and_get_element_intersections(elements: List[int], ray_start_positi
         ray_end_position: ray_end_position
         radius: radius
 
-    Example:
-        >>> from cadwork import point_3d
+    Examples:
         >>> import element_controller as ec
+        >>> from cadwork import point_3d
         >>> ray_start = point_3d(0, 0, 0)
         >>> ray_end = point_3d(1000, 0, 0)
         >>> hit_result = ec.cast_ray_and_get_element_intersections(ec.get_active_identifiable_element_ids(), ray_start, ray_end, 40.0)

src/machine_controller/__init__.pyi

@@ -1,4 +1,6 @@
 from typing import List
+from cadwork import vertex_list
+
 
 def get_last_error(error_code: int) -> str:
     """Gets the last error
@@ -41,13 +43,6 @@ def export_hundegger(hundeggertype: int) -> None:
         None
     """
 
-def clear_errors() -> None:
-    """clear errors
-
-    Returns:
-        None
-    """
-
 def export_hundegger_with_file_path(hundeggertype: int, file_path: str) -> None:
     """Exports a Hundegger file
 
@@ -139,3 +134,114 @@ def export_hundegger_with_file_path_and_presetting_silent(hundeggertype: int, fi
         None
     """
 
+
+def get_element_hundegger_processings(element_id: int, hundeggertype: int) -> List[int]:
+    """Get Hundegger processing IDs for an element.
+
+    Parameters:
+        element_id: The element ID.
+        hundeggertype: The Hundegger type.
+
+    Returns:
+        List of processing IDs.
+    """
+
+
+def get_element_btl_processings(element_id: int, btl_version: int) -> List[int]:
+    """Get BTL processing IDs for an element.
+
+    Parameters:
+        element_id: The element ID.
+        btl_version: The BTL version.
+
+    Returns:
+        List of processing IDs.
+    """
+
+
+def get_processing_name(reference_element_id: int, processing_id: int) -> str:
+    """Get the name of a processing.
+
+    Parameters:
+        reference_element_id: The reference element ID.
+        processing_id: The processing ID.
+
+    Examples:
+        >>> import cadwork
+        >>> import element_controller as ec
+        >>> import machine_controller as mc
+
+        >>> element: int = 123456789
+        >>> processings = mc.get_element_btl_processings(element, cadwork.btl_version.btlx_2_1.value)
+        >>> for processing in processings:
+        >>>     name = mc.get_processing_name(element, processing)
+
+    Returns:
+        The processing name.
+    """
+
+
+def get_processing_code(reference_element_id: int, processing_id: int) -> str:
+    """Get the code of a processing.
+
+    Parameters:
+        reference_element_id: The reference element ID.
+        processing_id: The processing ID.
+
+    Examples:
+        >>> import cadwork
+        >>> import element_controller as ec
+        >>> import machine_controller as mc
+
+        >>> element: int = 123456789
+        >>> processings = mc.get_element_btl_processings(element, cadwork.btl_version.btlx_2_1.value)
+        >>> for processing in processings:
+        >>>     code = mc.get_processing_code(element, processing)
+
+    Returns:
+        The processing code.
+    """
+
+
+def get_processing_points(reference_element_id: int, processing_id: int) -> vertex_list:
+    """Get the points of a processing.
+
+    Parameters:
+        reference_element_id: The reference element ID.
+        processing_id: The processing ID.
+
+    Examples:
+        >>> import cadwork
+        >>> import element_controller as ec
+        >>> import machine_controller as mc
+
+        >>> element: int = 123456789
+        >>> processings = mc.get_element_btl_processings(element, cadwork.btl_version.btlx_2_1.value)
+        >>> for processing in processings:
+        >>>     points = mc.get_processing_points(element, processing)
+
+    Returns:
+        A vertex_list of points.
+    """
+
+
+def get_processing_btl_parameter_set(reference_element_id: int, processing_id: int) -> List[str]:
+    """Get the BTL parameter set for a processing.
+
+    Parameters:
+        reference_element_id: The reference element ID.
+        processing_id: The processing ID.
+
+    Examples:
+        >>> import cadwork
+        >>> import element_controller as ec
+        >>> import machine_controller as mc
+
+        >>> element: int = 123456789
+        >>> processings = mc.get_element_btl_processings(element, cadwork.btl_version.btlx_2_1.value)
+        >>> for processing in processings:
+        >>>     parameters = mc.get_processing_btl_parameter_set(element, processing)
+
+    Returns:
+        List of BTL parameter strings.
+    """