def __init__(cls, name, bases, ns): try: if Model not in bases: # Allow for inheritance of the Model object # for use with SqlAlchemy inheritance patterns super(ModelMeta, cls).__init__(name, bases, ns) return except NameError: # if this is the Model class, then just return return # set the tablename, if it's user set, use that, otherwise use a # function to create one cls.__tablename__ = getattr(cls, "__tablename__", pluralize(camel_to_underscore(name))) # tableargs adds autoload to create schema reflection cls.__table_args__ = getattr(cls, "__table_args__", {}) if project.schema_reflection: # create or update the __table_args__ attribute cls.__table_args__['autoload'] = True if project.global_table_args: cls.__table_args__.update(project.global_table_args) # check if the class has at least one primary key # if not, automatically generate one. has_primary = any([False] + [value.primary_key for value in cls.__dict__.values() if isinstance(value, Column)]) if not has_primary: # treat the id as a mixin w/copy surrogate_pk = surrogate_pk_template.copy() surrogate_pk._creation_order = surrogate_pk_template._creation_order cls.id = surrogate_pk super(ModelMeta, cls).__init__(name, bases, ns)
def __init__(cls, name, bases, ns): try: if Model not in bases: # Allow for inheritance of the Model object # for use with SqlAlchemy inheritance patterns super(ModelMeta, cls).__init__(name, bases, ns) return except NameError: # if this is the Model class, then just return return # set the tablename, if it's user set, use that, otherwise use a # function to create one cls.__tablename__ = getattr(cls, "__tablename__", pluralize(camel_to_underscore(name))) # tableargs adds autoload to create schema reflection cls.__table_args__ = getattr(cls, "__table_args__", {}) if context.config.schema_reflection: # create or update the __table_args__ attribute cls.__table_args__['autoload'] = True if context.config.global_table_args: cls.__table_args__.update(context.config.global_table_args) # check if the class has at least one primary key # if not, automatically generate one. has_primary = any([False] + [value.primary_key for value in cls.__dict__.values() if isinstance(value, sqlalchemy.Column)]) if not has_primary: # treat the id as a mixin w/copy surrogate_pk = surrogate_pk_template.copy() surrogate_pk._creation_order = surrogate_pk_template._creation_order cls.id = surrogate_pk super(ModelMeta, cls).__init__(name, bases, ns)
def load(self): ''' Loads controllers from app.controllers. Uses the controller name to define a path to controller mapping. It does some text munging to camel-case the module name to look up the expected classname in the modules. It loads all controller candidates into a mapping block to look up URLs against. Called only once at the start of a pybald application. ''' controller_names = [] for controller in my_project.app.controllers.__all__: controller_name = camel_to_underscore(controller) try: controller_path_name = self.controller_pattern.search( controller_name).group(1) except AttributeError: controller_path_name = controller_name controller_names.append(controller_path_name) # self.controllers holds paths to map to modules and controller # names self.controllers[controller_path_name] = getattr(my_project.app.controllers, controller) # register the controller module names # with the mapper, creates the internal regular # expressions self.map.create_regs(controller_names)
def load(self, controllers): """ Handles walking the registry (or old-style controller module) and builds the lookup table for controller classes to match against. Does some text munging to change the camel-case class names into underscore-separated url like names. (HomeController to home) :param controllers: A controller registry All controller candidates are loaded into a hash to look up the matched "controller" urlvar against. The _controller suffix is removed from the module name for the url route mapping table (so controller="home" matches home_controller). against and the routes regex is initialized with a list of controller names. Called only once at the start of a pybald application. """ controller_names = [] # switch between old-style package container and registry model # both should work here if hasattr(controllers, "__all__"): controller_iterator = ((name, getattr(controllers, name)) for name in controllers.__all__) else: controller_iterator = ((controller.__name__, controller) for controller in controllers) for name, controller in controller_iterator: controller_name = camel_to_underscore(name) try: controller_path_name = self.controller_pattern.search(controller_name).group(1) except AttributeError: controller_path_name = controller_name controller_names.append(controller_path_name) # self.controllers holds paths to map to modules and controller # names self.controllers[controller_path_name] = controller # register the controller module names # with the mapper, creates the internal regular # expressions self.map.create_regs(controller_names)
def action_wrapper(self, environ, start_response): req = Request(environ) # add any url variables as members of the controller for key in req.urlvars.keys(): #Set the controller object to contain the url variables # parsed from the dispatcher / router setattr(self, key, req.urlvars[key]) # this code defines the template id to match against # template path = controller name + '/' + action name (except in the case of) # index try: template_root_name = camel_to_underscore( controller_pattern.search(self.__class__.__name__ ).group(1)) except AttributeError: template_root_name = '' self.template_id = "/".join(filter(lambda x: x != '', [template_root_name, template_name])) # add the pybald extension dict to the controller # object for key, value in req.environ.get('pybald.extension', {}).items(): setattr(self, key, value) setattr(self, 'request', req) setattr(self, 'request_url', req.url) # Return either the controllers _pre code, whatever # is returned from the controller # or the view. So pre has precedence over # the return which has precedence over the view none_func = lambda *pargs, **kargs: None pre = getattr(self, '_pre', none_func) post = getattr(self, '_post', none_func) view = getattr(self, '_view', none_func) resp = pre(req) or method(self, req) or view() # if the response is currently a string # wrap it in a response object if isinstance(resp, basestring): resp = Response(body=resp, charset="utf-8") # run the controllers post code post(req, resp) return resp(environ, start_response)
def load(self, controllers): ''' Walks the controller registry and builds the lookup table for controller classes to match against. Does some text munging to change the camel-case class names into underscore-separated url like names. (HomeController to home) :param controllers: A controller registry, a list of all controllers that will be used with this application. All controller candidates are loaded into a hash to look up the matched "controller" urlvar against. The _controller suffix is removed from the module name for the url route mapping table (so controller="home" matches home_controller). This method is called only once at the start of a pybald application. ''' controller_names = [] controller_iterator = ((controller.__name__, controller) for controller in controllers) for name, controller in controller_iterator: controller_name = camel_to_underscore(name) try: controller_path_name = self.controller_pattern.search( controller_name).group(1) except AttributeError: controller_path_name = controller_name controller_names.append(controller_path_name) # self.controllers holds paths to map to modules and controller # names self.controllers[controller_path_name] = controller # register the controller module names # with the mapper, creates the internal regular # expressions self.map.create_regs(controller_names)
def get_template_name(instance, method_name): ''' Defines the template id to match against. :param instance: the instance to generate a template for :param method_name: the method to combine with the instance class template path = controller name + '/' + action name, except in the case of index. If the template is specified as part of the processed object return that, short circuiting any other template name processing This form may removed later, considered a candidate for deprecation ''' template_id = getattr(instance, 'template_id', None) if template_id: return template_id # build a default template name if one isn't explicitly set try: template_root_name = camel_to_underscore( controller_pattern.search(instance.__class__.__name__).group(1)) except AttributeError: template_root_name = '' return "/".join(filter(None, [template_root_name, method_name]))
def get_template_name(instance, method_name): ''' Defines the template id to match against. :param instance: the instance to generate a template for :param method_name: the method to combine with the instance class template path = controller name + '/' + action name, except in the case of index. If the template is specified as part of the processed object return that, short circuiting any other template name processing This form may removed later, considered a candidate for deprecation ''' template_id = getattr(instance, 'template_id', None) if template_id: return template_id # build a default template name if one isn't explicitly set try: template_root_name = camel_to_underscore( controller_pattern.search(instance.__class__.__name__ ).group(1)) except AttributeError: template_root_name = '' return "/".join(filter(None, [template_root_name, method_name]))