How to use the pyrad.packet.AccessRequest function in pyrad

def _HandleAuthPacket(self, pkt):
            pyrad.server.Server._HandleAuthPacket(self, pkt)
            logger.info("Received authentication request")
            reply = self.CreateReplyPacket(pkt)
            reply.code = pyrad.packet.AccessAccept
            if self.t_events['invalid_code']:
                reply.code = pyrad.packet.AccessRequest
            if self.t_events['reject']:
                reply.code = pyrad.packet.AccessReject
            data = build_tunnel_password(reply.secret, pkt.authenticator,
                                         self.t_events['psk'])
            reply.AddAttribute("Tunnel-Password", data)
            if self.t_events['acct_interim_interval']:
                reply.AddAttribute("Acct-Interim-Interval",
                                   self.t_events['acct_interim_interval'])
            if self.t_events['session_timeout']:
                reply.AddAttribute("Session-Timeout",
                                   self.t_events['session_timeout'])
            self.SendReplyPacket(pkt.fd, reply)

client = pyrad.client.Client(server="127.0.0.1", authport=1812,
                                 secret=b"radius", dict=dict)
    client.retries = 1
    client.timeout = 1

    # unexpected State
    req = client.CreateAuthPacket(code=pyrad.packet.AccessRequest,
                                  User_Name="foo")
    req['State'] = b'foo-state'
    add_message_auth(req)
    reply = client.SendPacket(req)
    if reply.code != pyrad.packet.AccessReject:
        raise Exception("Unexpected RADIUS response code " + str(reply.code))

    # no EAP-Message
    req = client.CreateAuthPacket(code=pyrad.packet.AccessRequest,
                                  User_Name="foo")
    add_message_auth(req)
    try:
        reply = client.SendPacket(req)
        raise Exception("Unexpected response")
    except pyrad.client.Timeout:
        pass

#!/usr/bin/python
from __future__ import print_function
from pyrad.client import Client
from pyrad.dictionary import Dictionary
import socket
import sys
import pyrad.packet

srv = Client(server="localhost", secret=b"Kah3choteereethiejeimaeziecumi", dict=Dictionary("dictionary"))

req = srv.CreateAuthPacket(code=pyrad.packet.AccessRequest, User_Name="wichert")

req["NAS-IP-Address"] = "192.168.1.10"
req["NAS-Port"] = 0
req["Service-Type"] = "Login-User"
req["NAS-Identifier"] = "trillian"
req["Called-Station-Id"] = "00-04-5F-00-0F-D1"
req["Calling-Station-Id"] = "00-01-24-80-B3-9C"
req["Framed-IP-Address"] = "10.0.0.100"

try:
    print("Sending authentication request")
    reply = srv.SendPacket(req)
except pyrad.client.Timeout:
    print("RADIUS server does not reply")
    sys.exit(1)
except socket.error as error:

def _HandleAuthPacket(self, pkt):
        """Process a packet received on the authentication port.
        If this packet should be dropped instead of processed a
        ServerPacketError exception should be raised. The main loop will
        drop the packet and log the reason.

        :param pkt: packet to process
        :type  pkt: Packet class instance
        """
        self._AddSecret(pkt)
        if pkt.code != packet.AccessRequest:
            raise ServerPacketError(
                'Received non-authentication packet on authentication port')
        self.HandleAuthPacket(pkt)

def peers_alive(config):
  from pyrad.client import Client
  from pyrad.dictionary import Dictionary
  
  radconfig = config['radius']
  localconfig = config['local']

  auth_OK = True

  dictionary = Dictionary(localconfig['raddict'])
  
  for server in radconfig['servers']:
    srv = Client(server=server, secret=str(radconfig['secret']), dict=dictionary)
    req = srv.CreateAuthPacket(code=pyrad.packet.AccessRequest,
      User_Name=radconfig['username'],
      NAS_Identifier="localhost")
    req["User-Password"] = req.PwCrypt(radconfig['password'])

    try:
      reply = srv.SendPacket(req)
    except pyrad.client.Timeout:
      print "Could not contact:", server
      auth_OK = False

    if reply.code != 2:
      print "Auth failed to", server
      auth_OK = False
  return auth_OK

def processPacket(self, pkt):
        if pkt.code != packet.AccessRequest:
            raise PacketError(
                    'non-AccessRequest packet on authentication socket')

def processPacket(self, pkt):
        if pkt.code != packet.AccessRequest:
            raise PacketError(
                    'non-AccessRequest packet on authentication socket')

def _get_auth_packet(self, username, password, client):
        """
        Get the pyrad authentication packet for the username/password and the
        given pyrad client.
        """
        pkt = client.CreateAuthPacket(code=AccessRequest,
                                      User_Name=username)
        pkt["User-Password"] = pkt.PwCrypt(password)
        pkt["NAS-Identifier"] = 'django-radius'
        for key, val in list(getattr(settings, 'RADIUS_ATTRIBUTES', {}).items()):
            pkt[key] = val
        return pkt

def execute(self):
        args = self.args
        # pylint: disable=W0703
        try:
            username = args.get("username", "")
            password = args.get("password", "")
            rad_secret = args.get("secret", "").encode("utf-8")
            identifier = args.get("identifier", "")
            dictionary = args.get("dictionary", DEFAULT_DICTIONARY)
            ip, _port = self.get_address()
            srv = Client(server=ip, secret=rad_secret,
                         dict=Dictionary(dictionary))
            req = srv.CreateAuthPacket(code=pyrad.packet.AccessRequest,
                                       User_Name=username,
                                       NAS_Identifier=identifier)
            req["User-Password"] = req.PwCrypt(password)
            srv.SendPacket(req)
        except Exception as err:
            return (Event.DOWN,
                    "Failed connecting to %s: %s)" %
                    (self.get_address(), str(err)))
        version = "FreeRadius 1.0"  # Fetch from radiusmonitor later.
        self.version = version
        return Event.UP, "Radius: " + version

def authenticate(self, username=None, password=None, **kwargs):
        """
        Authenticate user against user and password
        """
        logging.debug("RADIUS authenticatation: username=%s" % username)
        is_active = True  # User activity flag
        is_superuser = False  # Superuser flag
        
        srv=Client(server=self.server, secret=self.secret,
              dict=Dictionary("main/auth/backends/radiusbackend.dict"))

        req=srv.CreateAuthPacket(code=pyrad.packet.AccessRequest,
                      User_Name=username, NAS_Identifier=self.nas_identifier)
        req["User-Password"]=req.PwCrypt(password)

        reply=srv.SendPacket(req)
        if reply.code==pyrad.packet.AccessAccept:
            logging.debug("RADIUS access accepted for '%s'" % username)
        else:
            logging.debug("RADIUS access denied for '%s'" % username)
            return None
        
        logging.debug("RADIUS Attributes returned by server: %s" % reply)

        logging.debug("RADIUS Check superuser_value of superuser_attribute '%s' to contain '%s'" % (self.superuser_attribute, self.superuser_value))
        for i in reply.keys():
            if str(i) == self.superuser_attribute and self.superuser_value in reply[i]:
                is_superuser = True