ayame 0.3__py3-none-any.whl

ayame/__init__.py

@@ -0,0 +1,17 @@
+#
+# ayame
+#
+#   Copyright (c) 2011-2021 Akinori Hattori <hattya@gmail.com>
+#
+#   SPDX-License-Identifier: MIT
+#
+
+__author__ = 'Akinori Hattori <hattya@gmail.com>'
+try:
+    from .__version__ import version as __version__
+except ImportError:
+    __version__ = 'unknown'
+
+from .app import *
+from .core import *
+from .exception import *

ayame/__version__.py

@@ -0,0 +1,3 @@
+# file generated by scmver; DO NOT EDIT.
+
+version = '0.3'

ayame/app/Ayame.properties

@@ -0,0 +1,21 @@
+Required = '{label}' is required
+Converter = The value of '{label}' is not a valid type '{type}'
+
+Choice.single = The value of '{label}' is not a valid choice
+Choice.multiple = The values of '{label}' contain invalid choices
+
+RangeValidator.type = The value of '{label}' cannot validate
+RangeValidator.minimum = The value of '{label}' must be at least {min}
+RangeValidator.maximum = The value of '{label}' must be at most {max}
+RangeValidator.range = The value of '{label}' must be between {min} and {max}
+RangeValidator.exact = The value of '{label}' must be exactly {exact}
+
+StringValidator.type = The value of '{label}' cannot validate
+StringValidator.minimum = The value of '{label}' must be at least {min} characters long
+StringValidator.maximum = The value of '{label}' must be at most {max} characters long
+StringValidator.range = The value of '{label}' must be between {min} and {max} characters long
+StringValidator.exact = The value of '{label}' must be exactly {exact} characters long
+
+RegexValidator = The value of '{label}' does not match pattern '{pattern}'
+EmailValidator = The value of '{label}' is not a valid email address
+URLValidator = The value of '{label}' is not a valid URL

ayame/app.py

