python-myghty 1.1-6 / usr / lib / python2.7 / dist-packages / myghty / component.py

# $Id: component.py 2133 2006-09-06 18:52:56Z dairiki $
# component.py - component base classes for Myghty
# Copyright (C) 2004, 2005 Michael Bayer mike_mp@zzzcomputing.com
# Original Perl code and documentation copyright (c) 1998-2003 by Jonathan Swartz. 
#
# This module is part of Myghty and is released under
# the MIT License: http://www.opensource.org/licenses/mit-license.php
#
#

"""the component package defines the Component class and several subclasses.  FileComponent
serves as the base class for template style-components, and ModuleComponent the base
for module-based components."""

from myghty import exception
from myghty.util import *
from myghty.args import *
import myghty.request
import myghty.csource

import weakref, string
import posixpath as unixpath
import sys, inspect, types

__all__ = ['Component', 'ModuleComponent', 'HTTPModuleComponent', 'FileComponent', 'SubComponent']

argtypes = (            
    (RequestArg, True, 'required_request_args'),
    (RequestArg, False, 'request_args'),
    (SubRequestArg, True, 'required_subrequest_args'),
    (SubRequestArg, False, 'subrequest_args'),
    (LocalArg, True, 'required_args'),
    (LocalArg, False, 'args'),
    (DynamicArg, True, 'required_dynamic_args'),
    (DynamicArg, False, 'dynamic_args'),
)
        
