pyVHDLModelTreesitter 0.1.0__tar.gz

pyvhdlmodeltreesitter-0.1.0/.gitignore

@@ -0,0 +1,5 @@
+/.coverage*
+/.junit.xml
+/.venv
+/dist/
+__pycache__/

pyvhdlmodeltreesitter-0.1.0/LICENSE

@@ -0,0 +1,13 @@
+Copyright 2025 Dominic Adam Walters
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

pyvhdlmodeltreesitter-0.1.0/PKG-INFO

@@ -0,0 +1,34 @@
+Metadata-Version: 2.4
+Name: pyVHDLModelTreesitter
+Version: 0.1.0
+Summary: An implementation of pyVHDLModel using treesitter
+Project-URL: Repository, https://gitlab.com/dawalters/pyVHDLModelTreesitter
+Author: Dominic Adam Walters
+License-File: LICENSE
+Keywords: language,model,treesitter,vhdl
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.12
+Requires-Dist: pyvhdlmodel==0.33.1
+Requires-Dist: tree-sitter-vhdl==1.5.0
+Requires-Dist: tree-sitter==0.25.2
+Provides-Extra: dev
+Requires-Dist: coverage==7.13.5; extra == 'dev'
+Requires-Dist: hatch==1.16.5; extra == 'dev'
+Requires-Dist: mypy==1.20.1; extra == 'dev'
+Requires-Dist: pre-commit==4.5.1; extra == 'dev'
+Requires-Dist: pytest-cov==7.1.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.10; extra == 'dev'
+Requires-Dist: sphinx==9.1.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# pyVHDLModelTreesitter
+
+`pyVHDLModelTreesitter` is an implementation of the `pyVHDLModel` API using
+`tree-sitter-vhdl`.

pyvhdlmodeltreesitter-0.1.0/README.md

@@ -0,0 +1,4 @@
+# pyVHDLModelTreesitter
+
+`pyVHDLModelTreesitter` is an implementation of the `pyVHDLModel` API using
+`tree-sitter-vhdl`.

pyvhdlmodeltreesitter-0.1.0/pyproject.toml

@@ -0,0 +1,119 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "pyVHDLModelTreesitter"
+version = "0.1.0"
+description = "An implementation of pyVHDLModel using treesitter"
+readme = "README.md"
+requires-python = ">=3.12"
+dependencies = [
+    "pyVHDLModel == 0.33.1",
+    "tree-sitter == 0.25.2",
+    "tree-sitter-vhdl == 1.5.0",  # TODO: try and update this?
+]
+authors = [
+    { name = "Dominic Adam Walters" },
+]
+keywords = ["language", "model", "treesitter", "vhdl"]
+classifiers = [
+  "Development Status :: 3 - Alpha",
+  "License :: OSI Approved :: MIT License",
+  "Programming Language :: Python :: 3 :: Only",
+  "Programming Language :: Python :: 3.12",
+  "Intended Audience :: Developers",
+]
+
+[project.optional-dependencies]
+dev = [
+    "coverage == 7.13.5",
+    "hatch == 1.16.5",
+    "mypy == 1.20.1",
+    "pre-commit == 4.5.1",
+    "pytest == 9.0.3",
+    "pytest-cov == 7.1.0",
+    "pytest-sugar == 1.1.1",
+    "pytest-xdist == 3.8.0",
+    "ruff == 0.15.10",
+    "sphinx == 9.1.0",
+]
+
+[project.urls]
+Repository = "https://gitlab.com/dawalters/pyVHDLModelTreesitter"
+
+[tool.codespell]
+ignore-words-list = "inout"
+
+[tool.coverage.html]
+directory = ".htmlcov"
+
+[tool.coverage.report]
+exclude_also = [
+    "@overload",
+    "if TYPE_CHECKING:",
+]
+
+[tool.coverage.run]
+branch = true
+
+[tool.coverage.xml]
+output = ".coverage.xml"
+
+[tool.hatch.build]
+include = [
+    "src/pyVHDLModelTreesitter/*.py",
+    "src/pyVHDLModelTreesitter/py.typed",
+]
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/pyVHDLModelTreesitter"]
+
+[tool.hatch.envs.hatch-test]
+dependencies = [
+    "coverage == 7.13.5",
+    "pytest == 9.0.3",
+    "pytest-cov == 7.1.0",
+    "pytest-sugar == 1.1.1",
+    "pytest-xdist == 3.8.0",
+]
+
+[[tool.hatch.envs.hatch-test.matrix]]
+python = ["3.12"]
+
+[tool.mypy]
+strict = true
+warn_unreachable = true
+implicit_reexport = true
+
+[tool.pytest.ini_options]
+addopts = "--capture=fd -n 0 --cov=pyVHDLModelTreesitter --cov-report html --cov-report xml --verbose --junitxml=.junit.xml -o junit_family=legacy"
+testpaths = [
+    "tests",
+]
+
+[tool.ruff]
+unsafe-fixes = true
+
+[tool.ruff.lint]
+fixable = ["ALL"]
+ignore = [
+    "CPY001",   # I don't want copyright notices in every file
+    "D203",     # I don't want blank lines before class docstrings
+    "D212",     # I want docstring opening lines to be after the """
+    "DOC201",   # I don't want to mandate documenting return type with typehints
+    "FIX002",   # I want to be able to type TODO
+    "N999",     # I want to use the same structure as pyVHDLModel
+    "TD002",    # I don't want TODOs to need authors
+    "TD003",    # I don't want TODOs to need issue IDs
+]
+preview = true
+select = [
+    "ALL",
+]
+unfixable = [
+    "T201", # Don't fix print statements
+]
+
+[tool.ruff.lint.flake8-self]
+ignore-names = ["_AddEntity"]

