return "Unknown error";
        }

        final Supplier<String> stacktraceString = () -> {
            final StringBuilder sb = new StringBuilder();
            if (StringUtil.isBlank(cause.getMessage())) {
                sb.append(cause.getClass().getName());
            } else {
                sb.append(cause.getMessage());
            }

            }
        }
        return LaResponseUtil.getResponse().encodeURL(sb.toString());
    }

    public static String sdh(final String input) {
        if (StringUtil.isBlank(input)) {
            return input;
        }
        return ComponentUtil.getDocumentHelper().encodeSimilarDocHash(input);
    }

    public static String join(final Object input) {

        return userBhv.selectEntity(cb -> {
            cb.query().setName_Equal(username);
        });
    }

    public void store(final User user) {
        if (StringUtil.isBlank(user.getSurname())) {
            user.setSurname(user.getName());
        }

        ComponentUtil.getAuthenticationManager().insert(user);

        userBhv.insertOrUpdate(user, op -> {

        }
    }

    private static int process(final Options options) {
        final Crawler crawler = ComponentUtil.getComponent(Crawler.class);

        if (StringUtil.isBlank(options.sessionId)) {
            // use a default session id
            final SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMddHHmmss");
            options.sessionId = sdf.format(new Date());
        } else {

            dfos = out;
            CopyUtil.copy(in, out);
            out.flush();

            Extractor extractor = StringUtil.isBlank(mimeType) ? null : extractorFactory.getExtractor(mimeType);
            if (extractor == null) {
                final String detectedMimeType = getMimeType(out);

            }
        }
        return redirect(getClass()); // no-op
    }

    private CurlRequest getCurlRequest(final String header) {
        if (StringUtil.isBlank(header)) {
            return null;
        }

        final String[] values = header.split(" ");
        if (values.length != 2) {
            return null;
        }

        final String path;

"""

import argparse
import os


def should_convert(var_name: str,
                   blacklist: list[str] | None,
                   whitelist_prefix: list[str] | None):
  """Check the variable name against white/black lists."""
  if blacklist and var_name in blacklist:
    return False
  if not whitelist_prefix:
    return True

  for prefix in whitelist_prefix:
    if var_name.startswith(prefix):
      return True

    protected boolean isEmptyArray(final String[] values) {
        if (values == null || values.length == 0) {
            return true;
        }
        return stream(values).get(stream -> stream.allMatch(StringUtil::isBlank));
    }

    protected static String[] simplifyArray(final String[] values) {
        return stream(values).get(stream -> stream.filter(StringUtil::isNotBlank).distinct().toArray(n -> new String[n]));
    }

            }
            builder.endObject();
            return builder;
        }, XContentType.JSON)) {
            message = ((ByteArrayOutputStream) out).toString(Constants.UTF_8);
            if (StringUtil.isBlank(message)) {
                message = "{}";
            }
        } catch (final IOException e) {
            throw new IORuntimeException(e);
        }
    }

    public int getStatus() {

    }

    protected String getScriptType(final DataStoreParams paramMap) {
        final String value = paramMap.getAsString(SCRIPT_TYPE);
        if (StringUtil.isBlank(value)) {
            return Constants.DEFAULT_SCRIPT;
        }
        return value;
    }

    protected Object convertValue(final String scriptType, final String template, final Map<String, Object> paramMap) {