markdown-up 2.1.4__tar.gz → 2.2.0__tar.gz

markdown_up-2.2.0/PKG-INFO

@@ -0,0 +1,150 @@
+Metadata-Version: 2.4
+Name: markdown-up
+Version: 2.2.0
+Summary: The MarkdownUp launcher
+Home-page: https://github.com/craigahobbs/markdown-up-py
+Author: Craig A. Hobbs
+Author-email: craigahobbs@gmail.com
+License: MIT
+Keywords: Markdown,viewer
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Utilities
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: chisel>=1.5.0
+Requires-Dist: waitress>=3.0.0
+Dynamic: license-file
+
+# markdown-up
+
+[![PyPI - Status](https://img.shields.io/pypi/status/markdown-up)](https://pypi.org/project/markdown-up/)
+[![PyPI](https://img.shields.io/pypi/v/markdown-up)](https://pypi.org/project/markdown-up/)
+[![GitHub](https://img.shields.io/github/license/craigahobbs/markdown-up-py)](https://github.com/craigahobbs/markdown-up-py/blob/main/LICENSE)
+[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/markdown-up)](https://pypi.org/project/markdown-up/)
+
+MarkdownUp is a Markdown viewer.
+
+
+## Install MarkdownUp
+
+Use Python's `pip` to install MarkdownUp as follows:
+
+~~~
+pip install markdown-up
+~~~
+
+
+## View Markdown Files
+
+To start MarkdownUp, open a terminal and run the `markdown-up` application:
+
+~~~
+markdown-up
+~~~
+
+The `markdown-up` application opens the web browser to the MarkdownUp file browser, which allows you
+to view Markdown or HTML files and navigate directories. To view a file, click on its link.
+
+You can view a specific file as follows:
+
+~~~
+markdown-up README.md
+~~~
+
+**Note:** MarkdownUp runs entirely offline. It does not use an external service to render Markdown
+files.
+
+
+## Running MarkdownUp
+
+When you run the `markdown-up` application, in addition to opening the web browser, it starts a
+[chisel](https://pypi.org/project/chisel/)
+backend API application using
+[waitress](https://pypi.org/project/waitress/).
+
+
+### Automatically Creates HTML for Markdown Files
+
+When you run MarkdownUp and click on a Markdown file link, the link navigates to an HTML file that
+renders the Markdown file. Every Markdown file hosted by MarkdownUp has a corresponding `.html` file
+of the same name. For example, if you run Markdown up in a directory that has the following Markdown
+files: "README.md" and "CHANGELOG.md". The MarkdownUp service automatically generates "README.html"
+and "CHANGELOG.html" files.
+
+The generated `.html` files are HTML stubs for the
+[MarkdownUp Front-End Application](https://github.com/craigahobbs/markdown-up#readme).
+All Markdown parsing and rendering are done on the client to minimize server costs.
+
+
+### Command-Line Arguments
+
+The `markdown-up` application has the following command-line arguments:
+
+```
+usage: markdown-up [-h] [-p N] [-t N] [-n] [-r] [-q] [path]
+
+positional arguments:
+  path        the file or directory to view (default is ".")
+
+options:
+  -h, --help  show this help message and exit
+  -p N        the application port (default is 8080)
+  -t N        the number of web server threads (default is 8)
+  -n          don't open a web browser
+  -r          release mode (cache statics, remove documentation and index)
+  -q          don't display access logging
+```
+
+
+## MarkdownUp Applications
+
+[MarkdownUp Applications](https://github.com/craigahobbs/markdown-up?tab=readme-ov-file#dynamic-markdown-applications)
+are front-end applications that run within the
+[MarkdownUp Front-End Application](https://github.com/craigahobbs/markdown-up#readme)
+using the
+[BareScript](https://github.com/craigahobbs/bare-script#readme)
+programming language. Markdown files viewed within MarkdownUp may contain `markdown-script` fenced
+code blocks containing
+[BareScript](https://github.com/craigahobbs/bare-script#readme)
+that executes when the Markdown renders.
+
+MarkdownUp has libraries for dynamically generating and rendering Markdown text, drawing SVG images,
+performing data analytics, parsing application arguments, and much more. See the
+[MarkdownUp Library](https://craigahobbs.github.io/markdown-up/library/)
+and
+[MarkdownUp Include Library](https://craigahobbs.github.io/markdown-up/library/include.html)
+for more information.
+
+Here's an example of a simple MarkdownUp application:
+
+~~~markdown
+# The First Ten Numbers
+
+Here are the first ten numbers:
+
+```markdown-script
+i = 1
+while i <= 10:
+    markdownPrint('', stringNew(i))
+    i = i + 1
+endwhile
+```
+~~~
+
+
+## Development
+
+This package is developed using [python-build](https://github.com/craigahobbs/python-build#readme).
+It was started using [python-template](https://github.com/craigahobbs/python-template#readme) as follows:
+
+~~~
+template-specialize python-template/template/ markdown-up-py/ -k package markdown-up -k name 'Craig A. Hobbs' -k email 'craigahobbs@gmail.com' -k github 'craigahobbs' -k noapi 1
+~~~

markdown_up-2.2.0/README.md

@@ -0,0 +1,125 @@
+# markdown-up
+
+[![PyPI - Status](https://img.shields.io/pypi/status/markdown-up)](https://pypi.org/project/markdown-up/)
+[![PyPI](https://img.shields.io/pypi/v/markdown-up)](https://pypi.org/project/markdown-up/)
+[![GitHub](https://img.shields.io/github/license/craigahobbs/markdown-up-py)](https://github.com/craigahobbs/markdown-up-py/blob/main/LICENSE)
+[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/markdown-up)](https://pypi.org/project/markdown-up/)
+
+MarkdownUp is a Markdown viewer.
+
+
+## Install MarkdownUp
+
+Use Python's `pip` to install MarkdownUp as follows:
+
+~~~
+pip install markdown-up
+~~~
+
+
+## View Markdown Files
+
+To start MarkdownUp, open a terminal and run the `markdown-up` application:
+
+~~~
+markdown-up
+~~~
+
+The `markdown-up` application opens the web browser to the MarkdownUp file browser, which allows you
+to view Markdown or HTML files and navigate directories. To view a file, click on its link.
+
+You can view a specific file as follows:
+
+~~~
+markdown-up README.md
+~~~
+
+**Note:** MarkdownUp runs entirely offline. It does not use an external service to render Markdown
+files.
+
+
+## Running MarkdownUp
+
+When you run the `markdown-up` application, in addition to opening the web browser, it starts a
+[chisel](https://pypi.org/project/chisel/)
+backend API application using
+[waitress](https://pypi.org/project/waitress/).
+
+
+### Automatically Creates HTML for Markdown Files
+
+When you run MarkdownUp and click on a Markdown file link, the link navigates to an HTML file that
+renders the Markdown file. Every Markdown file hosted by MarkdownUp has a corresponding `.html` file
+of the same name. For example, if you run Markdown up in a directory that has the following Markdown
+files: "README.md" and "CHANGELOG.md". The MarkdownUp service automatically generates "README.html"
+and "CHANGELOG.html" files.
+
+The generated `.html` files are HTML stubs for the
+[MarkdownUp Front-End Application](https://github.com/craigahobbs/markdown-up#readme).
+All Markdown parsing and rendering are done on the client to minimize server costs.
+
+
+### Command-Line Arguments
+
+The `markdown-up` application has the following command-line arguments:
+
+```
+usage: markdown-up [-h] [-p N] [-t N] [-n] [-r] [-q] [path]
+
+positional arguments:
+  path        the file or directory to view (default is ".")
+
+options:
+  -h, --help  show this help message and exit
+  -p N        the application port (default is 8080)
+  -t N        the number of web server threads (default is 8)
+  -n          don't open a web browser
+  -r          release mode (cache statics, remove documentation and index)
+  -q          don't display access logging
+```
+
+
+## MarkdownUp Applications
+
+[MarkdownUp Applications](https://github.com/craigahobbs/markdown-up?tab=readme-ov-file#dynamic-markdown-applications)
+are front-end applications that run within the
+[MarkdownUp Front-End Application](https://github.com/craigahobbs/markdown-up#readme)
+using the
+[BareScript](https://github.com/craigahobbs/bare-script#readme)
+programming language. Markdown files viewed within MarkdownUp may contain `markdown-script` fenced
+code blocks containing
+[BareScript](https://github.com/craigahobbs/bare-script#readme)
+that executes when the Markdown renders.
+
+MarkdownUp has libraries for dynamically generating and rendering Markdown text, drawing SVG images,
+performing data analytics, parsing application arguments, and much more. See the
+[MarkdownUp Library](https://craigahobbs.github.io/markdown-up/library/)
+and
+[MarkdownUp Include Library](https://craigahobbs.github.io/markdown-up/library/include.html)
+for more information.
+
+Here's an example of a simple MarkdownUp application:
+
+~~~markdown
+# The First Ten Numbers
+
+Here are the first ten numbers:
+
+```markdown-script
+i = 1
+while i <= 10:
+    markdownPrint('', stringNew(i))
+    i = i + 1
+endwhile
+```
+~~~
+
+
+## Development
+
+This package is developed using [python-build](https://github.com/craigahobbs/python-build#readme).
+It was started using [python-template](https://github.com/craigahobbs/python-template#readme) as follows:
+
+~~~
+template-specialize python-template/template/ markdown-up-py/ -k package markdown-up -k name 'Craig A. Hobbs' -k email 'craigahobbs@gmail.com' -k github 'craigahobbs' -k noapi 1
+~~~

{markdown_up-2.1.4 → markdown_up-2.2.0}/setup.cfg

@@ -1,6 +1,6 @@
 [metadata]
 name = markdown-up
-version = 2.1.4
+version = 2.2.0
 url = https://github.com/craigahobbs/markdown-up-py
 author = Craig A. Hobbs
 author_email = craigahobbs@gmail.com
@@ -26,7 +26,7 @@ packages = markdown_up, markdown_up.static
 package_dir = 
 	= src
 install_requires = 
-	chisel >= 1.4.6
+	chisel >= 1.5.0
 	waitress >= 3.0.0
 
 [options.entry_points]

markdown_up-2.2.0/src/markdown_up/app.py

@@ -0,0 +1,283 @@
+# Licensed under the MIT License
+# https://github.com/craigahobbs/markdown-up-py/blob/main/LICENSE
+
+"""
+The MarkdownUp launcher back-end application
+"""
+
+import importlib.resources
+import os
+from pathlib import PurePosixPath
+import threading
+import urllib.parse
+
+import chisel
+
+
+class MarkdownUpApplication(chisel.Application):
+    """
+    The markdown-up back-end API WSGI application class
+    """
+
+    __slots__ = ('root', 'release', 'add_request_lock')
+
+
+    def __init__(self, root, release=False):
+        super().__init__()
+        self.root = root
+        self.release = release
+        self.add_request_lock = threading.Lock()
+
+        if release:
+            # Add the MarkdownUp application
+            self.add_requests(chisel.create_doc_requests(api=False, app=False, markdown_up=True))
+        else:
+            # Add the chisel documentation application (and the MarkdownUp application)
+            self.add_requests(chisel.create_doc_requests())
+
+            # Add the markdown-up APIs
+            self.add_request(markdown_up_index)
+
+            # Add the markdown-up statics
+            self.add_static('index.html', content_type='text/html; charset=utf-8', urls=(('GET', '/'),))
+            self.add_static('markdownUpIndex.bare')
+
+
+    def add_static(self, filename, content_type=None, urls=(('GET', None),), doc_group='MarkdownUp Index Statics'):
+        with importlib.resources.files('markdown_up.static').joinpath(filename).open('rb') as fh:
+            self.add_request(chisel.StaticRequest(filename, fh.read(), content_type=content_type, urls=urls, doc_group=doc_group))
+
+
+    def __call__(self, environ, start_response):
+        request_method = environ['REQUEST_METHOD']
+        path_info = environ['PATH_INFO']
+
+        # Chisel API request? Otherwise, its a static request...
+        request, _ = self.match_request(request_method, path_info)
+        if request is not None:
+            return super().__call__(environ, start_response)
+
+        # Compute the static file path
+        posix_path_info = PurePosixPath(path_info)
+        path = os.path.join(self.root, *posix_path_info.parts[1:])
+
+        # Directory path?
+        request = None
+        if os.path.isdir(path):
+
+            # Directory redirect?
+            if not path_info.endswith('/'):
+                request = chisel.RedirectRequest(((None, path_info),), path_info + '/', name=path_info)
+
+            # HTML index file exist?
+            if request is None:
+                for index_file in INDEX_FILES:
+                    index_posix_path = posix_path_info.joinpath(index_file)
+                    index_path = os.path.join(self.root, *index_posix_path.parts[1:])
+                    if os.path.isfile(index_path):
+                        with open(index_path, 'rb') as index_file:
+                            request = chisel.StaticRequest(
+                                path_info,
+                                index_file.read(),
+                                content_type='text/html; charset=utf-8',
+                                urls=(('GET', path_info),)
+                            )
+                        break
+
+            # No HTML index file - does a Markdown index file exist?
+            if request is None:
+                for index_markdown in INDEX_MARKDOWN:
+                    markdown_posix_path = posix_path_info.joinpath(index_markdown)
+                    markdown_path = os.path.join(self.root, *markdown_posix_path.parts[1:])
+                    if os.path.isfile(markdown_path):
+                        request = chisel.StaticRequest(
+                            path_info,
+                            create_markdown_up_stub(markdown_posix_path.name),
+                            content_type='text/html; charset=utf-8',
+                            urls=(('GET', path_info),)
+                        )
+                        break
+
+        # File path?
+        elif os.path.isfile(path):
+            try:
+                with open(path, 'rb') as path_file:
+                    request = chisel.StaticRequest(path_info, path_file.read(), urls=(('GET', path_info),))
+            except AssertionError as exc:
+                ctx = chisel.Context(self, environ, start_response)
+                ctx.log.warning(str(exc))
+
+        # Auto-generate MarkdownUp HTML stub?
+        elif posix_path_info.suffix == HTML_EXTS[0]:
+            for markdown_ext in MARKDOWN_EXTS:
+                markdown_posix_path = posix_path_info.with_suffix(markdown_ext)
+                markdown_path = os.path.join(self.root, *markdown_posix_path.parts[1:])
+                if os.path.isfile(markdown_path):
+                    request = chisel.StaticRequest(
+                        path_info,
+                        create_markdown_up_stub(markdown_posix_path.name),
+                        content_type='text/html; charset=utf-8',
+                        urls=(('GET', path_info),)
+                    )
+                    break
+
+        # Not found?
+        if not request:
+            start_response('404 Not Found', [('Content-Type', 'text/plain; charset=utf-8')])
+            return [b'Not Found']
+
+        # Add the request, if caching of statics is enabled
+        if self.release:
+            with self.add_request_lock:
+                request_lock, _ = self.match_request('GET', path_info)
+                if request_lock is None:
+                    self.add_request(request)
+
+        # Bad method?
+        if isinstance(request, chisel.StaticRequest) and request_method != 'GET':
+            start_response('405 Method Not Allowed', [('Content-Type', 'text/plain; charset=utf-8')])
+            return [b'Method Not Allowed']
+
+        # Handle the request
+        return request(environ, start_response)
+
+
+# Render-able file extensions
+MARKDOWN_EXTS = ('.md', '.markdown')
+HTML_EXTS = ('.html', '.htm')
+
+
+# Index file names
+INDEX_FILES = ('index.html', 'index.htm')
+INDEX_MARKDOWN = ('index.md', 'README.md')
+
+
+def create_markdown_up_stub(filename):
+    return f'''\
+<!DOCTYPE html>
+<html lang="en">
+    <head>
+        <title>MarkdownUp</title>
+        <meta charset="UTF-8">
+        <meta name="viewport" content="width=device-width, initial-scale=1">
+        <link rel="stylesheet" href="/markdown-up/app.css">
+
+        <!-- Preloads -->
+        <link rel="modulepreload" href="/markdown-up/bare-script/lib/data.js" as="script">
+        <link rel="modulepreload" href="/markdown-up/bare-script/lib/library.js" as="script">
+        <link rel="modulepreload" href="/markdown-up/bare-script/lib/model.js" as="script">
+        <link rel="modulepreload" href="/markdown-up/bare-script/lib/options.js" as="script">
+        <link rel="modulepreload" href="/markdown-up/bare-script/lib/parser.js" as="script">
+        <link rel="modulepreload" href="/markdown-up/bare-script/lib/runtime.js" as="script">
+        <link rel="modulepreload" href="/markdown-up/bare-script/lib/runtimeAsync.js" as="script">
+        <link rel="modulepreload" href="/markdown-up/bare-script/lib/value.js" as="script">
+        <link rel="modulepreload" href="/markdown-up/element-model/lib/elementModel.js" as="script">
+        <link rel="modulepreload" href="/markdown-up/lib/app.js" as="script">
+        <link rel="modulepreload" href="/markdown-up/lib/dataTable.js" as="script">
+        <link rel="modulepreload" href="/markdown-up/lib/dataUtil.js" as="script">
+        <link rel="modulepreload" href="/markdown-up/lib/lineChart.js" as="script">
+        <link rel="modulepreload" href="/markdown-up/lib/script.js" as="script">
+        <link rel="modulepreload" href="/markdown-up/lib/scriptLibrary.js" as="script">
+        <link rel="modulepreload" href="/markdown-up/markdown-model/lib/elements.js" as="script">
+        <link rel="modulepreload" href="/markdown-up/markdown-model/lib/highlight.js" as="script">
+        <link rel="modulepreload" href="/markdown-up/markdown-model/lib/parser.js" as="script">
+        <link rel="modulepreload" href="/markdown-up/schema-markdown-doc/lib/schemaMarkdownDoc.js" as="script">
+        <link rel="modulepreload" href="/markdown-up/schema-markdown/lib/encode.js" as="script">
+        <link rel="modulepreload" href="/markdown-up/schema-markdown/lib/parser.js" as="script">
+        <link rel="modulepreload" href="/markdown-up/schema-markdown/lib/schema.js" as="script">
+        <link rel="modulepreload" href="/markdown-up/schema-markdown/lib/schemaUtil.js" as="script">
+        <link rel="modulepreload" href="/markdown-up/schema-markdown/lib/typeModel.js" as="script">
+        <link rel="preload" href="/markdown-up/app.css" as="style">
+        <link rel="preload" href="/markdown-up/markdown-model/static/markdown-model.css" as="style">
+    </head>
+    <body>
+    </body>
+    <script type="module">
+        import {{MarkdownUp}} from '/markdown-up/lib/app.js';
+        const app = new MarkdownUp(window, {{
+            'systemPrefix': '/markdown-up/include/',
+            'url': '{urllib.parse.quote(filename)}'
+        }});
+        app.run();
+    </script>
+</html>
+'''.encode('utf-8')
+
+
+@chisel.action(spec='''\
+group "MarkdownUp Index API"
+
+
+# The MarkdownUp launcher index API
+action markdown_up_index
+    urls
+        GET
+
+    query
+        # The relative sub-directory path
+        optional string(len > 0) path
+
+    output
+        # The index path
+        string path
+
+        # The parent path
+        optional string parent
+
+        # The path's files
+        IndexFile[] files
+
+        # The path's sub-directories
+        string[] directories
+
+    errors
+        # The path is invalid
+        InvalidPath
+
+
+# An index file
+struct IndexFile
+
+    # The file name
+    string name
+
+    # The file's display name
+    optional string display
+''')
+def markdown_up_index(ctx, req):
+    # Validate the path
+    posix_path = PurePosixPath(req['path'] if 'path' in req else '')
+    if posix_path.is_absolute() or any(part == '..' for part in posix_path.parts):
+        raise chisel.ActionError('InvalidPath')
+
+    # Verify that the path exists
+    path = os.path.join(ctx.app.root, *posix_path.parts)
+    if not os.path.isdir(path):
+        raise chisel.ActionError('InvalidPath')
+
+    # Compute parent path
+    parent_path = str(posix_path.parent) if 'path' in req else None
+
+    # Get the list of files and sub-directories from the current sub-directory
+    files = []
+    directories = []
+    for entry in os.scandir(path):
+        if entry.is_file():
+            # Markdown files are viewed using their generated MarkdownUp HTML stubs
+            name_root, name_ext = os.path.splitext(entry.name)
+            if name_ext in MARKDOWN_EXTS:
+                files.append({'name': f'{name_root}{HTML_EXTS[0]}', 'display': entry.name})
+            elif name_ext in HTML_EXTS:
+                files.append({'name': entry.name})
+        elif entry.is_dir(): # pragma: no branch
+            directories.append(entry.name)
+
+    # Return the response
+    response = {
+        'path': path,
+        'files': sorted(files, key=lambda file_: file_.get('display', file_['name'])),
+        'directories': sorted(directories)
+    }
+    if parent_path is not None and parent_path != '.':
+        response['parent'] = parent_path
+    return response

{markdown_up-2.1.4 → markdown_up-2.2.0}/src/markdown_up/main.py

@@ -6,14 +6,14 @@ The MarkdownUp launcher command-line application
 """
 
 import argparse
+from functools import partial
 import os
 import threading
 import webbrowser
 
-from schema_markdown import encode_query_string
 import waitress
 
-from .app import HTML_EXTS, MarkdownUpApplication
+from .app import HTML_EXTS, MARKDOWN_EXTS, MarkdownUpApplication
 
 
 def main(argv=None):
@@ -24,11 +24,15 @@ def main(argv=None):
     # Command line arguments
     parser = argparse.ArgumentParser(prog='markdown-up')
     parser.add_argument('path', nargs='?', default='.',
-                        help='the markdown file or directory to view (default is ".")')
+                        help='the file or directory to view (default is ".")')
     parser.add_argument('-p', metavar='N', dest='port', type=int, default=8080,
                         help='the application port (default is 8080)')
+    parser.add_argument('-t', metavar='N', dest='threads', type=int, default=8,
+                        help='the number of web server threads (default is 8)')
     parser.add_argument('-n', dest='no_browser', action='store_true',
                         help="don't open a web browser")
+    parser.add_argument('-r', dest='release', action='store_true',
+                        help="release mode (cache statics, remove documentation and index)")
     parser.add_argument('-q', dest='quiet', action='store_true',
                         help="don't display access logging")
     args = parser.parse_args(args=argv)
@@ -52,11 +56,12 @@ def main(argv=None):
     # Construct the URL
     host = '127.0.0.1'
     if is_file:
-        if args.path.endswith(HTML_EXTS):
-            url = f'http://{host}:{args.port}/{os.path.basename(args.path)}'
+        path_base = os.path.basename(args.path)
+        path_root, path_ext = os.path.splitext(path_base)
+        if path_ext in MARKDOWN_EXTS:
+            url = f'http://{host}:{args.port}/{path_root}{HTML_EXTS[0]}'
         else:
-            hash_args = encode_query_string({'url': os.path.basename(args.path)})
-            url = f'http://{host}:{args.port}/#{hash_args}'
+            url = f'http://{host}:{args.port}/{path_base}'
     else:
         url = f'http://{host}:{args.port}/'
 
@@ -67,17 +72,18 @@ def main(argv=None):
         webbrowser_thread.start()
 
     # Create the WSGI application
-    wsgiapp = MarkdownUpApplication(root)
-
-    # Wrap the WSGI application and the start_response function so we can log status and environ
-    def wsgiapp_wrap(environ, start_response):
-        def log_start_response(status, response_headers):
-            if not args.quiet:
-                print(f'markdown-up: {status[0:3]} {environ["REQUEST_METHOD"]} {environ["PATH_INFO"]} {environ["QUERY_STRING"]}')
-            return start_response(status, response_headers)
-        return wsgiapp(environ, log_start_response)
+    wsgiapp = MarkdownUpApplication(root, args.release)
+    wsgiapp_wrap = wsgiapp if args.quiet else partial(_wsgiapp_log_access, wsgiapp)
 
     # Host the application
     if not args.quiet:
         print(f'markdown-up: Serving at {url} ...')
-    waitress.serve(wsgiapp_wrap, port=args.port)
+    waitress.serve(wsgiapp_wrap, port=args.port, threads=max(args.threads, 1))
+
+
+# WSGI application wrapper and the start_response function so we can log status and environ
+def _wsgiapp_log_access(wsgiapp, environ, start_response):
+    def log_start_response(status, response_headers):
+        print(f'markdown-up: {status[0:3]} {environ["REQUEST_METHOD"]} {environ["PATH_INFO"]} {environ["QUERY_STRING"]}')
+        return start_response(status, response_headers)
+    return wsgiapp(environ, log_start_response)