@@ -0,0 +1,199 @@
+#
+# ayame.app
+#
+#   Copyright (c) 2011-2024 Akinori Hattori <hattya@gmail.com>
+#
+#   SPDX-License-Identifier: MIT
+#
+
+import locale
+import os
+import sys
+
+import werkzeug.datastructures
+
+from . import (converter, core, http, i18n, local, markup, page, res, route,
+               session, uri, util)
+from .exception import AyameError, _Redirect
+
+
+__all__ = ['Ayame', 'Request']
+
+
+class Ayame:
+
+    def __init__(self, name):
+        self._name = name
+        try:
+            self._root = os.path.abspath(os.path.dirname(sys.modules[name].__file__))
+        except (AttributeError, KeyError):
+            self._root = os.getcwd()
+        session_dir = os.path.join(self._root, 'session')
+        self.config = {
+            'ayame.converter.registry': converter.ConverterRegistry(),
+            'ayame.i18n.cache': util.LRUCache(64),
+            'ayame.i18n.localizer': i18n.Localizer(),
+            'ayame.markup.cache': util.LRUCache(64),
+            'ayame.markup.encoding': 'utf-8',
+            'ayame.markup.loader': markup.MarkupLoader,
+            'ayame.markup.pretty': False,
+            'ayame.markup.renderer': markup.MarkupRenderer,
+            'ayame.markup.separator': '.',
+            'ayame.max.redirect': 7,
+            'ayame.page.http': page.HTTPStatusPage,
+            'ayame.request': Request,
+            'ayame.resource.loader': res.ResourceLoader(),
+            'ayame.route.map': route.Map(),
+            'ayame.session.store': session.FileSystemSessionStore(session_dir, 'ayame_%s.sess'),
+            'ayame.session.name': 'session_id',
+            'ayame.session.expires': None,
+            'ayame.session.max_age': None,
+            'ayame.session.domain': None,
+            'ayame.session.path': '/',
+            'ayame.session.secure': False,
+            'ayame.session.httponly': True,
+        }
+
+    @property
+    def context(self):
+        return local.context()
+
+    @property
+    def environ(self):
+        return self.context.environ
+
+    @property
+    def request(self):
+        return self.context.request
+
+    @property
+    def session(self):
+        return self.context.session
+
+    @property
+    def _router(self):
+        return self.context._router
+
+    def __call__(self, environ, start_response):
+        try:
+            ctx = local.push(self, environ)
+            ctx._router = self.config['ayame.route.map'].bind(environ)
+            # dispatch
+            o, values = ctx._router.match()
+            ctx.request = self.config['ayame.request'](environ, values)
+            ctx.session = session.get(self, environ)
+            for _ in range(self.config['ayame.max.redirect']):
+                try:
+                    status, headers, content = self.handle_request(o)
+                except _Redirect as r:
+                    if r.args[3] == _Redirect.PERMANENT:
+                        raise http.MovedPermanently(uri.application_uri(environ)
+                                                    + self.uri_for(*r.args[:3], relative=True)[1:])
+                    elif r.args[3] != _Redirect.INTERNAL:
+                        raise http.Found(uri.application_uri(environ)
+                                         + self.uri_for(*r.args[:3], relative=True)[1:])
+                    o = r.args[0]
+                    ctx.request.path = None
+                    continue
+                break
+            else:
+                raise AyameError('reached to the maximum number of internal redirects')
+            exc_info = None
+            set_cookie = session.save(self, ctx.session)
+            if set_cookie:
+                headers.append(set_cookie)
+        except Exception as e:
+            status, headers, exc_info, content = self.handle_error(e)
+        finally:
+            ctx = local.pop()
+            if ctx.request is not None:
+                ctx.request.close()
+
+        start_response(status, headers, exc_info)
+        return content
+
+    def handle_request(self, object):
+        if isinstance(object, type):
+            if issubclass(object, core.Page):
+                object = object()
+            else:
+                # type is callable, so it might cause unexpected error
+                object = None
+        if callable(object):
+            return object()
+        raise http.NotFound(uri.request_path(self.environ))
+
+    def handle_error(self, error):
+        if isinstance(error, http.HTTPStatus):
+            page = self.config['ayame.page.http'](error)
+            status, headers, content = page()
+            exc_info = None
+        else:
+            status, headers, content = http.InternalServerError.status, [], []
+            exc_info = sys.exc_info()
+        return status, headers, exc_info, content
+
+    def forward(self, object, values=None, anchor=None):
+        raise _Redirect(object, values, anchor, _Redirect.INTERNAL)
+
+    def redirect(self, object, values=None, anchor=None, permanent=False):
+        raise _Redirect(object, values, anchor, _Redirect.PERMANENT if permanent else _Redirect.TEMPORARY)
+
+    def uri_for(self, *args, **kwargs):
+        return self._router.build(*args, **kwargs)
+
+
+class Request:
+
+    __slots__ = ('environ', 'method', 'uri', 'query', 'form_data', 'path',
+                 'locale')
+
+    def __init__(self, environ, values):
+        self.environ = environ
+        self.method = environ['REQUEST_METHOD']
+        self.uri = values
+        self.query = uri.parse_qs(environ)
+        self.form_data = http.parse_form_data(environ)
+        # retrieve ayame:path
+        if self.method == 'GET':
+            self.path = self.query.get(core.AYAME_PATH)
+        elif self.method == 'POST':
+            self.path = self.form_data.get(core.AYAME_PATH)
+        else:
+            self.path = None
+        if self.path:
+            self.path = self.path[0]
+        self.locale = self._parse_locales(environ)
+
+    def _parse_locales(self, environ):
+        values = http.parse_accept(environ.get('HTTP_ACCEPT_LANGUAGE'))
+        if values:
+            v = values[0][0]
+            sep = '-'
+        else:
+            v = locale.getlocale()[0]
+            sep = '_'
+        if v:
+            v = v.split(sep, 1)
+            return (v[0].lower(), v[1].upper() if len(v) > 1 else None)
+        return (None,) * 2
+
+    @property
+    def input(self):
+        return self.environ['wsgi.input']
+
+    @property
+    def session(self):
+        return local.context().session
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *exc_info):
+        self.close()
+
+    def close(self):
+        for _, data in self.form_data.items():
+            for v in data:
+                if isinstance(v, werkzeug.datastructures.FileStorage):
+                    v.close()