class Component(object):
    """Base class for all components.  the primary method is the run() method which
    executes the Component in the context of a particular request.  A Component instance
    is usually cached in memory based on its component ID and can execute many requests
    simultaneously."""
    
    def __init__(self, interpreter, component_source, **params):
        """initializes a new Component. this method is called by the Interpreter."""
        self.filter = None
        self.owner = self.parent_component = None
        
        self.flags = {}
        self.attr = {}
        self.arguments = []

        self.component_source = component_source
        
        self.is_method = self.is_file = self.is_subcomponent = self.is_module = False
        
        self.size = 0
        
        self.use_count = 0
        self.interpreter = interpreter
        self.threads_init = ThreadLocal()

    id = property(lambda self: self.component_source.id, 
        doc="unique identifier for this component")
        
    source_id = property(lambda self: self.component_source.id, 
        doc="unique identifier for the ComponentSource of this component")
        
    name = property(lambda self: self.component_source.name,
        doc="name of this component")
    
    dir_name = property(lambda self: self.component_source.dir_name,
        doc="relative directory name of the component")

    path = property(lambda self: self.component_source.path,
        doc="relative full path of the component")

    file = property(lambda self: self.component_source.file_path,
        doc="the actual filename of the component, if one exists")
        
    def _parentattr(self):
        if self.parent_component is not None:
                return self.parent_component.attributes
        else:
            return None
        
    attributes = property(lambda self: InheritedDict(self.attr, lambda: self._parentattr()))

    def component_init(self):
        """initializes the component after construction.  Calls the do_component_init() method
        before setting up the component's arguments."""
        self.do_component_init()
        self._convert_component_args()
        
    def _convert_component_args(self):
        # the args system has been overhauled to be just a list of 
        # ComponentArgs objects, which come straight from the compiled
        # component file.
        # but try to do some compatibility, for older compiled components
        # and module components that have all the separate ***_args arrays 
        # attached to them.  we generate the _args if it doesnt exist,
        # and then recreate the ***_args arrays in all cases.
        for argtype in argtypes:
            self.arguments += [argtype[0](arg, argtype[1]) for arg in getattr(self, argtype[2], [])]
            # TODO: try to use property() for this
            setattr(self, argtype[2], [arg.name for arg in self.arguments if arg.__class__ == argtype[0] and arg.required == argtype[1]])

    def do_component_init(self):
        """overridden by subclasses to perform per-instance initialization steps."""
        raise NotImplementedError()
        
    def run(self, request, **params):
        """runs this component in the context of the given request.  **params are the arguments
        sent to the component, which become ARGS in the context of the component's
        runtime environment."""
        self.use_count += 1
        compparams = {}

        for arg in self.arguments:
            arg.get_arg(request, compparams, **params)

        compparams.update(request.global_args)
    
        if not self.threads_init.exists():
            self.do_thread_init()
            self.threads_init.assign(True)

        return self.do_run_component(m = request, ARGS = params, **compparams)
        
    def has_filter(self):
        """returns True if this component defines a <%filter> section."""
        return self.filter != None
    
    def _init_filter_func(self, d = None):
        if self.flags.has_key('trim'):
            # the 'trim' flag implies that the component is
            # buffered as well
            self.flags['autoflush'] = False

            try:
                func = {'left':string.lstrip, 'right':string.rstrip, 'both':string.strip}[self.flags['trim']]
                if d is not None:
                    return lambda f, **kwargs: d(func(f), **kwargs)
                else:
                    return lambda f, **kwargs: func(f)
            except KeyError, e:
                raise exception.Interpreter("invalid 'trim' argument '%s'" % e)

        elif d is not None:
            return d

    def get_flag(self, key, inherit = False):
        """returns a flag defines in this component's <%flags> section."""
        if self.flags.has_key(key):
            return self.flags[key]
        elif inherit:
            parent = self.parent_component
            if parent is not None:
                return parent.get_flag(key, True)
        
        return None

    def get_sub_component(self, name):
        """returns a SubComponent of the given name, represented within the source
        of this Component."""
        return None
    
    def do_run_component(self, m, ARGS, **params):
        """overridden by subclasses to provide the main execution body of the component."""
        raise NotImplementedError()

    def do_thread_init(self):
        """overridden by subclasses to provide a per-thread initialization routine."""
        pass
    
    def locate_inherited_method(self, method_name):
        """returns a method SubComponent of the given name, represented either within the
        source of this Component or within the source of an inherited Component, 
        i.e. the inheritance hierarchy will be searched for the approrpriate method call."""
        raise NotImplementedError()

    def call_method(self, method_name, **params):
        """calls a method SubComponent of the given name on this component.  
        This amounts to locating it via locate_inherited_method, retrieving the
        current request via request.instance(), and then calling execute_component
        on that request.

        See also m.comp("component:methodname")
        """
        
        method_component = self.locate_inherited_method(method_name)            
        return myghty.request.instance().execute_component(method_component, args = params, base_component = self)

    def scall_method(self, method_name, **params):
        """same as call_method, but returns the component output as a string
        See also m.scomp("component:methodname")
        """
        
        method_component = self.locate_inherited_method(method_name)            
        buffer = StringIO()
        myghty.request.instance().execute_component(method_component, args = params, base_component = self, store = buffer)
        return buffer.getvalue()
    
    def use_auto_flush(self):
        """returns True if this component defines the "autoflush" flag as True, or
        if an inherited component defines this flag."""
        return self.get_flag('autoflush', inherit = True)
    

    # these are all deprecated
    def get_attribute(self, key, inherit = True): 
        return self.attributes(key)
    def set_attribute(self, key, value): 
        self.attributes(key, value)
    def get_attributes(self): 
        return self.attributes
    def attribute_exists(self, key): 
        return self.attributes.has_key(key)

    def get_owner(self):
        return self.owner
    def get_parent_component(self):
        return self.parent_component
    def get_id(self):
        return self.id
    def get_name(self):
        return self.name 
    def get_source_id(self):
        return self.source_id
    def get_file(self): 
        return self.file
    def get_path(self): 
        return self.path
    def get_dir_name(self): 
        return self.dir_name
    def is_method_component(self):
        return self.is_method
    def is_module_component(self):
        return self.is_module
    def is_file_component(self):
        return self.is_file
    def is_sub_component(self):
        return self.is_subcomponent
    
    

