# Bind the extra arguments (args and kwargs) starting from parameter 1
                bindings = {}
                allowed_params = callable_expr.arg_specs[1:]
                allowed_names = {spec.name for spec in allowed_params}
                func_name = getattr(func, "__name__", "callable")

                # Positional arguments:
                for idx, val in enumerate(args):
                    if idx >= len(allowed_params):
                        raise TypeError(
                            f"too many positional arguments for {func_name}: expected {len(allowed_params)}, got {len(args)}"
                        )
                    param_name = allowed_params[idx].name
                    bindings[param_name] = val

                # Keyword arguments:
                for key, val in kwargs.items():
                    if key not in allowed_names:
                        raise TypeError(
                            f"{func_name}() got an unexpected keyword argument '{key}'"
                        )
                    if key in bindings:
                        raise TypeError(
                            f"{func_name}() got multiple values for argument '{key}'"
                        )
                    bindings[key] = val

                # Bind defaults for other parameters (excluding the first 'row' parameter)
                for spec in allowed_params:
                    if (
                        spec.name not in bindings
                        and spec.default_value is not inspect.Parameter.empty
                    ):
                        bindings[spec.name] = spec.default_value

        bindings = {}
        pos_idx = 0
        arg_names = {spec.name for spec in self.arg_specs}

        # Validate unexpected keyword arguments
        for key in kwargs:
            if key not in arg_names:
                raise TypeError(f"got an unexpected keyword argument '{key}'")

        def to_expr(val):
            if isinstance(val, ex.Expression):
                return val
            return ex.const(val)

        for spec in self.arg_specs:
            if spec.is_varargs:
                raise NotImplementedError(
                    "varargs in compiled python functions is not supported"
                )

            if pos_idx < len(args):
                if spec.name in kwargs:
                    raise TypeError(f"got multiple values for keyword argument '{spec.name}'")
                bindings[spec.name] = to_expr(args[pos_idx])
                pos_idx += 1
            elif spec.name in kwargs:
                bindings[spec.name] = to_expr(kwargs[spec.name])
            elif spec.default_value is not inspect.Parameter.empty:
                bindings[spec.name] = to_expr(spec.default_value)
            else:
                raise TypeError(f"missing required argument: '{spec.name}'")

        if pos_idx < len(args):
            raise TypeError(
                f"too many positional arguments: expected {len(self.arg_specs)}, got {len(args)}"
            )

        return self.expr.bind_variables(bindings)