# -*- coding: utf-8 -*-
# #############################################################################
# Copyright (C) 2018 manatlan manatlan[at]gmail(dot)com
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published
# by the Free Software Foundation; version 2 only.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# https://github.com/manatlan/wuy
# #############################################################################
__version__ = "0.10.1"
from aiohttp import web, WSCloseCode
from multidict import CIMultiDict
import concurrent
import aiohttp
import asyncio
import json, sys, os
import webbrowser
import traceback
import uuid
import inspect
import types
import base64
import socket
import tempfile
import subprocess
import platform
from urllib.parse import urlparse
import inspect
import re
from datetime import datetime, date
"""
cef troubles, to fix (before 1.0 release):
- FIX: set title don't work on *nix (Issue #252)
- FIX: chain'able broken (test app3)
- EVOL: make contextual menu (dev tools) optional
- TEST: freezing with cef
"""
DEFAULT_PORT = 8080
application = None
currents = {} # NEW
isLog = None
FULLSCREEN = "fullscreen" # const !
PATH = os.path.dirname(os.path.abspath(os.path.realpath(sys.argv[0])))
try:
if not getattr(
sys, "frozen", False
): # bypass uvloop in frozen app (wait pyinstaller hook)
import uvloop
asyncio.set_event_loop_policy(uvloop.EventLoopPolicy())
except ImportError:
pass
# helpers
#############################################################
def isFree(ip, port):
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
try:
s.bind((ip, int(port)))
return True
except socket.error as e:
return False
finally:
s.close()
def serialize(obj):
def toJSDate(d):
assert type(d) in [datetime, date]
d = datetime(d.year, d.month, d.day, 0, 0, 0, 0) if type(d) == date else d
return d.isoformat() + "Z"
if isinstance(obj, (datetime, date)):
return toJSDate(obj)
if isinstance(obj, bytes):
return str(obj, "utf8")
if hasattr(obj, "__dict__"):
return obj.__dict__
else:
return str(obj)
def unserialize(obj):
if type(obj) == str:
if re.search("^\d\d\d\d-\d\d-\d\dT\d\d:\d\d:\d\d\.\d+Z$", obj):
return datetime.strptime(obj, "%Y-%m-%dT%H:%M:%S.%fZ")
elif re.search("^\d\d\d\d-\d\d-\d\dT\d\d:\d\d:\d\dZ$", obj):
return datetime.strptime(obj, "%Y-%m-%dT%H:%M:%SZ")
elif type(obj) == list:
return [unserialize(i) for i in obj]
return obj
def jDumps(obj):
return json.dumps(obj, default=serialize)
def jLoads(s):
return unserialize(
json.loads(s, object_pairs_hook=lambda obj: {k: unserialize(v) for k, v in obj})
)
class JDict:
def __init__(self, f: str):
self.__f = os.path.join(PATH, f)
try:
with open(self.__f, "r+") as fid:
self.__d = (
json.load(
fid,
object_pairs_hook=lambda obj: {
k: unserialize(v) for k, v in obj
},
)
or {}
)
except FileNotFoundError as e:
self.__d = {}
def set(self, k: str, v):
self.__d[k] = v
self.__save()
def get(self, k: str = None):
return self.__d.get(k, None) if k else self.__d
def __save(self):
with open(self.__f, "w+") as fid:
json.dump(self.__d, fid, indent=4, sort_keys=True, default=serialize)
def path(f):
if hasattr(sys, "_MEIPASS"): # when freezed with pyinstaller ;-)
return os.path.join(sys._MEIPASS, f)
else:
return os.path.join(PATH, f)
def wlog(*l):
if isLog:
s = " ".join([str(i) for i in l])
if len(s) > 200:
s = s[:200] + "..."
print(s)
def find_chrome_win():
import winreg # TODO: pip3 install winreg
reg_path = r"SOFTWARE\Microsoft\Windows\CurrentVersion\App Paths\chrome.exe"
for install_type in winreg.HKEY_CURRENT_USER, winreg.HKEY_LOCAL_MACHINE:
try:
with winreg.OpenKey(install_type, reg_path, 0, winreg.KEY_READ) as reg_key:
return winreg.QueryValue(reg_key, None)
except WindowsError:
pass
def find_chrome_mac():
default_dir = "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome"
if os.path.exists(default_dir):
return default_dir
class ChromeApp:
def __init__(self, url, size=None, chromeArgs=[]):
self.__instance = None
if sys.platform[:3] == "win":
exe = find_chrome_win()
elif sys.platform == "darwin":
exe = find_chrome_mac()
else:
for i in ["chromium-browser", "chromium", "google-chrome", "chrome"]:
try:
exe = webbrowser.get(i).name
break
except webbrowser.Error:
exe = None
if exe:
args = [exe, "--app=" + url] + chromeArgs
if size == FULLSCREEN:
args.append("--start-fullscreen")
if tempfile.gettempdir():
args.append(
"--user-data-dir=%s"
% os.path.join(tempfile.gettempdir(), ".wuyapp")
)
# self.__instance = subprocess.Popen( args, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL ) # make troubles on windows (freezd with noconsole don't start)
self.__instance = subprocess.Popen(args)
else:
raise Exception("no browser")
def wait(self):
if self.__instance:
return self.__instance.wait()
def __del__(self):
if self.__instance:
self.__instance.kill()
###############################################################
## works with CefPython3
###############################################################
class ChromeAppCef:
def __init__(self, url, size=None, chromeArgs=None): # chromeArgs is not used
import pkgutil
assert pkgutil.find_loader("cefpython3"), "cefpython3 not available"
def cefbrowser():
from cefpython3 import cefpython as cef
import ctypes
isWin = platform.system() == "Windows"
windowInfo = cef.WindowInfo()
windowInfo.windowName = "CefPython3"
if type(size) == tuple:
w, h = size[0], size[1]
windowInfo.SetAsChild(0, [0, 0, w, h]) # not win
else:
w, h = None, None
sys.excepthook = cef.ExceptHook
settings = {
"product_version": "Wuy/%s" % __version__,
"user_agent": "Wuy/%s (%s)" % (__version__, platform.system()),
"context_menu": dict(
enabled=True,
navigation=False,
print=False,
view_source=False,
external_browser=False,
devtools=True,
),
}
cef.Initialize(settings, {})
b = cef.CreateBrowserSync(windowInfo, url=url)
if isWin and w and h:
window_handle = b.GetOuterWindowHandle()
SWP_NOMOVE = 0x0002 # X,Y ignored with SWP_NOMOVE flag
ctypes.windll.user32.SetWindowPos(
window_handle, 0, 0, 0, w, h, SWP_NOMOVE
)
# ===---
def wuyInit(width, height):
if size == FULLSCREEN:
if isWin:
b.ToggleFullscreen() # win only
else:
b.SetBounds(0, 0, width, height) # not win
bindings = cef.JavascriptBindings()
bindings.SetFunction("wuyInit", wuyInit)
b.SetJavascriptBindings(bindings)
b.ExecuteJavascript("wuyInit(window.screen.width,window.screen.height)")
# ===---
class WuyClientHandler(object):
def OnLoadEnd(self, browser, **_):
pass # could serve in the future (?)
class WuyDisplayHandler(object):
def OnTitleChange(self, browser, title):
try:
cef.WindowUtils.SetTitle(browser, title)
except AttributeError:
print(
"**WARNING** : title changed '%s' not work on linux" % title
)
b.SetClientHandler(WuyClientHandler())
b.SetClientHandler(WuyDisplayHandler())
cef.MessageLoop()
cef.Shutdown()
from threading import Thread
t = Thread(target=cefbrowser)
t.start()
###############################################################
# -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
jar = aiohttp.CookieJar(unsafe=True)
class Request: # just to transform aiohttp.Request in wuy.Request (abstraction)
def __init__(self, req):
self.method = req.method
self.path = req.path
self.headers = req.headers
self.query = req.rel_url.query
self.body = None
class Response:
def __init__(self, status, content, headers=None):
self.status = status
if headers is None:
self.headers = CIMultiDict()
if content is not None and type(content) == bytes:
self.headers["Content-Type"] = "application/octet-stream"
else:
self.headers["Content-Type"] = "text/html"
else:
if type(headers) == str:
self.headers = CIMultiDict([("Content-Type", headers)])
else:
self.headers = headers
self.content = content
async def request(
url, data=None, headers={}
): # mimic urllib.Request() (GET & POST only)
async with aiohttp.ClientSession(cookie_jar=jar) as session:
try:
if data:
async with session.post(
url, data=data, headers=headers, ssl=False
) as resp:
return Response(
resp.status, await resp.text(), headers=resp.headers
)
else:
async with session.get(url, headers=headers, ssl=False) as resp:
return Response(
resp.status, await resp.text(), headers=resp.headers
)
except aiohttp.client_exceptions.ClientConnectorError as e:
return Response(None, str(e))
# -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
# Async aiohttp things (use current)
#############################################################
async def wsSend(ws, **kargs):
if not ws.closed:
wlog("< send:", kargs)
await ws.send_str(jDumps(kargs)) # TODO: should remove ws from list ?
async def wsBroadcast(instance, event, args, exceptMe=None):
for ws in instance._clients:
if id(ws) != id(exceptMe):
await wsSend(ws, event=event, args=args)
async def handleProxy(req): # proxify "/_/<url>" with headers starting with "set-"
url = req.match_info.get("url", None)
if req.query_string:
url = url + "?" + req.query_string
headers = {k[4:]: v for k, v in req.headers.items() if k.lower().startswith("set-")}
r = await request(
url, data=req.can_read_body and (await req.text()), headers=headers
)
wlog(". serve proxy url", url, headers, ":", r.status)
h = {"Server": "Wuy Proxified request (%s)" % __version__}
for k, v in r.headers.items():
if k.lower() in ["content-type", "date", "expires", "cache-control"]:
h[k] = v
return web.Response(status=r.status or 0, text=r.content, headers=h)
getname = lambda x: x.rsplit(".", 1)[0].replace("/", ".")
async def handleWeb(req): # serve all statics from web folder
ressource = req.match_info.get("path", "")
if ressource == "" or ressource.endswith("/"):
ressource += "index.html"
if ressource.lower().endswith((".html", ".htm")):
name = getname(ressource)
if name in currents:
html = currents[name]._render(path(os.path.dirname(ressource)))
if html: # the instance render its own html, go with it
if re.findall(r"""<.*script.*src.*=.*['"]wuy.js['"].*>""", html):
return web.Response(status=200, body=html, content_type="text/html")
else:
return web.Response(
status=200,
body='<script src="wuy.js"></script>\n' + html,
content_type="text/html",
)
# classic serve static file or 404
file = path(os.path.join("web", ressource))
if os.path.isfile(file):
wlog("- serve static file", file)
return web.FileResponse(file)
else:
wreq = Request(req)
if req.body_exists: # override body
wreq.body = await req.read()
for name, instance in currents.items():
ret = instance.request(wreq)
if ret is not None:
r = await ret if asyncio.iscoroutine(ret) else ret
if r is not None:
if type(r) != Response:
r = Response(status=200, content=r)
wlog("- serve dynamic via", name, r)
return web.Response(
status=r.status, body=r.content, headers=r.headers
)
wlog("! 404 on", file)
return web.Response(status=404, body="file not found")
async def handleJs(req): # serve the JS
pp = urlparse(req.headers["Referer"]).path[
1:
] # TODO: what if browser hide its referer ????
if pp.endswith("/") or pp == "":
pp += "index.html"
page = getname(pp)
instance = currents[page]
wlog(
"- serve wuy.js to",
page,
instance._size and ("(with resize to " + str(instance._size) + ")") or "",
)
name = os.path.basename(sys.argv[0])
if "." in name:
name = name.split(".")[0]
js = """
document.addEventListener("DOMContentLoaded", function(event) {
%s
%s
},true)
const dateFormat = /^\d\d\d\d-\d\d-\d\dT\d\d:\d\d:\d\d(\.\d+)?Z$/;
function reviver(key, value) {
if (typeof value === "string" && dateFormat.test(value)) {
return new Date(value);
}
return value;
}
function setupWS( cbCnx ) {
var url=window.location.origin.replace("http","ws")+"/_ws_%s"
var ws=new WebSocket( url );
ws.onmessage = function(evt) {
var r = JSON.parse(evt.data, reviver );
if(r.uuid) // that's a response from call py !
document.dispatchEvent( new CustomEvent('wuy-'+r.uuid,{ detail: r} ) );
else if(r.event){ // that's an event from anywhere !
document.dispatchEvent( new CustomEvent(r.event,{ detail: r.args } ) );
}
};
ws.onclose = function(evt) {
console.log("disconnected");
cbCnx(null);
%s
};
ws.onerror = function(evt) {cbCnx(null);};
ws.onopen=function(evt) {
console.log("Connected",evt)
cbCnx(ws);
}
return ws;
}
var wuy={
_ws: setupWS( function(ws){wuy._ws = ws; document.dispatchEvent( new CustomEvent("init") )} ),
on: function( evt, callback ) { // to register an event on a callback
var listener = function(e) { callback.apply(callback,e.detail) }
document.addEventListener(evt, listener)
return function() { document.removeEventListener(evt, listener) }
},
emit: function( evt, data) { // to emit a event to all clients (except me), return a promise when done
var args=Array.prototype.slice.call(arguments)
return wuy._call("emit", args)
},
init: function( callback ) {
function start() {
document.removeEventListener("init", start)
callback()
}
if(wuy._ws.readyState == wuy._ws.OPEN)
start()
else
document.addEventListener("init", start)
},
_call: function( method, args ) {
var cmd={
command: method,
args: args,
uuid: method+"-"+Math.random().toString(36).substring(2), // stamp the exchange, so the callback can be called back (thru customevent),
};
if(wuy._ws) {
wuy._ws.send( JSON.stringify(cmd) );
return new Promise( function (resolve, reject) {
document.addEventListener('wuy-'+cmd.uuid, function handler(x) {
this.removeEventListener('wuy-'+cmd.uuid, handler);
var x=x.detail;
if(x && x.result!==undefined)
resolve(x.result)
else if(x && x.error!==undefined)
reject(x.error)
});
})
}
else
return new Promise( function (resolve, reject) {
reject("not connected");
})
},
fetch: function(url,obj) {
var h={"cache-control": "no-cache"}; // !!!
if(obj && obj.headers)
Object.keys(obj.headers).forEach( function(k) {
h["set-"+k]=obj.headers[k];
})
var newObj = Object.assign({}, obj)
newObj.headers=h;
newObj.credentials= 'same-origin';
return fetch( "/_/"+url,newObj )
},
};
""" % (
instance._size
and "window.resizeTo(%s,%s);" % (instance._size[0], instance._size[1])
or "",
'if(!document.title) document.title="%s";' % name,
page,
instance._closeIfSocketClose
and "window.close()"
or "setTimeout( function() {setupWS(cbCnx)}, 1000);",
)
if instance._kwargs:
for k, v in instance._kwargs.items():
j64 = str(
base64.b64encode(bytes(jDumps(v), "utf8")), "utf8"
) # thru b64 to avoid trouble with quotes or strangers chars
js += """\nwuy.%s=JSON.parse(atob("%s"),reviver);""" % (k, j64)
for k in instance._routes.keys():
js += (
"""\nwuy.%s=function(_) {return wuy._call("%s", Array.prototype.slice.call(arguments) )};"""
% (k, k)
)
return web.Response(status=200, text=js)
async def wshandle(req):
global currents
page = req.match_info["page"]
if page not in currents:
return None
instance = currents[page]
ws = web.WebSocketResponse()
await ws.prepare(req)
instance._clients.append(ws)
wlog("Socket connected", page)
try:
async for msg in ws:
if msg.type == web.WSMsgType.text:
try:
o = jLoads(msg.data)
wlog("> RECEPT", page, o)
if o["command"] == "emit":
event, *args = o["args"]
await wsBroadcast(
instance, event, args, ws
) # emit to everybody except me
r = dict(
result=args
) # but return the same content sended, thru the promise
else:
ret = instance._routes[o["command"]](*o["args"])
if ret and asyncio.iscoroutine(ret):
wlog(". ASync call", page, o["command"])
async def waitReturn(coroutine, uuid):
try:
ret = await coroutine
m = dict(result=ret, uuid=uuid)
except concurrent.futures._base.CancelledError as e:
m = dict(error="task cancelled", uuid=uuid)
except Exception as e:
m = dict(error=str(e), uuid=uuid)
print("=" * 40, "in ASync", o["command"])
print(traceback.format_exc().strip())
print("=" * 40)
await wsSend(ws, **m)
asyncio.ensure_future(waitReturn(ret, o["uuid"]))
continue # don't answer yet (the coroutine will do it)
r = dict(result=ret)
except Exception as e:
r = dict(error=str(e))
print("=" * 40, "Exception on Recept", msg.data)
print(traceback.format_exc().strip())
print("=" * 79)
if "uuid" in o:
r["uuid"] = o["uuid"]
await wsSend(ws, **r)
elif msg.type == web.WSMsgType.close or msg.tp == web.WSMsgType.error:
break
finally:
wlog("Socket disconnected", page)
instance._clients.remove(ws)
if instance._closeIfSocketClose:
_exit(instance)
return ws
def _emit(instance, event, *args): # sync version of emit for py side !
asyncio.ensure_future(wsBroadcast(instance, event, args))
def _exit(instance=None): # exit method
global application
if asyncio.get_event_loop().is_running():
asyncio.get_event_loop().stop()
if instance and hasattr(instance, "_browser") and instance._browser:
del instance._browser
instance._browser = None
application = None
wlog("exit")
async def on_shutdown(app):
async def handle_exception(task):
try:
await task.cancel()
except Exception:
pass
for task in asyncio.all_tasks():
asyncio.ensure_future(handle_exception(task))
# WUY routines
#############################################################
class Base:
_routes = {}
_closeIfSocketClose = False
_size = None
_kwargs = {} # Window/Server only
def __init__(self, log=True):
global isLog
isLog = log
self._name = self.__class__.__name__
self._routes = {
n: v
for n, v in inspect.getmembers(self, inspect.ismethod)
if not v.__func__.__qualname__.startswith(("Base.", "Window.", "Server."))
}
self._routes.update(
dict(set=self.set, get=self.get)
) # add get/set config methods
if "init" in self._routes:
del self._routes[
"init"
] # ensure that a server-side init() is not exposed on client-side
self._clients = []
def _render(
self, folder="."
): # override this, if you want to do more complex things
html = self.__doc__
if html is None:
# create startpage if not present and no docstring
startpage = path(
os.path.join(folder, "web", self.__class__.__name__ + ".html")
)
if not os.path.isfile(startpage):
if not os.path.isdir(os.path.dirname(startpage)):
os.makedirs(os.path.dirname(startpage))
with open(startpage, "w+") as fid:
fid.write("""<script src="wuy.js"></script>\n""")
fid.write("""Hello Wuy'rld ;-)""")
print("Create '%s', just edit it" % startpage)
return html
@classmethod
def _start(cls, host, port, instances, appmode):
global application, currents
for i in instances:
i.init()
currents = {i._name: i for i in instances}
wlog(
"Will accept : %s"
% ["%s: %s" % (k, list(v._routes.keys())) for k, v in currents.items()]
) # TODO: not neat
if application is None:
routes = [
web.get("/_ws_{page}", wshandle),
web.get("/{path:.*}wuy.js", handleJs),
web.get("/", handleWeb),
web.route("*", "/_/{url:.+}", handleProxy),
web.route("*", "/{path:.+}", handleWeb),
]
application = web.Application()
try:
application.add_routes(routes)
except AttributeError:
application.router.add_routes(routes) # Py3.5 + aiohttp3.0b
application.on_shutdown.append(on_shutdown)
try:
if (
appmode
): # app-mode, don't shout "server started, Running on, ctrl-c"
web.run_app(
application, host=host, port=port, print=lambda *a, **k: None
)
else:
web.run_app(application, host=host, port=port)
except concurrent.futures._base.CancelledError:
pass # die silently
except RuntimeError: # for tests stopping loop TODO check
_exit()
except KeyboardInterrupt:
_exit()
asyncio.set_event_loop(
asyncio.new_event_loop()
) # renew, so multiple start are availables
def emit(self, *a, **k): # emit available for all
_emit(self, *a, **k)
def init(self): # override this to make initializations
pass
def request(self, req): # override to hook others web http requests
pass
def exit(self): # available for ALL !!!
_exit()
def set(self, key, value, file="config.json"):
c = JDict(file)
c.set(key, value)
def get(self, key=None, file="config.json"):
c = JDict(file)
return c.get(key)
class Window(Base):
size = True # or a tuple (wx,wy)
_port = None
chromeArgs = []
def __init__(self, port=DEFAULT_PORT, log=True, **kwargs):
super().__init__(log)
self.__dict__.update(kwargs)
self._kwargs = kwargs
self._run(port=port)
def _run(self, port): # start method (app can be True, (width,height), ...)
app = self.size
self._closeIfSocketClose = True
host = "localhost"
if Window._port is None:
while not isFree(host, port):
port += 1
Window._port = port
else:
port = Window._port
url = "http://%s:%s/%s?%s" % (
host,
port,
self._name + ".html",
uuid.uuid4().hex,
)
if type(app) == tuple and len(app) == 2: # it's a size tuple : set it !
self._size = app
try:
# self._browser=ChromeAppCef(url,app) # with CefPython3 !!!
self._browser = ChromeApp(url, app, chromeArgs=self.chromeArgs)
except Exception as e:
print("Can't find Chrome on your desktop : %s" % e)
sys.exit(-1)
Base._start(host, port, [self], True)
class Server(Base):
def __init__(self, port=DEFAULT_PORT, log=True, autorun=True, **kwargs):
super().__init__(log)
self.__dict__.update(kwargs)
self._kwargs = kwargs
if autorun:
Base._start("0.0.0.0", port, [self], False)
@classmethod
def run(cls, port=DEFAULT_PORT, log=True, **kwargs):
global isLog
isLog = log
allClasses = globals()[cls.__name__].__subclasses__()
instances = [c(autorun=False, **kwargs) for c in allClasses]
cls._start("0.0.0.0", port, instances, False)
if __name__ == "__main__":
pass