class FileComponent(Component):
    "a component that corresponds to a Myghty template file"

    def __init__(self, interpreter, component_source, **params):
        Component.__init__(self, interpreter, component_source, **params)

        
        self.defs = None
        self.methods = None
        self.inherit_path = None
        self.inherit_start_path = None
        self.is_file = True

        self.size = component_source.modulesize

        self.component_init()

        if self.uses_thread_local():
            self.thread_local = ThreadLocal(creator = self.thread_local_initializer)
        
        if self.uses_request_local():
            self.request_local = weakref.WeakKeyDictionary()
            
        self.subcomponents = self.defs.copy()
        self.subcomponents.update(self.methods)
        self._determine_inheritance()
        
        

    def uses_thread_local(self):raise NotImplementedError()
    def uses_request_local(self):raise NotImplementedError()

    def is_file_component(self):return True

    def get_sub_component(self, name):
        if self.subcomponents.has_key(name):
            return self.subcomponents[name]
        else:
            return None

    def _call_dynamic(self, key, m, ARGS, **params):
        """handles components with %threadlocal and/or %requestlocal sections"""
        
        context = None
        
        if self.uses_thread_local():
            if self.uses_request_local():
                if self.request_local.has_key(m):
                    context = self.request_local[m]
                else:
                    initializer = self.thread_local.get(self, m, ARGS, **params)
                    context = initializer(self, m, ARGS, **params)
                    self.request_local[m] = context
                
            else:
                context = self.thread_local.get(self, m, ARGS, **params)
            
        elif self.uses_request_local():
            if self.request_local.has_key(m):
                context = self.request_local[m]
            else:
                context = self.request_local_initializer(self, m, ARGS, **params)
                self.request_local[m] = context
                
        if context is None:
            raise exception.Error("dynamic method context not found")
        else:
            return context[key](m, ARGS, **params)


        
    def locate_inherited_method(self, method_name):
        component = self
        while component:
            if component.methods.has_key(method_name):
                return component.methods[method_name]
            component = component.parent_component

        raise exception.MethodNotFound("no such method '%s' found" % method_name)
        
    
    def _determine_inheritance(self):
    
        interpreter = self.interpreter
        source = self.component_source

        if self.flags.has_key('inherit'):
            if self.flags['inherit'] is None:
                pass
            else:
                self.inherit_path = unixpath.normpath(unixpath.join(source.dir_name, self.flags['inherit']))
        elif interpreter.use_auto_handlers:
            if source.name == interpreter.auto_handler_name:
                if source.dir_name and source.dir_name != '/':
                    self.inherit_start_path = unixpath.dirname(source.dir_name)
                else:
                    # we are the autohandler in the root directory
                    pass
            else:
                self.inherit_start_path = self.component_source.dir_name
        

    def _parent_component(self):
        """returns the parent component of this component, taking into account
        the component's inherit flag as well as the interpreter's autohandler properties"""

        try:
            request = myghty.request.instance()

            # optional - cache results of this function on the request
            #try:
            #   return request.attributes['_parent_comp_%s' % self.id]
            #except KeyError: pass
            
        except KeyError:
            # no current request for whatever reason, so call
            # load() off the interpreter
            request = None

        if self.inherit_path is not None:
            if request is not None:
                component = request.load_component(self.inherit_path, resolver_context = 'inherit')
            else:
                component = self.interpreter.load(self.inherit_path, resolver_context = 'inherit')
        elif self.inherit_start_path is not None:
            if request is not None:
                component = request.load_component(unixpath.join(self.inherit_start_path, self.interpreter.auto_handler_name), search_upwards = True, raise_error = False, resolver_context = 'inherit')
            else:
                component = self.interpreter.load(unixpath.join(self.inherit_start_path, self.interpreter.auto_handler_name), search_upwards = True, raise_error = False, resolver_context = 'inherit')
        else:
            component = None
        
        #if request is not None:
        #   request.attributes['_parent_comp_%s' % self.id] = component
            
        return component

    parent_component = property(_parent_component, lambda s, p: None)


class SubComponent(Component):
    """a component that corresponds to a <%def> or <%method> tag 
    inside a file-based component."""
    
    def __init__(self, name, owner, is_method, **params):
        Component.__init__(self, owner.interpreter, owner.component_source, **params)
        self.__name = name
        self.__owner = owner
        self.is_method = is_method
        self.is_subcomponent = True

        self.component_init()


    def _call_dynamic(self, key, m, ARGS, **params):
        return self.owner._call_dynamic(key, m, ARGS, **params)

    id = property(lambda self: self.owner.id + ":" + self.name)
    parent_component = property(lambda self: self.owner.parent_component, lambda s, p:None)
    name = property(lambda self: self.__name, lambda s,p:None)
    owner = property(lambda self: self.__owner, lambda s,p:None)
    
    def get_sub_component(self, name):return self.owner.get_sub_component(name)

    def locate_inherited_method(self, method_name):return self.owner.locate_inherited_method(method_name)
    def call_method(self, *args, **params):return self.owner.call_method(*args, **params)
    def scall_method(self, *args, **params):return self.owner.scall_method(*args, **params)




