pybald 0.5.8__py3-none-any.whl

pybald/__init__.py

@@ -0,0 +1,230 @@
+#!/usr/bin/env python
+# encoding: utf-8
+# __init__.py
+'''
+Pybald
+======
+
+An MVC-like framework using many best-of-breed components (i.e. webob,
+sqlalchemy).
+
+(c) 2015 Michael Kowalchik
+MIT License, see LICENSE file
+'''
+import types
+import sys
+import os
+from pybald.util.context import AppContext
+import logging
+from .default import default_config
+from collections import namedtuple
+log = logging.getLogger(__name__)
+
+__version__ = '0.5.8'
+
+
+def read_config_module(root_path='.', filename='project.py'):
+    '''Read a configuration module and append it's path to sys.path'''
+    # since the config module may have relative imports
+    # add the _config files_ path to root before executing the config
+    if root_path not in sys.path:
+        sys.path.insert(1, root_path)
+    filename = os.path.join(root_path, filename)
+    config_module = types.ModuleType("config")
+    config_module.__dict__['__file__'] = filename
+    config_module.__dict__['path'] = root_path
+    with open(filename) as config_file:
+        exec(compile(config_file.read(), filename, 'exec'),
+             config_module.__dict__)
+    return config_module
+
+
+class Unconfigured(object):
+    def __getattr__(self, key):
+        raise RuntimeError("Pybald is not configured, you must run "
+                           "pybald.configure() before context.{0} can"
+                           " be used".format(key))
+
+
+class DefaultApp(dict):
+    def __init__(self, *pargs, **kargs):
+        self.register('config', {})
+        self.register('controller_registry', [])
+        # self.register('model_registry', [])
+        self.unconfigured = True
+        super(DefaultApp, self).__init__(*pargs, **kargs)
+
+    # def __getattr__(self, key):
+    #     if key in ('models', 'engine', 'metdata'):
+    #         raise RuntimeError("Pybald is not configured, you must run "
+    #                            "pybald.configure() before context.{0} can"
+    #                            " be used".format(key))
+    #     else:
+    #         return super(DefaultApp, self).__getattr__(key)
+
+    def register(self, key, value):
+        self[key] = value
+        setattr(self, key, self[key])
+
+# unconfigured application stack context
+context = AppContext()
+# register the context as a module
+sys.modules['pybald.context'] = context
+# push the default placeholder app onto the context stack
+# the default allows for temporary storage of elements required
+# for bootstrapping (and eliminates some sequencing requirements
+# for configuration)
+context._push(DefaultApp())
+
+# the template engine and database session are built at config time
+context_template = '''
+from pybald.core.templates import TemplateEngine
+from pybald.util.command_line import start
+from pybald.core.models import ContextBoundModels
+from pybald.db.db_engine import create_dump_engine
+
+render = TemplateEngine()
+dump_engine = create_dump_engine()
+if config.database_engine_uri:
+    models = ContextBoundModels()
+    db = models.db
+else:
+    models = Unconfigured()
+    db = Unconfigured()
+
+def register(key, value):
+    globals()[key] = value
+
+'''
+
+
+def create_config_dict_from_module(module):
+    '''Converts a module into a dictionary filtering out common module
+    level attributes'''
+    return {key: getattr(module, key) for key in module.__dict__.keys() if
+            not key.startswith('_') and key not in ('sys', 'os')}
+
+
+def create_config_object(config_object):
+    '''Convert a config dictionary to a config object named tuple
+    and combines it with the default configuration dictionary.'''
+    keys = set(default_config.keys()) | set(config_object.keys())
+    ConfigObject = namedtuple("ConfigObject", keys)
+    return ConfigObject(**dict(list(default_config.items()) +
+                               list(config_object.items())))
+
+
+def bootstrap(bootstrap_file=None):
+    '''Execute the python file passed in. It's assumed that the bootstrap
+    python module file will execute configure() before returning although
+    not strictly necessary
+
+    This is intended for complicated projects that need to do a lot of
+    dynamic stuff before configuring the project. It's primarily a convenience
+    hook that sets the sys.path to the current working directory before
+    executing the module import.
+
+    Use of this method should be rare, ask yourself if you really need it :)
+    '''
+    # since bootstrap can be anywhere, add bootstrap to sys.path as well
+    if os.getcwd() not in sys.path:
+        sys.path.insert(1, os.getcwd())
+    possible_root_path = os.getcwd()
+    root_path, filename = os.path.split(os.path.join(possible_root_path,
+                                                     bootstrap_file))
+    if root_path not in sys.path:
+        sys.path.insert(1, root_path)
+    filename = os.path.join(root_path, filename)
+    bootstrap_module = types.ModuleType("bootstrap")
+    bootstrap_module.__dict__['__file__'] = filename
+    with open(filename) as bootstrap_file:
+        exec(compile(bootstrap_file.read(), filename, 'exec'),
+             bootstrap_module.__dict__)
+    return bootstrap_module
+
+
+def configure(name=None, config_file=None, config_object=None, **kargs):
+    '''
+    Generate a dynamic context module that's pushed / popped on
+    the application context stack.
+    '''
+    script_name = sys.argv[0]
+    # always add current working directory to the path regardless
+    # was trying to avoid this but too much path munging happening
+    if os.getcwd() not in sys.path:
+        sys.path.insert(1, os.getcwd())
+
+    if config_object:
+        if 'project_name' not in config_object:
+            config_object['project_name'] = script_name
+        # create a named tuple that's the combo of default plus input dict
+        root_path = config_object['path'] = config_object.get('path',
+                                                              os.getcwd())
+        config = create_config_object(config_object)
+        # add root path to config?
+    elif config_file:
+        # possible root path if relative filename specified
+        possible_root_path = os.getcwd()
+        root_path, filename = os.path.split(os.path.join(possible_root_path,
+                                                         config_file))
+        try:
+            config_module = read_config_module(root_path=root_path,
+                                               filename=filename)
+        except IOError:
+            log.exception("Config Error:\n"
+                          "File Error or File not "
+                          "found\n{0}".format(config_file))
+            sys.exit(1)
+        config = create_config_object(create_config_dict_from_module(config_module))
+    elif kargs:
+        if 'project_name' not in kargs:
+            kargs['project_name'] = script_name
+
+        root_path = kargs['path'] = kargs.get('path',
+                                              os.getcwd())
+        config = create_config_object(kargs)
+    else:
+        root_path = os.getcwd()
+        log.warning("Warning: Using current path for the config "
+                    "file {0}".format(root_path))
+        if root_path not in sys.path:
+            sys.path.insert(1, root_path)
+        try:
+            config_module = read_config_module(root_path=root_path,
+                                               filename='project.py')
+            log.warning("Found project.py in default path, "
+                        "using for the config file")
+        except IOError:
+            config = create_config_object(default_config)
+            log.warning("No config file, using default pybald configuration")
+        else:
+            config = create_config_object(create_config_dict_from_module(config_module))
+
+    # if the discovered root_path is not in sys.path, add it in the least ugly
+    # way possible
+    if root_path not in sys.path:
+        sys.path.insert(1, root_path)
+
+    if config.debug:
+        from pybald.core.logs import default_debug_log
+        default_debug_log()
+
+    new_context = types.ModuleType("context")
+
+    if context._proxied() and hasattr(context._proxied(), 'unconfigured'):
+        # if we're at the root, consume any placeholder values
+        placeholder = context._pop()
+        new_context.__dict__.update(placeholder)
+    else:
+        new_context.__dict__['controller_registry'] = []
+    # always set the runtime config
+    new_context.__dict__['path'] = root_path
+    new_context.__dict__['config'] = config
+    new_context.__dict__['name'] = name
+    new_context.__dict__['__file__'] = None
+    new_context.__dict__['Unconfigured'] = Unconfigured
+    # new_context.__dict__['__path__'] = None
+    # now execute the app context with this config
+    context._push(new_context)
+    exec(compile(context_template, '<string>', 'exec'), new_context.__dict__)
+    return new_context

