Rename PinAnnotation to IOAnnotation

Author: robtaylor

chipflow_lib/platforms/utils.py

@@ -30,15 +30,15 @@ def _chipflow_schema_uri(name: str, version: int) -> str:
     return f"https://api.chipflow.com/schemas/{version}/{name}"
 
 
-class _PinAnnotationModel(BaseModel):
+class _IOAnnotationModel(BaseModel):
     model_config = ConfigDict(use_enum_values=True)
     direction: io.Direction
     width: int
     options: dict = {}
 
     @classmethod
     def _annotation_schema(cls):
-        schema = _PinAnnotationModel.model_json_schema()
+        schema = _IOAnnotationModel.model_json_schema()
         schema['$schema'] = "https://json-schema.org/draft/2020-12/schema"
         schema['$id'] = _chipflow_schema_uri("pin-annotation", 0)
         return schema
@@ -48,11 +48,11 @@ def __init__(self, **kwargs):
         super().__init__(**kwargs)
 
 
-class _PinAnnotation(meta.Annotation):
-    schema = _PinAnnotationModel._annotation_schema()
+class _IOAnnotation(meta.Annotation):
+    schema = _IOAnnotationModel._annotation_schema()
 
     def __init__(self, **kwargs):
-        self.model = _PinAnnotationModel(**kwargs)
+        self.model = _IOAnnotationModel(**kwargs)
 
     @property
     def origin(self):  # type: ignore
@@ -124,7 +124,7 @@ def options(self) -> dict:
 
     def annotations(self, *args):
         annotations = wiring.Signature.annotations(self, *args)
-        pin_annotation = _PinAnnotation(direction=self._direction, width=self._width, options=self._options)
+        pin_annotation = _IOAnnotation(direction=self._direction, width=self._width, options=self._options)
         return annotations + (pin_annotation,)
 
     def __repr__(self):

tests/test_utils.py

@@ -7,7 +7,7 @@
 
 from amaranth.lib import io
 
-from chipflow_lib.platforms.utils import IOSignature, OutputIOSignature, InputIOSignature, BidirIOSignature, _PinAnnotation, _PinAnnotationModel
+from chipflow_lib.platforms.utils import IOSignature, OutputIOSignature, InputIOSignature, BidirIOSignature, _IOAnnotation, _IOAnnotationModel
 from chipflow_lib.platforms.utils import PinList, _group_consecutive_items,_find_contiguous_sequence, _Side
 
 
@@ -86,18 +86,18 @@ def test_pin_signature():
     assert "i" in sig_bidir_fn.members
 
 def test_pin_annotation_model():
-    model = _PinAnnotationModel(direction=io.Direction.Output, width=32)
+    model = _IOAnnotationModel(direction=io.Direction.Output, width=32)
     assert model.direction == "o"
     assert model.width == 32
 
 def test_pin_annotation():
-    annotation = _PinAnnotation(direction=io.Direction.Input, width=16)
-    assert isinstance(annotation, _PinAnnotation)
+    annotation = _IOAnnotation(direction=io.Direction.Input, width=16)
+    assert isinstance(annotation, _IOAnnotation)
     assert annotation.model.direction == "i"
     assert annotation.model.width == 16
 
 def test_pin_annotation_as_json():
-    annotation = _PinAnnotation(direction=io.Direction.Bidir, width=8)
+    annotation = _IOAnnotation(direction=io.Direction.Bidir, width=8)
     json_output = annotation.as_json()
     print(f"json_output: {json_output}") # Debug print using print()
     assert isinstance(json_output, dict)

tests/test_utils_additional.py

@@ -9,8 +9,8 @@
 from chipflow_lib import ChipFlowError
 from chipflow_lib.platforms.utils import (
     _chipflow_schema_uri,
-    _PinAnnotationModel,
-    _PinAnnotation,
+    _IOAnnotationModel,
+    _IOAnnotation,
     PIN_ANNOTATION_SCHEMA,
     IOSignature,
     _Side,
@@ -36,24 +36,24 @@ def test_side_str(self):
             self.assertEqual(str(side), side.name)
 
     def test_pin_annotation_model(self):
-        """Test _PinAnnotationModel class"""
+        """Test _IOAnnotationModel class"""
         # Test initialization
-        model = _PinAnnotationModel(direction=io.Direction.Output, width=32, options={"opt1": "val1"})
+        model = _IOAnnotationModel(direction=io.Direction.Output, width=32, options={"opt1": "val1"})
 
         # Check properties
         self.assertEqual(model.direction, "o")
         self.assertEqual(model.width, 32)
         self.assertEqual(model.options, {"opt1": "val1"})
 
         # Test _annotation_schema class method
-        schema = _PinAnnotationModel._annotation_schema()
+        schema = _IOAnnotationModel._annotation_schema()
         self.assertEqual(schema["$schema"], "https://json-schema.org/draft/2020-12/schema")
         self.assertEqual(schema["$id"], PIN_ANNOTATION_SCHEMA)
 
     def test_pin_annotation(self):
-        """Test _PinAnnotation class"""
+        """Test _IOAnnotation class"""
         # Test initialization
-        annotation = _PinAnnotation(direction=io.Direction.Input, width=16)
+        annotation = _IOAnnotation(direction=io.Direction.Input, width=16)
 
         # Check model
         self.assertEqual(annotation.model.direction, "i")
@@ -103,26 +103,26 @@ def test_pin_signature_annotations(self):
         self.assertIsInstance(annotations, tuple)
         self.assertGreater(len(annotations), 0)
 
-        # Find PinAnnotation in annotations
+        # Find IOAnnotation in annotations
         pin_annotation = None
         for annotation in annotations:
-            if isinstance(annotation, _PinAnnotation):
+            if isinstance(annotation, _IOAnnotation):
                 pin_annotation = annotation
                 break
 
-        # Verify the PinAnnotation was found and has correct values
-        self.assertIsNotNone(pin_annotation, "PinAnnotation not found in annotations")
+        # Verify the IOAnnotation was found and has correct values
+        self.assertIsNotNone(pin_annotation, "IOAnnotation not found in annotations")
         self.assertEqual(pin_annotation.model.direction, "o")
         self.assertEqual(pin_annotation.model.width, 8)
         self.assertEqual(pin_annotation.model.options["init"], 42)
 
         # Call multiple times to ensure we don't get duplicate annotations
         annotations1 = sig.annotations(mock_obj)
         annotations2 = sig.annotations(mock_obj)
-        # Count PinAnnotations in each result
-        count1 = sum(1 for a in annotations1 if isinstance(a, _PinAnnotation))
-        count2 = sum(1 for a in annotations2 if isinstance(a, _PinAnnotation))
-        # Should have exactly one PinAnnotation in each result
+        # Count IOAnnotations in each result
+        count1 = sum(1 for a in annotations1 if isinstance(a, _IOAnnotation))
+        count2 = sum(1 for a in annotations2 if isinstance(a, _IOAnnotation))
+        # Should have exactly one IOAnnotation in each result
         self.assertEqual(count1, 1)
         self.assertEqual(count2, 1)