Method to_python_method

py/generate_bidi.py:200–383

Generate Python method code for this command. Args: enhancements: Dictionary with enhancement rules for this method

(self, enhancements: dict[str, Any] | 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
        # (This is used unless there's no required_params, in which case all params are optional)
        if self.required_params:
            method_snake = self._camel_to_snake(self.name)
            for param_name, snake_param in param_names:
                if param_name in self.required_params:
                    body += f"        if {snake_param} is None:\n"
                    msg = f"{method_snake}() missing required argument:"
                    error_message = f"{msg} {snake_param!r}"
                    body += f"            raise TypeError({error_message!r})\n"
            body += "\n"