pybald/config/constants.py

@@ -0,0 +1,40 @@
+'''The constants helper module is to allow for creating 'safer' ini files for
+values that will be injected into templates. The basic rationale is that there
+are often values that you want non-technical people to control (phone numbers,
+marketing claims, addresses) and similar values. Using constants allows these
+individuals to use friendlier ini format but still have the values available
+for page templates.
+'''
+# TODO: The constants helper object should probably do something 'safe' when
+# constants are deleted, maybe issuing a warning. Just a saftey net to avoid
+# breaking templates if sections or values are accidently deleted.
+try:
+    from ConfigParser import ConfigParser as configparser
+except ImportError:
+    from configparser import ConfigParser as configparser
+from collections import namedtuple
+
+# generate constants for templates
+# this is a little squirrley looking, but all it does is use the config
+# parser to read an INI file and then generates a two level set of named
+# tuples to surface the data. Inside the template the section/data of the
+# constants ini is dereferenced using constants.SECTION.KEY
+
+
+def read(filename='constants.ini', constants_file=None):
+    '''Read a constants ini file and return the constants helper object.
+
+    When added to the page_options config, these constants can be used inside
+    the templates where the section/data of the constants ini is dereferenced
+    using constants.SECTION.KEY.
+    '''
+    config = configparser()
+    if constants_file:
+        config.read_file(constants_file)
+    else:
+        config.read(filename)
+    constants = namedtuple("Constant", config.sections())._make([
+        namedtuple('Field', dict(config.items(section)).keys()
+            )._make(dict(config.items(section)).values())
+                for section in config.sections() ])
+    return constants

