"""

if isinstance(obj, dict):

def setFunc(var, value):

obj[var] = value

d = obj

else:

def setFunc(var, value):

setattr(obj, var, value)

d = obj.__dict__

props = {}

for var, value in d.items():

if var.startswith('_set_'):

props.setdefault(var[5:], {})['set'] = value

elif var.startswith('_get_'):

props.setdefault(var[5:], {})['get'] = value

elif var.startswith('_del_'):

props.setdefault(var[5:], {})['del'] = value

elif var.startswith('_doc_'):

props.setdefault(var[5:], {})['doc'] = value

for var, setters in props.items():

if len(setters) == 1 and 'doc' in setters:

continue

if var in d:

if isinstance(d[var], (types.MethodType, types.FunctionType)):

warnings.warn(

"I tried to set the property %r, but it was "

"already set, as a method (%r). Methods have "

"significantly different semantics than properties, "

"and this may be a sign of a bug in your code."

% (var, d[var]))

continue

setFunc(var,

property(setters.get('get'), setters.get('set'),

if isinstance(obj, dict):

def delFunc(obj, var):

del obj[var]

d = obj

else:

delFunc = delattr

d = obj.__dict__

for var, value in list(d.items()):

if isinstance(value, property):

for prop in [value.fget, value.fset, value.fdel]:

if prop and prop.__name__ not in d:

delFunc(obj, var)

depends = []

for klass in classregistry.registry(registry).allClasses():

if findDependantColumns(name, klass):

depends.append(klass)

else:

for join in klass.sqlmeta.joins:

if isinstance(join, joins.SORelatedJoin) and \

join.otherClassName == name:

depends.append(klass)

break

depends = []

for _col in klass.sqlmeta.columnList:

if _col.foreignKey == name and _col.cascade is not None:

depends.append(_col)

"""Finds all attributes in `new_attrs` that are instances of

result = []

for attr, value in new_attrs.items():

if isinstance(value, look_for_class):

value.name = attr

delattr(cls, attr)

result.append(value)

"""

"""

table = None

idName = None

idSize = None # Allowed values are 'TINY/SMALL/MEDIUM/BIG/None'

idSequence = None

# This function is used to coerce IDs into the proper format,

# so you should replace it with str, or another function, if you

# aren't using integer IDs

idType = int

style = None

lazyUpdate = False

defaultOrder = None

cacheValues = True

registry = None

fromDatabase = False

# Default is false, but we set it to true for the *instance*

# when necessary: (bad clever? maybe)

expired = False

# This is a mapping from column names to SOCol (or subclass)

# instances:

columns = {}

columnList = []

# This is a mapping from column names to Col (or subclass)

# instances; these objects don't have the logic that the SOCol

# objects do, and are not attached to this class closely.

columnDefinitions = {}

# These are lists of the join and index objects:

indexes = []

indexDefinitions = []

joins = []

joinDefinitions = []

# These attributes shouldn't be shared with superclasses:

_unshared_attributes = ['table', 'columns', 'childName']

# These are internal bookkeeping attributes; the class-level

# definition is a default for the instances, instances will

# reset these values.

# When an object is being created, it has an instance

# variable _creating, which is true. This way all the

# setters can be captured until the object is complete,

# and then the row is inserted into the database. Once

# that happens, _creating is deleted from the instance,

# and only the class variable (which is always false) is

# left.

_creating = False

_obsolete = False

# Sometimes an intance is attached to a connection, not

# globally available. In that case, self.sqlmeta._perConnection

# will be true. It's false by default:

_perConnection = False

# Inheritance definitions:

parentClass = None # A reference to the parent class

childClasses = {} # References to child classes, keyed by childName

childName = None # Class name for inheritance child object creation

# Does the row require syncing?

dirty = False

# Default encoding for UnicodeCol's

dbEncoding = None

def __classinit__(cls, new_attrs):

for attr in cls._unshared_attributes:

if attr not in new_attrs:

setattr(cls, attr, None)

declarative.setup_attributes(cls, new_attrs)

def __init__(self, instance):

self.instance = weakref.proxy(instance)

@classmethod

def send(cls, signal, *args, **kw):

events.send(signal, cls.soClass, *args, **kw)

@classmethod

def setClass(cls, soClass):

if cls.idType not in (int, str):

