pyVHDLModelTreesitter 0.5.2__tar.gz → 0.7.0__tar.gz

{pyvhdlmodeltreesitter-0.5.2 → pyvhdlmodeltreesitter-0.7.0}/.gitignore

@@ -1,6 +1,8 @@
 /.coverage*
 /.htmlcov/
 /.junit.xml
+/.opencode/node_modules/
+/.opencode/package*.json
 /.token
 /.venv
 /dist/

{pyvhdlmodeltreesitter-0.5.2 → pyvhdlmodeltreesitter-0.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyVHDLModelTreesitter
-Version: 0.5.2
+Version: 0.7.0
 Summary: An implementation of pyVHDLModel using treesitter
 Project-URL: Repository, https://gitlab.com/dawalters/pyVHDLModelTreesitter
 Author: Dominic Adam Walters
@@ -21,21 +21,21 @@ Requires-Dist: rich>=11.0.0
 Requires-Dist: tree-sitter-vhdl>=1.2.5
 Requires-Dist: tree-sitter>=0.23.0
 Provides-Extra: dev
-Requires-Dist: coverage==7.14.0; extra == 'dev'
-Requires-Dist: cryptography==48.0.0; extra == 'dev'
-Requires-Dist: hatch==1.16.5; extra == 'dev'
-Requires-Dist: idna==3.16; extra == 'dev'
+Requires-Dist: coverage==7.15.0; extra == 'dev'
+Requires-Dist: cryptography==49.0.0; extra == 'dev'
+Requires-Dist: hatch==1.17.0; extra == 'dev'
+Requires-Dist: idna==3.18; extra == 'dev'
 Requires-Dist: jaraco-context==6.1.2; extra == 'dev'
 Requires-Dist: mypy==2.1.0; extra == 'dev'
 Requires-Dist: pre-commit==4.6.0; extra == 'dev'
 Requires-Dist: pytest-cov==7.1.0; extra == 'dev'
-Requires-Dist: pytest-order==1.4.0; extra == 'dev'
+Requires-Dist: pytest-order==1.5.0; extra == 'dev'
 Requires-Dist: pytest-sugar==1.1.1; extra == 'dev'
 Requires-Dist: pytest-xdist==3.8.0; extra == 'dev'
-Requires-Dist: pytest==9.0.3; extra == 'dev'
-Requires-Dist: ruff==0.15.14; extra == 'dev'
-Requires-Dist: ty==0.0.39; extra == 'dev'
-Requires-Dist: uv==0.11.16; extra == 'dev'
+Requires-Dist: pytest==9.1.1; extra == 'dev'
+Requires-Dist: ruff==0.15.20; extra == 'dev'
+Requires-Dist: ty==0.0.56; extra == 'dev'
+Requires-Dist: uv==0.11.26; extra == 'dev'
 Description-Content-Type: text/markdown
 
 # pyVHDLModelTreesitter

{pyvhdlmodeltreesitter-0.5.2 → pyvhdlmodeltreesitter-0.7.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "pyVHDLModelTreesitter"
-version = "0.5.2"
+version = "0.7.0"
 description = "An implementation of pyVHDLModel using treesitter"
 readme = "README.md"
 requires-python = ">=3.11"
@@ -32,23 +32,26 @@ classifiers = [
 
 [project.optional-dependencies]
 dev = [
-    "coverage == 7.14.0",
-    "hatch == 1.16.5",
-        "cryptography == 48.0.0",  # forced to avoid CVE
-        "idna == 3.16",  # forced to avoid CVE
+    "coverage == 7.15.0",
+    "hatch == 1.17.0",
+        "cryptography == 49.0.0",  # forced to avoid CVE
+        "idna == 3.18",  # forced to avoid CVE
         "jaraco-context == 6.1.2",  # forced to avoid CVE
     "mypy == 2.1.0",
     "pre-commit == 4.6.0",
-    "pytest == 9.0.3",
+    "pytest == 9.1.1",
     "pytest-cov == 7.1.0",
-    "pytest-order == 1.4.0",
+    "pytest-order == 1.5.0",
     "pytest-sugar == 1.1.1",
     "pytest-xdist == 3.8.0",
-    "ruff == 0.15.14",
-    "ty == 0.0.39",
-    "uv == 0.11.16",
+    "ruff == 0.15.20",
+    "ty == 0.0.56",
+    "uv == 0.11.26",
 ]
 
+[project.scripts]
+dump-treesitter-parse = "pyVHDLModelTreesitter.cli._dump_treesitter_parse:main"
+
 [project.urls]
 Repository = "https://gitlab.com/dawalters/pyVHDLModelTreesitter"
 
@@ -102,6 +105,7 @@ testpaths = [
 
 [tool.ruff]
 unsafe-fixes = true
+exclude = ["tests/examples/oss/open-logic"]
 
 [tool.ruff.lint]
 fixable = ["ALL"]
@@ -137,3 +141,7 @@ required-imports = ["from __future__ import annotations"]
 [tool.ruff.lint.per-file-ignores]
 "tests/**/*.py" = ["S101"]
 "tests/examples/local/**/*.py" = ["D100", "D103", "INP001", "TID252"]
+
+[tool.ty.rules]
+all = "error"
+missing-override-decorator = "ignore"  # this is emitted for every dunder override

{pyvhdlmodeltreesitter-0.5.2 → pyvhdlmodeltreesitter-0.7.0}/src/pyVHDLModelTreesitter/Association.py

@@ -22,8 +22,7 @@ from pyVHDLModel.Association import (
     PortAssociationItem as pyVHDLModel_PortAssociationItem,
 )
 
-from pyVHDLModelTreesitter._parse import parse_conditional_expression
-from pyVHDLModelTreesitter.Name import selected_or_simple_name
+from pyVHDLModelTreesitter.Name import parse_name
 from pyVHDLModelTreesitter.Symbol import SimpleObjectOrFunctionCallSymbol
 from pyVHDLModelTreesitter.treesitter import (
     TreesitterNodeMixin,
@@ -48,9 +47,12 @@ class AssociationItemMixin(TreesitterNodeMixin, pyVHDLModel_AssociationItem):
         formal = None
         if formal_node is not None:
             formal = SimpleObjectOrFunctionCallSymbol(
-                selected_or_simple_name(get_node_text(formal_node)),
+                parse_name(get_node_text(formal_node)),
             )
         actual_node = get_node(node, captures, "actual")
+        # ruff: ignore[import-outside-top-level]
+        from pyVHDLModelTreesitter._parse import parse_conditional_expression
+
         actual = parse_conditional_expression(actual_node)
         if actual is None:
             return []
@@ -78,20 +80,20 @@ class AssociationItemMixin(TreesitterNodeMixin, pyVHDLModel_AssociationItem):
         )
 
 
-class AssociationItem(AssociationItemMixin):  # noqa: D101
+class AssociationItem(AssociationItemMixin):  # ruff: ignore[undocumented-public-class]
     pass
 
 
-class GenericAssociationItem(AssociationItemMixin, pyVHDLModel_GenericAssociationItem):  # noqa: D101
+class GenericAssociationItem(AssociationItemMixin, pyVHDLModel_GenericAssociationItem):  # ruff: ignore[undocumented-public-class]
     pass
 
 
-class ParameterAssociationItem(  # noqa: D101
+class ParameterAssociationItem(  # ruff: ignore[undocumented-public-class]
     AssociationItemMixin,
     pyVHDLModel_ParameterAssociationItem,
 ):
     pass
 
 
-class PortAssociationItem(AssociationItemMixin, pyVHDLModel_PortAssociationItem):  # noqa: D101
+class PortAssociationItem(AssociationItemMixin, pyVHDLModel_PortAssociationItem):  # ruff: ignore[undocumented-public-class]
     pass

{pyvhdlmodeltreesitter-0.5.2 → pyvhdlmodeltreesitter-0.7.0}/src/pyVHDLModelTreesitter/Base.py

@@ -4,11 +4,13 @@ from __future__ import annotations
 
 __all__ = [
     "Range",
+    "WaveformElement",
 ]
 
 from typing import TYPE_CHECKING, Self
 
 import pyVHDLModel
+from pyVHDLModel.Base import WaveformElement as VHDLModel_WaveformElement
 
 if TYPE_CHECKING:
     from tree_sitter import Node
@@ -67,9 +69,9 @@ def parse_as_mode(string: str) -> pyVHDLModel.Base.Mode | None:
         return None
 
 
-class Range(TreesitterNodeMixin, pyVHDLModel.Base.Range):  # noqa: D101
+class Range(TreesitterNodeMixin, pyVHDLModel.Base.Range):  # ruff: ignore[undocumented-public-class]
     @classmethod
-    def from_treesitter_node(  # noqa: C901, PLR0912
+    def from_treesitter_node(  # ruff: ignore[complex-structure, too-many-branches]
         cls,
         node: Node,
     ) -> Self | None:
@@ -92,7 +94,7 @@ class Range(TreesitterNodeMixin, pyVHDLModel.Base.Range):  # noqa: D101
             raise NodeMissingChildError(node, "simple_range")
         if node.text is None or len(node.text) == 0:
             raise NodeTextIsNoneError(node)
-        if len(node.children) != 3:  # noqa: PLR2004
+        if len(node.children) != 3:  # ruff: ignore[magic-value-comparison]
             raise NodeExtraChildError(node, "all children", 3)
         left = node.child(0)
         if left is None:
@@ -133,7 +135,7 @@ class Range(TreesitterNodeMixin, pyVHDLModel.Base.Range):  # noqa: D101
             )
         return cls(left_expr, right_expr, direction, _treesitter_node=node)
 
-    def __eq__(self, other: object) -> bool:  # noqa: D105
+    def __eq__(self, other: object) -> bool:  # ruff: ignore[undocumented-magic-method]
         if not isinstance(other, self.__class__):
             return False
         return (
@@ -142,7 +144,7 @@ class Range(TreesitterNodeMixin, pyVHDLModel.Base.Range):  # noqa: D101
             and self._direction == other._direction
         )
 
-    def __hash__(self) -> int:  # noqa: D105
+    def __hash__(self) -> int:  # ruff: ignore[undocumented-magic-method]
         return hash(
             (
                 self._leftBound,
@@ -151,7 +153,7 @@ class Range(TreesitterNodeMixin, pyVHDLModel.Base.Range):  # noqa: D101
             ),
         )
 
-    def __repr__(self) -> str:  # noqa: D105
+    def __repr__(self) -> str:  # ruff: ignore[undocumented-magic-method]
         return (
             f"{self.__class__.__name__}("
             f"_leftBound={self._leftBound!r}, "
@@ -159,3 +161,45 @@ class Range(TreesitterNodeMixin, pyVHDLModel.Base.Range):  # noqa: D101
             f"_direction={self._direction!r}, "
             ")"
         )
+
+
+class WaveformElement(TreesitterNodeMixin, VHDLModel_WaveformElement):  # ruff: ignore[undocumented-public-class]
+    @classmethod
+    def from_treesitter_node(
+        cls,
+        node: Node,
+    ) -> Self | None:
+        """Create a WaveformElement from a treesitter node."""
+        if node.type != "waveform_element":
+            return None
+        simple_expression_node = None
+        for child in node.children:
+            if child.type == "simple_expression":
+                simple_expression_node = child
+                break
+        if simple_expression_node is None:
+            NotImplementedWarning.warn(
+                "waveform_element expects a 'simple_expression' child",
+                node,
+            )
+            return None
+        expression = parse_simple_expression(simple_expression_node)
+        if expression is None:
+            return None
+        return cls(expression, _treesitter_node=node)
+
+    def __eq__(self, other: object) -> bool:  # ruff: ignore[undocumented-magic-method]
+        if not isinstance(other, self.__class__):
+            return False
+        return self._expression == other._expression and self._after == other._after  # type: ignore[no-any-return]
+
+    def __hash__(self) -> int:  # ruff: ignore[undocumented-magic-method]
+        return hash((self._expression, self._after))
+
+    def __repr__(self) -> str:  # ruff: ignore[undocumented-magic-method]
+        return (
+            f"{self.__class__.__name__}("
+            f"_expression={self._expression!r}, "
+            f"_after={self._after!r}, "
+            ")"
+        )

pyvhdlmodeltreesitter-0.7.0/src/pyVHDLModelTreesitter/Concurrent.py

@@ -0,0 +1,243 @@
+"""Submodule mirroring modified aspects of pyVHDLModel.Concurrent."""
+
+from __future__ import annotations
+
+__all__ = [
+    "ComponentInstantiation",
+    "ConcurrentSimpleSignalAssignment",
+    "EntityInstantiation",
+]
+
+from typing import TYPE_CHECKING, Any, Self
+
+from pyVHDLModel.Concurrent import (
+    ComponentInstantiation as pyVHDLModel_ComponentInstantiation,
+)
+from pyVHDLModel.Concurrent import (
+    ConcurrentSimpleSignalAssignment as pyVHDLModel_ConcurrentSimpleSignalAssignment,
+)
+from pyVHDLModel.Concurrent import (
+    EntityInstantiation as pyVHDLModel_EntityInstantiation,
+)
+
+from pyVHDLModelTreesitter.Association import (
+    GenericAssociationItem,
+    PortAssociationItem,
+)
+from pyVHDLModelTreesitter.Base import WaveformElement
+from pyVHDLModelTreesitter.Name import parse_name
+from pyVHDLModelTreesitter.Symbol import (
+    ArchitectureSymbol,
+    ComponentInstantiationSymbol,
+    EntityInstantiationSymbol,
+)
+from pyVHDLModelTreesitter.treesitter import (
+    TreesitterNodeMixin,
+    get_node,
+    get_node_text,
+    get_nodes,
+)
+from pyVHDLModelTreesitter.treesitter.query import (
+    ComponentInstantiationStatement,
+)
+from pyVHDLModelTreesitter.treesitter.query import (
+    ConcurrentSimpleSignalAssignment as ConcurrentSimpleSignalAssignmentQuery,
+)
+
+if TYPE_CHECKING:
+    import tree_sitter
+
+
+def _parse_instantiation_common(
+    node: tree_sitter.Node,
+    captures: dict[str, list[tree_sitter.Node]],
+) -> tuple[str, list[Any], list[Any]]:
+    label_node = get_node(node, captures, "label")
+    label = get_node_text(label_node)
+    generic_associations = []
+    for association_node in get_nodes(node, captures, "generics", optional=True):
+        generic_associations.extend(
+            GenericAssociationItem.from_treesitter_node(association_node),
+        )
+    port_associations = []
+    for association_node in get_nodes(node, captures, "ports", optional=True):
+        port_associations.extend(
+            PortAssociationItem.from_treesitter_node(association_node),
+        )
+    return label, generic_associations, port_associations
+
+
+class ComponentInstantiation(TreesitterNodeMixin, pyVHDLModel_ComponentInstantiation):  # ruff: ignore[undocumented-public-class]
+    @classmethod
+    def from_treesitter_node(
+        cls,
+        node: tree_sitter.Node,
+    ) -> list[Self]:
+        """Create one or more `ComponentInstantiation`s from a treesitter node."""
+        captures = ComponentInstantiationStatement.capture(node)
+        label, generic_associations, port_associations = _parse_instantiation_common(
+            node,
+            captures,
+        )
+        name_node = get_node(node, captures, "component_name")
+        component_symbol = ComponentInstantiationSymbol(
+            parse_name(get_node_text(name_node)),
+        )
+        return [
+            cls(
+                label=label,
+                componentSymbol=component_symbol,
+                genericAssociations=generic_associations,
+                portAssociations=port_associations,
+                _treesitter_node=node,
+            ),
+        ]
+
+    def __eq__(self, other: object) -> bool:  # ruff: ignore[undocumented-magic-method]
+        if not isinstance(other, self.__class__):
+            return False
+        return (
+            self._label == other._label
+            and self._component == other._component
+            and self._genericAssociations == other._genericAssociations
+            and self._portAssociations == other._portAssociations
+        )
+
+    def __hash__(self) -> int:  # ruff: ignore[undocumented-magic-method]
+        return hash(
+            (
+                self._label,
+                self._component,
+                self._genericAssociations,
+                self._portAssociations,
+            ),
+        )
+
+    def __repr__(self) -> str:  # ruff: ignore[undocumented-magic-method]
+        return (
+            f"{self.__class__.__name__}("
+            f"_label={self._label!r}, "
+            f"_component={self._component!r}, "
+            f"_genericAssociations={self._genericAssociations!r}, "
+            f"_portAssociations={self._portAssociations!r}, "
+            ")"
+        )
+
+
+class EntityInstantiation(TreesitterNodeMixin, pyVHDLModel_EntityInstantiation):  # ruff: ignore[undocumented-public-class]
+    @classmethod
+    def from_treesitter_node(
+        cls,
+        node: tree_sitter.Node,
+    ) -> list[Self]:
+        """Create one or more `EntityInstantiation`s from a treesitter node."""
+        captures = ComponentInstantiationStatement.capture(node)
+        label, generic_associations, port_associations = _parse_instantiation_common(
+            node,
+            captures,
+        )
+        entity_str = ""
+        namespace_node = get_node(node, captures, "namespace", optional=True)
+        if namespace_node is not None:
+            entity_str = f"{get_node_text(namespace_node)}."
+        entity_node = get_node(node, captures, "entity")
+        entity_str += get_node_text(entity_node)
+        entity_symbol = EntityInstantiationSymbol(
+            parse_name(entity_str),
+        )
+        architecture_node = get_node(node, captures, "architecture", optional=True)
+        architecture_symbol = None
+        if architecture_node is not None:
+            architecture_symbol = ArchitectureSymbol(
+                parse_name(get_node_text(architecture_node)),
+            )
+        return [
+            cls(
+                label=label,
+                entitySymbol=entity_symbol,
+                architectureSymbol=architecture_symbol,
+                genericAssociations=generic_associations,
+                portAssociations=port_associations,
+                _treesitter_node=node,
+            ),
+        ]
+
+    def __eq__(self, other: object) -> bool:  # ruff: ignore[undocumented-magic-method]
+        if not isinstance(other, self.__class__):
+            return False
+        return (
+            self._label == other._label
+            and self._entity == other._entity
+            and self._architecture == other._architecture
+            and self._genericAssociations == other._genericAssociations
+            and self._portAssociations == other._portAssociations
+        )
+
+    def __hash__(self) -> int:  # ruff: ignore[undocumented-magic-method]
+        return hash(
+            (
+                self._label,
+                self._entity,
+                self._architecture,
+                self._genericAssociations,
+                self._portAssociations,
+            ),
+        )
+
+    def __repr__(self) -> str:  # ruff: ignore[undocumented-magic-method]
+        return (
+            f"{self.__class__.__name__}("
+            f"_label={self._label!r}, "
+            f"_entity={self._entity!r}, "
+            f"_architecture={self._architecture!r}, "
+            f"_genericAssociations={self._genericAssociations!r}, "
+            f"_portAssociations={self._portAssociations!r}, "
+            ")"
+        )
+
+
+class ConcurrentSimpleSignalAssignment(  # ruff: ignore[undocumented-public-class]
+    TreesitterNodeMixin,
+    pyVHDLModel_ConcurrentSimpleSignalAssignment,
+):
+    @classmethod
+    def from_treesitter_node(
+        cls,
+        node: tree_sitter.Node,
+    ) -> list[Self]:
+        """Create ConcurrentSimpleSignalAssignments from a treesitter node."""
+        captures = ConcurrentSimpleSignalAssignmentQuery.capture(node)
+        label_node = get_node(node, captures, "label", optional=True)
+        label = get_node_text(label_node) if label_node is not None else ""
+        target_node = get_node(node, captures, "lhs")
+        target = parse_name(get_node_text(target_node))
+        waveform_node = get_node(node, captures, "rhs")
+        waveform = [
+            we
+            for child in waveform_node.children
+            if child.type == "waveform_element"
+            for we in [WaveformElement.from_treesitter_node(child)]
+            if we is not None
+        ]
+        return [cls(label, target, waveform, _treesitter_node=node)]
+
+    def __eq__(self, other: object) -> bool:  # ruff: ignore[undocumented-magic-method]
+        if not isinstance(other, self.__class__):
+            return False
+        return (
+            self._label == other._label
+            and self._target == other._target
+            and self._waveform == other._waveform
+        )
+
+    def __hash__(self) -> int:  # ruff: ignore[undocumented-magic-method]
+        return hash((self._label, self._target, tuple(self._waveform)))
+
+    def __repr__(self) -> str:  # ruff: ignore[undocumented-magic-method]
+        return (
+            f"{self.__class__.__name__}("
+            f"_label={self._label!r}, "
+            f"_target={self._target!r}, "
+            f"_waveform={self._waveform!r}, "
+            ")"
+        )