618 lines
23 KiB
Python
Executable File
618 lines
23 KiB
Python
Executable File
#!/usr/bin/env python3
|
|
# Copyright (C) 2016-2017 Florian Festi
|
|
#
|
|
# 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, either version 3 of the License, or
|
|
# (at your option) any later version.
|
|
#
|
|
# 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.
|
|
#
|
|
# You should have received a copy of the GNU General Public License
|
|
# along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
from __future__ import annotations
|
|
|
|
import argparse
|
|
import gettext
|
|
import glob
|
|
import html
|
|
import mimetypes
|
|
import os.path
|
|
import re
|
|
import sys
|
|
import tempfile
|
|
import threading
|
|
import time
|
|
import traceback
|
|
from typing import Any
|
|
from urllib.parse import parse_qs
|
|
from urllib.parse import unquote_plus, quote
|
|
from wsgiref.simple_server import make_server
|
|
|
|
import markdown
|
|
|
|
try:
|
|
import boxes.generators
|
|
except ImportError:
|
|
sys.path.append(os.path.join(os.path.dirname(__file__), ".."))
|
|
import boxes.generators
|
|
|
|
|
|
class FileChecker(threading.Thread):
|
|
def __init__(self, files=[], checkmodules=True) -> None:
|
|
super().__init__()
|
|
self.checkmodules = checkmodules
|
|
self.timestamps = {}
|
|
self._stopped = False
|
|
for path in files:
|
|
self.timestamps[path] = os.stat(path).st_mtime
|
|
if checkmodules:
|
|
self._addModules()
|
|
|
|
def _addModules(self):
|
|
for name, module in sys.modules.items():
|
|
path = getattr(module, "__file__", None)
|
|
if not path:
|
|
continue
|
|
if path not in self.timestamps:
|
|
self.timestamps[path] = os.stat(path).st_mtime
|
|
|
|
def filesOK(self):
|
|
if self.checkmodules:
|
|
self._addModules()
|
|
for path, timestamp in self.timestamps.items():
|
|
try:
|
|
if os.stat(path).st_mtime != timestamp:
|
|
return False
|
|
except FileNotFoundError:
|
|
return False
|
|
return True
|
|
|
|
def run(self):
|
|
while not self._stopped:
|
|
if not self.filesOK():
|
|
os.execv(__file__, sys.argv)
|
|
time.sleep(1)
|
|
|
|
def stop(self):
|
|
self._stopped = True
|
|
|
|
|
|
class ArgumentParserError(Exception): pass
|
|
|
|
|
|
class ThrowingArgumentParser(argparse.ArgumentParser):
|
|
def error(self, message):
|
|
raise ArgumentParserError(message)
|
|
|
|
|
|
# Evil hack
|
|
boxes.ArgumentParser = ThrowingArgumentParser # type: ignore
|
|
|
|
|
|
class BServer:
|
|
lang_re = re.compile(r"([a-z]{2,3}(-[-a-zA-Z0-9]*)?)\s*(;\s*q=(\d\.?\d*))?")
|
|
|
|
def __init__(self, url_prefix="", static_url="static") -> None:
|
|
self.boxes = {b.__name__: b for b in boxes.generators.getAllBoxGenerators().values() if b.webinterface}
|
|
self.boxes['TrayLayout2'] = boxes.generators.traylayout.TrayLayout2 # type: ignore # no attribute "traylayout"
|
|
self.groups = boxes.generators.ui_groups
|
|
self.groups_by_name = boxes.generators.ui_groups_by_name
|
|
|
|
for name, box in self.boxes.items():
|
|
self.groups_by_name.get(box.ui_group,
|
|
self.groups_by_name["Misc"]).add(box)
|
|
|
|
self.staticdir = os.path.join(os.path.dirname(__file__), '../static/')
|
|
self._languages = None
|
|
self._cache: dict[Any, Any] = {}
|
|
self.url_prefix = url_prefix
|
|
self.static_url = static_url
|
|
|
|
def getLanguages(self, domain=None, localedir=None):
|
|
if self._languages is not None:
|
|
return self._languages
|
|
self._languages = []
|
|
domain = "boxes.py"
|
|
for localedir in ["locale", gettext._default_localedir]:
|
|
files = glob.glob(os.path.join(localedir, '*', 'LC_MESSAGES', '%s.mo' % domain))
|
|
self._languages.extend([file.split(os.path.sep)[-3] for file in files])
|
|
self._languages.sort()
|
|
return self._languages
|
|
|
|
def getLanguage(self, args, accept_language):
|
|
lang = None
|
|
langs = []
|
|
|
|
for i, arg in enumerate(args):
|
|
if arg.startswith("language="):
|
|
lang = arg[len("language="):]
|
|
del args[i]
|
|
break
|
|
if lang:
|
|
try:
|
|
return gettext.translation('boxes.py', localedir='locale', languages=[lang])
|
|
except OSError:
|
|
pass
|
|
try:
|
|
return gettext.translation('boxes.py', languages=[lang])
|
|
except OSError:
|
|
pass
|
|
|
|
# selected language not found try browser default
|
|
languages = accept_language.split(",")
|
|
for l in languages:
|
|
m = self.lang_re.match(l.strip())
|
|
if m:
|
|
langs.append((float(m.group(4) or 1.0), m.group(1)))
|
|
|
|
langs.sort(reverse=True)
|
|
langs = [l[1].replace("-", "_") for l in langs]
|
|
|
|
try:
|
|
return gettext.translation('boxes.py', localedir='locale', languages=langs)
|
|
except OSError:
|
|
return gettext.translation('boxes.py', languages=langs, fallback=True)
|
|
|
|
def arg2html(self, a, prefix, defaults={}, _=lambda s: s):
|
|
name = a.option_strings[0].replace("-", "")
|
|
if isinstance(a, argparse._HelpAction):
|
|
return ""
|
|
viewname = name
|
|
if prefix and name.startswith(prefix + '_'):
|
|
viewname = name[len(prefix) + 1:]
|
|
|
|
default = defaults.get(name, None)
|
|
row = """<tr><td id="%s"><label for="%s">%s</label></td><td>%%s</td><td id="%s">%s</td></tr>\n""" % \
|
|
(name + "_id", name, _(viewname), name + "_description", "" if not a.help else markdown.markdown(_(a.help)))
|
|
if (isinstance(a, argparse._StoreAction) and
|
|
hasattr(a.type, "html")):
|
|
input = a.type.html(name, default or a.default, _)
|
|
elif a.dest == "layout":
|
|
val = (default or a.default).split("\n")
|
|
input = """<textarea name="%s" id="%s" aria-labeledby="%s %s" cols="%s" rows="%s">%s</textarea>""" % \
|
|
(name, name, name + "_id", name + "_description", max(len(l) for l in val) + 10, len(val) + 1, default or a.default)
|
|
elif a.choices:
|
|
options = "\n".join(
|
|
"""<option value="%s"%s>%s</option>""" %
|
|
(e, ' selected="selected"' if (e == (default or a.default)) or (str(e) == str(default or a.default)) else "",
|
|
_(e)) for e in a.choices)
|
|
input = """<select name="{}" id="{}" aria-labeledby="{} {}" size="1" >\n{}</select>\n""".format(name, name, name + "_id", name + "_description", options)
|
|
else:
|
|
input = """<input name="%s" id="%s" aria-labeledby="%s %s" type="text" value="%s" >""" % \
|
|
(name, name, name + "_id", name + "_description", default or a.default)
|
|
|
|
return row % input
|
|
|
|
scripts = """
|
|
<script>
|
|
function showHide(id) {
|
|
var e = document.getElementById(id);
|
|
var h = document.getElementById("h-" + id);
|
|
if(e.style.display == null || e.style.display == "none") {
|
|
e.style.display = "block";
|
|
h.classList.add("open");
|
|
h.setAttribute("aria-expanded","true");
|
|
} else {
|
|
e.style.display = "none";
|
|
h.classList.remove("open");
|
|
h.setAttribute("aria-expanded","false");
|
|
}
|
|
}
|
|
function hideargs() {
|
|
for ( i=0; i<%i; i++) {
|
|
showHide(i);
|
|
}
|
|
}
|
|
</script>
|
|
"""
|
|
|
|
def args2html_cached(self, name, box, lang, action="", defaults={}):
|
|
if defaults == {}:
|
|
key = (name, lang.info().get('language', None), action)
|
|
if key not in self._cache:
|
|
self._cache[key] = list(self.args2html(name, box, lang, action, defaults))
|
|
return self._cache[key]
|
|
|
|
return self.args2html(name, box, lang, action, defaults)
|
|
|
|
def args2html(self, name, box, lang, action="", defaults={}):
|
|
_ = lang.gettext
|
|
lang_name = lang.info().get('language', None)
|
|
|
|
langparam = ""
|
|
lang_attr = ""
|
|
if lang_name:
|
|
langparam = "?language=" + lang_name
|
|
lang_attr = f" lang=\"{lang_name}\""
|
|
|
|
result = [f"""<!DOCTYPE html>
|
|
<html{lang_attr}>
|
|
<head>
|
|
<title>{_("%s - Boxes") % _(name)}</title>
|
|
<meta charset="utf-8">
|
|
<link rel="icon" type="image/svg+xml" href="{self.static_url}/boxes-logo.svg" sizes="any">
|
|
<link rel="icon" type="image/x-icon" href="{self.static_url}/favicon.ico">
|
|
{self.genHTMLMetaLanguageLink()}
|
|
<link rel="stylesheet" href="{self.static_url}/self.css">
|
|
{self.scripts % (len(box.argparser._action_groups) - 3)}
|
|
<meta name="flattr:id" content="456799">
|
|
</head>
|
|
<body onload="hideargs()">
|
|
|
|
<div class="container" style="background-color: #FFF8EA;">
|
|
<div style="float: left;">
|
|
<a href="./{langparam}"><h1>{_("Boxes.py")}</h1></a>
|
|
</div>
|
|
<div style="width: 120px; float: right;">
|
|
<img alt="self-Logo" src="{self.static_url}/boxes-logo.svg" width="120" >
|
|
</div>
|
|
<div>
|
|
<div class="clear"></div>
|
|
<hr>
|
|
<h2 style="margin: 0px 0px 0px 20px;" >{_(name)}</h2>
|
|
<p>{_(box.__doc__) if box.__doc__ else ""}</p>
|
|
<form action="{action}" method="GET" rel="nofollow">
|
|
"""]
|
|
groupid = 0
|
|
for group in box.argparser._action_groups[3:] + box.argparser._action_groups[:3]:
|
|
if not group._group_actions:
|
|
continue
|
|
if len(group._group_actions) == 1 and isinstance(group._group_actions[0], argparse._HelpAction):
|
|
continue
|
|
prefix = getattr(group, "prefix", None)
|
|
result.append(f'''<h3 id="h-{groupid}" role="button" aria-expanded="true" tabindex="0" class="open" onclick="showHide({groupid})" onkeypress="if(event.keyCode == 13) showHide({groupid})">{_(group.title)}</h3>\n<table role="presentation" id="{groupid}">\n''')
|
|
|
|
for a in group._group_actions:
|
|
if a.dest in ("input", "output"):
|
|
continue
|
|
result.append(self.arg2html(a, prefix, defaults, _))
|
|
result.append("</table>")
|
|
groupid += 1
|
|
result.append(f"""
|
|
<p>
|
|
<button name="render" value="1" formtarget="_blank">{_("Generate")}</button>
|
|
<button name="render" value="2" formtarget="_self">{_("Download")}</button>
|
|
<button name="render" value="0" formtarget="_self">{_("Save to URL")}</button>
|
|
</p>
|
|
</form>
|
|
</div>
|
|
|
|
<div class="clear"></div>
|
|
<hr>
|
|
<div class="description">
|
|
""")
|
|
no_img_msg = _('There is no image yet. Please donate an image of your project on <a href="https://github.com/florianfesti/boxes/issues/140" target="_blank" rel="noopener">GitHub</a>!')
|
|
|
|
if box.description:
|
|
result.append(
|
|
markdown.markdown(_(box.description), extensions=["extra"])
|
|
.replace('src="static/', f'src="{self.static_url}/'))
|
|
|
|
result.append(f'''<div>
|
|
<img src="{self.static_url}/samples/{box.__class__.__name__}.jpg" width="100%" onerror="this.parentElement.innerHTML = '{no_img_msg}';">
|
|
</div>
|
|
</div>
|
|
</div>
|
|
{self.footer(lang)}</body>
|
|
</html>
|
|
''')
|
|
return (s.encode("utf-8") for s in result)
|
|
|
|
def menu(self, lang):
|
|
_ = lang.gettext
|
|
lang_name = lang.info().get('language', None)
|
|
|
|
langparam = ""
|
|
lang_attr = ""
|
|
if lang_name:
|
|
langparam = "?language=" + lang_name
|
|
lang_attr = f" lang=\"{lang_name}\""
|
|
|
|
result = [f"""<!DOCTYPE html>
|
|
<html{lang_attr}>
|
|
<head>
|
|
<title>{_("Boxes.py")}</title>
|
|
<meta charset="utf-8">
|
|
<link rel="icon" type="image/svg+xml" href="{self.static_url}/boxes-logo.svg" sizes="any">
|
|
<link rel="icon" type="image/x-icon" href="{self.static_url}/favicon.ico">
|
|
{self.genHTMLMetaLanguageLink()}
|
|
<link rel="stylesheet" href="{self.static_url}/self.css">
|
|
""",
|
|
""" <script>
|
|
function change(group, img_link){
|
|
document.getElementById("sample-"+group).src = img_link;
|
|
document.getElementById("sample-"+group).style.height = "auto";
|
|
}
|
|
|
|
function changeback(group){
|
|
document.getElementById("sample-" + group).src= "%s/nothing.png";
|
|
document.getElementById("sample-" + group).style.height= "0px";
|
|
}
|
|
""" % self.static_url,
|
|
f""" </script>{self.scripts % len(self.groups)}
|
|
<meta name="flattr:id" content="456799">
|
|
</head>
|
|
<body onload="hideargs()">
|
|
<div class="container" style="background-color: #FFF8EA;">
|
|
<div style="width: 75%; float: left;">
|
|
<h1>{_("Boxes.py")}</h1>
|
|
<p>{_("Create boxes and more with a laser cutter!")}</p>
|
|
<p>
|
|
{_('''
|
|
<a href="https://hackaday.io/project/10649-boxespy">Boxes.py</a> is an <a href="https://www.gnu.org/licenses/gpl-3.0.en.html">Open Source</a> box generator written in <a href="https://www.python.org/">Python</a>. It features both finished parametrized generators as well as a Python API for writing your own. It features finger and (flat) dovetail joints, flex cuts, holes and slots for screws, hinges, gears, pulleys and much more.''')}
|
|
</p>
|
|
</div>
|
|
|
|
<div style="width: 25%; float: left;">
|
|
<img alt="self-Logo" src="{self.static_url}/boxes-logo.svg" width="250" >
|
|
</div>
|
|
<div>
|
|
<div class="clear"></div>
|
|
<hr>
|
|
<div class="menu" style="width: 100%">
|
|
"""]
|
|
for nr, group in enumerate(self.groups):
|
|
result.append(f'''
|
|
<h3 id="h-{nr}" role="button" aria-expanded="false" class="open" tabindex="0" onclick="showHide('{nr}')" onkeypress="if(event.keyCode == 13) showHide('{nr}')"
|
|
onmouseenter="change('{group.name}', '{self.static_url}/samples/{group.thumbnail}')"
|
|
onmouseleave="changeback('{group.name}')">{_(group.title)}</h3>
|
|
<img style="width: 200px;" id="sample-{group.name}" src="{self.static_url}/nothing.png" alt="">
|
|
<div id="{nr}"><ul>''')
|
|
for box in group.generators:
|
|
name = box.__name__
|
|
if name in ("TrayLayout2",):
|
|
continue
|
|
docs = ""
|
|
if box.__doc__:
|
|
docs = " - " + _(box.__doc__)
|
|
result.append(f"""
|
|
<li onmouseenter="change('{group.name}', '{self.static_url}/samples/{name}-thumb.jpg')" onmouseleave="changeback('{group.name}')"><a href="{name}{langparam}">{_(name)}</a>{docs}</li>""")
|
|
result.append("\n</ul></div>\n")
|
|
result.append(f"""
|
|
</div>
|
|
|
|
<div style="width: 5%; float: left;"></div>
|
|
<div class="clear"></div>
|
|
<hr>
|
|
</div>
|
|
</div>
|
|
{self.footer(lang)}
|
|
</body>
|
|
</html>
|
|
""")
|
|
return (s.encode("utf-8") for s in result)
|
|
|
|
def genHTMLMetaLanguageLink(self) -> str:
|
|
"""Generates meta language list for search engines."""
|
|
languages = self.getLanguages()
|
|
|
|
s = ""
|
|
for language in languages:
|
|
s += f"<link rel='alternate' hreflang='{language}' href='https://www.festi.info/boxes.py/?language={language}'>\n"
|
|
return s
|
|
|
|
def genHTMLLanguageSelection(self, lang) -> str:
|
|
"""Generates a dropdown selection for the language change."""
|
|
current_language = lang.info().get('language', '')
|
|
languages = self.getLanguages()
|
|
|
|
if len(languages) < 2:
|
|
return "<!-- No other languages to select found. -->"
|
|
|
|
html_option = ""
|
|
for language in languages:
|
|
html_option += f"<option value='{language}'{' selected' if language == current_language else ''}>{language}</option>\n"
|
|
|
|
return """
|
|
<form>
|
|
<select name="language" onchange='if(this.value != \"""" + current_language + """\") { this.form.submit(); }'>
|
|
""" + html_option + """
|
|
</select>
|
|
</form>
|
|
"""
|
|
|
|
def footer(self, lang) -> str:
|
|
_ = lang.gettext
|
|
|
|
return """
|
|
<div class="footer container">
|
|
<ul>
|
|
<li>""" + self.genHTMLLanguageSelection(lang) + """</li>
|
|
<li><a href="https://florianfesti.github.io/boxes/html/usermanual.html" target="_blank" rel="noopener">""" + _("Help") + """</a></li>
|
|
<li><a href="https://hackaday.io/project/10649-boxespy" target="_blank" rel="noopener">""" + _("Home Page") + """</a></li>
|
|
<li><a href="https://florianfesti.github.io/boxes/html/index.html" target="_blank" rel="noopener">""" + _("Documentation") + """</a></li>
|
|
<li><a href="https://github.com/florianfesti/boxes" target="_blank" rel="noopener">""" + _("Sources") + """</a></li>
|
|
</ul>
|
|
</div>
|
|
"""
|
|
|
|
def errorMessage(self, name, e, _):
|
|
return [(f"""<html>
|
|
<head>
|
|
<title>{_("Error generating %s") % _(name)}</title>
|
|
<meta name="flattr:id" content="456799">
|
|
</head>
|
|
<body>
|
|
<h1>{_("An error occurred!")}</h1>""" +
|
|
"".join("<p>%s</p>" % html.escape(s) for s in str(e).split("\n")) +
|
|
"""
|
|
</body>
|
|
</html>
|
|
""").encode("utf-8") ]
|
|
|
|
def serveStatic(self, environ, start_response):
|
|
filename = environ["PATH_INFO"][len("/static/"):]
|
|
path = os.path.join(self.staticdir, filename)
|
|
if (not re.match(r"[a-zA-Z0-9_/-]+\.[a-zA-Z0-9]+", filename) or
|
|
not os.path.exists(path)):
|
|
if re.match(r"samples/.*-thumb.jpg", filename):
|
|
path = os.path.join(self.staticdir, "nothing.png")
|
|
else:
|
|
start_response("404 Not Found", [('Content-type', 'text/plain')])
|
|
return [b"Not found"]
|
|
|
|
type_, encoding = mimetypes.guess_type(filename)
|
|
if encoding is None:
|
|
encoding = "utf-8"
|
|
|
|
# Images do not have charset. Just bytes. Except text based svg.
|
|
# Todo: fallback if type_ is None?
|
|
if type_ is not None and "image" in type_ and type_ != "image/svg+xml":
|
|
start_response("200 OK", [('Content-type', "%s" % type_)])
|
|
else:
|
|
start_response("200 OK", [('Content-type', f"{type_}; charset={encoding}")])
|
|
|
|
f = open(path, 'rb')
|
|
return environ['wsgi.file_wrapper'](f, 512 * 1024)
|
|
|
|
def getURL(self, environ):
|
|
url = environ['wsgi.url_scheme'] + '://'
|
|
|
|
if environ.get('HTTP_HOST'):
|
|
url += environ['HTTP_HOST']
|
|
else:
|
|
url += environ['SERVER_NAME']
|
|
|
|
if environ['wsgi.url_scheme'] == 'https':
|
|
if environ['SERVER_PORT'] != '443':
|
|
url += ':' + environ['SERVER_PORT']
|
|
else:
|
|
if environ['SERVER_PORT'] != '80':
|
|
url += ':' + environ['SERVER_PORT']
|
|
url += quote(self.url_prefix)
|
|
url += quote(environ.get('SCRIPT_NAME', ''))
|
|
url += quote(environ.get('PATH_INFO', ''))
|
|
if environ.get('QUERY_STRING'):
|
|
url += '?' + environ['QUERY_STRING']
|
|
|
|
return url
|
|
|
|
def serve(self, environ, start_response):
|
|
# serve favicon from static for generated SVGs
|
|
if environ["PATH_INFO"] == "favicon.ico":
|
|
environ["PATH_INFO"] = "/static/favicon.ico"
|
|
if environ["PATH_INFO"].startswith("/static/"):
|
|
return self.serveStatic(environ, start_response)
|
|
|
|
status = '200 OK'
|
|
headers = [('Content-type', 'text/html; charset=utf-8'), ('X-XSS-Protection', '1; mode=block'), ('X-Content-Type-Options', 'nosniff'), ('x-frame-options', 'SAMEORIGIN'), ('Referrer-Policy', 'no-referrer')]
|
|
|
|
d = parse_qs(environ.get('QUERY_STRING', ''))
|
|
name = environ["PATH_INFO"][1:]
|
|
args = [unquote_plus(arg) for arg in
|
|
environ.get('QUERY_STRING', '').split("&")]
|
|
render = "0"
|
|
for arg in args:
|
|
if arg.startswith("render="):
|
|
render = arg[len("render="):]
|
|
|
|
lang = self.getLanguage(args, environ.get("HTTP_ACCEPT_LANGUAGE", ""))
|
|
_ = lang.gettext
|
|
|
|
box_cls = self.boxes.get(name, None)
|
|
if not box_cls:
|
|
start_response(status, headers)
|
|
|
|
lang_name = lang.info().get('language', None)
|
|
if lang_name not in self._cache:
|
|
self._cache[lang_name] = list(self.menu(lang))
|
|
return self._cache[lang_name]
|
|
|
|
if name == "TrayLayout2":
|
|
box = box_cls(self, webargs=True)
|
|
else:
|
|
box = box_cls()
|
|
|
|
if render == "0":
|
|
defaults = {}
|
|
for a in args:
|
|
kv = a.split('=')
|
|
if len(kv) == 2:
|
|
k, v = kv
|
|
defaults[k] = html.escape(v, True)
|
|
start_response(status, headers)
|
|
return self.args2html_cached(name, box, lang, "./" + name, defaults=defaults)
|
|
else:
|
|
args = ["--" + arg for arg in args if not arg.startswith("render=")]
|
|
try:
|
|
box.parseArgs(args)
|
|
except (ArgumentParserError) as e:
|
|
start_response(status, headers)
|
|
return self.errorMessage(name, e, _)
|
|
if name == "TrayLayout":
|
|
start_response(status, headers)
|
|
box.fillDefault(box.x, box.y)
|
|
layout2 = boxes.generators.traylayout.TrayLayout2(self, webargs=True)
|
|
layout2.argparser.set_defaults(layout=str(box))
|
|
return self.args2html(name, layout2, lang, action="TrayLayout2")
|
|
if name == "TrayLayout2":
|
|
try:
|
|
box.parse(box.layout.split("\n"))
|
|
except Exception as e:
|
|
start_response(status, headers)
|
|
return self.errorMessage(name, e, _)
|
|
|
|
try:
|
|
fd, box.output = tempfile.mkstemp()
|
|
box.metadata["url"] = self.getURL(environ)
|
|
box.open()
|
|
box.render()
|
|
box.close()
|
|
except Exception as e:
|
|
if not isinstance(e, ValueError):
|
|
print("Exception during rendering:")
|
|
traceback.print_exc()
|
|
start_response("500 Internal Server Error",
|
|
headers)
|
|
return self.errorMessage(name, e, _)
|
|
|
|
http_headers = box.formats.http_headers.get(
|
|
box.format,
|
|
[('Content-type', 'application/unknown; charset=utf-8')])[:]
|
|
# Prevent crawlers.
|
|
http_headers.append(('X-Robots-Tag', 'noindex,nofollow'))
|
|
|
|
if box.format != "svg" or render == "2":
|
|
extension = box.format
|
|
if extension == "svg_Ponoko":
|
|
extension = "svg"
|
|
http_headers.append(('Content-Disposition', f'attachment; filename="{box.__class__.__name__}.{extension}"'))
|
|
start_response(status, http_headers)
|
|
result = open(box.output, 'rb').readlines()
|
|
os.close(fd)
|
|
os.remove(box.output)
|
|
return (l for l in result)
|
|
|
|
|
|
if __name__ == "__main__":
|
|
parser = argparse.ArgumentParser()
|
|
|
|
parser.add_argument("--host", default="")
|
|
parser.add_argument("--port", type=int, default=8000)
|
|
parser.add_argument("--url_prefix", default="",
|
|
help="URL path to Boxes.py instance")
|
|
parser.add_argument("--static_url", default="static",
|
|
help="URL of static content")
|
|
args = parser.parse_args()
|
|
|
|
boxserver = BServer(url_prefix=args.url_prefix, static_url=args.static_url)
|
|
|
|
fc = FileChecker()
|
|
fc.start()
|
|
|
|
httpd = make_server(args.host, args.port, boxserver.serve)
|
|
print(f"BoxesServer serving on {args.host}:{args.port}...")
|
|
try:
|
|
httpd.serve_forever()
|
|
except KeyboardInterrupt:
|
|
fc.stop()
|
|
httpd.server_close()
|
|
print("BoxesServer stops.")
|
|
else:
|
|
boxserver = BServer(url_prefix='/boxes.py', static_url="https://florianfesti.github.io/boxes/static")
|
|
application = boxserver.serve
|