ayame 0.3__tar.gz

ayame-0.3/CHANGES.rst

@@ -0,0 +1,37 @@
+Ayame Changelog
+===============
+
+Version 0.3
+-----------
+
+Release date: 2024-03-31
+
+* Support Python 3.10.
+* Drop Python 3.6 support.
+* Support Python 3.11.
+* Drop Python 3.7 support.
+* Support Python 3.12.
+
+
+Version 0.2
+-----------
+
+Release date: 2021-09-22
+
+* Support Python 3.5.
+* Support Python 3.6.
+* Drop Python 3.3 support.
+* Support Python 3.7.
+* Drop Python 3.4 support.
+* Support Python 3.8.
+* Drop Python 3.5 support.
+* Support Python 3.9.
+* Drop Python 2.7 support.
+
+
+Version 0.1
+-----------
+
+Release date: 2015-02-02
+
+* Initial release.

ayame-0.3/LICENSE.txt

@@ -0,0 +1,19 @@
+Copyright (c) 2011-2024 Akinori Hattori <hattya@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

ayame-0.3/MANIFEST.in

@@ -0,0 +1,6 @@
+include CHANGES.rst
+include MANIFEST.in
+include README.rst
+include pyproject.toml
+recursive-include doc *.svg
+recursive-include tests *.py *.html *.htm *.properties *.txt

ayame-0.3/PKG-INFO

@@ -0,0 +1,114 @@
+Metadata-Version: 2.1
+Name: ayame
+Version: 0.3
+Summary: An Apache Wicket-like component based WSGI framework
+Author-email: Akinori Hattori <hattya@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/hattya/ayame
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Web Environment
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Internet :: WWW/HTTP :: Dynamic Content
+Classifier: Topic :: Internet :: WWW/HTTP :: WSGI
+Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.8
+Description-Content-Type: text/x-rst
+License-File: LICENSE.txt
+Requires-Dist: Werkzeug
+Requires-Dist: secure-cookie
+
+Ayame
+=====
+
+Ayame is a component based WSGI framework. It is inspired by
+`Apache Wicket`_, `Apache Click`_ and Flask_.
+
+.. image:: https://img.shields.io/pypi/v/ayame.svg
+   :target: https://pypi.org/project/ayame
+
+.. image:: https://github.com/hattya/ayame/actions/workflows/ci.yml/badge.svg
+   :target: https://github.com/hattya/ayame/actions/workflows/ci.yml
+
+.. image:: https://ci.appveyor.com/api/projects/status/67nbqb4ej84liu9m?svg=true
+   :target: https://ci.appveyor.com/project/hattya/ayame
+
+.. image:: https://codecov.io/gh/hattya/ayame/branch/master/graph/badge.svg
+   :target: https://codecov.io/gh/hattya/ayame
+
+.. _Apache Wicket: https://wicket.apache.org/
+.. _Apache Click: https://click.apache.org/
+.. _Flask: https://palletsprojects.com/p/flask
+
+
+Requirements
+------------
+
+- Python 3.8+
+- Werkzeug
+- secure-cookie
+
+
+Example Application
+-------------------
+
+::
+
+    app.wsgi
+    app/
+        HelloWorld.html
+
+
+app.wsgi
+~~~~~~~~
+
+.. code:: python
+
+    from ayame import Ayame, Page
+    from ayame.basic import Label
+
+
+    class HelloWorld(Page):
+
+        def __init__(self):
+            super().__init__()
+            self.add(Label('message', 'Hello World!'))
+
+
+    application = Ayame(__name__)
+
+    map = application.config['ayame.route.map']
+    map.connect('/', HelloWorld)
+
+
+HelloWorld.html
+~~~~~~~~~~~~~~~
+
+.. code:: html
+
+    <?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>HelloWorld</title>
+      </head>
+      <body>
+        <p ayame:id="message">...</p>
+      </body>
+    </html>
+
+
+License
+-------
+
+Ayame is distributed under the terms of the MIT License.

ayame-0.3/README.rst

@@ -0,0 +1,86 @@
+Ayame
+=====
+
+Ayame is a component based WSGI framework. It is inspired by
+`Apache Wicket`_, `Apache Click`_ and Flask_.
+
+.. image:: https://img.shields.io/pypi/v/ayame.svg
+   :target: https://pypi.org/project/ayame
+
+.. image:: https://github.com/hattya/ayame/actions/workflows/ci.yml/badge.svg
+   :target: https://github.com/hattya/ayame/actions/workflows/ci.yml
+
+.. image:: https://ci.appveyor.com/api/projects/status/67nbqb4ej84liu9m?svg=true
+   :target: https://ci.appveyor.com/project/hattya/ayame
+
+.. image:: https://codecov.io/gh/hattya/ayame/branch/master/graph/badge.svg
+   :target: https://codecov.io/gh/hattya/ayame
+
+.. _Apache Wicket: https://wicket.apache.org/
+.. _Apache Click: https://click.apache.org/
+.. _Flask: https://palletsprojects.com/p/flask
+
+
+Requirements
+------------
+
+- Python 3.8+
+- Werkzeug
+- secure-cookie
+
+
+Example Application
+-------------------
+
+::
+
+    app.wsgi
+    app/
+        HelloWorld.html
+
+
+app.wsgi
+~~~~~~~~
+
+.. code:: python
+
+    from ayame import Ayame, Page
+    from ayame.basic import Label
+
+
+    class HelloWorld(Page):
+
+        def __init__(self):
+            super().__init__()
+            self.add(Label('message', 'Hello World!'))
+
+
+    application = Ayame(__name__)
+
+    map = application.config['ayame.route.map']
+    map.connect('/', HelloWorld)
+
+
+HelloWorld.html
+~~~~~~~~~~~~~~~
+
+.. code:: html
+
+    <?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>HelloWorld</title>
+      </head>
+      <body>
+        <p ayame:id="message">...</p>
+      </body>
+    </html>
+
+
+License
+-------
+
+Ayame is distributed under the terms of the MIT License.

ayame-0.3/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-0.3/ayame/__version__.py

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

ayame-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-0.3/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-0.3/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-0.3/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>