python can't set attribute on non-persistent property

class class User(models.Model):
   email = models.EmailField(max_length = 254, unique = True, db_index = True)

@property
def client_id(self):
   return self.internal_client_id

@client_id.setter
def client_id(self, value):
   self.internal_client_id = value

import persistent

class Book(persistent.Persistent):

   def __init__(self, title):
   self.title = title
self.authors = []

def add_author(self, author):
   self.authors.append(author)
self._p_changed = True

import persistent

class Book(persistent.Persistent):

   def __init__(self, title):
   self.title = title
self.authors = ()

def add_author(self, author):
   self.authors += (author, )

import persistent
import persistent.list

class Book(persistent.Persistent):

   def __init__(self, title):
   self.title = title
self.authors = persistent.list.PersistentList()

def add_author(self, author):
   self.authors.append(author)

import persistent
from BTrees.OOBTree
import TreeSet

class Book(persistent.Persistent):

   def __init__(self, title):
   self.title = title
self.authors = TreeSet()

def add_author(self, author):
   self.authors.add(author)

class Book(persistent.Persistent):

   publisher = 'UNKNOWN'

def __init__(self, title, publisher):
   self.title = title
self.publisher = publisher
self.authors = TreeSet()

def add_author(self, author):
   self.authors.add(author)

from catalog
import Publication as Book # XXX deprecated name

> set obj / myattr = "test"

obj.db.foo = [1, 2, 3, "bar"]
value = obj.db.foo

obj.attributes.add("myattr", 1234, category = "bar")
value = attributes.get("myattr", category = "bar")

from evennia
import DefaultObject
from evennia
import AttributeProperty

class MyObject(DefaultObject):
   foo = AttributeProperty(
      default = [1, 2, 3, "bar"])
myattr = AttributeProperty(100, category = 'bar')

import evennia

obj = evennia.create_object(key = "Foo")

obj.db.foo1 = 1234
obj.db.foo2 = [1, 2, 3, 4]
obj.db.weapon = "sword"
obj.db.self_reference = obj # stores a reference to the obj

#(let 's assume a rose exists in-game)
      rose = evennia.search_object(key = "rose")[0] # returns a list, grab 0 th element rose.db.has_thorns = True

      # retrieving val1 = obj.db.foo1 val2 = obj.db.foo2 weap = obj.db.weapon myself = obj.db.self_reference # retrieve reference from db, get object back

      is_ouch = rose.db.has_thorns

      # this will
      return None, not AttributeError!
         not_found = obj.db.jiwjpowiwwerw

      # returns all Attributes on the object obj.db.all

      # delete an Attribute del obj.db.foo2

is_ouch = rose.attributes.get("has_thorns")

obj.attributes.add("helmet", "Knight's helmet")
helmet = obj.attributes.get("helmet")

# you can give space - separated Attribute - names(can 't do that with .db)
      obj.attributes.add("my game log", "long text about ...")

class A(object):
   def meth(self): return "A"
class B(object):
   def meth(self): return "B"

class X(A, B): pass
class Y(B, A): pass

class Z(X, Y): pass

class A:
   def foo(self): pass

class B(A): pass

class C(A):
   def foo(self):
   B.foo(self)

self._p_jar.readCurrent(ob)

from persistent
import Persistent
from zope.annotation
import IAnnotations

class VolatileContext(object):
   ""
" Mix-in class to provide context variable to persistent classes which is not persistent.

Some subsystems(e.g.forms) expect objects to have a reference to parent / site / whatever.
However, it might not be a wise idea to have circular persistent references.

This helper class creates a context property which is volatile(never persistent),
   but can be still set on the object after creation or after database load.
""
"

def _set_context(self, context):
   self._v_context = context

def _get_context(self):
   return self._v_context

class MobileBehaviorStorage(VolatileContext, Persistent):
   ""
"Set mobile specific field properties on the context object and return the context object itself.#

This allows to use attribute storage with schema input validation.
""
"

mobileFolderListing = FieldPropertyDelegate(IMobileBehavior["mobileFolderListing"])

KEY = "mobile"

def manufacture_mobile_behavior(context):

   annotations = IAnnotations(context)
if not KEY in annotations:
   annotations[KEY] = MobileBehaviorStorage()

object = annotations[KEY]

# Set volatile context
object.context = context

return object

if hasattr(self, '_v_image'):
   return self._v_image

marker = []
value = getattr(self, "_v_image", marker)
if value is not marker:
   return value

try:
return self._v_image
except AttributeError:

self._v_image = expensive_calculation()
return self._v_image

expires_at = modification + timedelta(seconds = settings.SESSION_COOKIE_AGE)

>>> # initial assignment
   >>>
   request.session[0] = 'bar' >>>
   # subsequent requests following serialization & deserialization >>>
   # of session data >>>
   request.session[0] # KeyError >>>
   request.session['0']
'bar'

def post_comment(request, new_comment):
   if request.session.get('has_commented', False):
   return HttpResponse("You've already commented.")
c = comments.Comment(comment = new_comment)
c.save()
request.session['has_commented'] = True
return HttpResponse('Thanks for your comment!')

def login(request):
   m = Member.objects.get(username = request.POST['username'])
if m.check_password(request.POST['password']):
   request.session['member_id'] = m.id
return HttpResponse("You're logged in.")
else:
   return HttpResponse("Your username and password didn't match.")

def logout(request):
   try:
   del request.session['member_id']
except KeyError:
   pass
return HttpResponse("You're logged out.")

from django.http
import HttpResponse
from django.shortcuts
import render

def login(request):
   if request.method == 'POST':
   if request.session.test_cookie_worked():
   request.session.delete_test_cookie()
return HttpResponse("You're logged in.")
else:
   return HttpResponse("Please enable cookies and try again.")
request.session.set_test_cookie()
return render(request, 'foo/login_form.html')