pythonista-wkapp 0.1.0__py3-none-any.whl

pythonista_wkapp-0.1.0.dist-info/METADATA

@@ -0,0 +1,125 @@
+Metadata-Version: 2.4
+Name: pythonista-wkapp
+Version: 0.1.0
+Summary: WKApp - A modern HTML5 UI framework for building iOS apps with Pythonista 3 and WebKit
+Author-email: M4nw3l <63550247+M4nw3l@users.noreply.github.com>
+Requires-Python: >= 3.10
+Description-Content-Type: text/markdown
+License-Expression: MIT
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: iOS
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
+Classifier: Topic :: Software Development :: User Interfaces
+License-File: LICENSE
+Requires-Dist: bottle
+Requires-Dist: Mako
+Project-URL: Homepage, https://github.com/m4nw3l/pythonista-wkapp
+
+# pythonista-wkapp
+## WKApp - A modern HTML5 UI framework for building iOS apps with Pythonista 3 and WebKit
+
+WKApp is a modern, lightweight and minimal application framework for developing Python applications with desktop-class HTML 5 based user interfaces on Apple iOS devices in the [Pythonista 3 IDE](https://omz-software.com/pythonista/) for iOS. 
+It is a comprehensive and fully featured alternative to Pythonista's native app `ui` library, allowing user interfaces to be created with standard web technologies. Using powerful Python templating for dynamic HTML5/CSS/JavaScript views rendering with Mako, simple instanced view state binding supporting auto-wiring GET/POST values and two way Python/JavaScript interop via JSON over thread-safe message handlers. 
+
+Creating user interfaces for Python Apps in Pythonista becomes as simple as adding new .html view template files into your project. Which are then served locally from a Bottle.py HTTP/WSGI server and shown in a native WKWebView browser component. WKApp supports creating user interfaces with anything supported by modern web browsers using HTML5, CSS, JavaScript or even WebAssembly and browser based 2D/3D graphics! 
+
+
+## Getting started
+Pip is the recommended installation method for WKApp. 
+Install [StaSh](https://github.com/ywangd/stash) for Pythonista 3 using the installation instructions from its README first.
+Then install the `pythonista-wkapp` module with pip.
+```
+pip install pythonista-wkapp
+```
+Alternatively you can also clone or download a zip of this repository and copy/extract the project files into `site-packages/wkapp`.
+
+To create an app, simply add a folder somewhere containing an `app.py` file as follows.
+
+```python
+
+from wkapp import *
+
+app = WKApp(__file__)
+app.run()
+
+```
+
+Run this file and you should see a fullscreen browser control and the main view index.html placeholder page shown. 
+You can then start making your own views straight away!
+
+To replace the initial main view / index.html placeholder page: 
+- Create a `views` folder in the same folder as your `app.py` file.
+- Create a file `views/index.html`.
+- Then add your html and setup a `view_class` mixin definition like as below. 
+	- An instance of this class will be maintained with your view which can be used to store state, bind/manipulate elements, provide functions to be called from Javascript and evaluate Javascript from Python in the view to inspect and alter the DOM or backend state.
+
+A simple `views/index.html` view example:
+
+```python
+<%!
+
+class ViewClass:
+	def on_init(self):
+		self.name = ''
+		
+	def view_action(self, text,*args):
+		print(text,args)
+		self.element('header').set('text',f'hello javascript! text was {text} args were {args}')
+		
+
+view_class = ViewClass
+
+%>
+```
+```html
+<!-- inherit from the view.html template to render the views content inside the apps customisable base layout and structure -->
+<%inherit file="view.html"/>
+<!-- Your page content goes here -->
+<script type="text/javascript">
+  function invoke_view_action() {
+  	view.invoke('view_action', 'hello python!', 
+      {pass:'any',json:['compatible'], args:{ints:1}, floats:0.5},
+      ['lists',{},1,2.2],
+      'strings',
+      'numbers',1,1.5
+    );
+  }
+</script>
+<button onclick="invoke_view_action()">Call Python</button>
+<button onclick="app.exit()">Exit Application</button>
+<div>
+  <h1 id="header">Hello World!</h1>
+  <form method="POST">
+    <label>Enter your name:</label>
+    <input name="name" type="text" value="${view.name}" />
+    <br />
+    <input type="submit" value="Submit" />
+  </form>
+% if view.name != '': 
+    <h2> Hello ${view.name}! </h2>
+% endif
+</div>
+```
+Note: Code above is one file, it is just shown in two parts here for code highlighting purposes.
+
+### Dependencies
+WKApp requires the Pythonista 3 app on iOS to run but otherwise uses a minimal set of dependencies:
+
+- [Bottle.py 0.13.4](https://github.com/bottlepy/bottle)
+- [Mako 1.13.10](https://github.com/sqlalchemy/mako)
+- pythonista-wkwebview 1.2 (Bundled)
+	- 1.2 is an extended version for WKApp, updated with fixes and new features for using the native WKWebView from UIKit on iOS. Including a WKURLSchemeHandler implementation allowing creating custom url schemes with a single handler in a subclass, simplified javascript handlers threading concerns with a Dispatcher, arbitrary arguments passing from javascript to python via json. 
+	- 1.1 [Gist (@sbbosco)](https://gist.github.com/sbbosco/1290f59d79c6963e62bb678f0f05b035)
+	- 1.0 [Github (@mikaelho)](https://github.com/mikaelho/pythonista-webview)
+
+### Bundled Web frontend libraries:
+The base app html template bundles with it Bootstrap and JQuery to offer a way to just start developing apps rapidly right away straight out of the box. 
+However if you prefer other frameworks the `base/app.html` template can also be customised. 
+Simply create a copy of `views/base/app.html` from the repository and add it to your `views` folder in the same structure `views/base/app.html`.
+Any base template file may be replaced in this same way.
+
+- [Bootstrap 5.3.8](https://getbootstrap.com/docs/5.3/getting-started/introduction/)
+- [JQuery 3.7.1](https://jquery.com)
+

pythonista_wkapp-0.1.0.dist-info/RECORD

@@ -0,0 +1,5 @@
+wkapp.py,sha256=-PpbjklJ9X3ai2iPK2Z8gK1hTkAfq1_X4AlSl8dt4DY,25446
+pythonista_wkapp-0.1.0.dist-info/licenses/LICENSE,sha256=eJni0v8cBIs6ZvXEWIixdkS7y1IrCNiV1Zcnrg37qF8,1063
+pythonista_wkapp-0.1.0.dist-info/WHEEL,sha256=G2gURzTEtmeR8nrdXUJfNiB3VYVxigPQ-bEQujpNiNs,82
+pythonista_wkapp-0.1.0.dist-info/METADATA,sha256=nnO2AIY70gZsS6f0Ddfp6ld2YDezRRrAaqHzkEhBuvc,5915
+pythonista_wkapp-0.1.0.dist-info/RECORD,,

pythonista_wkapp-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: flit 3.12.0
+Root-Is-Purelib: true
+Tag: py3-none-any

pythonista_wkapp-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 M4nw3l
+
+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.

wkapp.py

@@ -0,0 +1,787 @@
+''' 
+WKApp - A modern HTML5 UI framework for building iOS apps with Pythonista 3 and WebKit
+
+https://github.com/M4nw3l/pythonista-wkapp
+'''
+__version__ = '0.1.0'
+
+try:
+    #pythonista specific libraries
+    import ui
+except:
+    raise Exception("Pythonista 3 is required.")
+
+import inspect
+import os
+import sys
+import threading
+from urllib.parse import urlparse, quote as urlencode, unquote as urldecode
+
+import requests
+
+import bottle
+from bottle import Bottle, default_app, BaseTemplate
+from bottle import WSGIRefServer
+from bottle import (
+    request,
+    response,
+    route,
+    static_file,
+    mako_template as template,
+)
+
+from mako.lookup import TemplateLookup
+from mako import parsetree
+from mako.lexer import Lexer
+
+import logging
+
+log = logging.getLogger(__name__)
+
+try:
+    from .WKWebView import *
+except:
+    from WKWebView import *
+
+
+class WKAppWebView(WKWebView):
+
+    def init(self):
+        self.scheme_handler = None
+
+    def scheme_wkapp(self, task):
+        log.warning(f'WKAppWebView - URL Scheme - {task.url}')
+        if not self.scheme_handler is None and hasattr(self.scheme_handler,
+                                                       'webview_scheme_wkapp'):
+            self.scheme_handler.webview_scheme_wkapp(self, task)
+        else:
+            task.failed(f'WKAppWebView - URL Scheme Unhandled')
+
+    def on_javascript_console_message(self, level, content):
+        log.warning(f'WKAppWebView - JS - {level.upper()}: {content}')
+
+    def webview_did_start_load(self, url):
+        log.warning(f'WKAppWebView - Start loading {url}')
+
+    def webview_did_finish_load(self, url):
+        log.warning(f'WKAppWebView - Finish loading {url}')
+
+
+class WKAppView(ui.View):
+
+    @property
+    def webview(self):
+        return self['webview']
+
+    def did_load(self):
+        if self.webview is None:
+            raise RuntimeError("WKWebView not loaded")
+
+    def load(self, app):
+        self.app = app
+        if self.webview is None:
+            raise RuntimeError("WKWebView not loaded")
+        self.webview.delegate = self.app
+        self.webview.scheme_handler = self.app
+        self.webview.load_url(self.app.app_url,
+                              no_cache=self.app.no_cache,
+                              clear_cache=self.app.clear_cache)
+
+    def will_close(self):
+        self.webview.close()
+        self.app.cleanup()
+
+
+class WKAppServer(threading.Thread):
+
+    def __init__(self, app, host='localhost', port=8080, server_class=None):
+        threading.Thread.__init__(self)
+        self.app = app
+        self.host = host
+        self.port = port
+        self.server_class = server_class
+
+    def run(self):
+        log.warning(f'WKApp - Server Starting...')
+        if self.server_class is None:
+            self.server_class = WSGIRefServer
+        server_class = self.server_class
+        self.server = server_class(port=self.port)
+        self.app.run(host=self.host,
+                     port=self.port,
+                     server=self.server,
+                     debug=True)
+
+    def get_id(self):
+        if hasattr(self, '_thread_id'):
+            return self._thread_id
+        for id, thread in threading._active.items():
+            if thread is self:
+                return id
+        return None
+
+    def stop(self):
+        log.warning(f'WKApp - Server Stopping...')
+        if hasattr(self, 'server') and hasattr(self.server, 'srv'):
+            server = self.server.srv
+            if hasattr(server, 'shutdown'):
+                server.shutdown()
+            if hasattr(server, 'close'):
+                server.close()
+            elif hasattr(server, 'server_close'):
+                server.server_close()
+        else:
+            thread_id = self.get_id()
+            if not thread_id is None:
+                res = ctypes.pythonapi.PyThreadState_SetAsyncExc(
+                    thread_id, ctypes.py_object(KeyboardInterrupt))
+                if res > 1:
+                    ctypes.pythonapi.PyThreadState_SetAsyncExc(thread_id, 0)
+        self.join()
+        log.warning(f'WKApp - Server Stopped.')
+
+
+class WKConstants:
+    unspecfied = object()
+
+
+class WKJavascript:
+
+    @staticmethod
+    def str_escape(value, delim='`'):
+        value = value.replace(delim, f'\\{delim}')
+        return value
+
+    @staticmethod
+    def value_to_js(value):
+        if isinstance(value, str):
+            value = WKJavascript.str_escape(value, '`')
+            value = f'`{value}`'
+        elif isinstance(value, bool):
+            value = 'true' if value == True else 'false'
+        elif isinstance(value, (int, float, complex)):
+            pass
+        else:
+            obj = json.dumps(value)
+            value = f'{obj}'
+        return value
+
+    @staticmethod
+    def value_to_py(value, typ, default=WKConstants.unspecfied):
+        if value is None:
+            if default == WKConstants.unspecfied:
+                if typ in [str, int, float, complex, bool]:
+                    return typ()
+                return value
+            else:
+                return default
+        return typ(value)
+
+    @staticmethod
+    def function_call(name, *args, chain=False):
+        code = [f'{name}(']
+        first = True
+        for arg in args:
+            if not first:
+                code.append(',')
+            code.append(WKJavascript.value_to_js(arg))
+            first = False
+        code.append(')')
+        if not chain:
+            code.append(';')
+        code = ''.join(code)
+        return code
+
+    @staticmethod
+    def field(instance, name):
+        return f'{instance}.{name}'
+
+    @staticmethod
+    def field_get(instance, name):
+        return WKJavascript.field(instance, name) + ';'
+
+    @staticmethod
+    def field_set(instance, name, value):
+        value = WKJavascript.value_to_js(value)
+        return WKJavascript.field(instance, name) + f' = {value};'
+
+    @staticmethod
+    def instance_call(instance, name, *args, chain=False):
+        return WKJavascript.field(
+            instance, WKJavascript.function_call(name, *args, chain=chain))
+
+    @staticmethod
+    def jquery(selector):
+        return f'$("{selector}")'
+
+    @staticmethod
+    def document_get_element_by_id(id):
+        return WKJavascript.instance_call('document', 'getElementById', id)
+
+
+class WKElementsRef:
+
+    def __init__(self, view, selector, js=WKJavascript):
+        self.view = view
+        self.selector = selector
+        self.js = js
+        self.elem = js.jquery(self.selector)
+
+    def call(self, name, *args):
+        script = self.js.instance_call(self.elem, name, *args)
+        return self.view.eval_js(script)
+
+    def get(self, name, typ=str, default=WKConstants.unspecfied):
+        value = self.call(name)
+        return self.js.value_to_py(value, typ, default)
+
+    def set(self, name, value):
+        self.call(name, value)
+
+
+class WKView:
+
+    def __init__(self,
+                 app=None,
+                 url='',
+                 path='',
+                 template=None,
+                 js=WKJavascript):
+        self.app = app
+        self.url = url
+        self.path = path
+        self.template = template
+        self.js = js
+        self.event('on_init')
+
+    def webview(self):
+        return self.app.app_webview
+
+    def eval_js(self, script):
+        return self.webview().eval_js(script)
+
+    def eval_js_async(self, script):
+        return self.webview().eval_js_async(script)
+
+    def elements(self, selector):
+        return WKElementsRef(self, selector, self.js)
+
+    def element(self, id):
+        return WKElementsRef(self, f'#{id}', self.js)
+
+    def event(self, name, *args, **kwargs):
+        if hasattr(self, name):
+            func = getattr(self, name)
+            func(*args, **kwargs)
+
+
+class WKViewsLexer(Lexer):
+
+    def match_expression(self):
+        match = self.match(r"(\$\$|%%){")
+        if not match is None:
+            # matches an 'escaped' expression for emitting an expression-like literal
+            escape = match.group(1)
+            match = self.match(r"(.*?)}", re.S)
+            self.append_node(parsetree.Text,
+                             escape[0] + "{" + match.group(1) + "}")
+            return True
+        match = self.match(r"(\$|%){")  # match expressions with ${} or %{}
+        if not match:
+            return False
+        # matched expression
+        line, pos = self.matched_lineno, self.matched_charpos
+        text, end = self.parse_until_text(True, r"\|", r"}")
+        if end == "|":
+            escapes, end = self.parse_until_text(True, r"}")
+        else:
+            escapes = ""
+        text = text.replace("\r\n", "\n")
+        self.append_node(
+            parsetree.Expression,
+            text,
+            escapes.strip(),
+            lineno=line,
+            pos=pos,
+        )
+        return True
+
+    def match_text(self):
+        match = self.match(
+            r"""
+                (.*?)         # anything, followed by:
+                (
+                 (?<=\n)(?=[ \t]*(?=%|\#\#))  # an eval or line-based
+                                            # comment, preceded by a
+                                            # consumed newline and whitespace
+                 |
+                 (?=(\$\$|%%){)      # an escaped expression
+                 |
+                 (?=(\$|%){)      # an expression
+                 |
+                 (?=</?%)  # a substitution or block or call start or end
+                              # - don't consume
+                 |
+                 (\\\r?\n)    # an escaped newline  - throw away
+                 |
+                 \Z           # end of string
+                )""",
+            re.X | re.S,
+        )
+        if match:
+            text = match.group(1)
+            if text:
+                self.append_node(parsetree.Text, text)
+            return True
+        else:
+            return False
+
+    @staticmethod
+    def preprocessor(template, *args, **kwargs):
+        #log.warning(f"WKViewsTemplate preprocess: {args} {kwargs}")
+        #log.warning(template)
+        return template
+
+
+class WKAppTemplate(bottle.MakoTemplate):
+
+    def prepare(self, **options):
+        from mako.template import Template
+        from mako.lookup import TemplateLookup
+        options.update({'input_encoding': self.encoding})
+        options.setdefault('format_exceptions', bool(bottle.DEBUG))
+        lookup = options.pop('template_lookup',
+                             None)  # threading can cause problems here
+        if lookup is None:
+            directories = options.pop('directories', self.lookup)
+            lookup = TemplateLookup(directories=directories, **options)
+        if self.source:
+            self.tpl = Template(self.source, lookup=lookup, **options)
+        else:
+            self.tpl = Template(uri=self.name,
+                                filename=self.filename,
+                                lookup=lookup,
+                                **options)
+
+
+wkapp_template = functools.partial(bottle.template,
+                                   template_adapter=WKAppTemplate)
+
+
+class WKViews:
+
+    def __init__(self, app, app_path, app_views_path, module_path,
+                 module_views_path):
+        bottle.TEMPLATE_PATH.clear()
+        bottle.TEMPLATE_PATH.append(app_views_path)
+        bottle.TEMPLATE_PATH.append(module_views_path)
+        imports = []
+        self.template_settings = {
+            'directories': bottle.TEMPLATE_PATH,
+            #'module_directory': os.path.join(app_path, 'views-cache'),
+            'imports': imports,
+            'preprocessor': WKViewsLexer.preprocessor,
+            'lexer_cls': WKViewsLexer
+        }
+        self.lookup = TemplateLookup(**self.template_settings)
+        self.app = app
+        self.load_view = None
+        self.next_view = None
+        self.views = {}
+        self.view = WKView()
+        self.views[self.view.url] = self.view
+        self.about_blank_view = WKView('about:blank')
+        self.views[self.about_blank_view.url] = self.about_blank_view
+
+    def template(self, path, **kwargs):
+        return wkapp_template(path,
+                              template_settings=self.template_settings,
+                              **kwargs)
+
+    @property
+    def base_url(self):
+        return self.app.base_url
+
+    @property
+    def url(self):
+        return self.view.url if self.view else ''
+
+    @property
+    def load_url(self):
+        return self.load_view.url if not self.load_view is None else ''
+
+    @property
+    def next_url(self):
+        return self.next_view.url if not self.next_view is None else ''
+
+    def cancel_load_view(self):
+        self.load_view = self.about_blank_view
+        return False
+
+    def get_url_path(self, url=None, path=None):
+        if url is None and path is None:
+            raise Exception('Must specify one of url or path')
+        if url == 'about:blank':
+            return url, url
+        if not path is None and not path.startswith('/'):
+            path = '/' + path
+        if url is None and not path is None:
+            url = self.base_url + path
+        if path is None and not url is None:
+            parsed_url = urlparse(url)
+            path = parsed_url.path
+        if url == self.base_url + '/' or path == '/':
+            path = '/index.html'
+            url = self.base_url + path
+        return url, path
+
+    def get_view(self, url=None, path=None, create=False):
+        view = None
+        url, path = self.get_url_path(url, path)
+        if url == 'about:blank':
+            return self.about_blank_view
+        if create and not path in self.views:
+            try:
+                view_template = self.lookup.get_template(path)
+                if view_template is None:
+                    raise Exception("Mako template not found.")
+                log.warning(
+                    f'WKViewState - Template found for {path} {view_template}')
+            except Exception as e:
+                log.warning(
+                    f'WKViewState - No template found for path {path} {view_template}, {e}'
+                )
+            if not view_template is None and hasattr(view_template.module,
+                                                     'view_class'):
+                view_class = view_template.module.view_class
+
+                class view_class_mixin(view_class, WKView):
+                    pass
+
+                view = view_class_mixin(self.app, url, path, view_template)
+                if view is None:
+                    raise Exception(
+                        f"view_class is defined but returned None or not an object value = '{view}'"
+                    )
+            else:
+                view = WKView(self.app, url, path, view_template)
+            self.views[path] = view
+            return view
+        if not path is None:
+            view = self.views[path]
+        return view
+
+    def prepare_load_view(self, url, scheme, nav_type):
+        log.warning(f'WKViewState - Preparing load {url}')
+        view = self.get_view(url=url, create=True)
+        self.load_view = view
+        view.event('on_prepare')
+        return True
+
+    def start_load_view(self, url):
+        log.warning(f'WKViewState - Start load {url}')
+        url, path = self.get_url_path(url=url)
+        if self.load_url != url:
+            raise Exception(
+                f'Unexpected view url "{url}" expected "{self.load_url}"')
+        self.load_view = None
+        view = self.get_view(url=url)
+        self.next_view = view
+        view.event('on_loading')
+
+    def finish_load_view(self, url):
+        log.warning(f'WKViewState - Finish load {url}')
+        url, path = self.get_url_path(url)
+        if self.next_url != url:
+            raise Exception(
+                f'Unexpected view url "{url}" expected "{self.next_url}"')
+        self.next_view = None
+        view = self.get_view(url=url)
+        self.view = view
+        view.event('on_loaded')
+
+
+class WKAppPlugin:
+
+    def __init__(self, app):
+        self.app = app
+        self.callbacks = {}
+        pass
+
+    def setup(self, app):
+        pass
+
+    def has_args(self, callback, *args):
+        spec = self.callbacks.get(callback, None)
+        if spec is None:
+            spec = inspect.getfullargspec(callback)
+            spec = spec[0]
+            self.callbacks[callback] = spec
+        for arg in args:
+            if not arg in spec:
+                return False
+        return True
+
+    def response_headers(self):
+        # Enable cross origin isolation for browser to consider context secure enough for full web assembly and webgl support
+        # https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/SharedArrayBuffer#security_requirements
+        response.add_header('Permissions-Policy', 'cross-origin-isolated=self')
+        response.add_header('Access-Control-Allow-Origin', '*')
+        response.add_header(
+            'Access-Control-Allow-Headers',
+            '"Origin, X-Requested-With, Content-Type, Accept"')
+        response.add_header('Access-Control-Allow-Methods', '*')
+        response.add_header('Cross-Origin-Opener-Policy', 'same-origin')
+        response.add_header('Cross-Origin-Embedder-Policy', 'require-corp')
+        response.add_header('Cross-Origin-Resource-Policy', 'cross-origin')
+
+    def apply(self, callback, route):
+        if not self.has_args(callback, 'view'):
+            return callback
+
+        def wrapper(*args, **kwargs):
+            view = self.app.get_view(url=request.url, create=True)
+            kwargs['view'] = view
+            self.response_headers()
+            return callback(*args, **kwargs)
+
+        return wrapper
+
+
+class WKApp:
+
+    def __init__(self,
+                 root=None,
+                 port=8080,
+                 host='localhost',
+                 app=None,
+                 server=None,
+                 app_views_path='views',
+                 app_static_path='static',
+                 module_views_path='views',
+                 module_static_path='static',
+                 custom_scheme=False,
+                 no_cache=True,
+                 clear_cache=False):
+        self.module_path = os.path.dirname(__file__)
+        self.module_static_path = os.path.join(self.module_path,
+                                               module_static_path)
+        self.module_views_path = os.path.join(self.module_path,
+                                              module_views_path)
+        self._app_path = ''
+        if root is None:
+            root = self.module_static_path
+        if os.path.isfile(root):
+            root = os.path.dirname(root)
+        self._app_path = root
+        self.app_static_path = os.path.join(self.app_path, app_static_path)
+        self.app_views_path = os.path.join(self.app_path, app_views_path)
+        self.custom_scheme = custom_scheme
+        self.no_cache = no_cache
+        self.clear_cache = clear_cache
+        if app is None:
+            self._app = Bottle()
+            default_app.push(self.app)
+        else:
+            self._app = app
+
+        self._app_view = None
+        self._views = WKViews(self, self.app_path, self.app_views_path,
+                              self.module_path, self.module_views_path)
+        self.host = host
+        self.port = port
+        self.server = server
+        self.server_internal = self.server is None
+
+        self.plugin = WKAppPlugin(self)
+        self.app.install(self.plugin)
+        with self.app:
+            self.setup_server_routes()
+
+        log.warning(f"WKApp - Init\n" +
+                    f"      - Module path: {self.module_path}\n"
+                    f"      - App path: {self.app_path}\n" +
+                    f"      - TEMPLATE_PATH: {bottle.TEMPLATE_PATH}")
+
+    @property
+    def app(self):
+        return self._app
+
+    @property
+    def app_path(self):
+        return self._app_path
+
+    @property
+    def base_url(self):
+        return f'http://{self.host}:{self.port}'
+
+    @property
+    def app_url(self):
+        if self.custom_scheme:
+            return f'wkapp://localhost/'
+        return self.base_url
+
+    def start_server(self):
+        if self.server is None and self.server_internal:
+            self.server = WKAppServer(self.app, self.host, self.port)
+            self.server.start()
+
+    def stop_server(self):
+        if not self.server is None and self.server_internal:
+            self.server.stop()
+            self.server = None
+
+    def present(self,
+                mode='fullscreen',
+                no_cache=True,
+                clear_cache=False,
+                **kwargs):
+        self._app_view = ui.load_view(
+            os.path.join(self.module_path, 'wkapp.pyui'))
+        self.no_cache = no_cache
+        self.clear_cache = clear_cache
+        self.app_view.load(self)
+        self.app_view.present(mode, **kwargs)
+
+    def run(self, **kwargs):
+        log.warning(f'WKApp - Run')
+        self.start_server()
+        self.present(**kwargs)
+
+    def exit(self):
+        if not self.app_view:
+            return
+        self.app_view.close()
+
+    def cleanup(self):
+        self.stop_server()
+
+    def static_file(self, filepath, root='/'):
+        if root == '/':
+            root = self.app_path
+        if root != self.module_static_path and not os.path.exists(
+                os.path.join(root, filepath)):
+            root = self.module_static_path
+        return static_file(filepath, root=root)
+
+    def template(self, path, **kwargs):
+        return self.views.template(path, **kwargs)
+
+    def get_view(self, url=None, path=None, create=False):
+        view = self.views.get_view(url=url, path=path, create=create)
+        log.warning(f'WKApp.get_view("{url}", "{path}", {create}) -> {view}')
+        if view is None:
+            return view
+        values = {}
+        query = {}
+        kwargs = {'request': request, 'values': values, 'query': query}
+        method = request.method
+        for k, v in request.query.iteritems():
+            query[k] = v
+            values[k] = v
+            if hasattr(view, k):
+                setattr(view, k, v)
+        if method == 'POST':
+            for k, v in request.forms.iteritems():
+                values[k] = v
+                if hasattr(view, k):
+                    setattr(view, k, v)
+        view.event('on_' + method, **kwargs)
+        return view
+
+    def setup_server_routes(self):
+
+        @route('/static/<filepath:path>')
+        def server_static(filepath):
+            return self.static_file(filepath)
+
+        @route('/<filepath:path>')
+        def server_template_get(filepath, view):
+            return self.template(filepath, view=view)
+
+        @route('/<filepath:path>', method='POST')
+        def server_template_post(filepath, view):
+            return self.template(filepath, view=view)
+
+        @route('/')
+        def server_index_get(view):
+            return server_template_get('index.html', view)
+
+        @route('/', method='POST')
+        def server_index_post(view):
+            return server_template_post('index.html', view)
+
+    @property
+    def app_view(self):
+        return self._app_view
+
+    @property
+    def app_webview(self):
+        return self.app_view.webview if self.app_view else None
+
+    @property
+    def views(self):
+        return self._views
+
+    @property
+    def view(self):
+        return self.views.view
+
+    def webview_should_start_load(self, webview, url, scheme, nav_type):
+        start = self.views.prepare_load_view(url, scheme, nav_type)
+        return start
+
+    def webview_did_start_load(self, webview, url):
+        self.views.start_load_view(url)
+
+    def webview_did_finish_load(self, webview, url):
+        self.views.finish_load_view(url)
+
+    def webview_on_invoke(self, sender, typ, context, target, args, kwargs):
+        url = sender.current_url
+        url, path = self.views.get_url_path(url=url)
+        log.warning(
+            f'WKApp - INVOKE "{url}" "{typ}" "{context}" "{target}" "{args}" "{kwargs}"'
+        )
+        pycontext = None
+        if typ == "WKApp":
+            pycontext = self
+        elif typ == "WKView":
+            if url == self.view.url:
+                pycontext = self.view
+            else:
+                pycontext = self.views.get_view(url=url, path=path)
+        else:
+            raise Exception(f"Context type {typ} unhandled")
+        if not hasattr(pycontext, target):
+            raise Exception(
+                f"Target '{target}' not found in context {pycontext}")
+        pytarget = getattr(pycontext, target)
+        if not callable(pytarget):
+            raise Exception(
+                f"Target '{target} {pytarget}' in context {pycontext} not callable"
+            )
+        pytarget(*args, **kwargs)
+
+    def webview_scheme_wkapp(self, webview, task):
+        command = task.host
+        if command == "localhost" or command == "proxy":
+            url = task.path
+            if command == "localhost":
+                url = self.base_url + url
+            else:
+                url = urldecode(url[1:])
+            response = requests.request(task.method,
+                                        url,
+                                        headers=task.headers,
+                                        data=task.body)
+            task.finish(status_code=response.status_code,
+                        headers=response.headers,
+                        data=response.content,
+                        content_type=response.headers.get('Content-Type'))
+
+
+if __name__ == '__main__':
+    app = WKApp(__file__, app_views_path='test/views')
+    app.run()
+