{
  "module": "hexa.parse_abc",
  "content": {
    "path": "hexa.parse_abc",
    "docstring": "# Summary\n\nParse an ABC Python module into a hexa PortNode tree.\n\nABC classes become port nodes.  A nested-struct attribute is expressed as a\n``@dataclass`` annotation on an ABC port (e.g. ``source: ExtractionSource``\nwhere ``ExtractionSource`` is a ``@dataclass``); the dataclass's fields are\nexpanded into a nested ``attributes`` entry.\n\n---\n# Notes\n\n- Accepts a file path, a module import string, or an already-loaded module.",
    "objects": {
      "ConfigValue": {
        "name": "ConfigValue",
        "kind": "attribute",
        "path": "hexa.parse_abc.ConfigValue",
        "signature": null,
        "docstring": null
      },
      "MethodSpec": {
        "name": "MethodSpec",
        "kind": "class",
        "path": "hexa.parse_abc.MethodSpec",
        "signature": "MethodSpec(name: str, args: list[str] = list(), kwargs: dict[str, str] = dict())",
        "docstring": "Specification of a single abstract method.\n\nAttributes:\n    name (str):\n        Name of the method.\n\n    args (list[str]):\n        Positional parameter names.\n\n    kwargs (dict[str, str]):\n        Keyword-only parameter names mapped to their type expressions.",
        "members": {
          "name": {
            "name": "name",
            "kind": "attribute",
            "path": "hexa.parse_abc.MethodSpec.name",
            "signature": null,
            "docstring": null
          },
          "args": {
            "name": "args",
            "kind": "attribute",
            "path": "hexa.parse_abc.MethodSpec.args",
            "signature": null,
            "docstring": null
          },
          "kwargs": {
            "name": "kwargs",
            "kind": "attribute",
            "path": "hexa.parse_abc.MethodSpec.kwargs",
            "signature": null,
            "docstring": null
          }
        }
      },
      "PortNode": {
        "name": "PortNode",
        "kind": "class",
        "path": "hexa.parse_abc.PortNode",
        "signature": "PortNode(name: str, port_cls: str, kind: str = 'leaf', attributes: dict[str, ConfigValue] = dict(), children: list[PortNode] = list(), methods: dict[str, MethodSpec] = dict())",
        "docstring": "A node in the hexa port tree.\n\nEach node is a leaf (no children), a port (has nested port slots), or the\nparent root of the tree. Every node carries a concrete typed shape derived\nfrom an ABC class name.\n\nAttributes:\n    name (str):\n        Slot name, e.g. ``\"parser\"``, ``\"amount_balance\"``.\n\n    port_cls (str):\n        ABC class name that gives this port its shape, e.g.\n        ``\"TransactionParserPort\"``.  Every port has a concrete typed shape.\n\n    kind (str):\n        One of ``\"leaf\"``, ``\"port\"``, or ``\"parent\"``.\n        - ``\"leaf\"``: no children (e.g. ``NumberPort``)\n        - ``\"port\"``: has children (e.g. ``TransactionParserPort``)\n        - ``\"parent\"``: the root of the tree (e.g. ``ExtractionPipeline``)\n\n    attributes (dict[str, ConfigValue]):\n        Annotated attributes: ``name -> type_expr`` for scalars, or a\n        nested ``dict`` of sub-attributes (a struct) for grouped values.\n\n    children (list[PortNode]):\n        Nested port slots.\n\n    methods (dict[str, MethodSpec]):\n        Abstract methods keyed by method name.",
        "members": {
          "name": {
            "name": "name",
            "kind": "attribute",
            "path": "hexa.parse_abc.PortNode.name",
            "signature": null,
            "docstring": null
          },
          "port_cls": {
            "name": "port_cls",
            "kind": "attribute",
            "path": "hexa.parse_abc.PortNode.port_cls",
            "signature": null,
            "docstring": null
          },
          "kind": {
            "name": "kind",
            "kind": "attribute",
            "path": "hexa.parse_abc.PortNode.kind",
            "signature": null,
            "docstring": null
          },
          "attributes": {
            "name": "attributes",
            "kind": "attribute",
            "path": "hexa.parse_abc.PortNode.attributes",
            "signature": null,
            "docstring": null
          },
          "children": {
            "name": "children",
            "kind": "attribute",
            "path": "hexa.parse_abc.PortNode.children",
            "signature": null,
            "docstring": null
          },
          "methods": {
            "name": "methods",
            "kind": "attribute",
            "path": "hexa.parse_abc.PortNode.methods",
            "signature": null,
            "docstring": null
          },
          "find": {
            "name": "find",
            "kind": "function",
            "path": "hexa.parse_abc.PortNode.find",
            "signature": "find(name: str)",
            "docstring": "Find a direct child by slot name.\n\nArgs:\n    name (str):\n        Slot name of the child to look up.\n\nReturns:\n    PortNode | None:\n        The matching child node, or ``None`` if no child has that name."
          },
          "walk": {
            "name": "walk",
            "kind": "function",
            "path": "hexa.parse_abc.PortNode.walk",
            "signature": "walk()",
            "docstring": "Return all nodes in depth-first order (self first).\n\nReturns:\n    list[PortNode]:\n        All nodes of the tree, self first, depth-first."
          },
          "diff": {
            "name": "diff",
            "kind": "function",
            "path": "hexa.parse_abc.PortNode.diff",
            "signature": "diff(other: PortNode, path: str = '')",
            "docstring": "Return a list of human-readable difference strings.\n\nAn empty list means the trees are equal.\n\nArgs:\n    other (PortNode):\n        Tree to compare against.\n\n    path (str):\n        Path prefix used when recursing into nested nodes; defaults to\n        the root path.\n\nReturns:\n    list[str]:\n        Human-readable difference strings, one per discrepancy."
          }
        }
      },
      "parse_abc": {
        "name": "parse_abc",
        "kind": "function",
        "path": "hexa.parse_abc.parse_abc",
        "signature": "parse_abc(module_or_path: str | Path | Any) -> PortNode",
        "docstring": "Parse an ABC Python module into a :class:`PortNode` tree.\n\nABC classes become port nodes.  A nested-struct attribute is expressed as a\n``@dataclass`` annotation on an ABC port (e.g. ``source: ExtractionSource``\nwhere ``ExtractionSource`` is a ``@dataclass``); the dataclass's fields are\nexpanded into a nested ``attributes`` entry.\n\nArgs:\n    module_or_path (str | Path | Any):\n        A file path to a ``.py`` file, a module import string, or a loaded\n        module.\n\nReturns:\n    PortNode:\n        The root node of the tree."
      }
    }
  }
}