/usr/lib/python2.7/dist-packages/sqlobject/styles.py is in python-sqlobject 1.6.0-1.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 | import re
__all__ = ["Style", "MixedCaseUnderscoreStyle", "DefaultStyle",
"MixedCaseStyle"]
class Style(object):
"""
The base Style class, and also the simplest implementation. No
translation occurs -- column names and attribute names match,
as do class names and table names (when using auto class or
schema generation).
"""
def __init__(self, pythonAttrToDBColumn=None,
dbColumnToPythonAttr=None,
pythonClassToDBTable=None,
dbTableToPythonClass=None,
idForTable=None,
longID=False):
if pythonAttrToDBColumn:
self.pythonAttrToDBColumn = lambda a, s=self: pythonAttrToDBColumn(s, a)
if dbColumnToPythonAttr:
self.dbColumnToPythonAttr = lambda a, s=self: dbColumnToPythonAttr(s, a)
if pythonClassToDBTable:
self.pythonClassToDBTable = lambda a, s=self: pythonClassToDBTable(s, a)
if dbTableToPythonClass:
self.dbTableToPythonClass = lambda a, s=self: dbTableToPythonClass(s, a)
if idForTable:
self.idForTable = lambda a, s=self: idForTable(s, a)
self.longID = longID
def pythonAttrToDBColumn(self, attr):
return attr
def dbColumnToPythonAttr(self, col):
return col
def pythonClassToDBTable(self, className):
return className
def dbTableToPythonClass(self, table):
return table
def idForTable(self, table):
if self.longID:
return self.tableReference(table)
else:
return 'id'
def pythonClassToAttr(self, className):
return lowerword(className)
def instanceAttrToIDAttr(self, attr):
return attr + "ID"
def instanceIDAttrToAttr(self, attr):
return attr[:-2]
def tableReference(self, table):
return table + "_id"
class MixedCaseUnderscoreStyle(Style):
"""
This is the default style. Python attributes use mixedCase,
while database columns use underscore_separated.
"""
def pythonAttrToDBColumn(self, attr):
return mixedToUnder(attr)
def dbColumnToPythonAttr(self, col):
return underToMixed(col)
def pythonClassToDBTable(self, className):
return className[0].lower() \
+ mixedToUnder(className[1:])
def dbTableToPythonClass(self, table):
return table[0].upper() \
+ underToMixed(table[1:])
def pythonClassToDBTableReference(self, className):
return self.tableReference(self.pythonClassToDBTable(className))
def tableReference(self, table):
return table + "_id"
DefaultStyle = MixedCaseUnderscoreStyle
class MixedCaseStyle(Style):
"""
This style leaves columns as mixed-case, and uses long
ID names (like ProductID instead of simply id).
"""
def pythonAttrToDBColumn(self, attr):
return capword(attr)
def dbColumnToPythonAttr(self, col):
return lowerword(col)
def dbTableToPythonClass(self, table):
return capword(table)
def tableReference(self, table):
return table + "ID"
defaultStyle = DefaultStyle()
def getStyle(soClass, dbConnection=None):
if dbConnection is None:
if hasattr(soClass, '_connection'):
dbConnection = soClass._connection
if hasattr(soClass.sqlmeta, 'style') and soClass.sqlmeta.style:
return soClass.sqlmeta.style
elif dbConnection and dbConnection.style:
return dbConnection.style
else:
return defaultStyle
############################################################
## Text utilities
############################################################
_mixedToUnderRE = re.compile(r'[A-Z]+')
def mixedToUnder(s):
if s.endswith('ID'):
return mixedToUnder(s[:-2] + "_id")
trans = _mixedToUnderRE.sub(mixedToUnderSub, s)
if trans.startswith('_'):
trans = trans[1:]
return trans
def mixedToUnderSub(match):
m = match.group(0).lower()
if len(m) > 1:
return '_%s_%s' % (m[:-1], m[-1])
else:
return '_%s' % m
def capword(s):
return s[0].upper() + s[1:]
def lowerword(s):
return s[0].lower() + s[1:]
_underToMixedRE = re.compile('_.')
def underToMixed(name):
if name.endswith('_id'):
return underToMixed(name[:-3] + "ID")
return _underToMixedRE.sub(lambda m: m.group(0)[1].upper(),
name)
|