pyvhdlmodeltreesitter-0.1.0/src/pyVHDLModelTreesitter/Base.py

@@ -0,0 +1,29 @@
+"""Submodule mirroring modified aspects of pyVHDLModel.Base."""
+
+__all__ = [
+    "parse_as_mode",
+]
+
+import pyVHDLModel
+
+
+def parse_as_mode(string: str) -> pyVHDLModel.Base.Mode | None:
+    """
+    Try and convert incorrect inputs.
+
+    This will accept any mix of the following:
+        - Incorrect capitalisation
+            - "IN"
+            - "iN"
+            - "in"
+        - Split words with whitespace
+            - "in out"
+    """
+    # TODO: make a PR on pyVHDLModel to add this
+    string = "".join(string.split()).lower().capitalize()
+    if string == "Inout":
+        string = "InOut"
+    try:
+        return pyVHDLModel.Base.Mode[string]
+    except IndexError:
+        return None

pyvhdlmodeltreesitter-0.1.0/src/pyVHDLModelTreesitter/DesignUnit.py

@@ -0,0 +1,278 @@
+"""Submodule mirroring modified aspects of pyVHDLModel.DesignUnit."""
+
+__all__ = [
+    "Entity",
+    "LibraryClause",
+    "UseClause",
+]
+
+from collections.abc import Iterable
+from functools import cmp_to_key
+from typing import Self, cast
+
+import pyVHDLModel
+import tree_sitter
+from pyVHDLModel.DesignUnit import LibraryClause as BaseLibraryClause
+from pyVHDLModel.DesignUnit import UseClause as BaseUseClause
+
+from pyVHDLModelTreesitter._error import ExtraNodeError, NodeTextIsNoneError
+from pyVHDLModelTreesitter.Interface import (
+    GenericConstantInterfaceItem,
+    PortSignalInterfaceItem,
+)
+from pyVHDLModelTreesitter.Name import SelectedName, SimpleName
+from pyVHDLModelTreesitter.Symbol import LibraryReferenceSymbol, PackageReferenceSymbol
+from pyVHDLModelTreesitter.treesitter import get_node_or_raise, get_nodes_or_raise
+from pyVHDLModelTreesitter.treesitter.query import (
+    EntityDeclaration,
+    InterfaceDeclarations,
+    LibraryClauses,
+    LibraryNamespaces,
+    SelectedNames,
+    UseClauses,
+)
+
+
+class LibraryClause(BaseLibraryClause):  # noqa: D101
+    @classmethod
+    def from_treesitter_node(
+        cls,
+        node: tree_sitter.Node,
+    ) -> list[Self]:
+        """
+        Create one or more LibraryClauses from a treesitter node.
+
+        Raises
+        ------
+        NodeTextIsNoneError:
+            If the `library_namespace` treesitter node contains no text.
+
+        """
+        captures = LibraryClauses.capture(node)
+        library_clause_nodes = get_nodes_or_raise(
+            node,
+            captures,
+            "library-clause",
+            LibraryClauses.TEXT,
+        )
+        ret = []
+        for library_clause_node in library_clause_nodes:
+            captures = LibraryNamespaces.capture(library_clause_node)
+            library_namespace_nodes = get_nodes_or_raise(
+                node,
+                captures,
+                "library",
+                LibraryNamespaces.TEXT,
+            )
+            symbols = []
+            for library_namespace_node in library_namespace_nodes:
+                if library_namespace_node.text is None:
+                    raise NodeTextIsNoneError(node, LibraryNamespaces.TEXT, "library")
+                library = library_namespace_node.text.decode()
+                symbols.append(LibraryReferenceSymbol(SimpleName(library)))
+            ret.append(cls(symbols))
+        return ret
+
+    def __eq__(self, other: object) -> bool:  # noqa: D105
+        if not isinstance(other, LibraryClause):
+            return False
+        # Required for LSP completions
+        other = cast("LibraryClause", other)  # type: ignore[redundant-cast]
+        return self._symbols == other._symbols
+
+    def __hash__(self) -> int:  # noqa: D105
+        return hash(
+            (self._symbols,),
+        )
+
+    def __repr__(self) -> str:  # noqa: D105
+        return f"{self.__class__.__name__}(_symbols={self._symbols!r}, )"
+
+
+class UseClause(BaseUseClause):  # noqa: D101
+    @classmethod
+    def from_treesitter_node(
+        cls,
+        node: tree_sitter.Node,
+    ) -> list[Self]:
+        """
+        Create one or more UseClauses from a treesitter node.
+
+        Raises
+        ------
+        NodeTextIsNoneError:
+            If the `library_namespace` treesitter node contains no text.
+
+        """
+        captures = UseClauses.capture(node)
+        use_clause_nodes = get_nodes_or_raise(
+            node,
+            captures,
+            "use-clause",
+            UseClauses.TEXT,
+        )
+        ret = []
+        for use_clause_node in use_clause_nodes:
+            captures = SelectedNames.capture(use_clause_node)
+            selected_name_nodes = get_nodes_or_raise(
+                node,
+                captures,
+                "selected-name",
+                SelectedNames.TEXT,
+            )
+            symbols = []
+            for selected_name_node in selected_name_nodes:
+                if selected_name_node.text is None:
+                    raise NodeTextIsNoneError(node, SelectedNames.TEXT, "selected-name")
+                selected_name = selected_name_node.text.decode()
+                selected_name_parts = selected_name.split(".")
+                selected_name_obj: SimpleName | SelectedName = SimpleName(
+                    selected_name_parts[0],
+                )
+                for part in selected_name_parts[1:]:
+                    selected_name_obj = SelectedName(part, selected_name_obj)
+                symbols.append(PackageReferenceSymbol(selected_name_obj))
+            ret.append(cls(symbols))
+        return ret
+
+    def __eq__(self, other: object) -> bool:  # noqa: D105
+        if not isinstance(other, UseClause):
+            return False
+        # Required for LSP completions
+        other = cast("UseClause", other)  # type: ignore[redundant-cast]
+        return self._symbols == other._symbols
+
+    def __hash__(self) -> int:  # noqa: D105
+        return hash(
+            (self._symbols,),
+        )
+
+    def __repr__(self) -> str:  # noqa: D105
+        return f"{self.__class__.__name__}(_symbols={self._symbols!r}, )"
+
+
+class Entity(pyVHDLModel.Entity):  # noqa: D101
+    @classmethod
+    def from_treesitter_node(
+        cls,
+        node: tree_sitter.Node,
+        *,
+        contextItems: Iterable[LibraryClause | UseClause] = [],  # noqa: N803
+    ) -> Self:
+        """
+        Create an Entity from a treesitter node.
+
+        Raises
+        ------
+        ExtraNodeError:
+            If there is more than one `generics` or `ports` capture.
+        NodeTextIsNoneError:
+            If the `name` capture has no text.
+
+        """
+        captures = EntityDeclaration.capture(node)
+        name_node = get_node_or_raise(
+            node,
+            captures,
+            "name",
+            EntityDeclaration.TEXT,
+        )
+        if name_node.text is None:
+            raise NodeTextIsNoneError(node, EntityDeclaration.TEXT, "name")
+        name_text = name_node.text.decode()
+        generics_nodes = captures.get("generics", [])
+        if len(generics_nodes) > 1:
+            raise ExtraNodeError(node, EntityDeclaration.TEXT, "generics")
+        ports_nodes = captures.get("ports", [])
+        if len(ports_nodes) > 1:
+            raise ExtraNodeError(node, EntityDeclaration.TEXT, "generics")
+        generic_items = None
+        if len(generics_nodes) == 1:
+            generics_node = generics_nodes[0]
+            captures = InterfaceDeclarations.capture(generics_node)
+            generic_items_with_nodes = [
+                (
+                    GenericConstantInterfaceItem.from_treesitter_node(interface_node),
+                    interface_node,
+                )
+                for interface_node in captures.get("interface", [])
+            ]
+            generic_items = [
+                obj
+                for obj, _ in sorted(
+                    generic_items_with_nodes,
+                    key=cmp_to_key(lambda l, r: l[1].start_byte - r[1].start_byte),  # type: ignore[index]  # noqa: E741
+                )
+            ]
+        port_items = None
+        if len(ports_nodes) == 1:
+            ports_node = ports_nodes[0]
+            captures = InterfaceDeclarations.capture(ports_node)
+            port_items_with_nodes = [
+                (
+                    PortSignalInterfaceItem.from_treesitter_node(interface_node),
+                    interface_node,
+                )
+                for interface_node in captures.get("interface", [])
+            ]
+            port_items = [
+                obj
+                for obj, _ in sorted(
+                    port_items_with_nodes,
+                    key=cmp_to_key(lambda l, r: l[1].start_byte - r[1].start_byte),  # type: ignore[index]  # noqa: E741
+                )
+            ]
+        return cls(
+            identifier=name_text,
+            contextItems=contextItems,
+            genericItems=generic_items,
+            portItems=port_items,
+            declaredItems=None,  # TODO: implement
+            statements=None,  # TODO: implement
+            documentation=None,  # TODO: implement
+            allowBlackbox=None,  # TODO: implement
+        )
+
+    def __eq__(self, other: object) -> bool:  # noqa: D105
+        if not isinstance(other, Entity):
+            return False
+        # Required for LSP completions
+        other = cast("Entity", other)  # type: ignore[redundant-cast]
+        return (
+            self._identifier == other._identifier
+            and self._contextItems == other._contextItems
+            and self._genericItems == other._genericItems
+            and self._portItems == other._portItems
+            and self._declaredItems == other._declaredItems
+            and self._statements == other._statements
+            and self._documentation == other._documentation
+            and self._allowBlackbox == other._allowBlackbox
+        )
+
+    def __hash__(self) -> int:  # noqa: D105
+        return hash(
+            (
+                self._identifier,
+                self._contextItems,
+                self._genericItems,
+                self._portItems,
+                self._declaredItems,
+                self._statements,
+                self._documentation,
+                self._allowBlackbox,
+            ),
+        )
+
+    def __repr__(self) -> str:  # noqa: D105
+        return (
+            f"{self.__class__.__name__}("
+            f"_identifier={self._identifier!r}, "
+            f"_contextItems={self._contextItems!r}, "
+            f"_genericItems={self._genericItems!r}, "
+            f"_portItems={self._portItems!r}, "
+            f"_declaredItems={self._declaredItems}, "
+            f"_statements={self._statements}, "
+            f"_documentation={self._documentation}, "
+            f"_allowBlackbox={self._allowBlackbox}, "
+            ")"
+        )

