How to use the slepc4py.SLEPc.EPS.Which.SMALLEST_MAGNITUDE function in slepc4py

def eig_slepc(AA, BB, **kwargs):
    '''Slepc solver'''
    assert has_slepc4py()
    from slepc4py import SLEPc

    nev = 3  # Number of eigenvalues
    eigenvalues = np.array([])
    size = AA.size[0]
    info('System size: %i' % size)
    eps_type = kwargs.get('eps_type', SLEPc.EPS.Type.GD)
    for which in (SLEPc.EPS.Which.SMALLEST_MAGNITUDE, SLEPc.EPS.Which.LARGEST_MAGNITUDE):
        # Setup the eigensolver
        E = SLEPc.EPS().create()
        E.setOperators(AA ,BB)
        E.setType(E.Type.GD)
        E.setDimensions(nev, PETSc.DECIDE)
        E.setTolerances(1E-6, 8000)

        E.setWhichEigenpairs(which)
        E.setProblemType(SLEPc.EPS.ProblemType.GHEP)
        E.setFromOptions()

        # Solve the eigensystem
        E.solve()

        its = E.getIterationNumber()
        info('Number of iterations of the method: %i' % its)

elif value == "generalized-davidson":
                        self.eps.setType(SLEPc.EPS.Type.GD)
                    else:
                        raise RuntimeError("Invalid solver type")
                elif key == "spectral_shift":
                    st = self.eps.getST()
                    st.setShift(value)
                elif key == "spectral_transform":
                    assert value == "shift-and-invert"
                    st = self.eps.getST()
                    st.setType(SLEPc.ST.Type.SINVERT)
                elif key == "spectrum":
                    if value == "largest magnitude":
                        self.eps.setWhichEigenpairs(SLEPc.EPS.Which.LARGEST_MAGNITUDE)
                    elif value == "smallest magnitude":
                        self.eps.setWhichEigenpairs(SLEPc.EPS.Which.SMALLEST_MAGNITUDE)
                    elif value == "largest real":
                        self.eps.setWhichEigenpairs(SLEPc.EPS.Which.LARGEST_REAL)
                    elif value == "smallest real":
                        self.eps.setWhichEigenpairs(SLEPc.EPS.Which.SMALLEST_REAL)
                    elif value == "largest imaginary":
                        self.eps.setWhichEigenpairs(SLEPc.EPS.Which.LARGEST_IMAGINARY)
                    elif value == "smallest imaginary":
                        self.eps.setWhichEigenpairs(SLEPc.EPS.Which.SMALLEST_IMAGINARY)
                    elif value == "target magnitude":
                        self.eps.setWhichEigenpairs(SLEPc.EPS.Which.TARGET_MAGNITUDE)
                        if "spectral_shift" in parameters:
                            self.eps.setTarget(parameters["spectral_shift"])
                    elif value == "target real":
                        self.eps.setWhichEigenpairs(SLEPc.EPS.Which.TARGET_REAL)
                        if "spectral_shift" in parameters:
                            self.eps.setTarget(parameters["spectral_shift"])