ssc_codegen 0.37.2__tar.gz → 0.39.0__tar.gz

{ssc_codegen-0.37.2 → ssc_codegen-0.39.0}/.gitignore

@@ -133,9 +133,10 @@ dmypy.json
 # Pyre type checker
 .pyre/
 
-# project
-test_schemas/
-.idea/.gitignore
+# project
+test_schemas/
+graphify-out/
+.idea/.gitignore
 .idea/.name
 .idea/misc.xml
 .idea/modules.xml
@@ -156,4 +157,5 @@ go.work.sum
 /tests/go/scratch/
 
 # slopmachines
-.claude/*
+.claude/*
+.scratch/*

{ssc_codegen-0.37.2 → ssc_codegen-0.39.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: ssc_codegen
-Version: 0.37.2
+Version: 0.39.0
 Summary: Python-dsl code converter to html parser for web scraping 
 Project-URL: Documentation, https://github.com/vypivshiy/selector_schema_codegen#readme
 Project-URL: Issues, https://github.com/vypivshiy/selector_schema_codegen/issues
@@ -42,7 +42,8 @@ Code generator for web scraping parsers. Describe HTML extraction rules in a dec
 
 - Declarative DSL based on KDL 2.0 syntax
 - Static type checking and linting before code generation
-- Multiple output targets: Python (bs4, lxml, parsel, selectolax), JavaScript (DOM API)
+- Multiple output targets: Python (bs4, lxml, parsel, selectolax), JavaScript (DOM API), Go (goquery)
+- Typed user extensions with lazy target imports and runtime helpers
 - Struct types: `item`, `list`, `dict`, `table`, `flat`
 - LLM-friendly: system prompt + linter loop for AI-assisted schema generation
 
@@ -154,37 +155,47 @@ curl https://books.toscrape.com/ | ssc-gen health examples/booksToScrape.kdl:Mai
 LLM agents can generate and validate `.kdl` schemas automatically using the
 linter feedback loop.
 
-### In chats (ChatGPT, Claude, etc.)
-
-Use [SYSTEM_PROMPT.md](SYSTEM_PROMPT.md) as system prompt. After generation,
-run `ssc-gen check -f json` and send errors back to the LLM for correction.
-
 ### In AI-powered IDEs (Claude Code, Cursor, opencode, etc.)
 
-Use the skills under [.agents/skills/](.agents/skills/):
+Project works through `agents + skills`. Use skills under [.agents/skills/](.agents/skills/):
 
 - **`sscgen-dsl`** — HTML scraping schemas (`css`, `text`, `(item)struct`,
   `(list)struct`, `(table)struct`, predicates, `jsonify`).
 - **`sscgen-rest`** — REST/JSON API clients (`(rest)struct`, `@request`,
   `@error`, typed placeholders).
-- **`sscgen-openapi`** — convert OpenAPI/Swagger specs into `.kdl`.
 
 ## Development
 
 ```bash
 uv sync                  # install dependencies
 uv build --wheel         # build wheel
-uv run pytest            # run tests
 uv run ruff check ssc_codegen/
+uv run mypy ssc_codegen/
 ```
 
-### Test dependencies
-
-Python tests require only `uv sync`. JS integration tests additionally need:
+### Running tests
 
 ```bash
-npm install      # installs jsdom (dev dependency in package.json)
+# Run full test suite
+uv run pytest
+
+# Run full test suite in parallel (faster, recommended)
+uv run pytest -n auto
+
+# Fast test run: skip external toolchains (Rust cargo, Go, Node.js)
+uv run pytest -m "not toolchain"
+
+# Run only toolchain tests (Go, Rust, JavaScript integration)
+uv run pytest -m toolchain
 ```
 
-Node.js must be installed and available as `node` in PATH. JS tests are automatically skipped if Node.js is not found.
+### Test dependencies
+
+Python and parser tests require only `uv sync`.
+
+Integration smoke tests for external compilers are skipped automatically if their toolchains are missing:
+
+- **JavaScript**: Requires Node.js in PATH and `npm install` (`jsdom` in `package.json`).
+- **Go**: Requires `go` in PATH.
+- **Rust**: Requires `cargo` in PATH.
 ```

{ssc_codegen-0.37.2 → ssc_codegen-0.39.0}/README.md

@@ -10,7 +10,8 @@ Code generator for web scraping parsers. Describe HTML extraction rules in a dec
 
 - Declarative DSL based on KDL 2.0 syntax
 - Static type checking and linting before code generation
-- Multiple output targets: Python (bs4, lxml, parsel, selectolax), JavaScript (DOM API)
+- Multiple output targets: Python (bs4, lxml, parsel, selectolax), JavaScript (DOM API), Go (goquery)
+- Typed user extensions with lazy target imports and runtime helpers
 - Struct types: `item`, `list`, `dict`, `table`, `flat`
 - LLM-friendly: system prompt + linter loop for AI-assisted schema generation
 
@@ -122,37 +123,47 @@ curl https://books.toscrape.com/ | ssc-gen health examples/booksToScrape.kdl:Mai
 LLM agents can generate and validate `.kdl` schemas automatically using the
 linter feedback loop.
 
-### In chats (ChatGPT, Claude, etc.)
-
-Use [SYSTEM_PROMPT.md](SYSTEM_PROMPT.md) as system prompt. After generation,
-run `ssc-gen check -f json` and send errors back to the LLM for correction.
-
-### In AI-powered IDEs (Claude Code, Cursor, opencode, etc.)
-
-Use the skills under [.agents/skills/](.agents/skills/):
+### In AI-powered IDEs (Claude Code, Cursor, opencode, etc.)
+
+Project works through `agents + skills`. Use skills under [.agents/skills/](.agents/skills/):
 
 - **`sscgen-dsl`** — HTML scraping schemas (`css`, `text`, `(item)struct`,
   `(list)struct`, `(table)struct`, predicates, `jsonify`).
 - **`sscgen-rest`** — REST/JSON API clients (`(rest)struct`, `@request`,
   `@error`, typed placeholders).
-- **`sscgen-openapi`** — convert OpenAPI/Swagger specs into `.kdl`.
 
 ## Development
 
 ```bash
 uv sync                  # install dependencies
 uv build --wheel         # build wheel
-uv run pytest            # run tests
 uv run ruff check ssc_codegen/
+uv run mypy ssc_codegen/
 ```
 
-### Test dependencies
-
-Python tests require only `uv sync`. JS integration tests additionally need:
+### Running tests
 
 ```bash
-npm install      # installs jsdom (dev dependency in package.json)
+# Run full test suite
+uv run pytest
+
+# Run full test suite in parallel (faster, recommended)
+uv run pytest -n auto
+
+# Fast test run: skip external toolchains (Rust cargo, Go, Node.js)
+uv run pytest -m "not toolchain"
+
+# Run only toolchain tests (Go, Rust, JavaScript integration)
+uv run pytest -m toolchain
 ```
 
-Node.js must be installed and available as `node` in PATH. JS tests are automatically skipped if Node.js is not found.
+### Test dependencies
+
+Python and parser tests require only `uv sync`.
+
+Integration smoke tests for external compilers are skipped automatically if their toolchains are missing:
+
+- **JavaScript**: Requires Node.js in PATH and `npm install` (`jsdom` in `package.json`).
+- **Go**: Requires `go` in PATH.
+- **Rust**: Requires `cargo` in PATH.
 ```

{ssc_codegen-0.37.2 → ssc_codegen-0.39.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "ssc_codegen"
-version = "0.37.2"
+version = "0.39.0"
 description = "Python-dsl code converter to html parser for web scraping "
 readme = "README.md"
 requires-python = ">=3.10"
@@ -64,11 +64,18 @@ dev = [
     "mypy>=1.14.1",
     "parsel>=1.9.1",
     "pytest>=8.3.4",
+    "pytest-xdist>=3.6.0",
     "respx>=0.23.1",
     "responses>=0.25",
     "ruff>=0.9.3",
     "selectolax>=0.3.27",
 ]
+docs = [
+    "mkdocs>=1.6.0",
+    "mkdocs-material>=9.5.0",
+    "mkdocstrings[python]>=0.27.0",
+    "mkdocs-click>=0.8.1",
+]
 
 [tool.ruff]
 target-version = "py310"
@@ -108,3 +115,10 @@ omit = [
     "*/scripts/*",
     "*/tests/*"
 ]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+markers = [
+    "toolchain: Tests requiring external toolchains (Rust cargo, Go compiler, Node.js)",
+]
+

ssc_codegen-0.39.0/ssc_codegen/__init__.py

@@ -0,0 +1,51 @@
+"""KDL-based schema code generator for web scraping parsers.
+
+This package provides tools for parsing KDL v2.1 schemas into an intermediate
+AST, validating selectors and pipelines, and compiling ASTs into native parser
+code for Python (bs4, lxml, parsel, selectolax), JavaScript (DOM API), and Go
+(goquery + net/http).
+
+Key API symbols:
+    parse_module: Parse KDL schema source into a Module AST and diagnostics.
+    format_diagnostics: Format diagnostics into text or JSON output.
+    resolve: Resolve a TargetSpec into a concrete TargetProfile.
+    TargetSpec: User-supplied target backend specification.
+    TargetProfile: Validated target backend profile with converter factory.
+    ResolutionError: Raised when target resolution or configuration fails.
+    ParseError: Raised on DSL syntax or schema parsing errors.
+    BuildTimeError: Raised on type mismatches or unresolved references at build time.
+    check_struct_health: Verify selector match rates against real HTML.
+    HealthResult: Container holding selector health statistics.
+    run_scout: Perform regex and CSS reconnaissance on raw HTML.
+    run_discover: High-level page structure analysis for selector discovery.
+    ScoutResult: Detailed results from an HTML scout run.
+    DiscoverResult: Aggregated structural overview of an HTML document.
+"""
+
+from __future__ import annotations
+
+from ssc_codegen.core.format import format_diagnostics
+from ssc_codegen.core.reader import parse_module
+from ssc_codegen.exceptions import BuildTimeError, ParseError
+from ssc_codegen.explore import DiscoverResult, ScoutResult, run_discover, run_scout
+from ssc_codegen.health import HealthResult, check_struct_health
+from ssc_codegen.targets.profile import TargetProfile
+from ssc_codegen.targets.resolver import ResolutionError, resolve
+from ssc_codegen.targets.spec import TargetSpec
+
+__all__ = [
+    "BuildTimeError",
+    "DiscoverResult",
+    "HealthResult",
+    "ParseError",
+    "ResolutionError",
+    "ScoutResult",
+    "TargetProfile",
+    "TargetSpec",
+    "check_struct_health",
+    "format_diagnostics",
+    "parse_module",
+    "resolve",
+    "run_discover",
+    "run_scout",
+]

{ssc_codegen-0.37.2 → ssc_codegen-0.39.0}/ssc_codegen/ast/__init__.py

@@ -1,9 +1,19 @@
 # mypy: ignore-errors
-"""
-AST nodes for the KDL Schema DSL.
+"""Intermediate representation (AST) node definitions for the KDL Schema DSL.
+
+Provides strongly-typed dataclass nodes representing all language constructs,
+pipeline operations, predicates, REST endpoint definitions, and type models.
+
+Examples:
+    ```python
+    from ssc_codegen.ast import CssSelect, Field, Module, Struct, Text
 
-Import everything from here:
-    from kdl_ast import Module, Field, CssSelect, ...
+    module = Module(source_file="schema.kdl")
+    struct = Struct(name="Product")
+    field = Field(name="title", body=[CssSelect(queries=["h1"]), Text()])
+    struct.body.append(field)
+    module.body.append(struct)
+    ```
 """
 
 from .types import VariableType, StructType, TypeInfo, VT
@@ -20,7 +30,16 @@ from .module import (
     Utilities,
 )
 
-from .function import FunctionDef
+from .function import FunctionDef
+
+from .extension import (
+    ExtensionCall,
+    ExtensionDef,
+    ExtensionHelper,
+    ExtensionImport,
+    ExtensionTarget,
+    ExtensionType,
+)
 
 from .typedef import TypeDef, TypeDefField
 
@@ -150,7 +169,14 @@ __all__ = [
     "Docstring",
     "Utilities",
     # function
-    "FunctionDef",
+    "FunctionDef",
+    # extensions
+    "ExtensionCall",
+    "ExtensionDef",
+    "ExtensionHelper",
+    "ExtensionImport",
+    "ExtensionTarget",
+    "ExtensionType",
     # typedef
     "TypeDef",
     "TypeDefField",

ssc_codegen-0.39.0/ssc_codegen/ast/array.py

@@ -0,0 +1,124 @@
+"""AST nodes for array and list collection operations.
+
+This module defines nodes operating on lists of elements (`is_array=True`):
+- `Index`: Extracts a single element at a 0-based offset (`first`, `last`, `index N`).
+- `Slice`: Extracts a sublist slice `[start:end]`.
+- `Len`: Returns the integer count of elements in a list.
+- `Unique`: Deduplicates elements in a list with optional order preservation (`keep_order`).
+"""
+
+from __future__ import annotations
+from dataclasses import dataclass, field
+
+from .base import Node
+from .types import TypeInfo, VariableType
+
+# Index, First, Last, Slice accept LIST_AUTO / return AUTO or LIST_AUTO.
+# Concrete types are resolved by the builder from the cursor type via
+# VariableType.scalar / VariableType.as_list helpers.
+
+
+@dataclass
+class Index(Node):
+    """Extracts a single element from a list by its index position.
+
+    Index is 0-based; negative indices count backwards from the end of the list (`-1` is the last item).
+    Target-specific backends without native negative or 0-based indexing must adapt expressions
+    accordingly during code generation (e.g. converting negative index `-k` to `len(arr) - k`,
+    or adding `+1` for 1-based index targets).
+
+    Attributes:
+        i: Zero-based integer index (negative values index backwards from the end).
+
+    Examples:
+        - KDL: `index 0`, `first`, `last`
+        - Python: `v1 = v[0]`, `v1 = v[-1]`
+        - JavaScript: `const v1 = v[0];`, `const v1 = v[v.length - 1];`
+        - Go: `v1 := v[0]`, `v1 := v[len(v)-1]`
+    """
+
+    i: int = 0
+    accept_type_info: TypeInfo = field(
+        default_factory=lambda: TypeInfo(base=VariableType.AUTO)
+    )
+    ret_type_info: TypeInfo = field(
+        default_factory=lambda: TypeInfo(base=VariableType.AUTO)
+    )
+
+
+@dataclass
+class Slice(Node):
+    """Extracts a sublist slice from start to end index `[start:end]`.
+
+    Indices are 0-based with half-open interval semantics `[start, end)`. Negative values
+    count backwards from the end of the collection. Backend codegen must adapt boundary
+    calculations to target language slice conventions.
+
+    Attributes:
+        start: Starting index of the slice (0-based, inclusive).
+        end: Ending index of the slice (0-based, exclusive).
+
+    Examples:
+        - KDL: `slice 0 5`
+        - Python: `v1 = v[0:5]`
+        - JavaScript: `const v1 = v.slice(0, 5);`
+        - Go: `v1 := v[0:5]`
+    """
+
+    start: int = 0
+    end: int = 0
+    accept_type_info: TypeInfo = field(
+        default_factory=lambda: TypeInfo(base=VariableType.AUTO)
+    )
+    ret_type_info: TypeInfo = field(
+        default_factory=lambda: TypeInfo(base=VariableType.AUTO, is_array=True)
+    )
+
+
+@dataclass
+class Len(Node):
+    """Calculates the number of elements in a list.
+
+    Examples:
+        - KDL: `len`
+        - Python: `v1 = len(v)`
+        - JavaScript: `const v1 = v.length;`
+        - Go: `v1 := len(v)`
+    """
+
+    accept_type_info: TypeInfo = field(
+        default_factory=lambda: TypeInfo(base=VariableType.AUTO)
+    )
+    ret_type_info: TypeInfo = field(
+        default_factory=lambda: TypeInfo(base=VariableType.INT)
+    )
+
+
+@dataclass
+class Unique(Node):
+    """Deduplicates string elements in a list.
+
+    When `keep_order=True`, the generator preserves the first-seen item order (e.g. `list(dict.fromkeys(v))`
+    in Python or helper in Go). When `keep_order=False`, backends may use faster unordered deduplication
+    (e.g. `list(set(v))` if target language optimizes set conversion).
+
+    Attributes:
+        keep_order: Flag indicating whether to preserve the original element order.
+
+    Examples:
+        - KDL: `unique`
+        - Python (keep_order=True): `v1 = list(dict.fromkeys(v))`
+        - Python (keep_order=False): `v1 = list(set(v))`
+        - JavaScript: `const v1 = Array.from(new Set(v));`
+        - Go: `v1 := stdUnique(v)`
+    """
+
+    keep_order: bool = False
+    accept_type_info: TypeInfo = field(
+        default_factory=lambda: TypeInfo(base=VariableType.STRING)
+    )
+    ret_type_info: TypeInfo = field(
+        default_factory=lambda: TypeInfo(
+            base=VariableType.STRING, is_array=True
+        )
+    )

ssc_codegen-0.39.0/ssc_codegen/ast/base.py

@@ -0,0 +1,85 @@
+from __future__ import annotations
+import warnings
+from dataclasses import dataclass, field
+
+from kdlquery.parser import Span
+
+from .types import TypeInfo, VariableType
+
+
+@dataclass
+class Node:
+    """Base abstract syntax tree node for intermediate representations.
+
+    All AST nodes inherit from this class to participate in traversal,
+    type propagation, and code generation passes.
+
+    Attributes:
+        ret_type_info: Resolved type metadata of the value returned by this node.
+        accept_type_info: Resolved type metadata of the input value accepted by this node.
+        parent: Reference to the parent AST node (excluded from representation and comparison).
+        body: Ordered list of child AST nodes contained within this node.
+        span: Optional source code location tracking (line, column) from the KDL source.
+    """
+
+    ret_type_info: TypeInfo = field(
+        default_factory=lambda: TypeInfo(base=VariableType.AUTO)
+    )
+    accept_type_info: TypeInfo = field(
+        default_factory=lambda: TypeInfo(base=VariableType.AUTO)
+    )
+    parent: Node | None = field(default=None, repr=False)
+    body: list[Node] = field(default_factory=list)
+    span: Span | None = field(default=None, repr=False, compare=False)
+
+    # ── backport properties (deprecated: prefer the TypeInfo fields) ───────────
+    @property
+    def ret(self) -> VariableType:
+        """Scalar return type shortcut.
+
+        Warning:
+            Deprecated: Use `ret_type_info.base` instead.
+
+        Returns:
+            The base `VariableType` of `ret_type_info`.
+        """
+        warnings.warn(
+            "Node.ret is deprecated; use Node.ret_type_info.base instead.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        return self.ret_type_info.base
+
+    @property
+    def accept(self) -> VariableType:
+        """Scalar accepted input type shortcut.
+
+        Warning:
+            Deprecated: Use `accept_type_info.base` instead.
+
+        Returns:
+            The base `VariableType` of `accept_type_info`.
+        """
+        warnings.warn(
+            "Node.accept is deprecated; use Node.accept_type_info.base instead.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        return self.accept_type_info.base
+
+    @property
+    def type_info(self) -> TypeInfo:
+        """TypeInfo alias shortcut.
+
+        Warning:
+            Deprecated: Use `ret_type_info` instead.
+
+        Returns:
+            The `ret_type_info` instance of this node.
+        """
+        warnings.warn(
+            "Node.type_info is deprecated; use Node.ret_type_info instead.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        return self.ret_type_info

ssc_codegen-0.39.0/ssc_codegen/ast/cast.py

@@ -0,0 +1,138 @@
+"""AST nodes for scalar type casting, JSON deserialization, and struct nesting.
+
+This module defines data conversion operations within field pipelines:
+- `ToInt`: Casts string/numeric values to 64-bit integer (`int` / `int64`).
+- `ToFloat`: Casts string/numeric values to 64-bit float (`float` / `float64`).
+- `ToBool`: Converts input to a boolean truth value.
+- `Jsonify`: Deserializes JSON string into a strongly-typed `JsonDef` model with key remapping.
+- `Nested`: Instantiates another parser struct passing current DOM element and invokes `.parse()`.
+"""
+
+from __future__ import annotations
+from dataclasses import dataclass, field
+
+from .base import Node
+from .types import TypeInfo, VariableType
+
+
+@dataclass
+class ToInt(Node):
+    """Casts string or numeric values directly to integers.
+
+    Validation of the input format is not performed prior to casting; the operation directly
+    attempts conversion and is allowed to fail with a runtime error (e.g. `ValueError` in Python,
+    `NaN` / `parseInt` error in JS, `strconv.Atoi` error in Go) unless protected by a `Fallback` node.
+
+    Examples:
+        - KDL: `to-int`
+        - Python: `v1 = int(v)`
+        - JavaScript: `const v1 = parseInt(v, 10);`
+        - Go: `v1, _ := strconv.Atoi(v)`
+    """
+
+    accept_type_info: TypeInfo = field(
+        default_factory=lambda: TypeInfo(base=VariableType.STRING)
+    )
+    ret_type_info: TypeInfo = field(
+        default_factory=lambda: TypeInfo(base=VariableType.INT)
+    )
+
+
+@dataclass
+class ToFloat(Node):
+    """Casts string or numeric values directly to floating-point numbers.
+
+    Validation of the input format is not performed prior to casting; the operation directly
+    invokes standard target language float parsing and may raise a runtime error unless
+    handled by `Fallback`.
+
+    Examples:
+        - KDL: `to-float`
+        - Python: `v1 = float(v)`
+        - JavaScript: `const v1 = parseFloat(v);`
+        - Go: `v1, _ := strconv.ParseFloat(v, 64)`
+    """
+
+    accept_type_info: TypeInfo = field(
+        default_factory=lambda: TypeInfo(base=VariableType.STRING)
+    )
+    ret_type_info: TypeInfo = field(
+        default_factory=lambda: TypeInfo(base=VariableType.FLOAT)
+    )
+
+
+@dataclass
+class ToBool(Node):
+    """Casts input values to boolean truth values.
+
+    Scalar values are cast using standard truthiness rules of the target language.
+
+    Examples:
+        - KDL: `to-bool`
+        - Python: `v1 = bool(v)`
+        - JavaScript: `const v1 = Boolean(v);`
+        - Go: `v1 := bool(len(v) > 0)`
+    """
+
+    accept_type_info: TypeInfo = field(
+        default_factory=lambda: TypeInfo(base=VariableType.AUTO)
+    )
+    ret_type_info: TypeInfo = field(
+        default_factory=lambda: TypeInfo(base=VariableType.BOOL)
+    )
+
+
+@dataclass
+class Jsonify(Node):
+    """Deserializes a JSON string into a structured model per a `JsonDef` schema.
+
+    Parses JSON text into an object or array. If `path` is specified, extracts the nested
+    sub-tree first. If the referenced `JsonDef` contains field aliases (`from="..."`),
+    remapping logic is executed to project keys into canonical schema properties.
+    Allowed to fail with a JSON parsing error if input is malformed.
+
+    Attributes:
+        schema_name: Identifier of the target `JsonDef` mapping schema.
+        path: Optional dot-notation path to extract from the parsed JSON before schema projection.
+
+    Examples:
+        - KDL: `jsonify User`, `jsonify Article path="data.item"`
+        - Python: `v1 = json.loads(v)` + `ssc_remap_json_keys(v1, ...)`
+        - JavaScript: `const v1 = sscRemapJsonKeys(JSON.parse(v), ...);`
+        - Go: `var v1 UserJson; json.Unmarshal([]byte(v), &v1)`
+    """
+
+    schema_name: str = ""
+    path: str | None = None
+    accept_type_info: TypeInfo = field(
+        default_factory=lambda: TypeInfo(base=VariableType.STRING)
+    )
+    ret_type_info: TypeInfo = field(
+        default_factory=lambda: TypeInfo(base=VariableType.JSON)
+    )
+
+
+@dataclass
+class Nested(Node):
+    """Passes the current document to another struct parser and returns its result.
+
+    Instantiates the target parser struct passing the current DOM element as the root document,
+    then executes its `.parse()` entry point.
+
+    Attributes:
+        struct_name: Identifier of the target parser struct.
+
+    Examples:
+        - KDL: `nested AuthorInfo`
+        - Python: `v1 = AuthorInfo(v).parse()`
+        - JavaScript: `const v1 = new AuthorInfo(v).parse();`
+        - Go: `v1 := NewAuthorInfo(v).Parse()`
+    """
+
+    struct_name: str = ""
+    accept_type_info: TypeInfo = field(
+        default_factory=lambda: TypeInfo(base=VariableType.DOCUMENT)
+    )
+    ret_type_info: TypeInfo = field(
+        default_factory=lambda: TypeInfo(base=VariableType.NESTED)
+    )