PyDocURLProtocol

• Download example

A PyObjC Example without documentation

Sources

PyDocBrowser.py

import AppKit  # noqa: F401
import Foundation  # noqa: F401
import PyDocEvents  # noqa: F401
import PyDocURLProtocol  # noqa: F401
import WebKit  # noqa: F401
from PyObjCTools import AppHelper

PyDocURLProtocol.setup()

# the web browser doesn't have or need any code really

if __name__ == "__main__":
    AppHelper.runEventLoop()

PyDocEvents.py

"""
Minimal applescript support.

The PyDocEventHandler handles just the event that is used to open URLs. Thanks
to this class you can use ``open pydoc:///os.open`` from a command-line, or
add ``pydoc:///`` to HTML files.
"""

import struct

import objc
from Cocoa import NSAppleEventManager, NSObject


def fourCharToInt(code):
    return struct.unpack(">l", code)[0]


class PyDocEventHandler(NSObject):
    webview = objc.IBOutlet("webview")
    urlfield = objc.IBOutlet("urlfield")

    def handleEvent_withReplyEvent_(self, event, replyEvent):
        theURL = event.descriptorForKeyword_(fourCharToInt(b"----"))

        self.urlfield.setStringValue_(theURL.stringValue())
        self.webview.takeStringURLFrom_(theURL)

    def awakeFromNib(self):
        manager = NSAppleEventManager.sharedAppleEventManager()

        # Add a handler for the event GURL/GURL. One might think that
        # Carbon.AppleEvents.kEISInternetSuite/kAEISGetURL would work,
        # but the system headers (and hence the Python wrapper for those)
        # are wrong.
        manager.setEventHandler_andSelector_forEventClass_andEventID_(
            self,
            "handleEvent:withReplyEvent:",
            fourCharToInt(b"GURL"),
            fourCharToInt(b"GURL"),
        )

PyDocURLProtocol.py

import sys

from Cocoa import (
    NSURL,
    NSData,
    NSError,
    NSString,
    NSURLCacheStorageNotAllowed,
    NSURLErrorDomain,
    NSURLErrorResourceUnavailable,
    NSURLProtocol,
    NSURLResponse,
)
from pydochelper import gethtmldoc

PY3K = sys.version_info[0] == 3

PYDOCSCHEME = "pydoc"


class PyDocURLProtocol(NSURLProtocol):
    def canInitWithRequest_(klass, request):
        if request.URL().scheme() == PYDOCSCHEME:
            return True
        return False

    def canonicalRequestForRequest_(klass, request):
        return request

    def startLoading(self):
        client = self.client()
        request = self.request()
        urlpath = request.URL().standardizedURL().path()
        modpath = urlpath.replace("/", ".").lstrip(".").replace(".html", "")

        if not PY3K:
            modpath = modpath.encode("utf-8")

        try:
            data = gethtmldoc(modpath)
            if PY3K:
                data = data.encode("utf-8")
        except Exception:
            client.URLProtocol_didFailWithError_(
                self,
                NSError.errorWithDomain_code_userInfo_(
                    NSURLErrorDomain, NSURLErrorResourceUnavailable, None
                ),
            )
        else:
            response = NSURLResponse.alloc().initWithURL_MIMEType_expectedContentLength_textEncodingName_(  # noqa: B950
                request.URL(), "text/html", len(data), "utf-8"
            )
            client.URLProtocol_didReceiveResponse_cacheStoragePolicy_(
                self, response, NSURLCacheStorageNotAllowed
            )
            client.URLProtocol_didLoadData_(
                self, NSData.dataWithBytes_length_(data, len(data))
            )
            client.URLProtocolDidFinishLoading_(self)

    def stopLoading(self):
        pass


def setup():
    NSURLProtocol.registerClass_(PyDocURLProtocol)


def teardown():
    NSURLProtocol.unregisterClass_(PyDocURLProtocol)


def main(*args):
    if not args:
        args = ("dict",)

    setup()
    try:
        for arg in args:
            url = NSURL.URLWithString_(f"pydoc:///{arg}")
            print(NSString.stringWithContentsOfURL_(url))
    finally:
        teardown()


if __name__ == "__main__":
    main(*sys.argv[1:])

pydochelper.py

import pydoc

__all__ = ["gethtmldoc"]


def gethtmldoc(thing, forceload=0):
    obj, name = pydoc.resolve(thing, forceload)
    page = pydoc.html.page(pydoc.describe(obj), pydoc.html.document(obj, name))
    return page

setup.py

"""
Script for building the example.

Usage:
    python3 setup.py py2app
"""

from setuptools import setup

plist = {
    "NSMainNibFile": "PyDocBrowser",
    "NSAppleScriptEnabled": True,
    "CFBundleURLTypes": [
        {"CFBundleURLName": "Python Documentation URL", "CFBundleURLSchemes": ["pydoc"]}
    ],
}

setup(
    app=["PyDocBrowser.py"],
    data_files=["PyDocBrowser.nib"],
    options={"py2app": {"plist": plist}},
    setup_requires=["py2app", "pyobjc-framework-Cocoa", "pyobjc-framework-WebKit"],
)