docs: def get(policy_class=None, return_full_policy_names=True,
          hierarchical_return=False, adml_language='en-US',
          return_not_configured=False):
      '''
      Get a policy value
  
      Args:
  
          policy_class (str):
              Some policies are both user and computer, by default all policies
              will be pulled, but this can be used to retrieve only a specific
              policy class User/USER/user = retrieve user policies
              Machine/MACHINE/machine/Computer/COMPUTER/computer = retrieve
              machine/computer policies
  
          return_full_policy_names (bool):
              True/False to return the policy name as it is seen in the
              ``gpedit.msc`` GUI or to only return the policy key/id.
  
          hierarchical_return (bool):
              True/False to return the policy data in the hierarchy as seen in the
              ``gpedit.msc`` GUI. The default of False will return data split only
              into User/Computer configuration sections
  
          adml_language (str):
              The ADML language to use for processing display/descriptive names
              and enumeration values of ADMX template data, defaults to en-US
  
          return_not_configured (bool):
              Include Administrative Template policies that are 'Not Configured'
              in the return data
  
      Returns:
          dict: A dictionary containing the policy values for the specified class
  
      CLI Example:
  
      .. code-block:: bash
  
          salt '*' lgpo.get machine return_full_policy_names=True
      '''
  
      vals = {}
      modal_returns = {}
      _policydata = _policy_info()
  
      if policy_class is None or policy_class.lower() == 'both':
          policy_class = _policydata.policies.keys()
      elif policy_class.lower() not in [z.lower() for z in _policydata.policies.keys()]:
          msg = 'The policy_class {0} is not an available policy class, please ' \
                'use one of the following: {1}, Both'
          raise SaltInvocationError(
              msg.format(policy_class, ', '.join(_policydata.policies.keys())))
      else:
          policy_class = [policy_class.title()]
  
      # handle policies statically defined in this module
      for p_class in policy_class:
          this_class_policy_names = _policydata.policies[p_class]['policies']
          class_vals = {}
          for policy_name in this_class_policy_names:
              _pol = None
              if policy_name in _policydata.policies[p_class]['policies']:
                  _pol = _policydata.policies[p_class]['policies'][policy_name]
              else:
                  for policy in _policydata.policies[p_class]['policies']:
                      if _policydata.policies[p_class]['policies'][policy]['Policy'].upper() == policy_name.upper():
                          _pol = _policydata.policies[p_class]['policies'][policy]
                          policy_name = policy
              if _pol:
                  vals_key_name = policy_name
                  if 'Registry' in _pol:
                      # get value from registry
                      class_vals[policy_name] = __utils__['reg.read_value'](
                          _pol['Registry']['Hive'],
                          _pol['Registry']['Path'],
                          _pol['Registry']['Value'])['vdata']
                      log.debug(
                          'Value %r found for reg policy %s',
                          class_vals[policy_name], policy_name
                      )
                  elif 'Secedit' in _pol:
                      # get value from secedit
                      _val = _get_secedit_value(option=_pol['Secedit']['Option'])
                      class_vals[policy_name] = _val
                  elif 'NetSH' in _pol:
                      # get value from netsh
                      class_vals[policy_name] = _findOptionValueNetSH(
                          profile=_pol['NetSH']['Profile'],
                          option=_pol['NetSH']['Option'])
                  elif 'AdvAudit' in _pol:
                      # get value from auditpol
                      class_vals[policy_name] = _findOptionValueAdvAudit(
                          option=_pol['AdvAudit']['Option'])
                  elif 'NetUserModal' in _pol:
                      # get value from UserNetMod
                      if _pol['NetUserModal']['Modal'] not in modal_returns:
                          modal_returns[_pol['NetUserModal']['Modal']] = win32net.NetUserModalsGet(
                                  None,
                                  _pol['NetUserModal']['Modal'])
                      class_vals[policy_name] = modal_returns[_pol['NetUserModal']['Modal']][_pol['NetUserModal']['Option']]
                  elif 'LsaRights' in _pol:
                      class_vals[policy_name] = _getRightsAssignments(_pol['LsaRights']['Option'])
                  elif 'ScriptIni' in _pol:
                      log.debug('Working with ScriptIni setting %s', policy_name)
                      class_vals[policy_name] = _getScriptSettingsFromIniFile(_pol)
                  if policy_name in class_vals:
                      class_vals[policy_name] = _transform_value(
                          value=class_vals[policy_name],
                          policy=_policydata.policies[p_class]['policies'][policy_name],
                          transform_type='Get')
                  if return_full_policy_names:
                      class_vals[_pol['Policy']] = class_vals.pop(policy_name)
                      vals_key_name = _pol['Policy']
                  if hierarchical_return:
                      if 'lgpo_section' in _pol:
                          firstItem = True
                          tdict = {}
                          for level in reversed(_pol['lgpo_section']):
                              newdict = {}
                              if firstItem:
                                  newdict[level] = {vals_key_name: class_vals.pop(vals_key_name)}
                                  firstItem = False
                              else:
                                  newdict[level] = tdict
                              tdict = newdict
                          if tdict:
                              class_vals = dictupdate.update(class_vals, tdict)
              else:
                  msg = 'The specified policy {0} is not currently available ' \
                        'to be configured via this module'
                  raise SaltInvocationError(msg.format(policy_name))
          class_vals = dictupdate.update(
              class_vals,
              _checkAllAdmxPolicies(policy_class=p_class,
                                    adml_language=adml_language,
                                    return_full_policy_names=return_full_policy_names,
                                    hierarchical_return=hierarchical_return,
                                    return_not_configured=return_not_configured))
          if _policydata.policies[p_class]['lgpo_section'] not in class_vals:
              temp_dict = {
                  _policydata.policies[p_class]['lgpo_section']: class_vals}
              class_vals = temp_dict
          vals = dictupdate.update(vals, class_vals)
  
      return vals