Django:调用user.objects.get()时"解压缩的值太多"

客户用户模型:

class UserObject(AbstractBaseUser):

    email = models.EmailField(max_length=254, unique=True, db_index=True)

    USERNAME_FIELD = 'email'
    # REQUIRED_FIELDS = ['student_or_business',]

    # Tells us whether the UserObject is a business or student
    @property
    def type(self):
        if hasattr(self, 'Student'.lower()):
            return 'S'
        elif hasattr(self, 'BusinessHandler'.lower()):
            return 'B'
        else:
            raise TypeError, "UserObject has neither Student nor BusinessHandler connected."

    # Gets us the actual UserObject's accompanying object, whether Student or Business
    @property
    def get_profile_object(self):
        if self.type == 'S':
            return getattr(self, 'Student'.lower())
        elif self.type == 'B':
            return getattr(self, 'BusinessHandler'.lower()) # to take advantage of refactoring

    @property
    def is_student(self):
        return self.type == 'S'

    @property
    def is_business(self):
        return self.type == 'B'

    def relevant_item(self, input_tuple):
        '''
        Takes in a tuple of options for return in form (Student, Business[, other]).
        Returns the appropriate option depending
        '''
        if not 2 <= len(input_tuple) <= 3:
            raise TypeError, "relevant_item() requires a tuple of 2 or 3."
        else:
            if self.type == 'S':
                return input_tuple[0]
            elif self.type == 'B':
                return input_tuple[1]
            else:
                return input_tuple[2] if len(input_tuple) == 3 else None


    signup_date = models.DateTimeField(auto_now_add=True)

    # admin stuff
    is_active = models.BooleanField(default=True)
    is_admin = models.BooleanField(default=False)
    is_staff = models.BooleanField(default=False)

    # Settings
    verified = models.BooleanField(default=False)
    accepted_TOS = models.DateField(default=datetime.datetime.today())
         # Date so can find who need to update when change TOS

    # Temporary hashes/strings
    verification_id = models.CharField(unique=True, default=lambda: random_string(20), max_length=20)
    reset_password_code = models.CharField(blank=True, default=lambda: random_string(20), max_length=20)

    def get_new_reset_password_code(self):
        self.reset_password_code = random_string(20)
        self.save()
        return self.reset_password_code

    def new_verification_id(self):
        self.verification_id = random_string(20)
        try:
            self.save()
        except IntegrityError:
            self.new_verification_id()

    objects = UserObjectManager()

class UserObjectManager(BaseUserManager):

    @staticmethod
    def create_accompanying_model(user, student_or_business):
        '''
        This creates the appropriate accompanying Student or BusinessHandler model when a
        new UserObject is created.
        '''

        if student_or_business == 'S':
            s = models.get_model('student', 'Student')
            new_item = s.objects.create(user_object=user, UserObject_creation=True)
            new_item.save()

        elif student_or_business == 'B':
            b = models.get_model('business', 'BusinessHandler')
            new_item = b.objects.create(user_object=user, UserObject_creation=True)
            new_item.save()

        else:
            msg = 'Must be Student or BusinessHandler.'
            raise ValueError(msg)

    def create_user(self, email, password, student_or_business):

        # normalize student_or_business
        if student_or_business.lower() in ('s', 'student'):
            student_or_business = 'S'
        elif student_or_business.lower() in ('b', 'business', 'BusinessHandler'.lower()):
            student_or_business = 'B'

        # Check if an email was provided
        if not email:
            msg = 'Users must have an email address.'
            raise ValueError(msg)

        # If a student, check if a '.edu' email address was provided
        if email and student_or_business == 'S':
            if not email.endswith('.edu'):
                msg = 'Students must sign up with a .edu email address.'
                raise ValueError(msg)

        user = self.model(
            email=UserObjectManager.normalize_email(email),

            # Removed the below because calculating that differently
            # student_or_business = student_or_business,

        )

        user.set_password(password)
        user.save(using=self._db)

        self.create_accompanying_model(user, student_or_business)

        return user

    def create_superuser(self, email, password, student_or_business):
        user = self.create_user(email, password, student_or_business)
        user.is_admin = True
        user.is_staff = True
        user.is_superuser = True
        user.save(using=self._db)
        return user