class ModuleComponent(Component):
    """A component that is a regular Python class inside of a plain Python module."""
    
    def __init__(self, interp, component_source, owner = None, do_init = True):
        Component.__init__(self, interp, component_source)
        self.__name = self.__class__.__name__
        self.is_method = True
        self.creationtime = component_source.last_modified
        
        self.methods = Registry()
        if owner is None:
            self.__owner = self
        else:
            self.__owner = owner

        if do_init:
            self.component_init()


    owner = property(lambda self: self.__owner, lambda s, p:None)
    name = property(lambda self: self.__name, lambda s, p:None)

    def _inspect_args(self, function):
        csource = self.component_source

        argspec = inspect.getargspec(function)
            
        argnames = argspec[0] or []
        defaultvalues = argspec[3] or []

        d = dict([(a, True) for a in self.interpreter.compiler().allow_globals + ['m', 'ARGS', 'self']])

        (self.required_args, self.args) = (
                [a for a in argnames[0:len(argnames) - len(defaultvalues)] if not d.has_key(a)], 
                [a for a in argnames[len(argnames) - len(defaultvalues):] if not d.has_key(a)]
                )
        
        self._allargs = argnames
        self._has_params = argspec[2] is not None

    def component_init(self):
        self.do_component_init()

        # if no new-style argument list has been set up
        if len(self.arguments) == 0:
            # and no old-style argument lists have been added
            for argtype in argtypes:
                if hasattr(self, argtype[2]):
                    break
            else:
                # then inspect the do_component_init function and figure out the args
                # that way.
                self._inspect_args(self.do_run_component.im_func)

        # tell base class to set up arguments list    
        self._convert_component_args()
        
    def do_component_init(self):pass

    def do_run_component(self, m, ARGS, **params):raise NotImplementedError()
    
    def is_module_component(self):return True

    def _find_method(self, method_name):
        if self.__class__.__name__ == method_name:
            return self

        return self.interpreter.load_module_component(self.__module__ + ":" + method_name)            
    
    def locate_inherited_method(self, method_name):
        if self.owner is self:
            return self.methods.get(method_name, createfunc = lambda: ModuleComponent._find_method(self, method_name))
        else:
            return self.owner.locate_inherited_method(method_name)
        
    
    
class HTTPModuleComponent(ModuleComponent):
    """A ModuleComponent that contains methods specific to a generic HTTP request."""

    def do_post(self, m, r, **params):
        # 'method not allowed', unless this is overridden
        m.abort(405)

    def do_get(self, m, r, **params):
        # 'method not allowed', unless this is overridden
        m.abort(405)
    
    def do_run_component(self, m, r, **params):
        methods = {
            'GET': HTTPModuleComponent.do_get,
            'POST': HTTPModuleComponent.do_post,
        }
        
        try:
            f = methods[r.method]
            return f(self, m, r, **params)
        except KeyError:
            m.abort(405)
            
class FunctionComponent(ModuleComponent):
    """a module component that "wraps" a regular Python function or method, including
    introspection of its signature to automatically produce the required_args
    and args lists """
    
    def do_component_init(self):
        csource = self.component_source

        self._inspect_args(csource.callable_)
        
        # if we are linked to a method off of an object instance,
        # see if the object instance has a do_component_init method and if the object instance
        # does not have a _component_init attribute.  call do_component_init() and 
        # set the _component_init attribute to True
        if self.component_source.has_method:
            target = self.component_source.callable_.im_self
            if hasattr(target, 'do_component_init') and not hasattr(target, '_component_init'):
                try:
                    getattr(target, 'do_component_init')(self)
                finally:
                    target._component_init = True
               
    def do_run_component(self, **params):
        if self._has_params:
            return self.component_source.callable_(**params)    
        else:
            d = {}
            for a in self._allargs:
                if params.has_key(a):
                    d[a] = params[a]
            return self.component_source.callable_(**d)
                
    def get_method_csource(self, name):    
        if not self.component_source.has_method:
            return None
        obj = self.component_source.callable_.im_self
        meth = getattr(obj, name)
        return myghty.csource.ModuleComponentSource(module=self.component_source.module, callable_=meth, name="method:" + meth.im_func.__name__)

    def get_method(self, m, name):
        cs = self.get_method_csource(name)
        return m.interpreter.load_component(cs)