pyvhdlmodeltreesitter-0.1.0/src/pyVHDLModelTreesitter/Expression.py

@@ -0,0 +1,80 @@
+"""Submodule mirroring modified aspects of pyVHDLModel.Expression."""
+
+__all__ = [
+    "EnumerationLiteral",
+    "FloatingPointLiteral",
+    "IntegerLiteral",
+    "StringLiteral",
+]
+
+from typing import cast
+
+import pyVHDLModel
+
+
+class EnumerationLiteral(pyVHDLModel.Expression.EnumerationLiteral):  # noqa: D101
+    def __eq__(self, other: object) -> bool:  # noqa: D105
+        if not isinstance(other, EnumerationLiteral):
+            return False
+        # Required for LSP completions
+        other = cast("EnumerationLiteral", other)  # type: ignore[redundant-cast]
+        return self._value.lower() == other._value.lower()
+
+    def __hash__(self) -> int:  # noqa: D105
+        return hash(
+            (self._value,),
+        )
+
+    def __repr__(self) -> str:  # noqa: D105
+        return f"{self.__class__.__name__}(_value={self._value!r}, )"
+
+
+class FloatingPointLiteral(pyVHDLModel.Expression.FloatingPointLiteral):  # noqa: D101
+    def __eq__(self, other: object) -> bool:  # noqa: D105
+        if not isinstance(other, FloatingPointLiteral):
+            return False
+        # Required for LSP completions
+        other = cast("FloatingPointLiteral", other)  # type: ignore[redundant-cast]
+        return self._value == other._value
+
+    def __hash__(self) -> int:  # noqa: D105
+        return hash(
+            (self._value,),
+        )
+
+    def __repr__(self) -> str:  # noqa: D105
+        return f"{self.__class__.__name__}(_value={self._value!r}, )"
+
+
+class IntegerLiteral(pyVHDLModel.Expression.IntegerLiteral):  # noqa: D101
+    def __eq__(self, other: object) -> bool:  # noqa: D105
+        if not isinstance(other, IntegerLiteral):
+            return False
+        # Required for LSP completions
+        other = cast("IntegerLiteral", other)  # type: ignore[redundant-cast]
+        return self._value == other._value
+
+    def __hash__(self) -> int:  # noqa: D105
+        return hash(
+            (self._value,),
+        )
+
+    def __repr__(self) -> str:  # noqa: D105
+        return f"{self.__class__.__name__}(_value={self._value!r}, )"
+
+
+class StringLiteral(pyVHDLModel.Expression.StringLiteral):  # noqa: D101
+    def __eq__(self, other: object) -> bool:  # noqa: D105
+        if not isinstance(other, StringLiteral):
+            return False
+        # Required for LSP completions
+        other = cast("StringLiteral", other)  # type: ignore[redundant-cast]
+        return self._value == other._value
+
+    def __hash__(self) -> int:  # noqa: D105
+        return hash(
+            (self._value,),
+        )
+
+    def __repr__(self) -> str:  # noqa: D105
+        return f"{self.__class__.__name__}(_value={self._value!r}, )"