raise TypeError('sqlmeta.idType must be int or str, not %r'

% cls.idType)

if cls.idSize not in ('TINY', 'SMALL', 'MEDIUM', 'BIG', None):

raise ValueError(

"sqlmeta.idType must be 'TINY', 'SMALL', 'MEDIUM', 'BIG' "

"or None, not %r" % cls.idSize)

cls.soClass = soClass

if not cls.style:

cls.style = styles.defaultStyle

try:

if cls.soClass._connection and cls.soClass._connection.style:

cls.style = cls.soClass._connection.style

except AttributeError:

pass

if cls.table is None:

cls.table = cls.style.pythonClassToDBTable(cls.soClass.__name__)

if cls.idName is None:

cls.idName = cls.style.idForTable(cls.table)

# plainSetters are columns that haven't been overridden by the

# user, so we can contact the database directly to set them.

# Note that these can't set these in the SQLObject class

# itself, because they specific to this subclass of SQLObject,

# and cannot be shared among classes.

cls._plainSetters = {}

cls._plainGetters = {}

cls._plainForeignSetters = {}

cls._plainForeignGetters = {}

cls._plainJoinGetters = {}

cls._plainJoinAdders = {}

cls._plainJoinRemovers = {}

# This is a dictionary of columnName: columnObject

# None of these objects can be shared with superclasses

cls.columns = {}

cls.columnList = []

# These, however, can be shared:

cls.columnDefinitions = cls.columnDefinitions.copy()

cls.indexes = []

cls.indexDefinitions = cls.indexDefinitions[:]

cls.joins = []

cls.joinDefinitions = cls.joinDefinitions[:]

############################################################

# Adding special values, like columns and indexes

############################################################

########################################

# Column handling

########################################

@classmethod

def addColumn(cls, columnDef, changeSchema=False, connection=None):

post_funcs = []

cls.send(events.AddColumnSignal, cls.soClass, connection,

columnDef.name, columnDef, changeSchema, post_funcs)

sqlmeta = cls

soClass = cls.soClass

del cls

column = columnDef.withClass(soClass)

name = column.name

assert name != 'id', (

"The 'id' column is implicit, and should not be defined as "

"a column")

assert name not in sqlmeta.columns, (

"The class %s.%s already has a column %r (%r), you cannot "

"add the column %r"

% (soClass.__module__, soClass.__name__, name,

sqlmeta.columnDefinitions[name], columnDef))

# Collect columns from the parent classes to test

# if the column is not in a parent class

parent_columns = []

for base in soClass.__bases__:

if hasattr(base, "sqlmeta"):

parent_columns.extend(base.sqlmeta.columns.keys())

if hasattr(soClass, name):

assert (name in parent_columns) or (name == "childName"), (

"The class %s.%s already has a variable or method %r, "

"you cannot add the column %r" % (

soClass.__module__, soClass.__name__, name, name))

sqlmeta.columnDefinitions[name] = columnDef

sqlmeta.columns[name] = column

# A stable-ordered version of the list...

sqlmeta.columnList.append(column)

###################################################

# Create the getter function(s). We'll start by

# creating functions like _SO_get_columnName,

# then if there's no function named _get_columnName

# we'll alias that to _SO_get_columnName. This

# allows a sort of super call, even though there's

# no superclass that defines the database access.

if sqlmeta.cacheValues:

# We create a method here, which is just a function

# that takes "self" as the first argument.

getter = eval(

'lambda self: self._SO_loadValue(%s)' %

repr(instanceName(name)))

else:

# If we aren't caching values, we just call the

# function _SO_getValue, which fetches from the

# database.

getter = eval('lambda self: self._SO_getValue(%s)' % repr(name))

setattr(soClass, rawGetterName(name), getter)

# Here if the _get_columnName method isn't in the

# definition, we add it with the default

# _SO_get_columnName definition.

if not hasattr(soClass, getterName(name)) or (name == 'childName'):

setattr(soClass, getterName(name), getter)

sqlmeta._plainGetters[name] = 1

#################################################

# Create the setter function(s)

# Much like creating the getters, we will create

# _SO_set_columnName methods, and then alias them

# to _set_columnName if the user hasn't defined

# those methods themself.

# @@: This is lame; immutable right now makes it unsettable,

# making the table read-only

if not column.immutable:

# We start by just using the _SO_setValue method

