boxespy/scripts/boxesserver

700 lines
25 KiB
Plaintext
Raw Normal View History

#!/usr/bin/env python3
2017-02-15 15:56:02 +01:00
# 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/>.
2023-01-08 19:41:02 +01:00
from __future__ import annotations
2016-03-04 12:10:59 +01:00
import argparse
import gettext
import glob
import html
import mimetypes
2016-10-08 15:08:30 +02:00
import os.path
import re
import sys
import tempfile
import threading
import time
import traceback
2023-01-29 21:38:15 +01:00
from typing import Any, NoReturn
from urllib.parse import unquote_plus, quote
2016-03-04 12:10:59 +01:00
from wsgiref.simple_server import make_server
import markdown
2023-02-20 22:30:06 +01:00
import qrcode
import io
2016-03-04 12:10:59 +01:00
try:
import boxes.generators
except ImportError:
sys.path.append(os.path.join(os.path.dirname(__file__), ".."))
import boxes.generators
2023-01-29 21:38:14 +01:00
class FileChecker(threading.Thread):
2023-01-29 21:38:15 +01:00
def __init__(self, files=[], checkmodules: bool = True) -> None:
super().__init__()
self.checkmodules = checkmodules
self.timestamps = {}
2022-08-28 11:24:21 +02:00
self._stopped = False
for path in files:
self.timestamps[path] = os.stat(path).st_mtime
if checkmodules:
self._addModules()
2023-01-29 21:38:15 +01:00
def _addModules(self) -> None:
for name, module in sys.modules.items():
path = getattr(module, "__file__", None)
if not path:
continue
if path not in self.timestamps:
2023-01-29 21:38:14 +01:00
self.timestamps[path] = os.stat(path).st_mtime
2023-01-29 21:38:15 +01:00
def filesOK(self) -> bool:
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
2023-01-29 21:38:15 +01:00
def run(self) -> None:
2022-08-28 11:24:21 +02:00
while not self._stopped:
if not self.filesOK():
os.execv(__file__, sys.argv)
time.sleep(1)
2023-01-29 21:38:15 +01:00
def stop(self) -> None:
2022-08-28 11:24:21 +02:00
self._stopped = True
def filter_url(url, non_default_args):
if len(url) == 0:
return ''
try:
base, args = url.split('?')
except ValueError:
return ''
args = args.split('&')
new_args = []
args_to_ignore = ["qr_code", "format"]
for arg in args:
a, b = arg.split('=')
if a.strip() in args_to_ignore:
continue
if a in non_default_args:
new_args.append(arg)
if len(new_args):
return f"{base}?{'&'.join(new_args)}"
else:
return f"{base}"
2023-01-29 21:38:14 +01:00
2016-03-04 12:10:59 +01:00
class ArgumentParserError(Exception): pass
2023-01-29 21:38:14 +01:00
2016-03-04 12:10:59 +01:00
class ThrowingArgumentParser(argparse.ArgumentParser):
2023-01-29 21:38:15 +01:00
def error(self, message) -> NoReturn:
2016-03-04 12:10:59 +01:00
raise ArgumentParserError(message)
2023-01-29 21:38:14 +01:00
2022-12-31 19:20:55 +01:00
# Evil hack
boxes.ArgumentParser = ThrowingArgumentParser # type: ignore
2016-03-04 12:10:59 +01:00
2016-03-04 12:10:59 +01:00
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:
2023-01-29 21:38:14 +01:00
self.boxes = {b.__name__: b for b in boxes.generators.getAllBoxGenerators().values() if b.webinterface}
self.groups = boxes.generators.ui_groups
self.groups_by_name = boxes.generators.ui_groups_by_name
for name, box in self.boxes.items():
box.UI = "web"
self.groups_by_name.get(box.ui_group,
self.groups_by_name["Misc"]).add(box)
2017-05-04 23:02:59 +02:00
self.staticdir = os.path.join(os.path.dirname(__file__), '../static/')
self._languages = None
2023-01-08 19:41:02 +01:00
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:
2023-01-29 21:38:14 +01:00
return gettext.translation('boxes.py', localedir='locale', languages=[lang])
except OSError:
pass
try:
return gettext.translation('boxes.py', languages=[lang])
except OSError:
pass
2017-05-04 23:02:59 +02:00
# 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:
2023-01-29 21:38:14 +01:00
return gettext.translation('boxes.py', localedir='locale', languages=langs)
except OSError:
return gettext.translation('boxes.py', languages=langs, fallback=True)
2023-01-29 21:38:14 +01:00
def arg2html(self, a, prefix, defaults={}, _=lambda s: s):
name = a.option_strings[0].replace("-", "")
2016-03-04 12:10:59 +01:00
if isinstance(a, argparse._HelpAction):
return ""
viewname = name
if prefix and name.startswith(prefix + '_'):
2023-01-29 21:38:14 +01:00
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""" % \
2023-01-29 21:38:14 +01:00
(name + "_id", name, _(viewname), name + "_description", "" if not a.help else markdown.markdown(_(a.help)))
if (isinstance(a, argparse._StoreAction) and
2023-01-29 21:38:14 +01:00
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>""" % \
2023-01-29 21:38:14 +01:00
(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(
2023-01-13 15:32:32 +01:00
"""<option value="%s"%s>%s</option>""" %
2023-01-29 21:38:14 +01:00
(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">""" % \
2023-01-29 21:38:14 +01:00
(name, name, name + "_id", name + "_description", default or a.default)
return row % input
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 = ""
if lang_name:
langparam = "?language=" + lang_name
result = [f"""{self.genHTMLStart(lang)}
2018-03-05 19:48:09 +01:00
<head>
<title>{_("%s - Boxes") % _(name)}</title>
{self.genHTMLMeta()}
{self.genHTMLMetaLanguageLink()}
{self.genHTMLCSS()}
{self.genHTMLJS()}
2016-09-20 23:14:24 +02:00
</head>
<body onload="initPage({len(box.argparser._action_groups) - 3})">
2016-09-20 23:14:24 +02:00
<div class="container" style="background-color: #FFF8EA;">
2016-12-18 21:22:15 +01:00
<div style="float: left;">
<a href="./{langparam}"><h1>{_("Boxes.py")}</h1></a>
2016-09-20 23:14:24 +02:00
</div>
2018-09-23 14:14:19 +02:00
<div style="width: 120px; float: right;">
<img alt="self-Logo" src="{self.static_url}/boxes-logo.svg" width="120">
2016-09-20 23:14:24 +02:00
</div>
<div>
<div class="clear"></div>
2021-11-11 00:46:03 +01:00
<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
2016-11-01 16:58:48 +01:00
for group in box.argparser._action_groups[3:] + box.argparser._action_groups[:3]:
if not group._group_actions:
2016-03-04 12:10:59 +01:00
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}" data-id="{groupid}" role="button" aria-expanded="true" tabindex="0" class="toggle open">{_(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
2023-02-20 22:30:06 +01:00
result.append(f"""
<input type="hidden" name="language" id="language" value="{lang_name}">
2020-08-26 08:33:19 +02:00
<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>
2023-02-20 22:30:06 +01:00
<button name="render" value="3" formtarget="_blank">{_("QR Code")}</button>
2020-08-26 08:33:19 +02:00
</p>
2016-03-04 12:10:59 +01:00
</form>
2016-09-20 23:14:24 +02:00
</div>
2016-09-20 23:14:24 +02:00
<div class="clear"></div>
2021-11-11 00:46:03 +01:00
<hr>
<div class="description">
""")
no_img_msg = _('There is no image yet. Please donate an image of your project on <a href=&quot;https://github.com/florianfesti/boxes/issues/140&quot; target=&quot;_blank&quot; rel=&quot;noopener&quot;>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 style="width:100%;" src="{self.static_url}/samples/{box.__class__.__name__}.jpg" onerror="this.parentElement.innerHTML = '{no_img_msg}';" alt="Picture of box.">
</div>
2018-03-06 11:07:10 +01:00
</div>
</div>
{self.genPagePartFooter(lang)}
</body>
2016-03-04 12:10:59 +01:00
</html>
2023-01-29 21:38:14 +01:00
''')
2016-03-04 12:10:59 +01:00
return (s.encode("utf-8") for s in result)
2018-06-14 22:09:41 +02:00
def genPageMenu(self, lang):
_ = lang.gettext
lang_name = lang.info().get('language', None)
langparam = ""
if lang_name:
langparam = "?language=" + lang_name
2018-06-14 22:09:41 +02:00
result = [f"""{self.genHTMLStart(lang)}
2018-03-05 19:48:09 +01:00
<head>
<title>{_("Boxes.py")}</title>
{self.genHTMLMeta()}
{self.genHTMLMetaLanguageLink()}
{self.genHTMLCSS()}
{self.genHTMLJS()}
2016-09-20 23:14:24 +02:00
</head>
<body onload="initPage()">
2016-09-20 23:14:24 +02:00
<div class="container" style="background-color: #FFF8EA;">
2018-09-23 14:14:19 +02:00
<div style="width: 75%; float: left;">
{self.genPagePartHeader(lang)}
<div class="menu" style="width: 100%">
<img style="width: 200px;" id="sample-preview" src="{self.static_url}/nothing.png" alt="">
2023-01-29 21:38:14 +01:00
"""]
for nr, group in enumerate(self.groups):
2020-11-14 16:41:41 +01:00
result.append(f'''
<h3 id="h-{nr}"
data-id="{nr}"
data-thumbnail="{self.static_url}/samples/{group.thumbnail}"
role="button"
aria-expanded="false"
class="toggle thumbnail open"
tabindex="0"
>
{_(group.title)}
</h3>
<div id="{nr}">\n <ul>\n''')
for box in group.generators:
name = box.__name__
docs = ""
if box.__doc__:
docs = " - " + _(box.__doc__)
result.append(f""" <li class="thumbnail" data-thumbnail="{self.static_url}/samples/{name}-thumb.jpg" id="search_id_{name}"><a href="{name}{langparam}">{_(name)}</a>{docs}</li>\n""")
result.append(" </ul>\n </div>\n")
result.append(f"""
2016-09-20 23:14:24 +02:00
</div>
<div style="width: 5%; float: left;"></div>
<div class="clear"></div>
2021-11-11 00:46:03 +01:00
<hr>
</div>
</div>
{self.genPagePartFooter(lang)}
2016-03-04 12:10:59 +01:00
</body>
</html>
""")
return (s.encode("utf-8") for s in result)
def genHTMLStart(self, lang) -> str:
lang_attr = lang.info().get("language", "")
if lang_attr != "":
return f"""<!DOCTYPE html><html lang="{lang_attr.replace('_', '-')}">"""
return "<!DOCTYPE html><html>"
def genHTMLMeta(self) -> str:
return f'''
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1">
<meta name="flattr:id" content="456799">
<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">
'''
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.replace("_", "-")}" href="https://www.festi.info/boxes.py/?language={language}">\n'
return s
def genHTMLCSS(self) -> str:
return f'<link rel="stylesheet" href="{self.static_url}/self.css">'
def genHTMLJS(self) -> str:
return f'<script src="{self.static_url}/self.js"></script>'
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 genPagePartHeader(self, lang) -> str:
_ = lang.gettext
lang_name = lang.info().get('language', None)
langparam = ""
if lang_name:
langparam = "?language=" + lang_name
return f"""
<h1><a href="./{langparam}">{_("Boxes.py")}</a></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="search">
\U0001f50d <input autocomplete="off" type="search" oninput="filterSearchItems();" name="search" id="search" placeholder="Search">
</div>"""
def genPagePartFooter(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>
<li><a href="Gallery">""" + _("Gallery") + """</a></li>
</ul>
</div>
"""
def genPageError(self, name, e, lang) -> list[bytes]:
"""Generates a error page."""
_ = lang.gettext
h = f"""{self.genHTMLStart(lang)}
<head>
<title>{_("Error generating %s") % _(name)}</title>
{self.genHTMLMeta()}
<meta name="robots" content="noindex">
</head>
<body>
<h1>{_("An error occurred!")}</h1>
"""
for s in str(e).split("\n"):
h += f"<p>{html.escape(s)}</p>\n"
h += "</body></html>"
return [h.encode("utf-8")]
2017-05-04 23:02:59 +02:00
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
2023-01-29 21:38:14 +01:00
not os.path.exists(path)):
if re.match(r"samples/.*-thumb.jpg", filename):
path = os.path.join(self.staticdir, "nothing.png")
else:
2023-01-29 21:38:14 +01:00
start_response("404 Not Found", [('Content-type', 'text/plain')])
return [b"Not found"]
2017-05-04 23:02:59 +02:00
type_, encoding = mimetypes.guess_type(filename)
if encoding is None:
2021-11-11 00:53:29 +01:00
encoding = "utf-8"
2017-05-04 23:02:59 +02:00
2021-11-11 00:53:29 +01:00
# 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}")])
2017-05-04 23:02:59 +02:00
f = open(path, 'rb')
2023-01-29 21:38:14 +01:00
return environ['wsgi.file_wrapper'](f, 512 * 1024)
2017-05-04 23:02:59 +02:00
2023-01-29 21:38:15 +01:00
def getURL(self, environ) -> str:
2023-01-29 21:38:14 +01:00
url = environ['wsgi.url_scheme'] + '://'
if environ.get('HTTP_HOST'):
url += environ['HTTP_HOST']
else:
url += environ['SERVER_NAME']
2017-05-04 23:02:59 +02:00
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 serveGallery(self, environ, start_response, lang):
_ = lang.gettext
lang_name = lang.info().get('language', None)
2023-02-05 16:14:14 +01:00
start_response("200 OK", [('Content-type', "text/html; charset=utf-8")])
if ("Gallery", lang_name) in self._cache:
return self._cache[("Gallery", lang_name)]
langparam = ""
if lang_name:
langparam = "?language=" + lang_name
result = [f"""
{self.genHTMLStart(lang)}
<head>
<title>{_("Gallery")} - {_("Boxes.py")}</title>
{self.genHTMLMeta()}
{self.genHTMLMetaLanguageLink()}
{self.genHTMLCSS()}
{self.genHTMLJS()}
</head>
<body onload="initPage()">
<div class="container" style="background-color: #FFF8EA;">
<div style="width: 75%; float: left;">
{self.genPagePartHeader(lang)}
"""]
for nr, group in enumerate(self.groups):
2023-02-05 16:07:03 +01:00
result.append(f"<h2>{_(group.title)}</h2>\n")
for box in group.generators:
name = box.__name__
fn = f"samples/{name}-thumb.jpg"
thumbnail = f"{self.static_url}/{fn}"
static_filename = os.path.join(self.staticdir, fn)
alt = f"{_(name)}"
href = f"{name}{langparam}"
if not os.path.exists(static_filename):
result.append(f""" <span class="gallery_missing" id="search_id_{name}"><a href="{href}">{_(name)}<br><br>{_(box.__doc__)}</a></span>\n""")
else:
result.append(f""" <span class="gallery" id="search_id_{name}"><a title="{_(name)} - {_(box.__doc__)}" href="{href}"><img alt="{alt}" src="{thumbnail}"/></a></span>\n""")
result.append(f"""
{self.genPagePartFooter(lang)}
</body>
</html>
"""
)
2023-02-05 16:14:14 +01:00
self._cache[("Gallery", lang_name)] = [s.encode("utf-8") for s in result]
return self._cache[("Gallery", lang_name)]
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"
2017-05-04 23:02:59 +02:00
if environ["PATH_INFO"].startswith("/static/"):
return self.serveStatic(environ, start_response)
2016-03-04 12:10:59 +01:00
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')]
2017-05-04 23:02:59 +02:00
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="):]
2017-05-04 23:02:59 +02:00
lang = self.getLanguage(args, environ.get("HTTP_ACCEPT_LANGUAGE", ""))
_ = lang.gettext
if name == "Gallery":
return self.serveGallery(environ, start_response, lang)
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.genPageMenu(lang))
return self._cache[lang_name]
2018-06-14 22:09:41 +02:00
box = box_cls()
box.translations = lang
if render == "0":
2023-01-29 21:38:14 +01:00
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)
2016-03-16 10:16:56 +01:00
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.genPageError(name, e, lang)
try:
fd, box.output = tempfile.mkstemp()
box.metadata["url"] = self.getURL(environ)
box.metadata["url_short"] = filter_url(box.metadata["url"],
box.non_default_args)
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.genPageError(name, e, lang)
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'))
2023-02-20 22:30:06 +01:00
if render == "3":
http_headers = [('Content-type', 'image/png')]
http_headers.append(('X-Robots-Tag', 'noindex,nofollow'))
qr_format="png"
fn = (box.__class__.__name__)
start_response(status, http_headers)
qrcode = get_qrcode(box.metadata["url_short"], qr_format)
2023-02-20 22:30:06 +01:00
return (qrcode,)
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)
2021-11-10 22:49:56 +01:00
2023-02-20 22:30:06 +01:00
def get_qrcode(url, format):
if url is None:
url = "no url"
img = qrcode.make(url)
image_bytes = io.BytesIO()
img.save(image_bytes, format=format)
return image_bytes.getvalue()
2023-01-29 21:38:14 +01:00
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}...")
2022-08-28 11:24:21 +02:00
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