def server(ctx, host=None, port=5000, debug=True, live=False, gitlogs=False):
"""Run the app server."""
if gitlogs:
git_logs(ctx)
from website.app import init_app
os.environ["DJANGO_SETTINGS_MODULE"] = "api.base.settings"
app = init_app(set_backends=True, routes=True)
settings.API_SERVER_PORT = port
if live:
from livereload import Server
server = Server(app.wsgi_app)
server.watch(os.path.join(HERE, "website", "static", "public"))
server.serve(port=port)
else:
if settings.SECURE_MODE:
context = (settings.OSF_SERVER_CERT, settings.OSF_SERVER_KEY)
else:
context = None
app.run(
host=host,
port=port,
debug=debug,
threaded=debug,
extra_files=[settings.ASSET_HASH_PATH],
ssl_context=context,
)
def do(self, *args):
"""Run Django with ImportD."""
for bp in self.blueprint_list:
self._apply_blueprint(bp)
if not args:
args = sys.argv[1:]
if len(args) == 0:
return self._handle_management_command(
self._get_runserver_cmd(), "8000")
if 'livereload' in sys.argv:
if not hasattr(self, "lr"):
print("Livereload setting, lr not configured.")
return
from livereload import Server
server = Server(self)
for pat, cmd in self.lr.items():
parts = pat.split(",")
for part in parts:
server.watch(part, cmd)
server.serve(port=8000)
return
return self._act_as_manage(*args)
def main():
parser = get_parser()
args = parser.parse_args()
srcdir = os.path.realpath(args.sourcedir)
outdir = os.path.realpath(args.outdir)
build_args = []
for arg, meta in SPHINX_BUILD_OPTIONS:
val = getattr(args, arg)
if not val:
continue
opt = '-{}'.format(arg)
if meta is None:
build_args.extend([opt] * val)
else:
for v in val:
build_args.extend([opt, v])
build_args.extend([srcdir, outdir])
build_args.extend(args.filenames)
ignored = []
if args.w: # Logfile
ignored.append(os.path.realpath(args.w[0]))
if args.d: # Doctrees
ignored.append(os.path.realpath(args.d[0]))
if not os.path.exists(outdir):
os.makedirs(outdir)
server = Server(watcher=LivereloadWatchdogWatcher())
server.watch(srcdir, SphinxBuilder(outdir, build_args, ignored))
server.watch(outdir)
server.serve(port=args.port, root=outdir)
def _execute(self, options, args):
"""Start the watcher."""
try:
from livereload import Server
except ImportError:
req_missing(['livereload>=2.0.0'], 'use the "auto" command')
return
# Run an initial build so we are uptodate
subprocess.call(("nikola", "build"))
port = options and options.get('port')
server = Server()
server.watch('conf.py')
server.watch('themes/')
server.watch('templates/')
server.watch(self.site.config['GALLERY_PATH'])
for item in self.site.config['post_pages']:
server.watch(os.path.dirname(item[0]))
for item in self.site.config['FILES_FOLDERS']:
server.watch(os.path.dirname(item))
out_folder = self.site.config['OUTPUT_FOLDER']
if options and options.get('browser'):
webbrowser.open('http://localhost:{0}'.format(port))
server.serve(port, None, out_folder)
def handle_noargs(self, **options):
server = Server()
pathlist = []
# Find statics/templates directories of all installed apps
for app in settings.INSTALLED_APPS:
try:
mod = import_module(app)
except ImportError as e:
raise ImproperlyConfigured('ImportError %s: %s' % (app, e.args[0]))
staticfiles_dir = os.path.join(os.path.dirname(mod.__file__),
'statics')
templates_dir = os.path.join(os.path.dirname(mod.__file__),
'templates')
if os.path.isdir(staticfiles_dir):
pathlist.append("{}".format(staticfiles_dir))
if os.path.isdir(templates_dir):
pathlist.append("{}".format(templates_dir))
# STATICFILES_DIRS, TEMPLATE_DIRS
for path in settings.STATICFILES_DIRS:
pathlist.append("{}".format(path))
for path in settings.TEMPLATE_DIRS:
pathlist.append("{}".format(path))
print('Start livereloading with followings...')
for path in pathlist:
print('- {}'.format(path))
server.watch(path)
# Listen 35729 which is a common port for LiveReload browser ext.
server.serve(port=35729)
def _execute(self, options, args):
"""Start the watcher."""
try:
from livereload import Server
except ImportError:
req_missing(["livereload==2.1.0"], 'use the "auto" command')
return
# Run an initial build so we are up-to-date
subprocess.call(("nikola", "build"))
port = options and options.get("port")
server = Server()
server.watch("conf.py", "nikola build")
server.watch("themes/", "nikola build")
server.watch("templates/", "nikola build")
server.watch(self.site.config["GALLERY_PATH"], "nikola build")
for item in self.site.config["post_pages"]:
server.watch(os.path.dirname(item[0]), "nikola build")
for item in self.site.config["FILES_FOLDERS"]:
server.watch(item, "nikola build")
out_folder = self.site.config["OUTPUT_FOLDER"]
if options and options.get("browser"):
webbrowser.open("http://localhost:{0}".format(port))
server.serve(port, None, out_folder)
def _execute(self, options, args):
"""Start the watcher."""
try:
from livereload import Server
except ImportError:
req_missing(['livereload'], 'use the "auto" command')
return
# Run an initial build so we are up-to-date
subprocess.call(("nikola", "build"))
port = options and options.get('port')
server = Server()
server.watch('conf.py', 'nikola build')
server.watch('themes/', 'nikola build')
server.watch('templates/', 'nikola build')
server.watch(self.site.config['GALLERY_PATH'], 'nikola build')
for item in self.site.config['post_pages']:
server.watch(os.path.dirname(item[0]), 'nikola build')
for item in self.site.config['FILES_FOLDERS']:
server.watch(item, 'nikola build')
out_folder = self.site.config['OUTPUT_FOLDER']
if options and options.get('browser'):
browser = True
else:
browser = False
server.serve(port, None, out_folder, True, browser)
def start_livereload(self):
from livereload import Server
server = Server()
for path in settings.STATICFILES_DIRS:
server.watch(path)
for path in settings.TEMPLATE_DIRS:
server.watch(path)
server.serve(port=settings.LIVERELOAD_PORT)
def main(filenames, port, host, settings, debug, profile, profile_dir,
profile_restriction):
"""Start fava for FILENAMES on http://host:port."""
if profile_dir:
profile = True
if profile:
debug = True
env_filename = os.environ.get('BEANCOUNT_FILE', None)
if env_filename:
filenames = filenames + (env_filename,)
if not filenames:
raise click.UsageError('No file specified')
app.config['BEANCOUNT_FILES'] = filenames
app.config['USER_SETTINGS'] = settings
load_settings()
load_file()
if debug:
if profile:
from werkzeug.contrib.profiler import ProfilerMiddleware
app.config['PROFILE'] = True
app.wsgi_app = ProfilerMiddleware(
app.wsgi_app,
restrictions=(profile_restriction,),
profile_dir=profile_dir if profile_dir else None)
app.run(host, port, debug)
else:
server = Server(app.wsgi_app)
if settings:
server.watch(settings, load_settings)
def reload_source_files(api):
filename = api.options['filename']
api.load_file()
include_path = os.path.dirname(filename)
for filename in api.options['include'] + \
api.options['documents']:
server.watch(os.path.join(include_path, filename),
lambda: reload_source_files(api))
for api in app.config['APIS'].values():
reload_source_files(api)
try:
server.serve(port=port, host=host, debug=debug)
except OSError as error:
if error.errno == errno.EADDRINUSE:
print("Error: Can not start webserver because the port/address"
"is already in use.")
print("Please choose another port with the '-p' option.")
else:
raise
def livereload():
from livereload import Server
server = Server(app)
# watch all js files else we'll only reload when app.js changes
paths = pathlib.Path('bauble/static/').glob('**/*.js')
for f in filter(lambda p: 'vendor' not in p, map(str, paths)):
server.watch(f)
server.serve(port=app.config.get('PORT', 5000))
def watch(name):
build(name)
def _build():
build(name)
server = Server()
server.watch(name, _build)
server.serve(root='_build')
def serve_docs():
from livereload import Server, shell
build_command = "sphinx-build -b html docs dist/docs"
run(build_command)
server = Server()
server.watch("*.rst", shell(build_command))
server.watch("docs/", shell(build_command))
server.serve(root="dist/docs")
def keep_alive(app, build_func):
"""Run the server and keep it reload and rebuild when contents changed
:return:
"""
live_server = Server(app.wsgi_app)
# [live_server.watch(path.join(app.path, p), build_func) for p in
# ['pages', 'static', 'templates', '_assets.yml', '_config.yml']]
live_server.watch(app.path)
live_server.serve()
def main():
build_project_path = '_build'
if not os.path.exists(build_project_path):
os.system('make html')
server = Server()
server.watch('./*.rst', shell('make html'))
server.watch('./*/*.rst', shell('make html'))
webbrowser.open_new_tab('http://127.0.0.1:5500')
server.serve(root='_build/html')
def server(host=None, port=5000, debug=True, live=False):
"""Run the app server."""
from website.app import init_app
app = init_app(set_backends=True, routes=True, mfr=True)
if live:
from livereload import Server
server = Server(app.wsgi_app)
server.watch(os.path.join(HERE, 'website', 'static', 'public'))
server.serve(port=port)
else:
app.run(host=host, port=port, debug=debug, extra_files=[settings.ASSET_HASH_PATH])
def livereload():
url = 'http://dev:35729/livereload.js'
print (
'To livereload your web pages add the following script tag to '
'your HTML:'
)
print ''
print ' <script type="text/javascript" src="{}"></script>'.format(url)
print ''
server = Server()
server.watch(env.static_dir)
server.watch(env.templates_dir)
server.serve(port=35729, host='0.0.0.0')
def run_livereload(config):
"Run app in foreground. don't use for production"
app = make_app(config=config)
server = Server(app)
# The command to build a site's resources will probably be different. The
# `.livereload` file triggers a livereload if it is modified.
server.watch('.livereload')
server.serve(
host=app.config.get("HOST", '127.0.0.1'),
port=app.config.get("PORT", 5000)
)
def develop(ctx: click.core.Context, site_path: str, host: str,
port: int) -> None:
"""Runs a local development server"""
def rebuild_site() -> mackerel.site.Site:
site = mackerel.site.Site(path=Path(site_path))
build = mackerel.build.Build(site=site)
build.execute()
return site
site = rebuild_site()
server = Server()
server.watch(str(site.content_path), rebuild_site)
server.watch(str(site.template_path), rebuild_site)
server.serve(host=host.strip(), port=port, root=str(site.output_path))
def main(filename, port, host, settings, debug, profile, profile_dir,
profile_restriction):
"""Start fava for FILENAME on http://host:port."""
if profile_dir:
profile = True
if profile:
debug = True
app.config['BEANCOUNT_FILE'] = filename
app.config['USER_SETTINGS'] = settings
load_settings()
if debug:
load_file()
if profile:
from werkzeug.contrib.profiler import ProfilerMiddleware
app.config['PROFILE'] = True
app.wsgi_app = ProfilerMiddleware(
app.wsgi_app,
restrictions=(profile_restriction,),
profile_dir=profile_dir if profile_dir else None)
app.run(host, port, debug)
else:
server = Server(app.wsgi_app)
if settings:
server.watch(settings, load_settings)
def reload_source_files():
load_file()
include_path = os.path.dirname(app.config['BEANCOUNT_FILE'])
for filename in api.options['include'] + api.options['documents']:
server.watch(os.path.join(include_path, filename),
reload_source_files)
reload_source_files()
try:
server.serve(port=port, host=host, debug=debug)
except OSError as e:
if e.errno == errno.EADDRINUSE:
print("Error: Can not start webserver because the port/address"
"is already in use.")
print("Please choose another port with the '-p' option.")
else:
raise
except:
print("Unexpected error:", e)
raise
def run(self):
mimetypes.init()
self.reload()
try:
from livereload import Server
except ImportError:
print("Please install the python3 livereload module to use this function.", file=sys.stderr)
return
server = Server(self.application)
server.watch(self.content_root, self.reload)
server.watch(self.theme_root, self.reload)
server.serve(port=8000, host="localhost")
def livereload():
db.create_all()
server = Server(app)
server.watch("gather/*.py")
server.watch("gather/templates/*.html")
server.watch("gather/assets/stylesheets/*.sass")
server.watch("gather/assets/javascripts/*.coffee")
server.serve(port=8000)
def server(host=None, port=5000, debug=True, live=False, gitlogs=False):
"""Run the app server."""
if gitlogs:
git_logs()
from website.app import init_app
os.environ['DJANGO_SETTINGS_MODULE'] = 'api.base.settings'
app = init_app(set_backends=True, routes=True)
settings.API_SERVER_PORT = port
if live:
from livereload import Server
server = Server(app.wsgi_app)
server.watch(os.path.join(HERE, 'website', 'static', 'public'))
server.serve(port=port)
else:
app.run(host=host, port=port, debug=debug, threaded=debug, extra_files=[settings.ASSET_HASH_PATH])
def serve():
"""Serve site at http://localhost:8000/"""
rebuild()
server = Server()
server.watch('content/*/*.md', build_html)
server.watch('theme/templates/*.html', build_html)
server.watch('theme/scss/*.scss', build_css)
server.watch('theme/scss/base/*.scss', build_css)
server.serve(root='output', port=8000, host='localhost', open_url_delay=0.1)
class Server(object):
"""Generate web-ready static files from templates/data/config"""
def __init__(self, source_dir='.', dest_dir='./deploy'):
self._source_dir = source_dir
self._dest_dir = dest_dir
self._server = LRServer()
self._port = 8080
def serve(self):
builder = Builder(self._source_dir, self._dest_dir)
self._server.watch('*/*.md', builder.build, delay=2)
self._server.serve(
root=self._dest_dir,
port=self._port
)
logging.info('Starting server on port: %s' % self._port)
def start(host, port):
app = Flask(
__name__,
static_folder='/static'
)
app.config['DEBUG'] = True
@app.route('/')
def index():
template_name = request.args.get('template')
vars_file = request.args.get('vars')
make_pdf = request.args.get('pdf')
if template_name is None:
return usage
if vars_file is not None:
with open(os.path.join('template-vars', vars_file), 'r') as f:
template_vars = json.load(f)
else:
template_vars = {}
for folder in jinja_config['template_folders']:
copy_tree(folder, '/static', update=1)
env = create_environment(jinja_config)
template = env.get_template(template_name)
rendered = template.render(**template_vars).encode('utf-8')
if make_pdf:
print('MAKING PDF!')
with open('/static/pdf_tmp.html', 'wb') as pdf:
pdf.write(rendered)
Popen(render_pdf_cmd, shell=True).wait()
return rendered
server = Server(app.wsgi_app)
watched_files = formic.FileSet(include='**/*',
exclude=['templates/**/*.css',
'templates/pdf_tmp.html',
'**/*.pdf'])
for file_name in watched_files:
server.watch(file_name, shell(
'node-sass-chokidar scss -o templates'
))
server.serve(host=host, port=port, liveport=35729)
def run(argv):
parser = argparse.ArgumentParser(description=__doc__,
formatter_class=argparse.RawDescriptionHelpFormatter)
parser.add_argument('-p', '--port',
action='store',
type=int,
default=5000,
help="Port to listen on.")
parser.add_argument('-H', '--host',
action='store',
type=str,
default='localhost',
help="Host for the webserver.")
parser.add_argument('-d', '--debug',
action='store_true',
help="Turn on debugging. This uses the built-in Flask \
webserver, and live-reloading of beancount-files is disabled.")
parser.add_argument('filename',
type=str,
help="Beancount input file.")
args = parser.parse_args(argv)
app.beancount_file = args.filename
app.filter_year = None
app.filter_tag = None
app.api = BeancountReportAPI(app.beancount_file)
if args.debug:
app.run(args.host, args.port, args.debug)
else:
server = Server(app.wsgi_app)
# auto-reload the main beancount-file and all it's includes
server.watch(app.beancount_file, app.api.load_file)
include_path = os.path.dirname(app.beancount_file)
for filename in app.api.options()['include']:
server.watch(os.path.join(include_path, filename), app.api.load_file)
server.serve(port=args.port, host=args.host, debug=args.debug)
def run(self):
mimetypes.init()
self.reload()
try:
from livereload import Server
except ImportError:
print("Please install the python3 livereload module to use this function.", file=sys.stderr)
return
server = Server(self.application)
# see https://github.com/lepture/python-livereload/issues/171
def do_reload():
self.reload()
server.watch(self.content_root, do_reload)
server.watch(self.theme_root, do_reload)
server.serve(port=8000, host="localhost")
def cmd(tool_opts, open_browser, tool, source):
with tempdir() as dirpath:
server = Server()
source_abspath = os.path.abspath(source)
command_instance = get_command(tool, source_abspath, dirpath,
tool_opts)
command_str = str(command_instance)
sh = shell(command_str, cwd=dirpath)
sh()
server.watch(source, sh)
image_filepath = command_instance.destination
image_filename = os.path.basename(image_filepath)
page = render(image_filename)
deploy(dirpath, page)
server.serve(root=dirpath, open_url_delay=open_browser)
def testserver(livereload, port):
from flask_app.app import create_app
os.environ['CONFIG_DIRECTORY'] = from_project_root("conf.d")
extra_files=[
from_project_root("flask_app", "app.yml")
]
app = create_app({'DEBUG': True, 'TESTING': True, 'SECRET_KEY': 'dummy'})
if livereload:
from livereload import Server
s = Server(app)
for filename in extra_files:
s.watch(filename)
s.watch('flask_app')
s.serve(port=port, liveport=35729)
else:
app.run(port=port, extra_files=extra_files)
def make_livereload_server(wsgi_app):
server = Server(wsgi_app)
# XXX: build step could be useful, e.g.
# making it `python app.py build`, but
# in this use case not really necessary
build_cmd = "true"
print "Files being monitored:"
cwd = getcwd()
for pattern in WATCH_PATTERNS:
print "Pattern: ", pattern
for filepath in FileSet(include=pattern):
print "=>", path.relpath(filepath, cwd)
server.watch(filepath, build_cmd)
print
return server
def remove_redundant_files(actual_files, directory, extension='html'):
files_in_directory = glob.glob(f'{directory}/*.{extension}')
for file in files_in_directory:
if file not in actual_files:
os.remove(file)
if __name__ == '__main__':
os.makedirs(HTML_PAGES_DIRNAME, exist_ok=True)
env = Environment(loader=FileSystemLoader(TEMPLATE_DIRNAME),
autoescape=select_autoescape(['html']))
args = get_parsed_arguments()
result_filepath = args.json_path or os.path.join(args.dest_dir,
'downloaded_books.json')
render_pages_from_template = partial(render_pages_from_template,
result_filepath, TEMPLATE_FILENAME)
render_pages_from_template()
template_filepath = os.path.join(TEMPLATE_DIRNAME, TEMPLATE_FILENAME)
server = Server()
server.watch(template_filepath, render_pages_from_template)
server.watch(result_filepath, render_pages_from_template)
server.serve(root='.')
def dev():
live_server = Server(app.wsgi_app)
live_server.watch('**/*.*')
from livereload import Server, shell
from pathlib import Path
import sys
doc_dir = Path(__file__).parent
root_dir = doc_dir.parent
server = Server()
def get_paths(*exts):
for tp in exts:
# top level
yield root_dir / f"**.{tp}"
# nested
yield root_dir / f"**/*.{tp}"
if "no" not in sys.argv:
exts = ("rst", "py", "jinja2", "md")
cmd = shell("make html", cwd=str(doc_dir))
for path in get_paths(*exts):
print(f"watching {path}")
server.watch(str(path), cmd)
server.serve(root=str(doc_dir / "_build" / "html"))
os.remove(filename)
def render_pages():
book_on_page = 10
with open("books.json", "r") as books_file:
books_json = books_file.read()
books = json.loads(books_json)
books_by_pages = list(chunked(books, book_on_page))
count_of_pages = len(books_by_pages)
paths_of_pages = []
for page_number, books_on_current_page in enumerate(books_by_pages, 1):
page_path = render_page(page_number, count_of_pages, books_on_current_page)
paths_of_pages.append(page_path)
template = env.get_template('main_page_template.html')
rendered_page = template.render(page_count = count_of_pages)
with open('index.html', 'w', encoding="utf8") as file:
file.write(rendered_page)
delete_old_pages(paths_of_pages)
if __name__ =='__main__':
render_pages()
server = Server()
server.watch('page_template.html', render_pages)
server.serve(root='.')
#!/usr/bin/env python
# This starts a web server on http://localhost:5500/ where doc files are automatically recompiled.
#
# If you need to create the docs from scratch, run:
# cd docs
# make html
#
from livereload import Server, shell
server = Server()
server.watch('docs/*.rst', shell('make html --always-make', cwd='docs'))
server.watch('docs/_static/*.css', shell('make html --always-make',
cwd='docs'))
print('PORT IS 5500')
server.serve(root='docs/_build/html')
livereload_: https://pypi.python.org/pypi/livereload
"""
import os
from livereload import Server, shell
rebuild_cmd = shell("make html", cwd=".")
rebuild_root = "_build/html"
watch_dirs = [
".",
"release_notes",
]
watch_globs = ["*.rst", "*.ipynb"]
watch_source_dir = "../xaitk_saliency"
server = Server()
server.watch("conf.py", rebuild_cmd)
# Cover above configured watch dirs and globs matrix.
for d in watch_dirs:
for g in watch_globs:
server.watch(os.path.join(d, g), rebuild_cmd)
# Watch source python files.
for dirpath, dirnames, filenames in os.walk(watch_source_dir):
server.watch(os.path.join(dirpath, "*.py"), rebuild_cmd)
# Optionally change to host="0.0.0.0" to make available outside localhost.
server.serve(root=rebuild_root)
#!/usr/bin/env python
from livereload import Server, shell
server = Server()
server.watch("source/", shell("make html"))
server.watch("../piccolo_api", shell("make html"))
server.serve(root="build/html")
#!/usr/bin/env python
from livereload import Server, shell
server = Server()
server.watch('*.rst', shell('make html'))
server.serve(root='_build/html', open_url=True)
return render_template('upload.html')
f = request.files['file']
# basepath = path.abspath(path.dirname(__file__))
# uploadpath = path.join(basepath, 'static\upload', secure_filename(f.filename))
uploadpath = path.join('E:\python\upload', f.filename)
f.save(uploadpath )
return render_template('upload.html')
@app.route('/about')
def about():
return 'Hello about!'
@app.route('/context')
def context():
return 'Hello context!'
#自定义测试函数
@app.template_test('current_url')
def is_current_url(link):
return link['href'] == url_for('context')
# return link['href'] == request.url
if __name__ == '__main__':
lvrld = Server(app.wsgi_app)
lvrld.watch('**/*.html')
lvrld.serve(open_url=True)
#!/usr/bin/env python
import sys
from livereload import Server, shell
if len(sys.argv) > 1:
md = sys.argv[1]
html = f"../docs/slides/{md.replace('.md', '.html')}"
else:
exit(0)
PANDOC_CMD = f'''pandoc
--from markdown+smart+footnotes+fenced_code_blocks+fenced_code_attributes
--to revealjs --output={html}
--variable revealjs-url=/y19-vis/lib/reveal.js
--css=/y19-vis/lib/reveal.css
--slide-level=2 --standalone --mathjax
{md}'''
print(PANDOC_CMD)
server = Server()
server.watch(md, shell(PANDOC_CMD, html))
server.serve()
#!/usr/bin/env python
from livereload import Server, shell
server = Server()
server.watch('./', shell('make html'))
server.serve(root='docs/_build/html')
def dev():
from livereload import Server
live_server = Server(app.wsgi_app)
live_server.watch('**/*.*')
live_server.serve(open_url=True)
nb_name = 'mathpsych-2018-slides'
exporter_standalone = nbconvert.SlidesExporter()
exporter_standalone.reveal_url_prefix = "https://cdnjs.cloudflare.com/ajax/libs/reveal.js/3.6.0"
exporter_standalone.reveal_transition = "none"
exporter_local = nbconvert.SlidesExporter()
exporter_local.reveal_url_prefix = "reveal.js/"
exporter_local.reveal_transition = "none"
writer = nbconvert.writers.FilesWriter()
def export_slides():
print("regenerating {}".format(nb_name))
slides, resources = exporter_local.from_filename(
"{}.ipynb".format(nb_name))
writer.write(slides, resources, notebook_name="{}.local".format(nb_name))
slides_standalone, resources_standalone = exporter_standalone.from_filename(
"{}.ipynb".format(nb_name))
writer.write(slides_standalone,
resources_standalone,
notebook_name=nb_name)
export_slides()
server = Server()
server.watch('{}.ipynb'.format(nb_name), export_slides, delay=2)
server.serve()
from bottle import template
from livereload import Server, shell
from hydrate.demo import state
# TODO Instead of forking and running Python, extract
# stuff from transcrypt.__main__.main
transpile = '../env/bin/transcrypt -b -m -n demo.py'
bottle.debug(True)
@route('/')
def index():
return template('hydrate/index', state=state)
@route('/<filepath:path>')
def server_static(filepath):
return static_file(filepath, root='hydrate')
if __name__ == '__main__':
app = default_app()
server = Server(app)
server.watch('hydrate/demo.py', shell(transpile, cwd='hydrate'))
server.watch('hydrate/__target__/*', delay=2)
server.watch('hydrate/demo.css')
server.watch('hydrate/index.tpl', ignore=False)
server.serve(root='hydrate')
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
from livereload import Server, shell
server = Server()
server.watch('./posts/*.md', shell('nikola build'))
server.serve(port=8889, root='./output')
return pages_href[count - 1]
else:
return None
def get_next_page_link(count, pages_href):
if count != len(pages_href) - 1:
return pages_href[count + 1]
else:
return None
def remove_files():
pages_folder = os.path.join(os.getcwd(), 'pages/*')
files = glob.glob(pages_folder)
for file in files:
os.remove(file)
if __name__ == '__main__':
os.makedirs('pages', exist_ok=True)
with open('books_metadata.json', 'r') as file:
books_metadata_json = json.load(file)
BOOKS_METADATA = quote_url(books_metadata_json)
render_website_pages()
server = Server()
server.watch('template.html', render_website_pages)
server.serve(root='.')
@app.route('/')
def index():
return render_template('index.html',
title="<h1>Welcome</h1>",
body="## header2")
@app.template_filter('md')
def markdown_to_html(txt):
from markdown import markdown
return markdown(txt)
def read_md(filename):
with open(filename) as md_file:
content = reduce(lambda x, y: x + y, md_file.readlines())
return content
@app.context_processor
def inject_methods():
return dict(read_md=read_md)
if __name__ == '__main__':
live_sever = Server(app.wsgi_app)
live_sever.watch('**/*.*')
live_sever.serve(open_url=True)
#app.run(debug=True) #debug 参数
def cmd() -> None:
subprocess.run(build_cmd, cwd=docsdir)
def docs(p: str) -> str:
return path.join(docsdir, p)
# subprocess.run(['make', 'clean'], cwd=docsdir)
cmd() # build once
server = Server()
# Wtach documets
server.watch(docs('/*.md'), cmd, delay=1)
server.watch(docs('/*.rst'), cmd, delay=1)
server.watch(docs('../*.rst'), cmd, delay=1)
server.watch(docs('*/*.rst'), cmd, delay=1)
server.watch(docs('*/*.md'), cmd, delay=1)
server.watch(docs('*/*/*.rst'), cmd, delay=1)
server.watch(docs('*/*/*.md'), cmd, delay=1)
# Watch template/style
server.watch(docs('_templates/'), cmd, delay=1)
server.watch(docs('_static/'), cmd, delay=1)
# Watch package
server.watch(docs('../wdom/*.py'), cmd, delay=1)
server.watch(docs('../wdom/*/*.py'), cmd, delay=1)
server.watch(docs('../wdom/*/*/*.py'), cmd, delay=1)
def dev():
from livereload import Server
live_server = Server(app.wsgi_app)
#监控文件变化参数是目录e.g:监控static文件夹 static/*.*
live_server.watch("**/*.*") #监控整个项目
live_server.serve(open_url=True)
for book in books:
current_book_path = book['book_path']
book['book_path'] = quote(current_book_path)
env = Environment(loader=FileSystemLoader('.'),
autoescape=select_autoescape(['html', 'xml']))
template = env.get_template('template.html')
chunked_books = chunked(books, books_per_page)
for num, chunk_books in enumerate(chunked_books, start=1):
rendered_page = template.render(total_pages=total_pages,
current_page=num,
books=chunked(chunk_books, 2))
with open(f'pages/{num}.html', 'w', encoding="utf8") as file:
file.write(rendered_page)
exists_pages = exists_pages | {num}
clean_pages_files(exists_pages)
if __name__ == '__main__':
template_file = 'template.html'
on_reload()
server = Server()
server.watch(template_file, on_reload)
server.serve(root='.')
@app.route('/context')
def context():
return 'Hello context!'
#自定义测试函数
@app.template_test('current_url')
def is_current_url(link):
return link['href'] == url_for('context')
# return link['href'] == request.url
def readfile(file):
with open(file) as f:
text = reduce(lambda x, y: x + y, f.readlines())
return text.decode('utf-8')
@app.context_processor
def cntxtp():
return dict(readfile=readfile)
if __name__ == '__main__':
lvrld = Server(app.wsgi_app)
lvrld.watch('**/base.html')
lvrld.serve(open_url=True)
app.run(debug=True)
#!/usr/bin/env python
"""
A script to launch a livereload server to watch and rebuild documentation
on some sources changes.
You need to have installed package with extra requirements ``dev`` to use it.
Once launched, server will be available on port 8002, like: ::
http://localhost:8002/
Borrowed from: ::
https://livereload.readthedocs.io/en/latest/#script-example-sphinx
"""
from livereload import Server, shell
server = Server()
# Watch root documents (not recursive)
server.watch('docs/*.rst', shell('make html', cwd='docs'))
# Serve the builded documentation
server.serve(
root='docs/_build/html',
port=8002,
host="0.0.0.0",
)
def dev():
"""reload when modification happened"""
from livereload import Server
live_server = Server(app.wsgi_app)
live_server.watch('**/*.*')
live_server.serve()
"""
Use livereload to serve, build, and reload the website when files change.
"""
from livereload import Server, shell
server = Server()
files = ["**/**.md", "_site.yml", "images/", "css/", "js/", "_layouts/", "_python/"]
for filename in files:
server.watch(filename, "urubu build")
server.serve(root="_build", port="8008", host="localhost", open_url_delay=1)
def readme():
"""Live reload readme"""
from livereload import Server, shell
server = Server()
server.watch("README.rst", lambda: run_task("readme_build"))
server.serve(open_url_delay=1, root="build/readme")
def livereload(c):
"""Automatically reload browser tab upon file modification."""
from livereload import Server
build(c)
server = Server()
# Watch the base settings file
server.watch(CONFIG["settings_base"], lambda: build(c))
# Watch content source files
content_file_extensions = [".md", ".rst"]
for extension in content_file_extensions:
content_blob = "{0}/**/*{1}".format(SETTINGS["PATH"], extension)
server.watch(content_blob, lambda: build(c))
# Watch the theme's templates and static assets
theme_path = SETTINGS["THEME"]
server.watch("{}/templates/*.html".format(theme_path), lambda: build(c))
server.watch("{}/templates/ea/*.html".format(theme_path), lambda: build(c))
server.watch("{}/templates/ea/includes/*.html".format(theme_path),
lambda: build(c))
static_file_extensions = [".css", ".js"]
for extension in static_file_extensions:
static_file = "{0}/static/**/*{1}".format(theme_path, extension)
server.watch(static_file, lambda: build(c))
# Serve output path on configured port
server.serve(port=CONFIG["port"], root=CONFIG["deploy_path"])
def watch_and_serve(args):
server = Server()
server.watch('template.html', lambda: build_page(args))
server.watch(__file__, lambda: reload_script() and build_page(args))
webbrowser.open('http://localhost:5500/page.html')
server.serve(root=PARENT_DIR, port=5500)
from livereload import Server
from app import app
if __name__ == '__main__':
server = Server(app.wsgi_app)
server.watch('../temp/index.css')
server.watch('templates/*.html')
server.serve()
def main(filenames, port, host, settings, debug, profile, profile_dir,
profile_restriction):
"""Start fava for FILENAMES on http://host:port."""
if profile_dir:
profile = True
if profile:
debug = True
env_filename = os.environ.get('BEANCOUNT_FILE', None)
if env_filename:
filenames = filenames + (env_filename, )
if not filenames:
raise click.UsageError('No file specified')
app.config['BEANCOUNT_FILES'] = filenames
app.config['USER_SETTINGS'] = settings
load_settings()
load_file()
if debug:
if profile:
from werkzeug.contrib.profiler import ProfilerMiddleware
app.config['PROFILE'] = True
app.wsgi_app = ProfilerMiddleware(
app.wsgi_app,
restrictions=(profile_restriction, ),
profile_dir=profile_dir if profile_dir else None)
app.run(host, port, debug)
else:
server = Server(app.wsgi_app)
if settings:
server.watch(settings, load_settings)
def reload_source_files(api):
filename = api.options['filename']
api.load_file(filename)
include_path = os.path.dirname(filename)
for filename in api.options['include'] + \
api.options['documents']:
server.watch(os.path.join(include_path, filename),
lambda: reload_source_files(api))
for api in app.config['APIS'].values():
reload_source_files(api)
try:
server.serve(port=port, host=host, debug=debug)
except OSError as e:
if e.errno == errno.EADDRINUSE:
print("Error: Can not start webserver because the port/address"
"is already in use.")
print("Please choose another port with the '-p' option.")
else:
raise
except:
print("Unexpected error:", e)
raise
#!/usr/bin/env python
import os
import sys
if __name__ == "__main__":
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "project.settings")
from django.core.management import execute_from_command_line
from dj_static import Cling, MediaCling
from local_settings import ENV
if len(sys.argv) >= 2 and sys.argv[1] == 'livereload':
import formic
from django.core.wsgi import get_wsgi_application
from livereload import Server
application = get_wsgi_application()
server = Server(Cling(application))
# Add your watch
for filepath in formic.FileSet(include=["**/*.html", "**/*.js"]):
server.watch(filepath)
server.serve(port=8000)
else:
execute_from_command_line(sys.argv)