pyvhdlmodeltreesitter-0.1.0/src/pyVHDLModelTreesitter/Interface.py

@@ -0,0 +1,298 @@
+"""Submodule defining the various interfaces that are available."""
+
+__all__ = [
+    "GenericConstantInterfaceItem",
+    "PortSignalInterfaceItem",
+]
+
+from typing import Self, cast
+
+import pyVHDLModel
+from tree_sitter import Node
+
+from pyVHDLModelTreesitter._error import (
+    ExtraNodeError,
+    MissingNodeError,
+    NodeTextIsNoneError,
+)
+from pyVHDLModelTreesitter.Base import parse_as_mode
+from pyVHDLModelTreesitter.Expression import (
+    EnumerationLiteral,
+    FloatingPointLiteral,
+    IntegerLiteral,
+    StringLiteral,
+)
+from pyVHDLModelTreesitter.Name import SimpleName
+from pyVHDLModelTreesitter.Symbol import SimpleSubtypeSymbol
+from pyVHDLModelTreesitter.treesitter import get_node_or_raise
+from pyVHDLModelTreesitter.treesitter.query import InterfaceDeclaration
+
+
+def parse_simple_expression(node: Node) -> pyVHDLModel.Expression.BaseExpression:
+    """
+    Parse a 'simple_expression' to a model object.
+
+    Raises
+    ------
+    MissingNodeError:
+        If `node` doesn't have exactly one child.
+
+    """
+    if node.child_count != 1:
+        raise MissingNodeError(
+            node,
+            InterfaceDeclaration.TEXT,
+            "simple_expression",
+        )
+    expression_child_node = node.children[0]
+    assert expression_child_node.text is not None  # noqa: S101
+    # TODO: support more simple expressions
+    if expression_child_node.type == "decimal_float":
+        return FloatingPointLiteral(
+            float(expression_child_node.text.decode()),
+        )
+    if expression_child_node.type == "decimal_integer":
+        return IntegerLiteral(
+            int(expression_child_node.text.decode()),
+        )
+    if expression_child_node.type == "library_constant_boolean":
+        return EnumerationLiteral(
+            expression_child_node.text.decode(),
+        )
+    if expression_child_node.type == "name":
+        assert expression_child_node.child_count == 1  # noqa: S101
+        name_node = expression_child_node.children[0]
+        assert name_node.text is not None  # noqa: S101
+        if name_node.type == "library_constant_std_logic":
+            return EnumerationLiteral(
+                name_node.text.decode()[1:-1],
+            )
+    if expression_child_node.type == "string_literal":
+        return StringLiteral(
+            expression_child_node.text.decode()[1:-1],
+        )
+    message = f"Default of type '{expression_child_node.type}' is not yet implemented"
+    raise NotImplementedError(message)
+
+
+class GenericConstantInterfaceItem(pyVHDLModel.Interface.GenericConstantInterfaceItem):  # noqa: D101
+    @classmethod
+    def from_treesitter_node(
+        cls,
+        node: Node,
+    ) -> Self:
+        """
+        Create a GenericConstantInterfaceItem from a treesitter node.
+
+        Raises
+        ------
+        MissingNodeError:
+            If `default` is present but isn't a simple expression.
+        NodeTextIsNoneError:
+            If the `name`, `type`, or `default` capture has no text.
+        ExtraNodeError:
+            If there is more than one `default`.
+
+        """
+        captures = InterfaceDeclaration.capture(node)
+        name_node = get_node_or_raise(
+            node,
+            captures,
+            "name",
+            InterfaceDeclaration.TEXT,
+        )
+        type_node = get_node_or_raise(
+            node,
+            captures,
+            "type",
+            InterfaceDeclaration.TEXT,
+        )
+        default_nodes = captures.get("default")
+
+        if name_node.text is None:
+            raise NodeTextIsNoneError(node, InterfaceDeclaration.TEXT, "name")
+        name_text = name_node.text.decode()
+
+        mode = pyVHDLModel.Base.Mode.In
+
+        if type_node.text is None:
+            raise NodeTextIsNoneError(node, InterfaceDeclaration.TEXT, "type")
+        type_text = type_node.text.decode()
+
+        default_expression: pyVHDLModel.Expression.BaseExpression | None = None
+        if default_nodes is not None:
+            if len(default_nodes) > 1:
+                raise ExtraNodeError(node, InterfaceDeclaration.TEXT, "default")
+            default_node = default_nodes[0]
+            # TODO: support non simple expressions
+            assert default_node.child_count == 1  # noqa: S101
+            simple_expression_node = default_node.children[0]
+            assert simple_expression_node.type == "simple_expression"  # noqa: S101
+            if simple_expression_node is None:
+                raise MissingNodeError(
+                    default_node,
+                    InterfaceDeclaration.TEXT,
+                    "simple_expression",
+                )
+            default_expression = parse_simple_expression(simple_expression_node)
+
+        return cls(
+            # TODO: why is there a list of identifiers?
+            identifiers=[name_text],
+            mode=mode,
+            # TODO: support types that aren't simple
+            subtype=SimpleSubtypeSymbol(SimpleName(type_text)),
+            defaultExpression=default_expression,
+            documentation=None,
+        )
+
+    def __eq__(self, other: object) -> bool:  # noqa: D105
+        if not isinstance(other, GenericConstantInterfaceItem):
+            return False
+        # Required for LSP completions
+        other = cast("GenericConstantInterfaceItem", other)  # type: ignore[redundant-cast]
+        return (
+            self._identifiers == other._identifiers
+            and self._mode == other._mode
+            and self._subtype == other._subtype
+            and self._defaultExpression == other._defaultExpression
+        )
+
+    def __hash__(self) -> int:  # noqa: D105
+        return hash(
+            (
+                self._identifiers,
+                self._mode,
+                self._subtype,
+                self._defaultExpression,
+            ),
+        )
+
+    def __repr__(self) -> str:  # noqa: D105
+        return (
+            f"{self.__class__.__name__}("
+            f"_identifiers={self._identifiers}, "
+            f"_mode={self._mode}, "
+            f"_subtype={self._subtype!r}, "
+            f"_defaultExpression={self._defaultExpression!r}, "
+            ")"
+        )
+
+
+class PortSignalInterfaceItem(pyVHDLModel.Interface.PortSignalInterfaceItem):  # noqa: D101
+    @classmethod
+    def from_treesitter_node(
+        cls,
+        node: Node,
+    ) -> Self:
+        """
+        Create a PortSignalInterfaceItem from a treesitter node.
+
+        Raises
+        ------
+        ExtraNodeError:
+            If `default` is captured more than once.
+        MissingNodeError:
+            If `default` is present but isn't a simple expression.
+        NodeTextIsNoneError:
+            If the `name`, `type`, `mode`, or `default` capture has no text.
+        ValueError:
+            If `mode` is not a valid mode.
+
+        """
+        captures = InterfaceDeclaration.capture(node)
+        name_node = get_node_or_raise(
+            node,
+            captures,
+            "name",
+            InterfaceDeclaration.TEXT,
+        )
+        mode_node = get_node_or_raise(
+            node,
+            captures,
+            "mode",
+            InterfaceDeclaration.TEXT,
+        )
+        type_node = get_node_or_raise(
+            node,
+            captures,
+            "type",
+            InterfaceDeclaration.TEXT,
+        )
+        default_nodes = captures.get("default")
+
+        if name_node.text is None:
+            raise NodeTextIsNoneError(node, InterfaceDeclaration.TEXT, "name")
+        name_text = name_node.text.decode()
+
+        if mode_node.text is None:
+            raise NodeTextIsNoneError(node, InterfaceDeclaration.TEXT, "mode")
+        mode_text = mode_node.text.decode()
+
+        if type_node.text is None:
+            raise NodeTextIsNoneError(node, InterfaceDeclaration.TEXT, "type")
+        type_text = type_node.text.decode()
+
+        default_expression: pyVHDLModel.Expression.BaseExpression | None = None
+        if default_nodes is not None:
+            if len(default_nodes) > 1:
+                raise ExtraNodeError(node, InterfaceDeclaration.TEXT, "default")
+            default_node = default_nodes[0]
+            # TODO: support non simple expressions
+            assert default_node.child_count == 1  # noqa: S101
+            simple_expression_node = default_node.children[0]
+            assert simple_expression_node.type == "simple_expression"  # noqa: S101
+            if simple_expression_node is None:
+                raise MissingNodeError(
+                    default_node,
+                    InterfaceDeclaration.TEXT,
+                    "simple_expression",
+                )
+            default_expression = parse_simple_expression(simple_expression_node)
+
+        mode = parse_as_mode(mode_text)
+        if mode is None:
+            message = f"'{mode_text}' is not a valid VHDL interface mode"
+            raise ValueError(message)
+
+        return cls(
+            # TODO: why is there a list of identifiers?
+            identifiers=[name_text],
+            mode=mode,
+            # TODO: support types that aren't simple
+            subtype=SimpleSubtypeSymbol(SimpleName(type_text)),
+            defaultExpression=default_expression,
+            documentation=None,
+        )
+
+    def __eq__(self, other: object) -> bool:  # noqa: D105
+        if not isinstance(other, PortSignalInterfaceItem):
+            return False
+        # Required for LSP completions
+        other = cast("PortSignalInterfaceItem", other)  # type: ignore[redundant-cast]
+        return (
+            self._identifiers == other._identifiers
+            and self._mode == other._mode
+            and self._subtype == other._subtype
+            and self._defaultExpression == other._defaultExpression
+        )
+
+    def __hash__(self) -> int:  # noqa: D105
+        return hash(
+            (
+                self._identifiers,
+                self._mode,
+                self._subtype,
+                self._defaultExpression,
+            ),
+        )
+
+    def __repr__(self) -> str:  # noqa: D105
+        return (
+            f"{self.__class__.__name__}("
+            f"_identifiers={self._identifiers}, "
+            f"_mode={self._mode}, "
+            f"_subtype={self._subtype!r}, "
+            f"_defaultExpression={self._defaultExpression!r}, "
+            ")"
+        )

