code: def _validate_arguments(self):
          
          # dtype
          if self.dtype not in ['numerical', 'categorical']:
              raise ValueError("dtype must be in ['numerical','categorical'], "\
                               "but found dtype = {}".format(self.dtype))
  
          # fit_linear XOR fit_splines
          if self.fit_linear == self.fit_splines:
              raise ValueError('term must have fit_linear XOR fit_splines, but found: '
                               'fit_linear= {}, fit_splines={}'.format(self.fit_linear, self.fit_splines))
  
          # penalties
          if not isiterable(self.penalties):
              self.penalties = [self.penalties]
  
          for i, p in enumerate(self.penalties):
              if not (hasattr(p, '__call__') or
                      (p in PENALTIES) or
                      (p is None)):
                  raise ValueError("penalties must be callable or in "\
                                   "{}, but found {} for {}th penalty"\
                                   .format(list(PENALTIES.keys()), p, i))
  
          # check lams and distribute to penalites
          if not isiterable(self.lam):
              self.lam = [self.lam]
  
          for lam in self.lam:
              check_param(lam, param_name='lam', dtype='float', constraint='>= 0')
  
          if len(self.lam) == 1:
              self.lam = self.lam * len(self.penalties)
  
          if len(self.lam) != len(self.penalties):
              raise ValueError('expected 1 lam per penalty, but found '\
                               'lam = {}, penalties = {}'.format(self.lam, self.penalties))
  
          # constraints
          if not isiterable(self.constraints):
              self.constraints = [self.constraints]
  
          for i, c in enumerate(self.constraints):
              if not (hasattr(c, '__call__') or
                      (c in CONSTRAINTS) or
                      (c is None)):
                  raise ValueError("constraints must be callable or in "\
                                   "{}, but found {} for {}th constraint"\
                                   .format(list(CONSTRAINTS.keys()), c, i))
  
          return self
docs: method to sanitize model parameters
  
          Parameters
          ---------
          None
  
          Returns
          -------
          None