Class CddlCommand

py/generate_bidi.py:184–412

Represents a CDDL command definition.

@dataclass
class CddlCommand:
    """Represents a CDDL command definition."""

    module: str
    name: str
    params: dict[str, str] = field(default_factory=dict)
    required_params: set[str] = field(default_factory=set)
    result: str | None = None
    description: str = ""

    def to_python_method(self, enhancements: dict[str, Any] | None = None) -> str:
        """Generate Python method code for this command.

        Args:
            enhancements: Dictionary with enhancement rules for this method
        """
        enhancements = enhancements or {}
        method_name = self._camel_to_snake(self.name)

        # Build parameter list with type hints
        # Check if there's a params_override for user-friendly named arguments
        params_to_use = self.params
        if "params_override" in enhancements:
            params_to_use = enhancements["params_override"]

        param_strs = []
        param_names = []  # Keep track of parameter names for later use
        for param_name, param_type in params_to_use.items():
            if param_type in ["bool", "str", "int"]:
                python_type = param_type
            else:
                python_type = CddlType.get_annotation(param_type)
            snake_param = self._camel_to_snake(param_name)
            param_names.append((param_name, snake_param))
            param_strs.append(f"{snake_param}: {python_type} | None = None")

        if param_strs:
            # Check if full signature would exceed line length limit (120 chars)
            single_line_signature = f"    def {method_name}(self, {', '.join(param_strs)}):"
            if len(single_line_signature) > 120:
                # Format parameters on multiple lines
                body = f"    def {method_name}(\n"
                body += "        self,\n"
                for i, param_str in enumerate(param_strs):
                    if i < len(param_strs) - 1:
                        body += f"        {param_str},\n"
                    else:
                        body += f"        {param_str},\n"
                body += "    ):\n"
            else:
                param_list = "self, " + ", ".join(param_strs)
                body = f"    def {method_name}({param_list}):\n"
        else:
            body = f"    def {method_name}(self):\n"
        docstring = enhancements.get("docstring") or self.description or f"Execute {self.module}.{self.name}."
        body += _emit_docstring(docstring, 8)

        # Add automatic validation for required parameters