pyvhdlmodeltreesitter-0.1.0/src/pyVHDLModelTreesitter/Name.py

@@ -0,0 +1,46 @@
+"""Submodule mirroring modified aspects of pyVHDLModel.Name."""
+
+__all__ = [
+    "SelectedName",
+    "SimpleName",
+]
+
+from typing import cast
+
+from pyVHDLModel.Name import (
+    SelectedName as BaseSelectedName,
+)
+from pyVHDLModel.Name import (
+    SimpleName as BaseSimpleName,
+)
+
+
+class SimpleName(BaseSimpleName):  # noqa: D101
+    def __eq__(self, other: object) -> bool:  # noqa: D105
+        if not isinstance(other, SimpleName):
+            return False
+        # Required for LSP completions
+        other = cast("SimpleName", other)  # type: ignore[redundant-cast]
+        return self._identifier == other._identifier
+
+    def __hash__(self) -> int:  # noqa: D105
+        return hash(
+            (self._identifier,),
+        )
+
+
+class SelectedName(BaseSelectedName):  # noqa: D101
+    def __eq__(self, other: object) -> bool:  # noqa: D105
+        if not isinstance(other, SelectedName):
+            return False
+        # Required for LSP completions
+        other = cast("SelectedName", other)  # type: ignore[redundant-cast]
+        return self._identifier == other._identifier and self._prefix == other._prefix
+
+    def __hash__(self) -> int:  # noqa: D105
+        return hash(
+            (
+                self._identifier,
+                self._prefix,
+            ),
+        )