setter = eval(

'lambda self, val: self._SO_setValue'

'(%s, val, self.%s, self.%s)' % (

repr(name),

'_SO_from_python_%s' % name, '_SO_to_python_%s' % name))

setattr(soClass, '_SO_from_python_%s' % name, column.from_python)

setattr(soClass, '_SO_to_python_%s' % name, column.to_python)

setattr(soClass, rawSetterName(name), setter)

# Then do the aliasing

if not hasattr(soClass, setterName(name)) or (name == 'childName'):

setattr(soClass, setterName(name), setter)

# We keep track of setters that haven't been

# overridden, because we can combine these

# set columns into one SQL UPDATE query.

sqlmeta._plainSetters[name] = 1

##################################################

# Here we check if the column is a foreign key, in

# which case we need to make another method that

# fetches the key and constructs the sister

# SQLObject instance.

if column.foreignKey:

# We go through the standard _SO_get_columnName deal

# we're giving the object, not the ID of the

# object this time:

origName = column.origName

if sqlmeta.cacheValues:

# self._SO_class_className is a reference

# to the class in question.

getter = eval(

'lambda self: self._SO_foreignKey'

'(self._SO_loadValue(%r), self._SO_class_%s, %s)' %

(instanceName(name), column.foreignKey,

column.refColumn and repr(column.refColumn)))

else:

# Same non-caching version as above.

getter = eval(

'lambda self: self._SO_foreignKey'

'(self._SO_getValue(%s), self._SO_class_%s, %s)' %

(repr(name), column.foreignKey,

column.refColumn and repr(column.refColumn)))

setattr(soClass, rawGetterName(origName), getter)

# And we set the _get_columnName version

if not hasattr(soClass, getterName(origName)):

setattr(soClass, getterName(origName), getter)

sqlmeta._plainForeignGetters[origName] = 1

if not column.immutable:

# The setter just gets the ID of the object,

# and then sets the real column.

setter = eval(

'lambda self, val: '

'setattr(self, %s, self._SO_getID(val, %s))' %

(repr(name), column.refColumn and repr(column.refColumn)))

setattr(soClass, rawSetterName(origName), setter)

if not hasattr(soClass, setterName(origName)):

setattr(soClass, setterName(origName), setter)

sqlmeta._plainForeignSetters[origName] = 1

classregistry.registry(sqlmeta.registry).addClassCallback(

column.foreignKey,

lambda foreign, me, attr: setattr(me, attr, foreign),

soClass, '_SO_class_%s' % column.foreignKey)

if column.alternateMethodName:

func = eval(

'lambda cls, val, connection=None: '

'cls._SO_fetchAlternateID(%s, %s, val, connection=connection)'

% (repr(column.name), repr(column.dbName)))

setattr(soClass, column.alternateMethodName, classmethod(func))

if changeSchema:

conn = connection or soClass._connection

conn.addColumn(sqlmeta.table, column)

if soClass._SO_finishedClassCreation:

makeProperties(soClass)

for func in post_funcs:

func(soClass, column)

@classmethod

def addColumnsFromDatabase(sqlmeta, connection=None):

soClass = sqlmeta.soClass

conn = connection or soClass._connection

for columnDef in conn.columnsFromSchema(sqlmeta.table, soClass):

if columnDef.name not in sqlmeta.columnDefinitions:

if isinstance(columnDef.name, unicode_type) and PY2:

columnDef.name = columnDef.name.encode('ascii')

sqlmeta.addColumn(columnDef)

@classmethod

def delColumn(cls, column, changeSchema=False, connection=None):

sqlmeta = cls

soClass = sqlmeta.soClass

if isinstance(column, str):

if column in sqlmeta.columns:

column = sqlmeta.columns[column]

elif column + 'ID' in sqlmeta.columns:

column = sqlmeta.columns[column + 'ID']

else:

raise ValueError('Unknown column ' + column)

if isinstance(column, col.Col):

for c in sqlmeta.columns.values():

if column is c.columnDef:

column = c

break

else:

raise IndexError(

"Column with definition %r not found" % column)

post_funcs = []

cls.send(events.DeleteColumnSignal, cls.soClass, connection,

column.name, column, post_funcs)

name = column.name

del sqlmeta.columns[name]

del sqlmeta.columnDefinitions[name]

sqlmeta.columnList.remove(column)

