ipxact-compiler 0.1.0__tar.gz

ipxact_compiler-0.1.0/LICENSE

@@ -0,0 +1,164 @@
+                   GNU LESSER GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+  This version of the GNU Lesser General Public License incorporates
+the terms and conditions of version 3 of the GNU General Public
+License, supplemented by the additional permissions listed below.
+
+  0. Additional Definitions.
+
+  As used herein, "this License" refers to version 3 of the GNU Lesser
+General Public License, and the "GNU GPL" refers to version 3 of the GNU
+General Public License.
+
+  "The Library" refers to a covered work governed by this License,
+other than an Application or a Combined Work as defined below.
+
+  An "Application" is any work that makes use of an interface provided
+by the Library, but which is not otherwise based on the Library.
+Defining a subclass of a class defined by the Library is deemed a mode
+of using an interface provided by the Library.
+
+  A "Combined Work" is a work produced by combining or linking an
+Application with the Library.  The particular version of the Library
+with which the Combined Work was made is also called the "Linked
+Version".
+
+  The "Minimal Corresponding Source" for a Combined Work means the
+Corresponding Source for the Combined Work, excluding any source code
+for portions of the Combined Work that, considered in isolation, are
+based on the Application, and not on the Linked Version.
+
+  The "Corresponding Application Code" for a Combined Work means the
+object code and/or source code for the Application, including any data
+and utility programs needed for reproducing the Combined Work from the
+Application, but excluding the System Libraries of the Combined Work.
+
+  1. Exception to Section 3 of the GNU GPL.
+
+  You may convey a covered work under sections 3 and 4 of this License
+without being bound by section 3 of the GNU GPL.
+
+  2. Conveying Modified Versions.
+
+  If you modify a copy of the Library, and, in your modifications, a
+facility refers to a function or data to be supplied by an Application
+that uses the facility (other than as an argument passed when the
+facility is invoked), then you may convey a copy of the modified
+version:
+
+   a) under this License, provided that you make a good faith effort to
+   ensure that, in the event an Application does not supply the
+   function or data, the facility still operates, and performs
+   whatever part of its purpose remains meaningful, or
+
+   b) under the GNU GPL, with none of the additional permissions of
+   this License applicable to that copy.
+
+  3. Object Code Incorporating Material from Library Header Files.
+
+  The object code form of an Application may incorporate material from
+a header file that is part of the Library.  You may convey such object
+code under terms of your choice, provided that, if the incorporated
+material is not limited to numerical parameters, data structure
+layouts and accessors, or small macros, inline functions and templates
+(ten or fewer lines in length), you do both of the following:
+
+   a) Give prominent notice with each copy of the object code that the
+   Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the object code with a copy of the GNU GPL and this license
+   document.
+
+  4. Combined Works.
+
+  You may convey a Combined Work under terms of your choice that,
+taken together, effectively do not restrict modification of the
+portions of the Library contained in the Combined Work and reverse
+engineering for debugging such modifications, if you also do each of
+the following:
+
+   a) Give prominent notice with each copy of the Combined Work that
+   the Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the Combined Work with a copy of the GNU GPL and this license
+   document.
+
+   c) For a Combined Work that displays copyright notices during
+   execution, include the copyright notice for the Library among
+   these notices, as well as a reference directing the user to the
+   copies of the GNU GPL and this license document.
+
+   d) Do one of the following:
+
+       0) Convey the Minimal Corresponding Source under the terms of this
+       License, and the Corresponding Application Code in a form
+       suitable for, and under terms that permit, the user to
+       recombine or relink the Application with a modified version of
+       the Linked Version to produce a modified Combined Work, in the
+       manner specified by section 6 of the GNU GPL for conveying
+       Corresponding Source.
+
+       1) Use a suitable shared library mechanism for linking with the
+       Library.  A suitable mechanism is one that (a) uses at run time
+       a copy of the Library already present on the user's computer
+       system, and (b) will operate properly with a modified version
+       of the Library that is interface-compatible with the Linked
+       Version.
+
+   e) Provide Installation Information, but only if you would otherwise
+   be required to provide such information under section 6 of the
+   GNU GPL, and only to the extent that such information is
+   necessary to install and execute a modified version of the
+   Combined Work produced by recombining or relinking the
+   Application with a modified version of the Linked Version. (If
+   you use option 4d0, the Installation Information must accompany
+   the Minimal Corresponding Source and Corresponding Application
+   Code. If you use option 4d1, you must provide the Installation
+   Information in the manner specified by section 6 of the GNU GPL
+   for conveying Corresponding Source.)
+
+  5. Combined Libraries.
+
+  You may place library facilities that are a work based on the
+Library side by side in a single library together with other library
+facilities that are not Applications and are not covered by this
+License, and convey such a combined library under terms of your
+choice, if you do both of the following:
+
+   a) Accompany the combined library with a copy of the same work based
+   on the Library, uncombined with any other library facilities,
+   conveyed under the terms of this License.
+
+   b) Give prominent notice with the combined library that part of it
+   is a work based on the Library, and explaining where to find the
+   accompanying uncombined form of the same work.
+
+  6. Revised Versions of the GNU Lesser General Public License.
+
+  The Free Software Foundation may publish revised and/or new versions
+of the GNU Lesser General Public License from time to time. Such new
+versions will be similar in spirit to the present version, but may
+differ in detail to address new problems or concerns.
+
+  Each version is given a distinguishing version number. If the
+Library as you received it specifies that a certain numbered version
+of the GNU Lesser General Public License "or any later version"
+applies to it, you have the option of following the terms and
+conditions either of that published version or of any later version
+published by the Free Software Foundation. If the Library as you
+received it does not specify a version number of the GNU Lesser
+General Public License, you may choose any version of the GNU Lesser
+General Public License ever published by the Free Software Foundation.
+
+  If the Library as you received it specifies that a proxy can decide
+whether future versions of the GNU Lesser General Public License shall
+apply, that proxy's public statement of acceptance of any version is
+permanent authorization for you to choose that version for the
+Library.

