    import re

    from ModelObject import ModelObject
    from MiscUtils import NoDefault, StringTypes
    from MiddleDict import MiddleDict

    try: # for Python < 2.3
        True, False
    except NameError:
        True, False = 1, 0

    nameRE = re.compile('^([A-Za-z_][A-Za-z_0-9]*)$')
    reservedRE = re.compile('allattrs|changed|clone|debugstr|dumpattrs|key|klass'
        '|serialnum|store|valueforattr|valueforkey', re.I)

    class Attr(MiddleDict, ModelObject):
        """An Attr represents an attribute of a Klass.

        The Attr objects behave like dictionaries.

        """

        def __init__(self, dict):
            MiddleDict.__init__(self, {})
            for key, value in dict.items():
                if key == 'Attribute':
                    key = 'Name'
                if type(value) in StringTypes and not value.strip():
                    value = None
                self[key] = value
            name = self['Name']
            match = nameRE.match(name)
            if match is None or len(match.groups()) != 1:
                raise ValueError, 'Bad name (%r) for attribute: %r.' % (name, dict)
            match = reservedRE.match(name)
            if match is not None:
                raise ValueError, 'Reserved name (%r) for attribute: %r.' % (name, dict)
            self._getPrefix = None
            self._setPrefix = None

        def name(self):
            return self.data['Name']

        def isRequired(self):
            """Return true if a value is required for this attribute.

            In Python, that means the value cannot be None. In relational theory
            terms, that means the value cannot be NULL.

            """
            return self.boolForKey('isRequired')

        def setKlass(self, klass):
            """Set the klass that the attribute belongs to."""
            self._klass = klass

        def klass(self):
            """Return the klass that this attribute is declared in and, therefore, belongs to."""
            return self._klass

        def pyGetName(self):
            """Return the name that should be used for the Python "get" accessor method for this attribute."""
            if self._getPrefix is None:
                self._computePrefixes()
            name = self.name()
            if self._getCapped:
                return self._getPrefix + name[0].upper() + name[1:]
            else:
                return self._getPrefix + name

        def pySetName(self):
            """Return the name that should be used for the Python "set" accessor method for this attribute."""
            if self._setPrefix is None:
                self._computePrefixes()
            name = self.name()
            if self._setCapped:
                return self._setPrefix + name[0].upper() + name[1:]
            else:
                return self._setPrefix + name

        def setting(self, name, default=NoDefault):
            """Return the value of a particular configuration setting taken from the model.

            Implementation note: Perhaps a future version should ask the klass and so on up the chain.

            """
            return self.model().setting(name, default)

        def model(self):
            return self._klass.klasses()._model

        def awakeFromRead(self):
            pass

        ## Warnings ##

        def printWarnings(self, out):
            pass

        ## Self Util ##

        def _computePrefixes(self):
            style = self.setting('AccessorStyle', 'methods').lower()
            assert style in ('properties', 'methods')
            if style == 'properties':
                self._getPrefix = '_get_'
                self._setPrefix = '_set_'
                self._getCapped = False
                self._setCapped = False
            else:
                # methods
                self._getPrefix = ''
                self._setPrefix = 'set'
                self._getCapped = False
                self._setCapped = True