pybald/core/controllers.py

@@ -0,0 +1,313 @@
+#!/usr/bin/env python
+# encoding: utf-8
+from six import with_metaclass
+from functools import wraps
+from webob import Request, Response, exc
+import re
+from pybald.util import camel_to_underscore
+from routes import redirect_to
+from pybald import context
+
+import json
+import random
+
+import uuid
+import logging
+console = logging.getLogger(__name__)
+
+controller_pattern = re.compile(r'(\w+)Controller')
+
+
+class CSRFValidationFailure(exc.HTTPForbidden):
+    pass
+
+
+def csrf_protected(action_func):
+    """
+    Decorator to add CSRF (cross-site request forgery) protection to POST
+    requests on an action. To use, include this decorator and provide the
+    token in any submitted forms.
+
+    For example, in the controller, do:
+
+    @action
+    @csrf_protected
+    def my_action(self, req):
+        ...
+
+    And in the template:
+
+    <form action='my_action' method='post'>
+    ${csrf_input}
+    ...
+    </form>
+    """
+    CSRF_TOKEN_POST_VARIABLE = '__csrf_token__'
+
+    @wraps(action_func)
+    def replacement(self, req):
+        if req.method == 'POST':
+            try:
+                if CSRF_TOKEN_POST_VARIABLE not in req.POST:
+                    raise CSRFValidationFailure(
+                        ("No %r value found in POST data. Please make sure "
+                         "that a ${csrf_input} is used in the form template.")
+                        % CSRF_TOKEN_POST_VARIABLE)
+
+                if not self.session.stash.get("csrf_token"):
+                    raise CSRFValidationFailure(
+                        "CSRF validation failed: no validation token available "
+                        "in this session.")
+
+                provided_csrf_token = req.POST.get(CSRF_TOKEN_POST_VARIABLE)
+
+                if provided_csrf_token != self.session.stash.get("csrf_token"):
+                    raise CSRFValidationFailure(
+                        "CSRF validation failed: token mismatch.")
+
+                else:
+                    # success! wipe out the used token
+                    self.session.stash(csrf_token=None)
+                    #del self.session.csrf_token
+
+            except CSRFValidationFailure:
+                # gentle mode, redirect to GET version of the page
+                # return self._redirect_to(req.path_qs)
+                raise
+
+        # always stash a new token
+        new_token = str(uuid.uuid4()).replace("-", "")
+        self.session.stash(csrf_token=new_token)
+
+        self.csrf_input = ("<input type='hidden' name='%s' value='%s' />" % (
+            CSRF_TOKEN_POST_VARIABLE, new_token))
+
+        return action_func(self, req)
+    return replacement
+
+
+# a no-op placeholder
+def noop_func(*pargs, **kargs):
+    '''Do nothing'''
+    pass
+
+
+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]))
+
+
+# action / method decorator
+def action(method):
+    '''
+    Decorates methods that are WSGI apps to turn them into pybald-style actions.
+
+    :param method: A method to turn into a pybald-style action.
+
+    This decorator is usually used to take the method of a controller instance
+    and add some syntactic sugar around it to allow the method to use WebOb
+    Request and Response objects. It will work with any method that
+    implements the WSGI spec.
+
+    It allows actions to work with WebOb request / response objects and handles
+    default behaviors, such as displaying the view when nothing is returned,
+    or setting up a plain text Response if a string is returned. It also
+    assigns instance variables from the ``pybald.extension`` environ variables
+    that can be set from other parts of the WSGI pipeline.
+
+    This decorator is optional but recommended for making working
+    with requests and responses easier.
+    '''
+    # the default template name is the controller class + method name
+    # the method name is pulled during decoration and stored for use
+    # in template lookups
+    template_name = method.__name__
+    # special case where 'call' or 'index' use the base class name
+    # for the template otherwise use the base name
+    if template_name in ('index', '__call__'):
+        template_name = ''
+
+    @wraps(method)
+    def action_wrapper(self, environ, start_response):
+        req = Request(environ)
+        # add any url variables as members of the controller
+        for varname, value in req.urlvars.items():
+            # Set the controller object to contain the url variables
+            # parsed from the dispatcher / router
+            setattr(self, varname, value)
+
+        # add the pybald extension dict to the controller
+        # object
+        for key, value in req.environ.setdefault('pybald.extension', {}).items():
+            setattr(self, key, value)
+
+        # TODO: fixme this is a hack
+        setattr(self, 'request', req)
+        setattr(self, 'request_url', req.url)
+
+        # set pre/post/view to a no-op if they don't exist
+        pre = getattr(self, '_pre', noop_func)
+        post = getattr(self, '_post', noop_func)
+
+        # set the template_id for this request
+        self.template_id = get_template_name(self, template_name)
+
+        # The response is 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
+        resp = (pre(req) or
+                 method(self, req) or
+                 context.render(template=self.template_id,
+                             data=self.__dict__ or {}))
+        # if the response is currently a string
+        # wrap it in a response object
+        if isinstance(resp, str) or isinstance(resp, bytes):
+            resp = Response(body=resp, charset="utf-8")
+        # run the controllers post code
+        post(req, resp)
+        return resp(environ, start_response)
+    return action_wrapper
+
+
+# def caching_pre(keys, method_name, prefix=''):
+#     '''Decorator for pybald _pre to return cached responses if available.'''
+#     if keys is None:
+#         keys = []
+
+#     def pre_wrapper(pre):
+#         def replacement(self, req):
+#             val = ":".join([prefix] + [str(getattr(self, k, '')) for
+#                         k in keys] + [method_name])
+#             self.cache_key = base64.urlsafe_b64encode(hashlib.md5(val).digest())
+#             resp = project.mc.get(self.cache_key)
+#             if resp:
+#                 return resp
+#             return pre(req)
+#         return replacement
+#     return pre_wrapper
+
+
+# def caching_post(time=0):
+#     '''Decorator for pybald _post to cache/store responses.'''
+#     def post_wrapper(post):
+#         def replacement(self, req, resp):
+#             post(req, resp)
+#             # only cache 2XX or 4XX responses
+#             if (200 <= resp.status_code < 300) or (400 <= resp.status_code < 500):
+#                 if 'X-Cache' not in resp.headers:
+#                     resp.headerlist.append(('X-Cache', 'MISS'))
+#                     project.mc.set(self.cache_key, resp, time)
+#                 else:
+#                     resp.headers['X-Cache'] = 'HIT'
+#         return replacement
+#     return post_wrapper
+
+# regenerate a content_cache_prefix on every reload so that content will
+# be force loaded after any full application restart
+# This provides a way to cache static content for the duration of the
+# application lifespan.
+content_cache_prefix = hex(random.randrange(0, 2 ** 32 - 1))
+
+
+# # memcache for actions
+# def action_cached(prefix=content_cache_prefix, keys=None, time=0):
+#     '''
+#     Wrap actions and return pre-generated responses when appropriate.
+#     '''
+#     if keys is None:
+#         keys = []
+
+#     # def cached_wrapper(my_action_method):
+#     #     @wraps(my_action_method)
+#     #     def replacement(self, environ, start_response):
+#     #         # bind newly wrapped methods to self
+#     #         self._pre = caching_pre(keys,
+#     #                                 my_action_method.__name__,
+#     #                                 prefix=prefix)(self._pre
+#     #                                     ).__get__(self, self.__class__)
+#     #         self._post = caching_post(time)(self._post
+#     #                                     ).__get__(self, self.__class__)
+#     #         return my_action_method(self, environ, start_response)
+#     #     # don't enable caching if requested
+#     #     if project.DISABLE_STATIC_CONTENT_CACHE:
+#     #         return my_action_method
+#     #     return replacement
+#     # return cached_wrapper
+
+class RegistryMount(type):
+    '''
+    A registry creating metaclass that keeps track of all defined classes that
+    inherit from a base class using this metaclass.
+    '''
+    # lifted almost verbatim from: http://martyalchin.com/2008/jan/10/simple-plugin-framework/
+    def __init__(cls, name, bases, attrs):
+        try:
+            cls.registry.append(cls)
+        except AttributeError:
+            # this is processing the first class (the mount point)
+            cls.registry = context.controller_registry
+
+        return super(RegistryMount, cls).__init__(name, bases, attrs)
+
+
+class Controller(with_metaclass(RegistryMount, object)):
+    '''Base Controller that provides a registry mount
+
+    The registry keeps track of all countrollers defined in the project. The
+    Controller class also has some minor convenience methods attached.
+    '''
+
+    def __init__(self, *pargs, **kargs):
+        for key, value in kargs.items():
+            setattr(self, key, value)
+
+    def _pre(self, req):
+        pass
+
+    def _post(self, req, resp):
+        pass
+
+    def _redirect_to(self, *pargs, **kargs):
+        '''Redirect the controller'''
+        return redirect_to(*pargs, **kargs)
+
+    def _not_found(self, text=None):
+        '''Raise the 404 http_client_error exception.'''
+        raise exc.HTTPNotFound(text)
+
+    def _status(self, code):
+        '''Raise an http_client_error exception using a specific code'''
+        raise exc.status_map[int(code)]
+
+    def _JSON(self, data, status=200):
+        '''Return JSON object with the proper-ish headers.'''
+        res = Response(body=json.dumps(data),
+                       status=status,
+                       content_type="application/json",
+                       charset='UTF-8')
+        return res
+
+# alias for backwards copatibility
+BaseController = Controller

pybald/core/default_templates/forms/fieldset.form.template

@@ -0,0 +1,9 @@
+% for field in fieldset:
+<div${literal(" class=\"input_errors\"") if field.errors else ""}>
+${field.label()}
+% for error in field.errors:
+<span class="field_error">${error}</span>
+% endfor
+    ${field}
+</div>
+% endfor

pybald/core/default_templates/forms/grid.form.template

@@ -0,0 +1,24 @@
+<thead>
+  <tr>
+    %for field in collection.render_fields.itervalues():
+      <th>${field.label()|h}</th>
+    %endfor
+  </tr>
+</thead>
+
+<tbody>
+%for i, row in enumerate(collection.rows):
+  <% collection._set_active(row) %>
+  <% row_errors = collection.get_errors(row) %>
+  <tr class="${i % 2 and 'odd' or 'even'}">
+  %for field in collection.render_fields.itervalues():
+    <td>
+      ${field.render()|n}
+      %for error in row_errors.get(field, []):
+      <span class="grid_error">${error}</span>
+      %endfor
+    </td>
+  %endfor
+  </tr>
+%endfor
+</tbody>