Format code with ruff

Author: rnestler

cadquery_helpers.py

@@ -21,15 +21,17 @@ class StepAssembly:
     """
     A STEP assembly.
     """
+
     def __init__(self, name: str):
         self.assembly = cq.Assembly(name=name)
 
         # Less verbose output
         for printer in Message.DefaultMessenger_s().Printers():
             printer.SetTraceLevel(Message_Gravity.Message_Fail)
 
-    def add_body(self, body: cq.Workplane, name: str, color: cq.Color,
-                 location: Optional[cq.Location] = None) -> None:
+    def add_body(
+        self, body: cq.Workplane, name: str, color: cq.Color, location: Optional[cq.Location] = None
+    ) -> None:
         """
         Add a body to the assembly.
 

common.py

@@ -1,6 +1,7 @@
 """
 Common functionality for generator scripts.
 """
+
 import collections
 import csv
 import re
@@ -18,7 +19,7 @@
     ('\r', '\\r'),
     ('\t', '\\t'),
     ('\v', '\\v'),
-    ('"',  '\\"'),
+    ('"', '\\"'),
 )
 
 
@@ -113,10 +114,7 @@ def get_pad_uuids(base_lib_path: str, pkg_uuid: str) -> Dict[str, str]:
     """
     with open(path.join(base_lib_path, 'pkg', pkg_uuid, 'package.lp'), 'r') as f:
         lines = f.readlines()
-    opt_matches = [
-        re.match(r' \(pad ([^\s]*) \(name "([^"]*)"\)\)$', line)
-        for line in lines
-    ]
+    opt_matches = [re.match(r' \(pad ([^\s]*) \(name "([^"]*)"\)\)$', line) for line in lines]
     matches = list(filter(None, opt_matches))
     mapping = {}
     for match in matches:
@@ -132,13 +130,16 @@ def human_sort_key(key: str) -> List[Any]:
     Function that can be used for natural sorting, where "PB2" comes before
     "PB10" and after "PA3".
     """
+
     def _convert(text: str) -> Union[int, str]:
         return int(text) if text.isdigit() else text
 
     return [_convert(x) for x in re.split(r'(\d+)', key) if x]
 
 
-def serialize_common(serializable: Any, output_directory: str, uuid: str, long_type: str, short_type: str) -> None:
+def serialize_common(
+    serializable: Any, output_directory: str, uuid: str, long_type: str, short_type: str
+) -> None:
     """
     Centralized serialize() implementation shared between Component, Symbol, Device, Package
     """

dfn_configs.py

@@ -9,7 +9,7 @@ def get_name(self) -> str:
 
 
 class UnitlessUnit(AttributeUnit):
-    NONE = "none"
+    NONE = 'none'
 
 
 class AttributeType(EnumValue):
@@ -26,16 +26,24 @@ def get_name(self) -> str:
         return 'type'
 
 
-class Attribute():
-    def __init__(self, name: str, value: Union[Value, str], attribute_type: AttributeType, unit: Optional[AttributeUnit]) -> None:
+class Attribute:
+    def __init__(
+        self,
+        name: str,
+        value: Union[Value, str],
+        attribute_type: AttributeType,
+        unit: Optional[AttributeUnit],
+    ) -> None:
         self.name = name
 
         self.value = Value(value) if isinstance(value, str) else value
         self.unit = unit or UnitlessUnit.NONE
         self.attribute_type = attribute_type
 
     def __str__(self) -> str:
-        return '(attribute "{}" {} {} {})'.format(self.name, self.attribute_type, self.unit, self.value)
+        return '(attribute "{}" {} {} {})'.format(
+            self.name, self.attribute_type, self.unit, self.value
+        )
 
 
 class CapacitanceUnit(AttributeUnit):

entities/attribute.py

@@ -13,15 +13,17 @@
 
 class EnumValue(Enum):
     """Helper class to represent enumeration like values"""
+
     def get_name(self) -> str:
         raise NotImplementedError('Override get_name in subclass')
 
     def __str__(self) -> str:
         return '({} {})'.format(self.get_name(), self.value)
 
 
-class DateValue():
+class DateValue:
     """Helper class to represent a single named date value"""
+
     def __init__(self, name: str, date: str):
         self.name = name
         self.date = date
@@ -30,8 +32,9 @@ def __str__(self) -> str:
         return '({} {})'.format(self.name, self.date)
 
 
-class UUIDValue():
+class UUIDValue:
     """Helper class to represent a single named UUID value"""
+
     def __init__(self, name: str, uuid: str):
         self.name = name
         self.uuid = uuid
@@ -40,8 +43,9 @@ def __str__(self) -> str:
         return '({} {})'.format(self.name, self.uuid)
 
 
-class BoolValue():
+class BoolValue:
     """Helper class to represent a single named boolean value"""
+
     def __init__(self, name: str, value: bool):
         self.name = name
         self.value = str(value).lower()
@@ -50,8 +54,9 @@ def __str__(self) -> str:
         return '({} {})'.format(self.name, self.value)
 
 
-class StringValue():
+class StringValue:
     """Helper class to represent a single named string value"""
+
     def __init__(self, name: str, value: str):
         self.name = name
         self.value = value
@@ -60,8 +65,9 @@ def __str__(self) -> str:
         return '({} "{}")'.format(self.name, escape_string(self.value))
 
 
-class FloatValue():
+class FloatValue:
     """Helper class to represent a single named float value"""
+
     def __init__(self, name: str, value: float):
         self.name = name
         self.value = value
@@ -115,7 +121,7 @@ def __init__(self, category: str):
         super().__init__('category', category)
 
 
-class Position():
+class Position:
     def __init__(self, x: float, y: float):
         self.x = x
         self.y = y
@@ -124,7 +130,7 @@ def __str__(self) -> str:
         return '(position {} {})'.format(format_float(self.x), format_float(self.y))
 
 
-class Position3D():
+class Position3D:
     def __init__(self, x: float, y: float, z: float):
         self.x = x
         self.y = y
@@ -135,15 +141,17 @@ def zero() -> 'Position3D':
         return Position3D(0.0, 0.0, 0.0)
 
     def __str__(self) -> str:
-        return '(3d_position {} {} {})'.format(format_float(self.x), format_float(self.y), format_float(self.z))
+        return '(3d_position {} {} {})'.format(
+            format_float(self.x), format_float(self.y), format_float(self.z)
+        )
 
 
 class Rotation(FloatValue):
     def __init__(self, rotation: float):
         super().__init__('rotation', rotation)
 
 
-class Rotation3D():
+class Rotation3D:
     def __init__(self, x: float, y: float, z: float):
         self.x = x
         self.y = y
@@ -154,7 +162,9 @@ def zero() -> 'Rotation3D':
         return Rotation3D(0.0, 0.0, 0.0)
 
     def __str__(self) -> str:
-        return '(3d_rotation {} {} {})'.format(format_float(self.x), format_float(self.y), format_float(self.z))
+        return '(3d_rotation {} {} {})'.format(
+            format_float(self.x), format_float(self.y), format_float(self.z)
+        )
 
 
 class Length(FloatValue):
@@ -187,7 +197,7 @@ def __init__(self, grab_area: bool):
         super().__init__('grab_area', grab_area)
 
 
-class Vertex():
+class Vertex:
     def __init__(self, position: Position, angle: Angle):
         self.position = position
         self.angle = angle
@@ -196,17 +206,24 @@ def __str__(self) -> str:
         return '(vertex {} {})'.format(self.position, self.angle)
 
 
-class Layer():
+class Layer:
     def __init__(self, layer: str):
         self.layer = layer
 
     def __str__(self) -> str:
         return '(layer {})'.format(self.layer)
 
 
-class Polygon():
-    def __init__(self, uuid: str, layer: Layer, width: Width, fill: Fill,
-                 grab_area: GrabArea, vertices: Optional[List[Vertex]] = None):
+class Polygon:
+    def __init__(
+        self,
+        uuid: str,
+        layer: Layer,
+        width: Width,
+        fill: Fill,
+        grab_area: GrabArea,
+        vertices: Optional[List[Vertex]] = None,
+    ):
         self.uuid = uuid
         self.layer = layer
         self.width = width
@@ -218,8 +235,9 @@ def add_vertex(self, vertex: Vertex) -> None:
         self.vertices.append(vertex)
 
     def __str__(self) -> str:
-        ret = '(polygon {} {}\n'.format(self.uuid, self.layer) +\
-            ' {} {} {}\n'.format(self.width, self.fill, self.grab_area)
+        ret = '(polygon {} {}\n'.format(self.uuid, self.layer) + ' {} {} {}\n'.format(
+            self.width, self.fill, self.grab_area
+        )
         ret += indent_entities(self.vertices)
         ret += ')'
         return ret
@@ -270,9 +288,17 @@ def __init__(self, diameter: float):
         super().__init__('diameter', diameter)
 
 
-class Circle():
-    def __init__(self, uuid: str, layer: Layer, width: Width, fill: Fill,
-                 grab_area: GrabArea, diameter: Diameter, position: Position):
+class Circle:
+    def __init__(
+        self,
+        uuid: str,
+        layer: Layer,
+        width: Width,
+        fill: Fill,
+        grab_area: GrabArea,
+        diameter: Diameter,
+        position: Position,
+    ):
         self.uuid = uuid
         self.layer = layer
         self.width = width
@@ -283,8 +309,9 @@ def __init__(self, uuid: str, layer: Layer, width: Width, fill: Fill,
 
     def __str__(self) -> str:
         ret = '(circle {} {}\n'.format(self.uuid, self.layer)
-        ret += ' {} {} {} {} {}\n'.format(self.width, self.fill, self.grab_area,
-                                          self.diameter, self.position)
+        ret += ' {} {} {} {} {}\n'.format(
+            self.width, self.fill, self.grab_area, self.diameter, self.position
+        )
         ret += ')'
         return ret
 
@@ -294,16 +321,25 @@ def __init__(self, value: str):
         super().__init__('value', value)
 
 
-class Align():
+class Align:
     def __init__(self, align: str):
         self.align = align
 
     def __str__(self) -> str:
         return '(align {})'.format(self.align)
 
 
-class Text():
-    def __init__(self, uuid: str, layer: Layer, value: Value, align: Align, height: Height, position: Position, rotation: Rotation):
+class Text:
+    def __init__(
+        self,
+        uuid: str,
+        layer: Layer,
+        value: Value,
+        align: Align,
+        height: Height,
+        position: Position,
+        rotation: Rotation,
+    ):
         self.uuid = uuid
         self.layer = layer
         self.value = value
@@ -313,18 +349,24 @@ def __init__(self, uuid: str, layer: Layer, value: Value, align: Align, height:
         self.rotation = rotation
 
     def __str__(self) -> str:
-        return '(text {} {} {}\n'.format(self.uuid, self.layer, self.value) +\
-               ' {} {} {} {}\n'.format(self.align, self.height, self.position, self.rotation) +\
-               ')'
+        return (
+            '(text {} {} {}\n'.format(self.uuid, self.layer, self.value)
+            + ' {} {} {} {}\n'.format(self.align, self.height, self.position, self.rotation)
+            + ')'
+        )
 
 
-class Resource():
+class Resource:
     def __init__(self, name: str, mediatype: str, url: str):
         self.name = name
         self.mediatype = mediatype
         self.url = url
 
     def __str__(self) -> str:
-        return '(resource "{}" (mediatype "{}")\n'.format(escape_string(self.name), escape_string(self.mediatype)) +\
-               ' (url "{}")\n'.format(escape_string(self.url)) +\
-               ')'
+        return (
+            '(resource "{}" (mediatype "{}")\n'.format(
+                escape_string(self.name), escape_string(self.mediatype)
+            )
+            + ' (url "{}")\n'.format(escape_string(self.url))
+            + ')'
+        )