pyvhdlmodeltreesitter-0.1.0/src/pyVHDLModelTreesitter/Symbol.py

@@ -0,0 +1,62 @@
+"""Submodule mirroring modified aspects of pyVHDLModel.Symbol."""
+
+__all__ = [
+    "LibraryReferenceSymbol",
+    "PackageReferenceSymbol",
+    "SimpleSubtypeSymbol",
+]
+
+from typing import cast
+
+import pyVHDLModel
+
+
+class LibraryReferenceSymbol(pyVHDLModel.Symbol.LibraryReferenceSymbol):  # noqa: D101
+    def __eq__(self, other: object) -> bool:  # noqa: D105
+        if not isinstance(other, LibraryReferenceSymbol):
+            return False
+        # Required for LSP completions
+        other = cast("LibraryReferenceSymbol", other)  # type: ignore[redundant-cast]
+        return self._name == other._name
+
+    def __hash__(self) -> int:  # noqa: D105
+        return hash(
+            (self._name,),
+        )
+
+    def __repr__(self) -> str:  # noqa: D105
+        return f"{self.__class__.__name__}(_name={self._name}, )"
+
+
+class PackageReferenceSymbol(pyVHDLModel.Symbol.PackageReferenceSymbol):  # noqa: D101
+    def __eq__(self, other: object) -> bool:  # noqa: D105
+        if not isinstance(other, PackageReferenceSymbol):
+            return False
+        # Required for LSP completions
+        other = cast("PackageReferenceSymbol", other)  # type: ignore[redundant-cast]
+        return self._name == other._name
+
+    def __hash__(self) -> int:  # noqa: D105
+        return hash(
+            (self._name,),
+        )
+
+    def __repr__(self) -> str:  # noqa: D105
+        return f"{self.__class__.__name__}(_name={self._name}, )"
+
+
+class SimpleSubtypeSymbol(pyVHDLModel.Symbol.SimpleSubtypeSymbol):  # noqa: D101
+    def __eq__(self, other: object) -> bool:  # noqa: D105
+        if not isinstance(other, SimpleSubtypeSymbol):
+            return False
+        # Required for LSP completions
+        other = cast("SimpleSubtypeSymbol", other)  # type: ignore[redundant-cast]
+        return self._name == other._name
+
+    def __hash__(self) -> int:  # noqa: D105
+        return hash(
+            (self._name,),
+        )
+
+    def __repr__(self) -> str:  # noqa: D105
+        return f"{self.__class__.__name__}(_name={self._name}, )"