ayame/basic.py

@@ -0,0 +1,122 @@
+#
+# ayame.basic
+#
+#   Copyright (c) 2011-2021 Akinori Hattori <hattya@gmail.com>
+#
+#   SPDX-License-Identifier: MIT
+#
+
+import collections.abc
+
+from . import core, markup, uri
+from . import model as mm
+
+
+__all__ = ['Label', 'ListView', 'PropertyListView', 'ContextPathGenerator',
+           'ContextImage', 'ContextLink']
+
+
+class Label(core.Component):
+
+    def __init__(self, id, model=None):
+        if isinstance(model, str):
+            model = mm.Model(model)
+        super().__init__(id, model)
+
+    def on_render(self, element):
+        element[:] = (self.model_object_as_string(),)
+        return element
+
+
+class ListView(core.MarkupContainer):
+
+    def __init__(self, id, model=None, populate_item=None):
+        if isinstance(model, collections.abc.Sequence):
+            model = mm.Model(model)
+        super().__init__(id, model)
+        self._populate_item = populate_item
+
+    def on_before_render(self):
+        o = self.model_object
+        if o is not None:
+            for i in range(len(o)):
+                li = self.new_item(i)
+                self.add(li)
+                self.populate_item(li)
+        super().on_before_render()
+
+    def on_render(self, element):
+        skel = element.copy()
+        skel.qname = markup.DIV
+        del element[:]
+        for c in self.children:
+            element.extend(c.on_render(skel.copy()))
+        return element
+
+    def populate_item(self, item):
+        if callable(self._populate_item):
+            return self._populate_item(item)
+
+    def new_item(self, index):
+        return _ListItem(index, self.new_model(index))
+
+    def new_model(self, index):
+        return _ListItemModel(self, index)
+
+
+class _ListItem(core.MarkupContainer):
+
+    def __init__(self, index, model):
+        super().__init__(str(index), model)
+        self.__index = index
+
+    @property
+    def index(self):
+        return self.__index
+
+
+class _ListItemModel(mm.Model):
+
+    def __init__(self, list_view, index):
+        self.__list_view = list_view
+        self.__index = index
+
+    def object():
+        def fget(self):
+            return self.__list_view.model_object[self.__index]
+
+        def fset(self, object):
+            self.__list_view.model_object[self.__index] = object
+
+        return locals()
+
+    object = property(**object())
+
+
+class PropertyListView(ListView):
+
+    def new_model(self, index):
+        return mm.CompoundModel(super().new_model(index))
+
+
+class ContextPathGenerator(core.AttributeModifier):
+
+    def __init__(self, attr, rel_path):
+        super().__init__(attr, mm.Model(rel_path))
+
+    def new_value(self, value, new_value):
+        return uri.relative_uri(self.environ, new_value)
+
+
+class ContextImage(core.Component):
+
+    def __init__(self, id, rel_path):
+        super().__init__(id)
+        self.add(ContextPathGenerator('src', rel_path))
+
+
+class ContextLink(core.Component):
+
+    def __init__(self, id, rel_path):
+        super().__init__(id)
+        self.add(ContextPathGenerator('href', rel_path))

ayame/border/FeedbackFieldBorder.html

@@ -0,0 +1,13 @@
+<?xml version="1.0"?>
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml" xmlns:ayame="http://hattya.github.io/ayame">
+  <head>
+    <title>FeedbackFieldBorder</title>
+  </head>
+  <body>
+    <ayame:border>
+      <ayame:body />
+      <p ayame:id="feedback" class="feedback">message</p>
+    </ayame:border>
+  </body>
+</html>

