class_docstr: Takes command-line input and transforms it into hyperopt search space
  An example of command-line input:
  --algorithms=ftrl,sgd --l2=1e-8..1e-4~LO -l=0.01..10~L --ftrl_beta=0.01..1 --passes=1..10~I -q=SE+SZ+DR,SE~O
code: def _process_vw_argument(self, arg, value, algorithm):
      try:
          distr_part = self.distr_pattern.findall(value)[0]
      except IndexError:
          distr_part = ""
      range_part = self.range_pattern.findall(value)[0]
      is_continuous = ".." in range_part
  
      ocd = self.only_continuous.findall(value)
      if not is_continuous and len(ocd) > 0 and ocd[0] != "":
          raise ValueError(
              (
                  "Need a range instead of a list of discrete values to define "
                  "uniform or log-uniform distribution. "
                  "Please, use [min..max]%s form"
              )
              % (distr_part)
          )
  
      if is_continuous and arg == "-q":
          raise ValueError(
              (
                  "You must directly specify namespaces for quadratic features "
                  "as a list of values, not as a parametric distribution"
              )
          )
  
      hp_choice_name = "_".join([algorithm, arg.replace("-", "")])
  
      try_omit_zero = "O" in distr_part
      distr_part = distr_part.replace("O", "")
  
      if is_continuous:
          if arg == "--lrq" or arg == "--lrqfa":
              possible_values = []
              for current_int in range_part.split(","):
                  possible_values_current = []
                  if "+" in current_int and arg == "--lrq":
                      list_range_part = current_int.split("+")
                      for range_part_k in list_range_part:
                          vmin, vmax = [
                              int(re.sub("[^0-9]", "", i))
                              for i in range_part_k.split("..")
                          ]
                          ns = re.sub("[^a-zA-Z]+", "", range_part_k)
                          possible_values_current.extend(
                              [
                                  f"{ns}{v}"
                                  for v in range(vmin, vmax + 1)
                              ]
                          )
                      n = len(list_range_part)
                      possible_values.extend(
                          self._create_combinations(
                              possible_values_current, n, arg
                          )
                      )
                  else:
                      vmin, vmax = [
                          int(re.sub("[^0-9]", "", i))
                          for i in current_int.split("..")
                      ]
                      ns = re.sub("[^a-zA-Z]+", "", current_int)
                      possible_values.extend(
                          [f"{ns}{v}" for v in range(vmin, vmax + 1)]
                      )
  
              distrib = hp.choice(hp_choice_name, possible_values)
          else:
              vmin, vmax = [float(i) for i in range_part.split("..")]
              if distr_part == "L":
                  distrib = hp.loguniform(
                      hp_choice_name, log(vmin), log(vmax)
                  )
              elif distr_part == "":
                  distrib = hp.uniform(hp_choice_name, vmin, vmax)
              elif distr_part == "I":
                  distrib = scope.int(
                      hp.quniform(hp_choice_name, vmin, vmax, 1)
                  )
              elif distr_part in {"LI", "IL"}:
                  distrib = hp.qloguniform(
                      hp_choice_name, log(vmin), log(vmax), 1
                  )
              else:
                  raise ValueError(
                      "Cannot recognize distribution: %s" % (distr_part)
                  )
  
      else:
          possible_values = range_part.split(",")
          arg_list = ["--lrq", "-q", "--quadratic", "--cubic"]
          if arg in arg_list:
              possible_values = [
                  v.replace("+", f" {arg} ") for v in possible_values
              ]
          distrib = hp.choice(hp_choice_name, possible_values)
      if try_omit_zero:
          hp_choice_name_outer = hp_choice_name + "_outer"
          distrib = hp.choice(hp_choice_name_outer, ["omit", distrib])
  
      return distrib
  
imports: from hyperopt import hp, fmin, tpe, rand, Trials, STATUS_OK
  from hyperopt.pyll import scope
  from sklearn.metrics import roc_curve, auc, log_loss, average_precision_score, hinge_loss, mean_squared_error
  import numpy
  from datetime import datetime
  import subprocess, shlex
  from math import exp, log
  import argparse
  import re
  import logging
  import json
  from matplotlib import pyplot
  import itertools
  from collections import Counter
label_desc: Use image node_id 3 for calling the HyperoptSpaceConstructor obj's underlying member method code with example usage: obj._process_vw_argument(arg, value, algorithm) and returns: distrib