pyvhdlmodeltreesitter-0.1.0/src/pyVHDLModelTreesitter/__init__.py

@@ -0,0 +1,228 @@
+"""The pyVHDLModelTreesitter package."""
+
+__all__: list[str] = [
+    "Design",
+    "DesignUnit",
+    "Document",
+    "Entity",
+    "Expression",
+    "ExtraNodeError",
+    "Interface",
+    "Library",
+    "MissingNodeError",
+    "Name",
+    "NodeTextIsNoneError",
+    "Symbol",
+]
+
+from ._error import ExtraNodeError, MissingNodeError, NodeTextIsNoneError  # noqa: I001
+from . import DesignUnit, Expression, Interface, Name, Symbol
+from .DesignUnit import Entity
+
+from pathlib import Path
+from typing import Self, cast
+
+from pyVHDLModel import (
+    Design as BaseDesign,
+    Document as BaseDocument,
+    Library as BaseLibrary,
+)
+from pyVHDLModelTreesitter.DesignUnit import LibraryClause, UseClause
+from pyVHDLModelTreesitter.treesitter.query import PARSER, DesignUnits
+
+
+class Library(BaseLibrary):  # noqa: D101
+    def __eq__(self, other: object) -> bool:  # noqa: D105
+        if not isinstance(other, Library):
+            return False
+        # Required for LSP completions
+        other = cast("Library", other)  # type: ignore[redundant-cast]
+        return (
+            self._allowBlackbox == other._allowBlackbox
+            and self._contexts == other._contexts
+            and self._configurations == other._configurations
+            and self._entities == other._entities
+            and self._architectures == other._architectures
+            and self._packages == other._packages
+            and self._packageBodies == other._packageBodies
+        )
+
+    def __hash__(self) -> int:  # noqa: D105
+        return hash(
+            (
+                self._allowBlackbox,
+                self._contexts,
+                self._configurations,
+                self._entities,
+                self._architectures,
+                self._packages,
+                self._packageBodies,
+            ),
+        )
+
+    def __repr__(self) -> str:  # noqa: D105
+        return (
+            f"{self.__class__.__name__}("
+            f"_allowBlackbox={self._allowBlackbox}, "
+            f"_contexts={self._contexts}, "
+            f"_configurations={self._configurations}, "
+            f"_entities={list(self._entities.values())!r}, "
+            f"_architectures={self._architectures}, "
+            f"_packages={self._packages}, "
+            f"_packageBodies={self._packageBodies}, "
+            ")"
+        )
+
+
+class Document(BaseDocument):  # noqa: D101
+    @classmethod
+    def from_file(cls, path: str | Path) -> Self:  # noqa: C901  # TODO: refactor
+        """
+        Create a Document, and all ModelEntities it contains.
+
+        Raises
+        ------
+        MissingNodeError:
+            - There are no `design_unit` nodes.
+            - Any `design_unit` node has no children.
+        NotImplementedError:
+            - If a node is encountered that isn't implemented.
+
+        """
+        if isinstance(path, str):
+            path = Path(path)
+        document = cls(path)
+
+        tree = PARSER.parse(path.read_bytes())
+        node = tree.root_node
+        captures = DesignUnits.capture(node)
+        design_unit_captures = captures.get("design-unit")
+        if design_unit_captures is None:
+            raise MissingNodeError(node, DesignUnits.TEXT, "design-unit")
+        for design_unit_capture in design_unit_captures:
+            if len(design_unit_capture.children) == 0:
+                raise MissingNodeError(node, DesignUnits.TEXT, "design-unit")
+            design_unit_child = design_unit_capture.children[-1]
+            context_children = design_unit_capture.children[:-1]
+            context_items: list[LibraryClause | UseClause] = []
+            for context_child in context_children:
+                if context_child is None:
+                    raise MissingNodeError(node, DesignUnits.TEXT, "design-unit")
+                if context_child.type == "library_clause":
+                    context_items.extend(
+                        LibraryClause.from_treesitter_node(context_child),
+                    )
+                elif context_child.type == "use_clause":
+                    context_items.extend(
+                        UseClause.from_treesitter_node(context_child),
+                    )
+                else:
+                    message = f"Node of type '{context_child.type}' is not supported"
+                    raise NotImplementedError(message)
+            if design_unit_child is None:
+                raise MissingNodeError(node, DesignUnits.TEXT, "design-unit")
+            if design_unit_child.type == "entity_declaration":
+                entity = Entity.from_treesitter_node(node, contextItems=context_items)
+                document._AddEntity(entity)
+            else:
+                message = f"Node of type '{design_unit_child.type}' is not supported"
+                raise NotImplementedError(message)
+        return document
+
+    def __eq__(self, other: object) -> bool:  # noqa: D105
+        if not isinstance(other, Document):
+            return False
+        # Required for LSP completions
+        other = cast("Document", other)  # type: ignore[redundant-cast]
+        return (
+            self._path == other._path
+            and self._contexts == other._contexts
+            and self._configurations == other._configurations
+            and self._entities == other._entities
+            and self._architectures == other._architectures
+            and self._packages == other._packages
+            and self._packageBodies == other._packageBodies
+            and self._verificationUnits == other._verificationUnits
+            and self._verificationProperties == other._verificationProperties
+            and self._verificationModes == other._verificationModes
+        )
+
+    def __hash__(self) -> int:  # noqa: D105
+        return hash(
+            (
+                self._path,
+                self._contexts,
+                self._configurations,
+                self._entities,
+                self._architectures,
+                self._packages,
+                self._packageBodies,
+                self._verificationUnits,
+                self._verificationProperties,
+                self._verificationModes,
+            ),
+        )
+
+    def __repr__(self) -> str:  # noqa: D105
+        return (
+            f"{self.__class__.__name__}("
+            f"_path={self._path}, "
+            f"_contexts={self._contexts}, "
+            f"_configurations={self._configurations}, "
+            f"_entities={list(self._entities.values())!r}, "
+            f"_architectures={self._architectures}, "
+            f"_packages={self._packages}, "
+            f"_packageBodies={self._packageBodies}, "
+            f"_verificationUnits={self._verificationUnits}, "
+            f"_verificationProperties={self._verificationProperties}, "
+            f"_verificationModes={self._verificationModes}, "
+            ")"
+        )
+
+
+class Design(BaseDesign):  # noqa: D101
+    def GetLibrary(  # noqa: D102, N802
+        self,
+        name: str,
+    ) -> Library:
+        library = self.Libraries.get(name)
+        if library is not None:
+            return cast("Library", library)
+        library = Library(
+            name,
+            allowBlackbox=self._allowBlackbox,
+        )
+        self.AddLibrary(library)
+        return library
+
+    def __eq__(self, other: object) -> bool:  # noqa: D105
+        if not isinstance(other, Design):
+            return False
+        # Required for LSP completions
+        other = cast("Design", other)  # type: ignore[redundant-cast]
+        return (
+            self._name == other._name
+            and self._allowBlackbox == other._allowBlackbox
+            and self._libraries == other._libraries
+            and self._documents == other._documents
+        )
+
+    def __hash__(self) -> int:  # noqa: D105
+        return hash(
+            (
+                self._name,
+                self._allowBlackbox,
+                self._libraries,
+                self._documents,
+            ),
+        )
+
+    def __repr__(self) -> str:  # noqa: D105
+        return (
+            f"{self.__class__.__name__}("
+            f"_name={self._name}, "
+            f"_allowBlackbox={self._allowBlackbox}, "
+            f"_libraries={list(self._libraries.values())!r}, "
+            f"_documents={self._documents!r}, "
+            ")"
+        )

