docs: def _harvest_validate(self, userkwargs):
          """Validate and Plant user provided arguments
          - Go through and plants the seedlings
            for any user arguments provided.
          - Validate the arguments, cleaning and adapting (valideer wise)
          - Extract negatives "!" arguments
          """
          # the valideer to parse the
          # user arguemnts when watering
          parser = {}
  
          userkwargs.update(self.network_kwargs)
          # a simple set of original provided argument keys (used in IGNORES)
          original_kwargs = set(map(lambda k: k.split('_')[1] if k.find('_')>-1 else k, userkwargs.keys()))
          # list of columns that are required from seeds
          requires = []
  
          # -------------
          # Clean up Aggs
          # -------------
          for key in userkwargs.keys():
              # agg example: "avg_total", "max_tax"
              if key.find('_') > 0:
                  agg, base = tuple(key.split('_'))
                  if base in userkwargs:
                      if type(userkwargs[base]) is not list:
                          userkwargs[base] = [(None, userkwargs[base])]
                      userkwargs[base].append( (agg, userkwargs.pop(key)) )
                  else:
                      userkwargs[base] = [(agg, userkwargs.pop(key))]
  
          # -----------------
          # Process Arguments
          # -----------------
          for key, seed in self.arguments.iteritems():
              # --------------
              # Argument Alias
              # --------------
              if seed.get('alias') and key in userkwargs:
                  # pop the value form the user kwargs (to change the key later)
                  value = userkwargs.pop(key) if key in userkwargs else NotImplemented
                  # for duplicate keys
                  oldkey = key+""
                  # change the key
                  key = seed.get('alias')
                  # change the seed
                  seed = get(self.arguments, seed.get('alias'))
                  # set the new key:value
                  if value is not NotImplemented:
                      if key in userkwargs:
                          raise valideer.ValidationError("Argument alias already specified for `%s` via `%s`" % (oldkey, key), oldkey)
                      userkwargs[key] = value
  
              # can provide multiple arguments
              if key.endswith('[]'):
                  multi = True
                  key = key[:-2]
              else:
                  multi = False
  
              # get value(s) from user
              if key in userkwargs:
                  value = userkwargs.pop(key)
              elif seed.get('copy'):
                  value = userkwargs.get(seed.get('copy'))
              else:
                  value = seed.get('default')
  
              # no argument provided, lets continue)
              if value is None or value == []:
                  if seed.get('required'):
                      raise valideer.ValidationError("missing required property: %s" % key, key)
                  else:
                      continue
  
              # add requires
              requires.extend(array(get(seed, 'requires', [])))
  
              # -----------
              # Inheritance
              # -----------
              # not permited from arguements yet. would need to happen above the ""PROCESS ARGUMENT"" block
              # self._inherit(*array(get(seed, 'inherit', [])))
  
              if type(value) is list and type(value[0]) is tuple:
                  # complex
                  for v in value:
                      ud, pd = self._harvest_args(key, seed, v, multi)
                      userkwargs.update(ud)
                      parser.update(pd)
              else:
                  ud, pd = self._harvest_args(key, seed, value, multi)
                  userkwargs.update(ud)
                  parser.update(pd)
  
          # ------------
          # Ignored Keys
          # ------------
          for seed in self.seeds:
              ignores = set(array(get(seed, 'ignore')))
              if ignores:
                  if ignores & original_kwargs:
                      if not get(seed, 'silent'):
                          additionals = ignores & original_kwargs
                          raise valideer.ValidationError("additional properties: %s" % ",".join(additionals), additionals)
                  [userkwargs.pop(key) for key in ignores if key in userkwargs]
  
          # -------------------------
          # Custom Operators (part 1)
          # -------------------------
          operators = {}
          for key, value in userkwargs.items():
              rk = key
              agg = None
              if key.find('_')>-1:
                  agg, rk = tuple(key.split('_'))
              seed = self.arguments.get(rk, self.arguments.get(rk+'[]'))
              if seed:
                  if type(value) is list:
                      operators[key] = []
                      # need to remove the operator for validating
                      new_values = []
                      for v in value:
                          operator, v = self._operator(v, *seed.get('column', "").rsplit("::", 1))
                          new_values.append(v)
                          operators[key].append((agg, operator) if agg else operator)
                      userkwargs[key] = new_values
                  else:
                      operator, value = self._operator(value, *seed.get('column', "").rsplit("::", 1))
                      operators[key] = (agg, operator) if agg else operator
                      userkwargs[key] = value
  
          # -----------------
          # Plant Sort Method
          # -----------------
          if 'sortby' in userkwargs:
              seed = self.arguments.get(userkwargs['sortby'].lower(), self.arguments.get(userkwargs['sortby'].lower()+'[]'))
              if seed:
                  seed['id'] = str(userkwargs['sortby'].lower())
  
          for r in set(requires):
              if userkwargs.get(r) is None:
                  raise valideer.ValidationError("required property not set: %s" % r, r)
  
          # --------
          # Validate
          # --------
          parser = valideer.parse(parser, additional_properties=False)
          validated = parser.validate(userkwargs, adapt=self.navigator.adapter())
          validated.update(self.network_kwargs)
          #   operators                   validated
          # --------------------------- | --------------------------------
          # {                           {
          #   "type": ["!", "!"],         "type": ['a', 'b'],
          #   "total": "<",               "total": "50",
          #   "tax": ("avg, ">"),         "tax": "1",
          #   "time": None                "time": "2014"
          # }                           }
          return operators, validated