ayame/border.py

@@ -0,0 +1,122 @@
+#
+# ayame.border
+#
+#   Copyright (c) 2011-2021 Akinori Hattori <hattya@gmail.com>
+#
+#   SPDX-License-Identifier: MIT
+#
+
+from . import basic, core, form, markup
+from .exception import RenderingError
+
+
+__all__ = ['Border', 'FeedbackFieldBorder']
+
+
+class Border(core.MarkupContainer):
+
+    def __init__(self, id, model=None):
+        super().__init__(id, model)
+        self.has_markup = True
+        self.render_body_only = True
+        # ayame:body element
+        self.body = _BorderBodyContainer(id)
+        self.add_to_border(self.body)
+        self.__body = False
+
+    def add_to_border(self, *args):
+        return super().add(*args)
+
+    def add(self, *args):
+        for o in args:
+            if isinstance(o, core._MessageContainer):
+                self.add_to_border(o)
+            else:
+                self.body.add(o)
+        return self
+
+    def on_render(self, element):
+        def step(element, depth):
+            return element.qname not in (markup.AYAME_BODY, markup.AYAME_HEAD)
+
+        # load markup for Panel
+        m = self.load_markup()
+        if m.root is None:
+            # markup is empty
+            return element
+
+        ayame_border = ayame_body = ayame_head = None
+        for elem, _ in m.root.walk(step=step):
+            if elem.qname == markup.AYAME_BORDER:
+                if ayame_border is None:
+                    ayame_border = elem
+            elif elem.qname == markup.AYAME_BODY:
+                if (ayame_border is not None
+                    and ayame_body is None):
+                    # replace children of ayame:body element
+                    ayame_body = elem
+                    ayame_body.type = markup.Element.OPEN
+                    ayame_body[:] = element
+            elif elem.qname == markup.AYAME_HEAD:
+                if ('html' in m.lang
+                    and ayame_head is None):
+                    ayame_head = elem
+        if ayame_border is None:
+            raise RenderingError(self, "'ayame:border' element is not found")
+        elif ayame_body is None:
+            raise RenderingError(self, "'ayame:body' element is not found")
+        # append ayame:head element to Page
+        if ayame_head is not None:
+            self.page().head.extend(ayame_head)
+        # render border
+        element[:] = ayame_border
+        return super().on_render(element)
+
+    def on_render_element(self, element):
+        if element.qname == markup.AYAME_BODY:
+            # skip duplicates
+            if not self.__body:
+                element.attrib[markup.AYAME_ID] = self.body.id
+                self.__body = True
+            return element
+        return super().on_render_element(element)
+
+
+class _BorderBodyContainer(core.MarkupContainer):
+
+    def __init__(self, id, model=None):
+        super().__init__(id + '_body', model)
+        self.render_body_only = True
+
+    def on_render_element(self, element):
+        if element.qname == markup.AYAME_BODY:
+            return element
+        return super().on_render_element(element)
+
+    def tr(self, key, component=None):
+        # retrieve message from parent of Border
+        return super().tr(key, self.parent.parent)
+
+
+class FeedbackFieldBorder(Border):
+
+    def __init__(self, id):
+        super().__init__(id)
+        self.render_body_only = False
+
+        self.__feedback = basic.Label('feedback', '')
+        self.add_to_border(self.__feedback)
+        self.add_to_border(self._ClassModifier('class', self.__feedback.model))
+
+    def on_configure(self):
+        for c, _ in self.walk():
+            if isinstance(c, form.FormComponent):
+                self.__feedback.model.object = c.error
+                self.__feedback.visible = bool(c.error)
+
+    class _ClassModifier(core.AttributeModifier):
+
+        def new_value(self, value, error):
+            if error:
+                return value + '-error' if value else 'error'
+            return value