pyvhdlmodeltreesitter-0.1.0/src/pyVHDLModelTreesitter/_error.py

@@ -0,0 +1,39 @@
+"""Submodule defining errors."""
+
+from tree_sitter import Node
+
+
+class BaseQueryCaptureError(RuntimeError):
+    """Error raised when a capture fails for some reason."""
+
+    def __init__(self, node: Node, query: str, name: str, message: str) -> None:
+        """Construct."""
+        assert node.text is not None  # noqa: S101
+        super().__init__(f"Capture '@{name}': {message}: {node.text.decode()}: {node}")
+        self._node = node
+        self._query = query
+        self._name = name
+
+
+class MissingNodeError(BaseQueryCaptureError):
+    """Error raised when an expected node is not found."""
+
+    def __init__(self, node: Node, query: str, name: str) -> None:
+        """Construct."""
+        super().__init__(node, query, name, "Not found in node")
+
+
+class ExtraNodeError(BaseQueryCaptureError):
+    """Error raised when an expected node is found too many times."""
+
+    def __init__(self, node: Node, query: str, name: str) -> None:
+        """Construct."""
+        super().__init__(node, query, name, "Found too many times in node")
+
+
+class NodeTextIsNoneError(BaseQueryCaptureError):
+    """Error raised when a node that is expected to have a `text` field doesn't."""
+
+    def __init__(self, node: Node, query: str, name: str) -> None:
+        """Construct."""
+        super().__init__(node, query, name, "`text` attribute not found for node")