ipxact_compiler-0.1.0/PKG-INFO

@@ -0,0 +1,133 @@
+Metadata-Version: 2.4
+Name: ipxact-compiler
+Version: 0.1.0
+Summary: Parses IEEE 1685-2022 IP-XACT XML into a Python object model.
+Author: Maxime Travaillard
+License-Expression: LGPL-3.0-only
+Project-URL: Repository, https://github.com/IP-XACT/ipxact-compiler
+Project-URL: Issues, https://github.com/IP-XACT/ipxact-compiler/issues
+Keywords: IP-XACT,IEEE 1685,XML,Compiler
+Classifier: Development Status :: 3 - Alpha
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Scientific/Engineering
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: lxml
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Dynamic: license-file
+
+# ipxact-compiler
+
+A Python library that parses [IEEE 1685-2022](https://standards.ieee.org/ieee/1685/10307/) IP-XACT
+XML documents into a Python object model.
+
+It is a standalone, general-purpose parsing library, not tied to any specific downstream tool or
+flow. `ipxact-compiler` reads IP-XACT and hands you back Python objects; it does not resolve
+cross-file references, elaborate a design, validate semantic consistency, or generate any output.
+That is the job of tools built on top of it.
+
+## What it supports
+
+Five IP-XACT top-level document types are supported for now:
+
+- `component`
+- `design`
+- `designConfiguration`
+- `busDefinition`
+- `abstractionDefinition`
+
+The object model aims for full fidelity with the IEEE 1685-2022 XSD schema for these document types:
+every element and attribute the schema defines is represented.
+
+A few things are intentionally represented in a simplified form rather than being modeled in full
+depth:
+
+- **Expressions are raw strings.** Fields typed as an IP-XACT `expression` (parameter values, array
+  bounds, and similar) are kept as unevaluated strings, not parsed or evaluated as arithmetic.
+- **`vendorExtensions` is opaque.** It is parsed generically, not modeled per-vendor.
+
+## Installation
+
+```bash
+pip install ipxact-compiler
+```
+
+Or, for local development:
+
+```bash
+git clone <this repo>
+cd ipxact-compiler
+pip install -e ".[dev]"
+```
+
+Requires Python >= 3.9. The only runtime dependency is [`lxml`](https://lxml.de/).
+
+## Usage
+
+```python
+import ipxact
+
+component = ipxact.parse_file("path/to/some_component.xml")
+
+component.vlnv            # VLNV
+component.bus_interfaces  # list[BusInterface]
+component.memory_maps     # list[MemoryMap]
+component.model           # Model | None
+```
+
+`ipxact.parse_file(path)` reads a file, figures out its document type from the root element, and
+returns the matching dataclass (`Component`, `Design`, `DesignConfiguration`, `BusDefinition`, or
+`AbstractionDefinition`).
+
+Every schema class (`Component`, `VLNV`, `BusInterface`, `Register`, `Field`, and so on) is
+re-exported at the top level, so `ipxact.<ClassName>` works without reaching into submodules.
+
+## Design principles
+
+- **Single-file parsing only.** `ipxact-compiler` never opens a second file on its own. Resolving
+  VLNV references across a library of files (for example, finding the `Component` that a `Design`'s
+  instance refers to) is left to the caller.
+- **Input files are assumed to be valid.** `ipxact-compiler` does not perform validation; it assumes
+  the IP-XACT documents you give it are already well-formed and conform to the standard. This is why
+  the parser currently favors defaulting over raising on missing or malformed data. This may change
+  (see "Known limitations").
+- **Hand-written, not XSD auto-generated.** The object model is a set of hand-written Python
+  dataclasses following the schema but not automatically generated from the XSD. This keeps the API
+  stable, at the cost of needing to keep it manually in sync with the standard.
+
+## Known limitations / ideas for later
+
+These are open items, not commitments. None of them are currently planned to start imminently.
+
+- **No XSD schema validation.** Malformed IP-XACT (missing required elements, wrong types, invalid
+  structure) is not rejected at parse time; the parser will generally just default missing fields
+  rather than erroring. A validation path using the bundled IEEE 1685-2022 XSDs and
+  `lxml.etree.XMLSchema` could be considered, but it means packaging the full IEEE 1685-2022 XSD
+  schema with this repository, for a benefit that only matters if you're feeding it genuinely
+  invalid files.
+- **No deliberate error-handling philosophy yet.** Right now, malformed input either silently
+  produces a default value or raises whatever low-level Python exception happens to occur (a
+  `ValueError`, an `AttributeError`, etc.) rather than a clear, intentional error type. Deciding on
+  and implementing a consistent policy (raise vs. warn vs. silently default, and what exception
+  types/messages to use) is still open.
+- **No Semantic Consistency Rule (SCR) checking**, per IEEE 1685-2022 Annex B. These are the
+  standard's own rules for validity that XSD alone can't express (VLNV resolution correctness,
+  bus/abstraction interface compatibility, and so on). Each rule is tagged with two independent
+  flags: whether it is checkable on a single document alone, and whether it applies
+  post-configuration (after linking). In our case, only the subset that is single-document-checkable
+  and not post-config could live in `ipxact-compiler`.
+- **No dedicated documentation yet.** This README covers the basics, but a proper documentation site
+  (full API reference, more usage examples) is planned for the future.
+
+## License
+
+LGPL-3.0. See [`LICENSE`](LICENSE).

ipxact_compiler-0.1.0/README.md

@@ -0,0 +1,106 @@
+# ipxact-compiler
+
+A Python library that parses [IEEE 1685-2022](https://standards.ieee.org/ieee/1685/10307/) IP-XACT
+XML documents into a Python object model.
+
+It is a standalone, general-purpose parsing library, not tied to any specific downstream tool or
+flow. `ipxact-compiler` reads IP-XACT and hands you back Python objects; it does not resolve
+cross-file references, elaborate a design, validate semantic consistency, or generate any output.
+That is the job of tools built on top of it.
+
+## What it supports
+
+Five IP-XACT top-level document types are supported for now:
+
+- `component`
+- `design`
+- `designConfiguration`
+- `busDefinition`
+- `abstractionDefinition`
+
+The object model aims for full fidelity with the IEEE 1685-2022 XSD schema for these document types:
+every element and attribute the schema defines is represented.
+
+A few things are intentionally represented in a simplified form rather than being modeled in full
+depth:
+
+- **Expressions are raw strings.** Fields typed as an IP-XACT `expression` (parameter values, array
+  bounds, and similar) are kept as unevaluated strings, not parsed or evaluated as arithmetic.
+- **`vendorExtensions` is opaque.** It is parsed generically, not modeled per-vendor.
+
+## Installation
+
+```bash
+pip install ipxact-compiler
+```
+
+Or, for local development:
+
+```bash
+git clone <this repo>
+cd ipxact-compiler
+pip install -e ".[dev]"
+```
+
+Requires Python >= 3.9. The only runtime dependency is [`lxml`](https://lxml.de/).
+
+## Usage
+
+```python
+import ipxact
+
+component = ipxact.parse_file("path/to/some_component.xml")
+
+component.vlnv            # VLNV
+component.bus_interfaces  # list[BusInterface]
+component.memory_maps     # list[MemoryMap]
+component.model           # Model | None
+```
+
+`ipxact.parse_file(path)` reads a file, figures out its document type from the root element, and
+returns the matching dataclass (`Component`, `Design`, `DesignConfiguration`, `BusDefinition`, or
+`AbstractionDefinition`).
+
+Every schema class (`Component`, `VLNV`, `BusInterface`, `Register`, `Field`, and so on) is
+re-exported at the top level, so `ipxact.<ClassName>` works without reaching into submodules.
+
+## Design principles
+
+- **Single-file parsing only.** `ipxact-compiler` never opens a second file on its own. Resolving
+  VLNV references across a library of files (for example, finding the `Component` that a `Design`'s
+  instance refers to) is left to the caller.
+- **Input files are assumed to be valid.** `ipxact-compiler` does not perform validation; it assumes
+  the IP-XACT documents you give it are already well-formed and conform to the standard. This is why
+  the parser currently favors defaulting over raising on missing or malformed data. This may change
+  (see "Known limitations").
+- **Hand-written, not XSD auto-generated.** The object model is a set of hand-written Python
+  dataclasses following the schema but not automatically generated from the XSD. This keeps the API
+  stable, at the cost of needing to keep it manually in sync with the standard.
+
+## Known limitations / ideas for later
+
+These are open items, not commitments. None of them are currently planned to start imminently.
+
+- **No XSD schema validation.** Malformed IP-XACT (missing required elements, wrong types, invalid
+  structure) is not rejected at parse time; the parser will generally just default missing fields
+  rather than erroring. A validation path using the bundled IEEE 1685-2022 XSDs and
+  `lxml.etree.XMLSchema` could be considered, but it means packaging the full IEEE 1685-2022 XSD
+  schema with this repository, for a benefit that only matters if you're feeding it genuinely
+  invalid files.
+- **No deliberate error-handling philosophy yet.** Right now, malformed input either silently
+  produces a default value or raises whatever low-level Python exception happens to occur (a
+  `ValueError`, an `AttributeError`, etc.) rather than a clear, intentional error type. Deciding on
+  and implementing a consistent policy (raise vs. warn vs. silently default, and what exception
+  types/messages to use) is still open.
+- **No Semantic Consistency Rule (SCR) checking**, per IEEE 1685-2022 Annex B. These are the
+  standard's own rules for validity that XSD alone can't express (VLNV resolution correctness,
+  bus/abstraction interface compatibility, and so on). Each rule is tagged with two independent
+  flags: whether it is checkable on a single document alone, and whether it applies
+  post-configuration (after linking). In our case, only the subset that is single-document-checkable
+  and not post-config could live in `ipxact-compiler`.
+- **No dedicated documentation yet.** This README covers the basics, but a proper documentation site
+  (full API reference, more usage examples) is planned for the future.
+
+## License
+
+LGPL-3.0. See [`LICENSE`](LICENSE).

ipxact_compiler-0.1.0/pyproject.toml

@@ -0,0 +1,51 @@
+[build-system]
+requires = ["setuptools>=77"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "ipxact-compiler"
+dynamic = ["version"]
+description = "Parses IEEE 1685-2022 IP-XACT XML into a Python object model."
+readme = "README.md"
+license = "LGPL-3.0-only"
+license-files = ["LICENSE"]
+authors = [
+    { name = "Maxime Travaillard"},
+]
+requires-python = ">=3.9"
+dependencies = [
+    "lxml",
+]
+keywords = [
+    "IP-XACT", "IEEE 1685", "XML", "Compiler",
+]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3 :: Only",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+    "Topic :: Scientific/Engineering",
+]
+
+[project.urls]
+Repository = "https://github.com/IP-XACT/ipxact-compiler"
+Issues = "https://github.com/IP-XACT/ipxact-compiler/issues"
+
+[project.optional-dependencies]
+dev = [
+    "pytest",
+]
+
+[tool.setuptools.dynamic]
+version = {attr = "ipxact.__version__"}
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+ipxact = ["py.typed"]

ipxact_compiler-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

ipxact_compiler-0.1.0/src/ipxact/__init__.py

@@ -0,0 +1,7 @@
+__version__ = "0.1.0"
+
+from .parser import parse_element, parse_file
+from .schema import *  # noqa: F401,F403
+from .schema import __all__ as _schema_all
+
+__all__ = [*_schema_all, "parse_element", "parse_file", "__version__"]

ipxact_compiler-0.1.0/src/ipxact/parser/__init__.py

@@ -0,0 +1,3 @@
+from .main_parser import parse_element, parse_file
+
+__all__ = ["parse_element", "parse_file"]

ipxact_compiler-0.1.0/src/ipxact/parser/abstractiondefinition_parser.py

@@ -0,0 +1,159 @@
+from __future__ import annotations
+
+from lxml import etree
+
+from ..schema.abstractiondefinition import (
+    AbstractionDefinition,
+    AbstractionPort,
+    PortConstraints,
+    Presence,
+    RequiresDriver,
+    TransactionalAbstractionPort,
+    TransactionalModeConstraints,
+    TransactionalSystemConstraints,
+    WireAbstractionPort,
+    WireModeConstraints,
+    WireSystemConstraints,
+)
+from .common_parser import (
+    as_bool,
+    attr_bool,
+    bool_text,
+    child,
+    children,
+    elem_text,
+    parse_assertions,
+    parse_children,
+    parse_choices,
+    parse_drive_constraint,
+    parse_load_constraint,
+    parse_parameters,
+    parse_protocol,
+    parse_qualifier,
+    parse_timing_constraints,
+    parse_vendor_extensions,
+    parse_vlnv,
+    parse_vlnv_ref,
+    text,
+)
+
+
+def parse_abstractiondefinition(root: etree._Element) -> AbstractionDefinition:
+    """Parse an ipxact:abstractionDefinition root element into an AbstractionDefinition object."""
+    extends_elem = child(root, "extends")
+    return AbstractionDefinition(
+        vlnv=parse_vlnv(root),
+        bus_type=parse_vlnv_ref(child(root, "busType")),
+        extends=parse_vlnv_ref(extends_elem) if extends_elem is not None else None,
+        ports=parse_children(root, "ports", "port", _parse_abstraction_port),
+        choices=parse_choices(root),
+        parameters=parse_parameters(root),
+        assertions=parse_assertions(root),
+        display_name=text(root, "displayName"),
+        short_description=text(root, "shortDescription"),
+        description=text(root, "description"),
+        vendor_extensions=parse_vendor_extensions(root),
+    )
+
+
+def _parse_port_constraints(elem: etree._Element) -> PortConstraints:
+    return PortConstraints(
+        timing_constraints=parse_timing_constraints(elem),
+        drive_constraint=parse_drive_constraint(elem),
+        load_constraint=parse_load_constraint(elem),
+    )
+
+
+def _parse_requires_driver(elem: etree._Element) -> RequiresDriver:
+    return RequiresDriver(value=as_bool(elem.text, False), driver_type=elem.get("driverType", "any"))
+
+
+def _parse_wire_mode_constraints(elem: etree._Element) -> WireModeConstraints:
+    presence = text(elem, "presence")
+    width_elem = child(elem, "width")
+    direction_elem = child(elem, "direction")
+    mode_constraints_elem = child(elem, "modeConstraints")
+    mirrored_mode_constraints_elem = child(elem, "mirroredModeConstraints")
+    return WireModeConstraints(
+        presence=Presence(presence) if presence else Presence.OPTIONAL,
+        width=elem_text(width_elem),
+        width_all_bits_required=attr_bool(width_elem, "allBits", False) if width_elem is not None else False,
+        # direction defaults to "out" when absent
+        direction=elem_text(direction_elem) or "out",
+        mode_constraints=(
+            _parse_port_constraints(mode_constraints_elem) if mode_constraints_elem is not None else None
+        ),
+        mirrored_mode_constraints=(
+            _parse_port_constraints(mirrored_mode_constraints_elem)
+            if mirrored_mode_constraints_elem is not None
+            else None
+        ),
+    )
+
+
+def _parse_wire_system_constraints(elem: etree._Element) -> WireSystemConstraints:
+    return WireSystemConstraints(group=text(elem, "group") or "", constraints=_parse_wire_mode_constraints(elem))
+
+
+def _parse_wire_abstraction_port(elem: etree._Element) -> WireAbstractionPort:
+    on_initiator_elem = child(elem, "onInitiator")
+    on_target_elem = child(elem, "onTarget")
+    requires_driver_elem = child(elem, "requiresDriver")
+    return WireAbstractionPort(
+        qualifier=parse_qualifier(elem),
+        on_system=[_parse_wire_system_constraints(e) for e in children(elem, "onSystem")],
+        on_initiator=_parse_wire_mode_constraints(on_initiator_elem) if on_initiator_elem is not None else None,
+        on_target=_parse_wire_mode_constraints(on_target_elem) if on_target_elem is not None else None,
+        default_value=text(elem, "defaultValue"),
+        requires_driver=_parse_requires_driver(requires_driver_elem) if requires_driver_elem is not None else None,
+    )
+
+
+def _parse_transactional_mode_constraints(elem: etree._Element) -> TransactionalModeConstraints:
+    presence = text(elem, "presence")
+    initiative_elem = child(elem, "initiative")
+    kind_elem = child(elem, "kind")
+    return TransactionalModeConstraints(
+        presence=Presence(presence) if presence else Presence.OPTIONAL,
+        # initiative defaults to "requires" when absent
+        initiative=elem_text(initiative_elem) or "requires",
+        kind=elem_text(kind_elem),
+        bus_width=text(elem, "busWidth"),
+        protocol=parse_protocol(elem),
+    )
+
+
+def _parse_transactional_system_constraints(elem: etree._Element) -> TransactionalSystemConstraints:
+    return TransactionalSystemConstraints(
+        group=text(elem, "group") or "", constraints=_parse_transactional_mode_constraints(elem)
+    )
+
+
+def _parse_transactional_abstraction_port(elem: etree._Element) -> TransactionalAbstractionPort:
+    on_initiator_elem = child(elem, "onInitiator")
+    on_target_elem = child(elem, "onTarget")
+    return TransactionalAbstractionPort(
+        qualifier=parse_qualifier(elem),
+        on_system=[_parse_transactional_system_constraints(e) for e in children(elem, "onSystem")],
+        on_initiator=(
+            _parse_transactional_mode_constraints(on_initiator_elem) if on_initiator_elem is not None else None
+        ),
+        on_target=_parse_transactional_mode_constraints(on_target_elem) if on_target_elem is not None else None,
+    )
+
+
+def _parse_abstraction_port(elem: etree._Element) -> AbstractionPort:
+    wire_elem = child(elem, "wire")
+    transactional_elem = child(elem, "transactional")
+    return AbstractionPort(
+        logical_name=text(elem, "logicalName") or "",
+        wire=_parse_wire_abstraction_port(wire_elem) if wire_elem is not None else None,
+        transactional=(
+            _parse_transactional_abstraction_port(transactional_elem) if transactional_elem is not None else None
+        ),
+        match=bool_text(elem, "match", False),
+        display_name=text(elem, "displayName"),
+        short_description=text(elem, "shortDescription"),
+        description=text(elem, "description"),
+        vendor_extensions=parse_vendor_extensions(elem),
+    )

ipxact_compiler-0.1.0/src/ipxact/parser/busdefinition_parser.py

@@ -0,0 +1,39 @@
+from __future__ import annotations
+
+from lxml import etree
+
+from ..schema.busdefinition import BusDefinition
+from .common_parser import (
+    bool_text,
+    child,
+    parse_assertions,
+    parse_choices,
+    parse_parameters,
+    parse_texts,
+    parse_vendor_extensions,
+    parse_vlnv,
+    parse_vlnv_ref,
+    text,
+)
+
+
+def parse_busdefinition(root: etree._Element) -> BusDefinition:
+    """Parse an ipxact:busDefinition root element into a BusDefinition object."""
+    extends_elem = child(root, "extends")
+    return BusDefinition(
+        vlnv=parse_vlnv(root),
+        direct_connection=bool_text(root, "directConnection", False),
+        is_addressable=bool_text(root, "isAddressable", False),
+        broadcast=bool_text(root, "broadcast"),
+        extends=parse_vlnv_ref(extends_elem) if extends_elem is not None else None,
+        max_initiators=text(root, "maxInitiators"),
+        max_targets=text(root, "maxTargets"),
+        system_group_names=parse_texts(root, "systemGroupNames", "systemGroupName"),
+        choices=parse_choices(root),
+        parameters=parse_parameters(root),
+        assertions=parse_assertions(root),
+        display_name=text(root, "displayName"),
+        short_description=text(root, "shortDescription"),
+        description=text(root, "description"),
+        vendor_extensions=parse_vendor_extensions(root),
+    )