delattr(soClass, rawGetterName(name))

if name in sqlmeta._plainGetters:

delattr(soClass, getterName(name))

delattr(soClass, rawSetterName(name))

if name in sqlmeta._plainSetters:

delattr(soClass, setterName(name))

if column.foreignKey:

delattr(soClass,

rawGetterName(soClass.sqlmeta.style.

instanceIDAttrToAttr(name)))

if name in sqlmeta._plainForeignGetters:

delattr(soClass, getterName(name))

delattr(soClass,

rawSetterName(soClass.sqlmeta.style.

instanceIDAttrToAttr(name)))

if name in sqlmeta._plainForeignSetters:

delattr(soClass, setterName(name))

if column.alternateMethodName:

delattr(soClass, column.alternateMethodName)

if changeSchema:

conn = connection or soClass._connection

conn.delColumn(sqlmeta, column)

if soClass._SO_finishedClassCreation:

unmakeProperties(soClass)

makeProperties(soClass)

for func in post_funcs:

func(soClass, column)

########################################

# Join handling

########################################

@classmethod

def addJoin(cls, joinDef):

sqlmeta = cls

soClass = cls.soClass

# The name of the method we'll create. If it's

# automatically generated, it's generated by the

# join class.

join = joinDef.withClass(soClass)

meth = join.joinMethodName

sqlmeta.joins.append(join)

index = len(sqlmeta.joins) - 1

if joinDef not in sqlmeta.joinDefinitions:

sqlmeta.joinDefinitions.append(joinDef)

# The function fetches the join by index, and

# then lets the join object do the rest of the

# work:

func = eval(

'lambda self: self.sqlmeta.joins[%i].performJoin(self)' % index)

# And we do the standard _SO_get_... _get_... deal

setattr(soClass, rawGetterName(meth), func)

if not hasattr(soClass, getterName(meth)):

setattr(soClass, getterName(meth), func)

sqlmeta._plainJoinGetters[meth] = 1

# Some joins allow you to remove objects from the

# join.

if hasattr(join, 'remove'):

# Again, we let it do the remove, and we do the

# standard naming trick.

func = eval(

'lambda self, obj: self.sqlmeta.joins[%i].remove(self, obj)' %

index)

setattr(soClass, '_SO_remove' + join.addRemoveName, func)

if not hasattr(soClass, 'remove' + join.addRemoveName):

setattr(soClass, 'remove' + join.addRemoveName, func)

sqlmeta._plainJoinRemovers[meth] = 1

# Some joins allow you to add objects.

if hasattr(join, 'add'):

# And again...

func = eval(

'lambda self, obj: self.sqlmeta.joins[%i].add(self, obj)' %

index)

setattr(soClass, '_SO_add' + join.addRemoveName, func)

if not hasattr(soClass, 'add' + join.addRemoveName):

setattr(soClass, 'add' + join.addRemoveName, func)

sqlmeta._plainJoinAdders[meth] = 1

if soClass._SO_finishedClassCreation:

makeProperties(soClass)

@classmethod

def delJoin(sqlmeta, joinDef):

soClass = sqlmeta.soClass

for join in sqlmeta.joins:

# previously deleted joins will be None, so it must

# be skipped or it'll error out on the next line.

if join is None:

continue

if joinDef is join.joinDef:

break

else:

raise IndexError(

"Join %r not found in class %r (from %r)"

% (joinDef, soClass, sqlmeta.joins))

meth = join.joinMethodName

sqlmeta.joinDefinitions.remove(joinDef)

for i in range(len(sqlmeta.joins)):

if sqlmeta.joins[i] is join:

# Have to leave None, because we refer to joins

# by index.

sqlmeta.joins[i] = None

delattr(soClass, rawGetterName(meth))

if meth in sqlmeta._plainJoinGetters:

delattr(soClass, getterName(meth))

if hasattr(join, 'remove'):

delattr(soClass, '_SO_remove' + join.addRemovePrefix)

if meth in sqlmeta._plainJoinRemovers:

delattr(soClass, 'remove' + join.addRemovePrefix)

if hasattr(join, 'add'):

delattr(soClass, '_SO_add' + join.addRemovePrefix)

if meth in sqlmeta._plainJoinAdders:

delattr(soClass, 'add' + join.addRemovePrefix)

if soClass._SO_finishedClassCreation:

unmakeProperties(soClass)

makeProperties(soClass)

########################################

# Indexes

########################################

@classmethod

def addIndex(cls, indexDef):

cls.indexDefinitions.append(indexDef)

index = indexDef.withClass(cls.soClass)

cls.indexes.append(index)

setattr(cls.soClass, index.name, index)

########################################

# Utility methods

########################################

@classmethod

def getColumns(sqlmeta):

return sqlmeta.columns.copy()

def asDict(self):

"""

result = {}

for key in self.getColumns():

result[key] = getattr(self.instance, key)

result['id'] = self.instance.id

return result

@classmethod

def expireAll(sqlmeta, connection=None):

"""

soClass = sqlmeta.soClass

connection = connection or soClass._connection

cache_set = connection.cache

cache_set.weakrefAll(soClass)

for item in cache_set.getAll(soClass):

if exception_level is not None and exception_level <= level:

raise NotImplementedError(message)

if warnings_level is not None and warnings_level <= level:

"""

global warnings_level, exception_level

warnings_level = warning

def __init__(self, name, deprecation_level):

self.name = name

self.deprecation_level = deprecation_level

def __get__(self, obj, type=None):

if self.deprecation_level is not None:

deprecated(

'Use of this attribute should be replaced with '

'.sqlmeta.%s' % self.name, level=self.deprecation_level)

_connection = sqlhub

sqlmeta = sqlmeta

# DSM: The _inheritable attribute controls wheter the class can by

# DSM: inherited 'logically' with a foreignKey and a back reference.

_inheritable = False # Is this class inheritable?

_parent = None # A reference to the parent instance

childName = None # Children name (to be able to get a subclass)

# The law of Demeter: the class should not call another classes by name

SelectResultsClass = SelectResults

def __classinit__(cls, new_attrs):

# This is true if we're initializing the SQLObject class,

# instead of a subclass:

is_base = cls.__bases__ == (object,)

cls._SO_setupSqlmeta(new_attrs, is_base)

implicitColumns = _collectAttributes(cls, new_attrs, col.Col)

implicitJoins = _collectAttributes(cls, new_attrs, joins.Join)

implicitIndexes = _collectAttributes(cls, new_attrs,

index.DatabaseIndex)

if not is_base:

cls._SO_cleanDeprecatedAttrs(new_attrs)

if '_connection' in new_attrs:

connection = new_attrs['_connection']

del cls._connection

assert 'connection' not in new_attrs

elif 'connection' in new_attrs:

connection = new_attrs['connection']

del cls.connection

else:

connection = None

cls._SO_finishedClassCreation = False

######################################################

# Set some attributes to their defaults, if necessary.

# First we get the connection:

if not connection and not getattr(cls, '_connection', None):

mod = sys.modules[cls.__module__]

# See if there's a __connection__ global in

# the module, use it if there is.

if hasattr(mod, '__connection__'):

connection = mod.__connection__

# Do not check hasattr(cls, '_connection') here - it is possible

# SQLObject parent class has a connection attribute that came

# from sqlhub, e.g.; check __dict__ only.

if connection and ('_connection' not in cls.__dict__):

cls.setConnection(connection)

sqlmeta = cls.sqlmeta

# We have to check if there are columns in the inherited

# _columns where the attribute has been set to None in this

# class. If so, then we need to remove that column from

# _columns.

for key in sqlmeta.columnDefinitions.keys():

if (key in new_attrs and new_attrs[key] is None):

del sqlmeta.columnDefinitions[key]

for column in sqlmeta.columnDefinitions.values():

sqlmeta.addColumn(column)

for column in implicitColumns:

sqlmeta.addColumn(column)

# Now the class is in an essentially OK-state, so we can

# set up any magic attributes:

declarative.setup_attributes(cls, new_attrs)

if sqlmeta.fromDatabase:

sqlmeta.addColumnsFromDatabase()

for j in implicitJoins:

sqlmeta.addJoin(j)

for i in implicitIndexes:

sqlmeta.addIndex(i)

def order_getter(o):

return o.creationOrder

sqlmeta.columnList.sort(key=order_getter)

sqlmeta.indexes.sort(key=order_getter)

sqlmeta.indexDefinitions.sort(key=order_getter)

# Joins cannot be sorted because addJoin created accessors

# that remember indexes.

# sqlmeta.joins.sort(key=order_getter)

sqlmeta.joinDefinitions.sort(key=order_getter)

# We don't setup the properties until we're finished with the

# batch adding of all the columns...

cls._notifyFinishClassCreation()

cls._SO_finishedClassCreation = True

makeProperties(cls)

# We use the magic "q" attribute for accessing lazy

# SQL where-clause generation. See the sql module for

# more.

if not is_base:

cls.q = sqlbuilder.SQLObjectTable(cls)

cls.j = sqlbuilder.SQLObjectTableWithJoins(cls)

classregistry.registry(sqlmeta.registry).addClass(cls)

@classmethod

def _SO_setupSqlmeta(cls, new_attrs, is_base):

"""

