Changeset 4202

Show
Ignore:
Timestamp:
03/06/08 19:02:57 (5 months ago)
Author:
chrisz
Message:

Code clean-up and small improvements in the toolbox. This also fixes #1620.

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • branches/1.0/turbogears/toolbox/admi18n/catalog.py

    r3366 r4202  
    11import sys 
    22import os 
    3 import re 
    4 import time 
    53import codecs 
    64import pygettext 
    …… 
    4139        new_lang.append(msg) 
    4240 
    43     save(path,new_lang) 
     41    save(path, new_lang) 
    4442 
    4543def items(path, sort_by, dir): 
    …… 
    5452    group = dict() 
    5553    sorted = list() 
    56     col_map  = dict( 
    57                 id='id', 
    58                 string='message', 
    59                 context='path' 
    60                ) 
     54    col_map  = dict(id='id', string='message', context='path') 
    6155    for message in po: 
    6256        group.setdefault(message[col_map[sort_by]], []).append(message) 
    …… 
    10397        if p['id'].strip() == msg_id.strip(): 
    10498            p['message'] = msg_text 
    105  
    10699    save(path, message_list) 
    107100 
    …… 
    222215            l = eval(l) 
    223216        except Exception, e: 
    224             print >> sys.stderr, 'Escape error on %s:%d' % (infile, lno), \ 
    225                   'before:', `l` 
     217            print >> sys.stderr, 'Escape error on %s: %d' % (infile, lno), \ 
     218                'before:', repr(l) 
    226219            raise ParseError(e) 
    227220 
    …… 
    229222            l = l.decode('utf8') 
    230223        except UnicodeDecodeError: 
    231             print >> sys.stderr, 'Encoding error on %s:%d' % (infile, lno), \ 
    232                   'before:', `l` 
     224            print >> sys.stderr, 'Encoding error on %s: %d' % (infile, lno), \ 
     225                'before:', repr(l) 
    233226            raise ParseError(e) 
    234227 
    …… 
    247240    # Add last entry 
    248241    if section == STR: 
    249         add(msgid, msgstr, prev_context, fuzzy,MESSAGES) 
     242        add(msgid, msgstr, prev_context, fuzzy, MESSAGES) 
    250243 
    251244    MESSAGES[0]['message'] = u''.join(header) 

  • branches/1.0/turbogears/toolbox/admi18n/__init__.py

    r3366 r4202  
    11"""Graphical user interface for i18n administration""" 
    2 import os,sys 
     2 
     3import os 
     4import sys 
    35import time 
    46import shutil 
    57import codecs 
    68 
    7 import turbogears 
    8 from turbogears import controllers 
    9  
    10 import cherrypy 
    11 from cherrypy.lib.cptools import serveFile 
    12  
    139import pygettext 
    1410import msgfmt 
    1511import catalog 
    1612 
     13import cherrypy 
     14from cherrypy.lib.cptools import serveFile 
     15 
     16import turbogears 
     17from turbogears import controllers, expose, i18n 
     18 
    1719 
    1820class Internationalization(controllers.RootController): 
    1921    """I18N administration tool. 
    20        Collect your strings, add and manage locales, 
    21        edit and compile your catalogs 
     22 
     23    Collect your strings, add and manage locales, 
     24    edit and compile your catalogs. 
     25 
    2226    """ 
    23     __label__ ="admi18n" 
     27 
     28    __label__ = "admi18n" 
    2429    __version__ = "0.1" 
    2530    __author__ = "Ronald Jaramillo" 
    …… 
    4045    def get_languages(self): 
    4146        if not self.languages: 
    42             self.languages = turbogears.i18n.get_languages() 
     47            self.languages = i18n.get_languages() 
    4348 
    4449        return self.languages 
    …… 
    5055 
    5156        for c in code: 
    52             path = os.path.join(locales,c) 
     57            path = os.path.join(locales, c) 
    5358            try: 
    5459                shutil.rmtree(path) 
    …… 
    100105        shutil.copy(src, dest) 
    101106 
     107    [expose(format='json')] 
    102108    def po_upload(self, myFile, code): 
    103109        path = os.path.join(self.locales_directory(), 
    …… 
    107113        f.close() 
    108114        raise cherrypy.HTTPRedirect(turbogears.url('language', code=code)) 
    109     po_upload = turbogears.expose(format='json')(po_upload) 
    110115 
    111116    def google_translate(self, code, from_lang, to_lang, args): 
    112117        path = os.path.join(self.locales_directory(), 
    113                 code, 'LC_MESSAGES', 'messages.po') 
     118            code, 'LC_MESSAGES', 'messages.po') 
    114119        for arg in args: 
    115120            if not 'text_' in arg: 
    116121                continue 
    117  
    118122            msg_id = args[arg] 
    119123            msg_id = msg_id.decode('utf-8') 
    120             translated = turbogears.i18n.utils.google_translate( 
     124            translated = i18n.utils.google_translate( 
    121125                    from_lang, to_lang, msg_id) 
    122126            translated = translated.encode('utf-8') 
    123127            catalog.update(path, msg_id, translated) 
    124128 
     129    [expose(format='json')] 
    125130    def update_catalog(self, code, msg_id, msg_text): 
    126131        path = os.path.join(self.locales_directory(), 
    127132                code, 'LC_MESSAGES', 'messages.po') 
    128133        catalog.update(path, msg_id, msg_text) 
    129  
    130134        return 'ok' 
    131     update_catalog = turbogears.expose(format='json')(update_catalog) 
    132  
     135 
     136    [expose(template='%s.po_view' % baseTemplate)] 
    133137    def po_view(self, code, sort_by=None, dir=None, 
    134138            from_lang=None, to_lang=None, **kargs): 
    …… 
    137141            visible_checkbox = True 
    138142            self.google_translate(code, from_lang, to_lang, kargs) 
    139  
    140143        path = os.path.join(self.locales_directory(), 
    141144                code, 'LC_MESSAGES', 'messages.po') 
    142         return dict(code=code, catalog=catalog.items(path,sort_by,dir), 
     145        return dict(code=code, catalog=catalog.items(path, sort_by, dir), 
    143146                visible_checkbox=visible_checkbox ) 
    144     po_view = turbogears.expose(template='%s.po_view'% baseTemplate)(po_view) 
    145  
    146     def language(self,code): 
    147         path = os.path.join(self.locales_directory(), 
    148                 code, 'LC_MESSAGES', 'messages.po') 
    149         po_message_file = dict( 
    150                             path=path, 
    151                             modified=time.ctime(os.path.getmtime(path)), 
    152                             size=os.path.getsize(path) 
    153                           ) 
    154  
     147 
     148    [expose(template='%s.language' % baseTemplate)] 
     149    def language(self, code): 
     150        path = os.path.join(self.locales_directory(), 
     151            code, 'LC_MESSAGES', 'messages.po') 
     152        po_message_file = dict(path=path, 
     153            modified=time.ctime(os.path.getmtime(path)), 
     154            size=os.path.getsize(path)) 
    155155        return dict(code=code, 
    156                     language=self.language_for_code(code), 
    157                     po_message_file=po_message_file 
    158                    ) 
    159     language= turbogears.expose(template='%s.language'% baseTemplate)(language) 
    160  
     156            language=self.language_for_code(code), 
     157            po_message_file=po_message_file) 
     158 
     159    [expose(format='json')] 
    161160    def language_list(self): 
    162161        return dict(languages=self.get_languages()) 
    163     language_list = turbogears.expose(format='json')(language_list) 
    164  
     162 
     163    [expose(template='%s.languageManagement' % baseTemplate)] 
    165164    def language_management(self, add=None, rem=None, compile=None, merge=None): 
    166165        if add: 
    167166            self.add_locale(add) 
    168  
    169167        if rem: 
    170168            self.remove_locale(rem) 
    171  
    172169        if compile: 
    173170            self.compile_catalogs(compile) 
    174  
    175171        if merge: 
    176172            self.merge_catalogs(merge) 
    177  
    178         return dict( 
    179                 languages=list(), 
    180                 locales=self.project_locales() 
    181                 ) 
    182     language_management = turbogears.expose( 
    183             template='%s.languageManagement'% baseTemplate)(language_management) 
     173        return dict(languages=list(), 
     174            locales=self.project_locales()) 
    184175 
    185176    def language_for_code(self, code): 
    …… 
    240231        def collect_files(file_list, dirpath, namelist): 
    241232            level = len([x for x in dirpath.split(os.sep) if x]) - base_level 
    242             slot0 = dict(# directory info 
    243                       dir=os.path.dirname(dirpath), 
    244                       file_name=os.path.basename(dirpath), 
    245                       path=dirpath, 
    246                       isdir=True, 
    247                       level=level 
    248                     ) 
    249  
     233            slot0 = dict( # directory info 
     234                dir=os.path.dirname(dirpath), 
     235                file_name=os.path.basename(dirpath), 
     236                path=dirpath, isdir=True, level=level) 
    250237            slot1 = list() # children directories info 
    251238            slot2 = list() # children files info 
    …… 
    254241            if level: 
    255242                dct[os.path.dirname(dirpath)][1].append(slots) 
    256  
    257243            else: 
    258244                file_list.append(slots) 
    …… 
    264250                    namelist.remove(name) 
    265251                    continue 
    266  
    267252                p = os.path.join(dirpath, name) 
    268253                if os.path.isfile(p) and \ 
    269254                        os.path.splitext(name)[-1] in ['.py','.kid','.tmpl']: 
    270                     slot2.append(dict( 
    271                                    dir=dirpath, 
    272                                    file_name=name, 
    273                                    path=p, 
    274                                    isdir=os.path.isdir(p), 
    275                                    level=level+1 
    276                                  )) 
     255                    slot2.append(dict(dir=dirpath, file_name=name, 
     256                        path=p, isdir=os.path.isdir(p), level=level+1)) 
    277257            # decide if current directory (and ancestors) should be visible 
    278258            visibility[dirpath] = bool(slot2) 
    …… 
    314294            return 
    315295 
    316         return dict( 
    317                 name='messages.pot', 
    318                 path=pot, 
    319                 modified=time.ctime(os.path.getmtime(pot)), 
    320                 size=os.path.getsize(pot) 
    321                 ) 
    322  
     296        return dict(name='messages.pot', path=pot, 
     297            modified=time.ctime(os.path.getmtime(pot)), 
     298            size=os.path.getsize(pot)) 
     299 
     300    [expose()] 
    323301    def lang_file(self, code): 
    324         #serve static file, the code can be pot or a lang code 
    325         locales = self.locales_directory() 
    326         if code=='pot': 
     302        # serve static file, the code can be pot or a lang code 
     303        locales = self.locales_directory() 
     304        if code == 'pot': 
    327305            path = os.path.join(locales, 'messages.pot') 
    328306        else: 
    …… 
    330308            path = os.path.join(path, 'LC_MESSAGES') 
    331309            path = os.path.join(path, 'messages.po') 
    332  
    333310        if 'If-Modified-Since' in cherrypy.request.headers: 
    334311            del cherrypy.request.headers['If-Modified-Since'] # see ticket #879 
    335  
    336312        return serveFile(path, "application/x-download", "attachment") 
    337     lang_file = turbogears.expose()(lang_file) 
    338  
     313 
     314    [expose(template='%s.stringCollection' % baseTemplate)] 
    339315    def string_collection(self, files=[]): 
    340316        if files: 
    341317            if type(files) != type([]): 
    342                 files=[files] 
    343  
     318                files = [files] 
    344319            self.collect_string_for_files(files) 
    345         return dict( 
    346                 project_files=self.project_files(), 
    347                 pot_message_file=self.pot_message_file() 
    348                 ) 
    349     string_collection = turbogears.expose( 
    350             template='%s.stringCollection'% baseTemplate)(string_collection) 
    351  
     320        return dict(project_files=self.project_files(), 
     321            pot_message_file=self.pot_message_file()) 
     322 
     323    [expose(template='%s.internationalization' % baseTemplate)] 
    352324    def index(self): 
    353325        return dict() 
    354     index = turbogears.expose( 
    355             template='%s.internationalization'% baseTemplate)(index) 

  • branches/1.0/turbogears/toolbox/base.py

    r4065 r4202  
    11"""Graphical user interface for managing TurboGears projects""" 
    22 
    3 from turbogears import controllers 
    4 from turbogears.util import setlike 
    5 from turbogears import identity 
    63import pkg_resources 
     4import cherrypy 
    75import turbogears 
    8 import cherrypy 
    9 import shell 
    10 import admi18n 
    11 import designer 
     6from turbogears.util import get_project_name, setlike 
     7from turbogears import controllers, expose 
     8 
    129 
    1310class Info(controllers.Controller): 
    1411    """TurboGears System Information. 
    15        Lists your TurboGears packages and version information 
     12 
     13    Lists your TurboGears packages and version information. 
     14 
    1615    """ 
    17     __label__ ="System Info" 
     16 
     17    __label__ = "System Info" 
    1818    __version__ = "0.1" 
    1919    __author__ = "Ronald Jaramillo" 
    …… 
    2424    icon = "/tg_static/images/info.png" 
    2525 
     26    [expose(template='turbogears.toolbox.info')] 
    2627    def index(self): 
    2728        from turbogears.command.info import retrieve_info 
    2829        packages, plugins = retrieve_info() 
    2930        return dict(packages=packages, plugins=plugins) 
    30     index = turbogears.expose(template='turbogears.toolbox.info')(index) 
     31 
    3132 
    3233class WidgetBrowser(controllers.Controller): 
    33     """Browse usage samples, description and source code for the available TurboGears Widgets""" 
    34     __label__ ="Widget Browser" 
     34    """The widget browser. 
     35 
     36    Browse usage samples, description and source code for the available 
     37    TurboGears Widgets. 
     38 
     39    """ 
     40 
     41    __label__ = "Widget Browser" 
    3542    __version__ = "0.1" 
    3643    __author__ = "Kevin Dangoor" 
    …… 
    4249    icon = "/tg_static/images/widgets.png" 
    4350 
    44     [turbogears.expose(template="turbogears.toolbox.widgets")] 
     51    [expose(template="turbogears.toolbox.widgets")] 
    4552    def index(self, name=None): 
    4653        from turbogears import widgets 
    …… 
    5764            all_descs = {name: all_descs[name]} 
    5865        desclist = all_descs.values() 
    59         desclist.sort(cmp=lambda x,y: cmp(x.name.lower(), y.name.lower())) 
     66        desclist.sort(cmp=lambda x, y: cmp(x.name.lower(), y.name.lower())) 
    6067        output = dict(descs=desclist, viewing_one=name != None) 
    6168        if name: 
    …… 
    9198            raise AttributeError(widgetname) 
    9299 
     100 
    93101class Toolbox(controllers.RootController): 
     102 
    94103    def __init__(self): 
    95104        self.toolbox = self.get_tools() 
    96105 
    97     def tool_icon(self,tool): 
    98         icon = getattr(tool,'icon','') 
    99         if icon: return icon 
     106    def tool_icon(self, tool): 
     107        icon = getattr(tool, 'icon', '') 
     108        if icon: 
     109            return icon 
    100110 
    101111    def get_tools(self): 
    102         tools = [] 
     112        project_name = get_project_name() 
     113        toolbox = [] 
    103114        for i in pkg_resources.iter_entry_points("turbogears.toolboxcommand"): 
    104  
    105115            tool = i.load() 
    106             tools.append((tool, i.name)) 
    107             setattr(self, i.name, tool()) 
    108         toolbox = [] 
    109         for tool, name in tools: 
    110116            args = { 
    111                     'path':name, 
    112                     'label':getattr(tool,'__label__',tool), 
    113                     'description':getattr(tool,'__doc__',''), 
    114                     'version':getattr(tool,'__version__',''), 
    115                     'author':getattr(tool,'__author__',''), 
    116                     'email':getattr(tool,'__email__',''), 
    117                     'copyright':getattr(tool,'__copyright__',''), 
    118                     'license':getattr(tool,'__license__',''), 
    119                     'icon':self.tool_icon(tool), 
    120                     'disabled': False 
    121                    } 
    122             if not turbogears.util.get_project_name() and getattr(tool, 'need_project', False): 
     117                'path': i.name, 
     118                'label': getattr(tool, '__label__', i.name), 
     119                'description': getattr(tool, '__doc__', ''), 
     120                'version': getattr(tool, '__version__', ''), 
     121                'author': getattr(tool, '__author__', ''), 
     122                'email': getattr(tool, '__email__', ''), 
     123                'copyright': getattr(tool, '__copyright__', ''), 
     124                'license': getattr(tool, '__license__', ''), 
     125                'icon': self.tool_icon(tool), 
     126                'disabled': False} 
     127            if project_name or not getattr(tool, 'need_project', False): 
     128                try: 
     129                    setattr(self, i.name, tool()) 
     130                except Exception, e: 
     131                    args["description"] = str(e) or 'Tool could not be loaded.' 
     132                    args["disabled"] = 'disabled' 
     133            else: 
     134                args["description"] += '\nNeeds project.' 
    123135                args["disabled"] = 'disabled' 
    124136            toolbox.append(args) 
    125137        return toolbox 
    126138 
    127     def arrange_in_pairs(self,tools): 
    128         p = [[],[]] 
    129         for idx,tool in enumerate(tools): p[idx%2].append(tool) 
    130         pairs = zip(p[0],p[1]) 
    131         if len(p[0]) > len(p[1]): pairs.append([p[0][-1],None]) 
    132         if len(p[0]) < len(p[1]): pairs.append([p[1][-1],None]) 
     139    def arrange_in_pairs(self, tools): 
     140        p = [[], []] 
     141        for idx, tool in enumerate(tools): 
     142            p[idx%2].append(tool) 
     143        pairs = zip(p[0], p[1]) 
     144        if len(p[0]) > len(p[1]): 
     145            pairs.append([p[0][-1], None]) 
     146        if len(p[0]) < len(p[1]): 
     147            pairs.append([p[1][-1], None]) 
    133148        return pairs 
    134149 
     150    [expose(template="turbogears.toolbox.main")] 
    135151    def index(self): 
    136152        return dict(toolbox = self.arrange_in_pairs(self.toolbox), 
    137                 project = turbogears.util.get_project_name()) 
    138     index = turbogears.expose(template="turbogears.toolbox.main")(index) 
     153            project = get_project_name()) 
    139154 
     155    [expose()] 
    140156    def noaccess(self): 
    141157        return """<h3>No access for %s</h3> 
    142                     <p> 
    143                        By default only localhost (127.0.0.1) 
    144                        has access to the Toolbox 
    145                     </p> 
    146                     <p> 
    147                        You can provide access to your client by passing 
    148                        your host address to Toolbox as a parameter. Ex: 
    149                     </p> 
    150                     <pre> 
    151                         tg-admin toolbox -c %s 
    152                     </pre> 
    153              """% (cherrypy.request.remoteAddr,cherrypy.request.remoteAddr) 
    154     noaccess = turbogears.expose()(noaccess) 
     158            <p> 
     159               By default only localhost (127.0.0.1) 
     160               has access to the Toolbox 
     161            </p> 
     162            <p> 
     163               You can provide access to your client by passing 
     164               your host address to Toolbox as a parameter. Ex: 
     165            </p> 
     166            <pre> 
     167                tg-admin toolbox -c %s 
     168            </pre> 
     169            """ % (cherrypy.request.remoteAddr,cherrypy.request.remoteAddr) 

  • branches/1.0/turbogears/toolbox/catwalk/browse.py

    r3366 r4202  
     1import cherrypy 
     2 
     3try: 
     4    import sqlobject 
     5except ImportError: 
     6    sqlobject = None 
     7else: 
     8    from sqlobject.sqlbuilder import Select, func, AND, IN 
     9 
    110import turbogears 
    2 import sqlobject 
    3 from sqlobject.sqlbuilder import * 
    4 import cherrypy 
     11from turbogears import expose 
     12 
    513 
    614class Browse(object): 
    7     def __getattr__(self,attrib): 
    8         """Delegate basic methods to CatWalk""" 
    9         return getattr(self.catwalk,attrib) 
    10  
    11  
    12     def list_view(sql_class_name,page_size=10,offset=10,fields=[],filters=[],sort_by=None): 
     15 
     16    def __getattr__(self, attrib): 
     17        """Delegate basic methods to CatWalk.""" 
     18        return getattr(self.catwalk, attrib) 
     19 
     20    def list_view(sql_class_name, page_size=10, offset=10, 
     21            fields=[], filters=[], sort_by=None): 
    1322        pass 
    1423 
    15     def index(self,object_name,start=0,page_size=10,context='',filters=''): 
     24    [expose(template='turbogears.toolbox.catwalk.browse_grid', allow_json=True)] 
     25    def index(self, object_name, start=0, page_size=10, 
     26            context='', filters=''): 
    1627        total = 0 
    1728        headers = [] 
    …… 
    1930        start = int(start) 
    2031        page_size = int(page_size) 
    21         if not context: context = object_name 
    22         headers = self.column_headers(object_name,context) 
     32        if not context: 
     33            context = object_name 
     34        headers = self.column_headers(object_name, context) 
    2335        headers = [header for header in headers if header['visible']] 
    24         total,rows = self.rows_for_model(object_name,start,page_size,filters) 
    25  
    26         return dict(object_name=object_name, 
    27                     start=start, 
    28                     page_size=page_size, 
    29                     total=total, 
    30                     headers= headers, 
    31                     rows = rows 
    32                    ) 
    33     index = turbogears.expose(template='turbogears.toolbox.catwalk.browse_grid', 
    34                               allow_json=True)(index) 
    35  
    36     def columns(self,object_name,context=''): 
    37         if not context:context = object_name 
    38         return dict(object_name=object_name, 
    39                     context = context, 
    40                     columns=self.extended_column_headers(object_name,context)) 
    41     columns = turbogears.expose(template='turbogears.toolbox.catwalk.columns', 
    42                                 allow_json=True)(columns) 
    43  
    44     def save_columns(self,object_name,context,order,hidden_columns,updated_fk_labels): 
    45         self.save_column_order(context,order) 
    46         self.hide_columns(context,hidden_columns) 
     36        total, rows = self.rows_for_model( 
     37            object_name, start, page_size, filters) 
     38        return dict(object_name=object_name, start=start, page_size=page_size, 
     39            total=total, headers= headers, rows = rows) 
     40 
     41    [expose(template='turbogears.toolbox.catwalk.columns', allow_json=True)] 
     42    def columns(self, object_name, context=''): 
     43        if not context: 
     44            context = object_name 
     45        return dict(object_name=object_name, context = context, 
     46            columns=self.extended_column_headers(object_name, context)) 
     47 
     48    [expose(allow_json=True)] 
     49    def save_columns(self, object_name, context, order, hidden_columns, 
     50            updated_fk_labels): 
     51        self.save_column_order(context, order) 
     52        self.hide_columns(context, hidden_columns) 
    4753        if updated_fk_labels: 
    4854            for updated_fk_label in updated_fk_labels.split('|'): 
    49                 object,column_name = updated_fk_label.split(':') 
    50                 self.column_label_for_object(object,column_name) 
    51         return "<script>parent.cat_browse.columns_saved('%s','%s');</script>"% (object_name,context) 
    52     save_columns= turbogears.expose(allow_json=True)(save_columns) 
    53  
    54     def extended_column_headers(self,object_name,context): 
    55         cols = [{'name':'id','title':'#','type':'SOInteger'}] 
    56         cols.extend(self.column_labels(object_name,extended=True)) 
    57         cols.extend(self.join_labels(object_name,extended=True)) 
    58         cols = self.arrange_columns(cols,context) 
    59         return cols 
    60  
    61     def column_headers(self,object_name,context): 
    62         cols = [{'name':'id','title':'#'}] 
     55                obj, column_name = updated_fk_label.split(':') 
     56                self.column_label_for_object(obj, column_name) 
     57        return ("<script>parent.cat_browse.columns_saved('%s','%s');" 
     58            "</script>" % (object_name, context)) 
     59 
     60    def extended_column_headers(self, object_name, context): 
     61        cols = [{'name': 'id', 'title': '#', 'type': 'SOInteger'}] 
     62        cols.extend(self.column_labels(object_name, extended=True)) 
     63        cols.extend(self.join_labels(object_name, extended=True)) 
     64        cols = self.arrange_columns(cols, context) 
     65        return cols 
     66 
     67    def column_headers(self, object_name, context): 
     68        cols = [{'name': 'id', 'title': '#'}] 
    6369        cols.extend(self.column_labels(object_name)) 
    6470        cols.extend(self.join_labels(object_name)) 
    65         cols = self.arrange_columns(cols,object_name) 
    66         return cols 
    67  
    68     def arrange_columns(self,headers,context): 
    69         #arrange order and visibility 
     71        cols = self.arrange_columns(cols, object_name) 
     72        return cols 
     73 
     74    def arrange_columns(self, headers, context): 
     75        # arrange order and visibility 
    7076        hidden_columns = self.load_columns_visibility_state(context) 
    7177        order = self.load_column_order(context) 
    7278        for col in headers: 
    7379            col['visible'] = True 
    74             if col['name'] in hidden_columns: col['visible'] = False 
    75  
    76         if not order:return headers 
    77         c={} 
     80            if col['name'] in hidden_columns: 
     81                col['visible'] = False 
     82        if not order: 
     83            return headers 
     84        c = {} 
    7885        for col in headers: 
    7986            c[col['name']] = col 
    80             if col['name'] not in order:order.append(col['name']) 
     87            if col['name'] not in order: 
     88                order.append(col['name']) 
    8189        rearrenged = [] 
    8290        for name in order: 
    83             if name not in c.keys():continue 
     91            if name not in c.keys(): 
     92                continue 
    8493            rearrenged.append(c[name]) 
    8594        return rearrenged 
    8695 
    87     def prepare_filter(self,obj,filter): 
     96    def prepare_filter(self, obj, filter): 
    8897        for column in obj.sqlmeta.columns.values(): 
    8998            if column.origName == filter[0]: 
    90                 return getattr(obj.q,column.name) == filter[1] 
    91  
    92         #if we got so far we couldn't find the column, bark at the moon 
    93         msg='filter_column_error. Could not find the column for filter:%s'% filter[0] 
     99                return getattr(obj.q, column.name) == filter[1] 
     100        # if we got so far we couldn't find the column, bark at the moon 
     101        msg = ('filter_column_error.' 
     102            ' Could not find the column for filter: %s' % filter[0]) 
    94103        raise cherrypy.HTTPRedirect(turbogears.url('/error', msg=msg)) 
    95104 
    96     def filtered_query(self,obj,filters): 
    97         if not ':' in filters: #there should at least be a semicolon 
    98             msg='filter_format_error. The format is column_name:value, not %s'% filters 
     105    def filtered_query(self, obj, filters): 
     106        if not ':' in filters: # there should at least be a semicolon 
     107            msg = ('filter_format_error.' 
     108                ' The format is column_name:value, not %s' % filters) 
    99109            raise cherrypy.HTTPRedirect(turbogears.url('/error', msg=msg)) 
    100110 
    101111        filters = [filter.split(':') for filter in filters.split(',')] 
    102         conditions =  tuple([self.prepare_filter(obj,filter) for filter in filters]) 
    103         return obj.select(AND(* conditions )) 
    104  
    105     def rows_for_model(self,object_name,start,page_size,filters): 
    106         ids = [] 
     112        conditions =  tuple([self.prepare_filter(obj, filter) 
     113            for filter in filters]) 
     114        return obj.select(AND(* conditions)) 
     115 
     116    def rows_for_model(self, object_name, start, page_size, filters): 
    107117        rows = {} 
    108118        obj = self.load_object(object_name) 
    109119 
    110120        if filters: 
    111             query = self.filtered_query(obj,filters) 
     121            query = self.filtered_query(obj, filters) 
    112122        else: 
    113123            query = obj.select() 
    …… 
    120130 
    121131        for result in results: 
    122             rows[result.id] = self.fields(object_name,result) 
    123  
    124         relations = self.relation_values(object_name,rows) 
    125         rows = self.merge_relation_values(rows,relations) 
    126         rows = self.foreign_key_alias_value(object_name,rows) 
    127         return total,rows 
    128  
    129     def relation_values(self,object_name,rows): 
     132            rows[result.id] = self.fields(object_name, result) 
     133 
     134        relations = self.relation_values(object_name, rows) 
     135        rows = self.merge_relation_values(rows, relations) 
     136        rows = self.foreign_key_alias_value(object_name, rows) 
     137        return total, rows 
     138 
     139    def relation_values(self, object_name, rows): 
    130140        joins = {} 
    131141        ids = rows.keys() 
    132         if not ids: return joins 
     142        if not ids: 
     143            return joins 
    133144 
    134145        obj = self.load_object(object_name) 
    …… 
    138149            coltype = self.get_column_type(column) 
    139150            if coltype in ('SOMultipleJoin', 'SOSQLMultipleJoin'): 
    140                 query = conn.sqlrepr( Select( [ 
    141                                          column.soClass.q.id, 
    142                                          func.Count(column.otherClass.q.id) 
    143                                          ], 
    144                                          where=AND( 
    145                                                     column.soClass.q.id==self.join_foreign_key(column), 
    146                                                     IN(column.soClass.q.id,ids) 
    147                                                 ), groupBy=column.soClass.q.id)) 
     151                query = conn.sqlrepr(Select([ 
     152                    column.soClass.q.id, 
     153                    func.Count(column.otherClass.q.id)], 
     154                    where=AND( 
     155                        column.soClass.q.id==self.join_foreign_key(column), 
     156                        IN(column.soClass.q.id, ids)), 
     157                    groupBy=column.soClass.q.id)) 
    148158 
    149159            elif coltype in ('SORelatedJoin', 'SOSQLRelatedJoin'): 
    150160                d = (column.intermediateTable, 
    151                     column.joinColumn, 
    152                     column.intermediateTable, 
    153                     column.otherColumn, 
    154                     column.intermediateTable, 
    155                     column.intermediateTable, 
    156                     column.joinColumn, 
    157                     ','.join(['%s'%x for x in ids]), 
    158                     column.intermediateTable, 
    159                     column.joinColumn) 
    160  
    161                 query = "SELECT %s.%s, Count(%s.%s) FROM %s WHERE %s.%s IN(%s) GROUP BY %s.%s" % d 
    162  
     161                    column.joinColumn, 
     162                    column.intermediateTable, 
     163                    column.otherColumn, 
     164                    column.intermediateTable, 
     165                    column.intermediateTable, 
     166                    column.joinColumn, 
     167                    ','.join(['%s' % x for x in ids]), 
     168                    column.intermediateTable, 
     169                    column.joinColumn) 
     170 
     171                query = ("SELECT %s.%s, Count(%s.%s) FROM %s" 
     172                    " WHERE %s.%s IN(%s) GROUP BY %s.%s" % d) 
    163173 
    164174            elif coltype == 'SOSingleJoin': 
    165175                alias = self.load_label_column_for_object(column.otherClassName) 
    166                 query = conn.sqlrepr( Select( [ column.soClass.q.id,getattr(column.otherClass.q,alias)], 
    167                                                 where=AND( 
    168                                                     column.soClass.q.id==self.join_foreign_key(column), 
    169                                                     IN(column.soClass.q.id,ids) 
    170                                                 ))) 
    171  
    172             if not query: continue 
     176                query = conn.sqlrepr(Select([ 
     177                    column.soClass.q.id, getattr(column.otherClass.q, alias)], 
     178                    where=AND( 
     179                        column.soClass.q.id==self.join_foreign_key(column), 
     180                        IN(column.soClass.q.id,ids)))) 
     181 
     182            if not query: 
     183                continue 
    173184            joins[column.joinMethodName] = conn.queryAll(query) 
    174185        return joins 
    175186 
    176     def foreign_key_alias_value(self,object_name,rows): 
     187    def foreign_key_alias_value(self, object_name, rows): 
    177188        for column in self.foreign_key_columns(object_name): 
    178189            alias = self.load_label_column_for_object(column.foreignKey) 
    179             if alias == 'id':continue 
    180             column_name = column.name.replace('ID','') 
    181             fk_values = self.foreign_key_query(column,alias,[x[column_name] for x in rows]) 
    182             for row in rows: row[column_name] = fk_values.get(row[column_name],'') 
     190            if alias == 'id': 
     191                continue 
     192            column_name = column.name.replace('ID', '') 
     193            fk_values = self.foreign_key_query(column, alias, 
     194                [x[column_name] for x in rows]) 
     195            for row in rows: 
     196                row[column_name] = fk_values.get(row[column_name], '') 
    183197        return rows 
    184198 
    185     def foreign_key_query(self,column,alias,ids): 
    186         if not ids: return {} 
     199    def foreign_key_query(self, column, alias, ids): 
     200        if not ids: 
     201            return {} 
    187202        sql_object = self.load_object(column.foreignKey) 
    188203        conn = sql_object._connection 
    189         query = conn.sqlrepr( Select( [ sql_object.q.id,getattr(sql_object.q,alias) ], 
    190                                       where=IN(sql_object.q.id,ids) ) ) 
     204        query = conn.sqlrepr(Select( 
     205            [sql_object.q.id, getattr(sql_object.q, alias)], 
     206            where=IN(sql_object.q.id, ids))) 
    191207        fk_values = {} 
    192         for id,alias in conn.queryAll(query): fk_values[str(id)] = self.encode_label( alias ) 
     208        for id, alias in conn.queryAll(query): 
     209            fk_values[str(id)] = self.encode_label(alias) 
    193210        return fk_values 
    194211 
    195     def join_foreign_key(self,column): 
    196         foreign_key = '%sID'% column.joinColumn.split('_')[0] 
    197         return getattr(column.otherClass.q,foreign_key) 
    198  
    199     def column_label_options(self,column): 
    200         foreign_key_labels = [{'name':'id','title':'#'}] 
     212    def join_foreign_key(self, column): 
     213        foreign_key = '%sID' % column.joinColumn.split('_')[0] 
     214        return getattr(column.otherClass.q, foreign_key) 
     215 
     216    def column_label_options(self, column): 
     217        foreign_key_labels = [{'name': 'id', 'title': '#'}] 
    201218        foreign_key_labels.extend(self.column_labels(column.foreignKey)) 
    202219        return foreign_key_labels 
    203220 
    204     def column_labels(self,object_name,extended=False): 
     221    def column_labels(self, object_name, extended=False): 
    205222        cols = [] 
    206223        sql_object = self.load_object(object_name) 
    207224        for column_name in sql_object.sqlmeta.columns: 
    208225            column = sql_object.sqlmeta.columns[column_name] 
    209             if sql_object._inheritable and column_name == 'childName':continue 
    210             cols.append({'name':column.name, 'title':self.column_title(column)}) 
     226            if sql_object._inheritable and column_name == 'childName': 
     227                continue 
     228            cols.append({'name': column.name, 
     229                'title': self.column_title(column)}) 
     230            col = cols[-1] 
    211231            if isinstance(column, sqlobject.col.SOForeignKey): 
    212                 cols[-1]['name'] = cols[-1]['name'].replace('ID','') 
     232                col['name'] = col['name'].replace('ID', '') 
    213233            if extended: 
    214                 cols[-1]['type']=self.get_column_type(column) 
     234                col['type'] = self.get_column_type(column) 
    215235                if isinstance(column, sqlobject.col.SOForeignKey): 
    216                     cols[-1]['column_label'] = self.load_label_column_for_object(column.foreignKey) 
    217                     cols[-1]['label_options']=self.column_label_options(column) 
    218                     cols[-1]['other_class_name'] = column.foreignKey 
    219         return cols 
    220  
    221     def join_labels(self,object_name,extended=False): 
     236                    col['column_label'] = self.load_label_column_for_object( 
     237                        column.foreignKey) 
     238                    col['label_options'] = self.column_label_options(column) 
     239                    col['other_class_name'] = column.foreignKey 
     240        return cols 
     241 
     242    def join_labels(self, object_name, extended=False): 
    222243        cols = [] 
    223244        sql_object = self.load_object(object_name) 
    224245        for col in sql_object.sqlmeta.joins: 
    225             cols.append({'name':col.joinMethodName,'title':''}) 
     246            cols.append({'name': col.joinMethodName, 'title': ''}) 
    226247            if extended: 
    227                 cols[-1]['type']=self.get_column_type(col) 
     248                cols[-1]['type'] = self.get_column_type(col) 
    228249                cols[-1]['other_class_name'] = col.otherClassName 
    229250        return cols 
    230251<