if ('sqlmeta' not in new_attrs and not is_base):

# We have to create our own subclass, usually.

# type(className, bases_tuple, attr_dict) creates a new subclass.

cls.sqlmeta = type('sqlmeta', (cls.sqlmeta,), {})

if not issubclass(cls.sqlmeta, sqlmeta):

# We allow no superclass and an object superclass, instead

# of inheriting from sqlmeta; but in that case we replace

# the class and just move over its attributes:

assert cls.sqlmeta.__bases__ in ((), (object,)), (

"If you do not inherit your sqlmeta class from "

"sqlobject.sqlmeta, it must not inherit from any other "

"class (your sqlmeta inherits from: %s)"

% cls.sqlmeta.__bases__)

for base in cls.__bases__:

superclass = getattr(base, 'sqlmeta', None)

if superclass:

break

else:

assert 0, (

"No sqlmeta class could be found in any superclass "

"(while fixing up sqlmeta %r inheritance)"

% cls.sqlmeta)

values = dict(cls.sqlmeta.__dict__)

for key in list(values.keys()):

if key.startswith('__') and key.endswith('__'):

# Magic values shouldn't be passed through:

del values[key]

cls.sqlmeta = type('sqlmeta', (superclass,), values)

if not is_base: # Do not pollute the base sqlmeta class

cls.sqlmeta.setClass(cls)

@classmethod

def _SO_cleanDeprecatedAttrs(cls, new_attrs):

"""

for attr in ():

if attr in new_attrs:

deprecated("%r is deprecated and read-only; please do "

"not use it in your classes until it is fully "

"deprecated" % attr, level=1, stacklevel=5)

@classmethod

def get(cls, id, connection=None, selectResults=None):

assert id is not None, \

'None is not a possible id for %s' % cls.__name__

id = cls.sqlmeta.idType(id)

if connection is None:

cache = cls._connection.cache

else:

cache = connection.cache

# This whole sequence comes from Cache.CacheFactory's

# behavior, where a None returned means a cache miss.

val = cache.get(id, cls)

if val is None:

try:

val = cls(_SO_fetch_no_create=1)

val._SO_validatorState = sqlbuilder.SQLObjectState(val)

val._init(id, connection, selectResults)

cache.put(id, cls, val)

finally:

cache.finishPut(cls)

elif selectResults and not val.sqlmeta.dirty:

val._SO_writeLock.acquire()

try:

val._SO_selectInit(selectResults)

val.sqlmeta.expired = False

finally:

val._SO_writeLock.release()

return val

@classmethod

def _notifyFinishClassCreation(cls):

pass

def _init(self, id, connection=None, selectResults=None):

assert id is not None

# This function gets called only when the object is

# created, unlike __init__ which would be called

# anytime the object was returned from cache.

self.id = id

self._SO_writeLock = threading.Lock()

# If no connection was given, we'll inherit the class

# instance variable which should have a _connection

# attribute.

if (connection is not None) and \

(getattr(self, '_connection', None) is not connection):

self._connection = connection

# Sometimes we need to know if this instance is

# global or tied to a particular connection.

# This flag tells us that:

self.sqlmeta._perConnection = True

if not selectResults:

dbNames = [col.dbName for col in self.sqlmeta.columnList]

selectResults = self._connection._SO_selectOne(self, dbNames)

if not selectResults:

raise SQLObjectNotFound(

"The object %s by the ID %s does not exist" % (

self.__class__.__name__, self.id))

self._SO_selectInit(selectResults)

self._SO_createValues = {}

self.sqlmeta.dirty = False

def _SO_loadValue(self, attrName):

try:

return getattr(self, attrName)