py2docfx 0.1.15rc2025477__py3-none-any.whl → 0.1.16__py3-none-any.whl

py2docfx/venv/venv1/Lib/site-packages/isapi/samples/redirector_with_filter.py

@@ -1,162 +0,0 @@
-# This is a sample configuration file for an ISAPI filter and extension
-# written in Python.
-#
-# Please see README.txt in this directory, and specifically the
-# information about the "loader" DLL - installing this sample will create
-# "_redirector_with_filter.dll" in the current directory.  The readme explains
-# this.
-
-# Executing this script (or any server config script) will install the extension
-# into your web server. As the server executes, the PyISAPI framework will load
-# this module and create your Extension and Filter objects.
-
-# This sample provides sample redirector:
-# It is implemented by a filter and an extension, so that some requests can
-# be ignored.  Compare with 'redirector_simple' which avoids the filter, but
-# is unable to selectively ignore certain requests.
-# The process is sample uses is:
-# * The filter is installed globally, as all filters are.
-# * A Virtual Directory named "python" is setup.  This dir has our ISAPI
-#   extension as the only application, mapped to file-extension '*'.  Thus, our
-#   extension handles *all* requests in this directory.
-# The basic process is that the filter does URL rewriting, redirecting every
-# URL to our Virtual Directory.  Our extension then handles this request,
-# forwarding the data from the proxied site.
-# For example:
-# * URL of "index.html" comes in.
-# * Filter rewrites this to "/python/index.html"
-# * Our extension sees the full "/python/index.html", removes the leading
-#   portion, and opens and forwards the remote URL.
-
-
-# This sample is very small - it avoid most error handling, etc.  It is for
-# demonstration purposes only.
-
-import sys
-import urllib.error
-import urllib.parse
-import urllib.request
-
-from isapi import isapicon, threaded_extension
-from isapi.simple import SimpleFilter
-
-# sys.isapidllhandle will exist when we are loaded by the IIS framework.
-# In this case we redirect our output to the win32traceutil collector.
-if hasattr(sys, "isapidllhandle"):
-    import win32traceutil
-
-# The site we are proxying.
-proxy = "https://www.python.org"
-# The name of the virtual directory we install in, and redirect from.
-virtualdir = "/python"
-
-# The key feature of this redirector over the simple redirector is that it
-# can choose to ignore certain responses by having the filter not rewrite them
-# to our virtual dir. For this sample, we just exclude the IIS help directory.
-
-
-# The ISAPI extension - handles requests in our virtual dir, and sends the
-# response to the client.
-class Extension(threaded_extension.ThreadPoolExtension):
-    "Python sample Extension"
-
-    def Dispatch(self, ecb):
-        # Note that our ThreadPoolExtension base class will catch exceptions
-        # in our Dispatch method, and write the traceback to the client.
-        # That is perfect for this sample, so we don't catch our own.
-        # print(f'IIS dispatching "{ecb.GetServerVariable("URL")}"')
-        url = ecb.GetServerVariable("URL")
-        if url.startswith(virtualdir):
-            new_url = proxy + url[len(virtualdir) :]
-            print("Opening", new_url)
-            fp = urllib.request.urlopen(new_url)
-            headers = fp.info()
-            ecb.SendResponseHeaders("200 OK", str(headers) + "\r\n", False)
-            ecb.WriteClient(fp.read())
-            ecb.DoneWithSession()
-            print(f"Returned data from '{new_url}'!")
-        else:
-            # this should never happen - we should only see requests that
-            # start with our virtual directory name.
-            print(f"Not proxying '{url}'")
-
-
-# The ISAPI filter.
-class Filter(SimpleFilter):
-    "Sample Python Redirector"
-
-    filter_flags = isapicon.SF_NOTIFY_PREPROC_HEADERS | isapicon.SF_NOTIFY_ORDER_DEFAULT
-
-    def HttpFilterProc(self, fc):
-        # print("Filter Dispatch")
-        nt = fc.NotificationType
-        if nt != isapicon.SF_NOTIFY_PREPROC_HEADERS:
-            return isapicon.SF_STATUS_REQ_NEXT_NOTIFICATION
-
-        pp = fc.GetData()
-        url = pp.GetHeader("url")
-        # print(f"URL is '{url}'")
-        prefix = virtualdir
-        if not url.startswith(prefix):
-            new_url = prefix + url
-            print(f"New proxied URL is '{new_url}'")
-            pp.SetHeader("url", new_url)
-            # For the sake of demonstration, show how the FilterContext
-            # attribute is used.  It always starts out life as None, and
-            # any assignments made are automatically decref'd by the
-            # framework during a SF_NOTIFY_END_OF_NET_SESSION notification.
-            if fc.FilterContext is None:
-                fc.FilterContext = 0
-            fc.FilterContext += 1
-            print("This is request number %d on this connection" % fc.FilterContext)
-            return isapicon.SF_STATUS_REQ_HANDLED_NOTIFICATION
-        else:
-            print(f"Filter ignoring URL '{url}'")
-
-            # Some older code that handled SF_NOTIFY_URL_MAP.
-            # print("Have URL_MAP notify")
-            # urlmap = fc.GetData()
-            # print("URI is", urlmap.URL)
-            # print("Path is", urlmap.PhysicalPath)
-            # if urlmap.URL.startswith("/UC/"):
-            # # Find the /UC/ in the physical path, and nuke it (except
-            # # as the path is physical, it is \)
-            # p = urlmap.PhysicalPath
-            # pos = p.index("\\UC\\")
-            # p = p[:pos] + p[pos+3:]
-            # p = r"E:\src\pyisapi\webroot\PyTest\formTest.htm"
-            # print("New path is", p)
-            # urlmap.PhysicalPath = p
-
-
-# The entry points for the ISAPI extension.
-def __FilterFactory__():
-    return Filter()
-
-
-def __ExtensionFactory__():
-    return Extension()
-
-
-if __name__ == "__main__":
-    # If run from the command-line, install ourselves.
-    from isapi.install import *
-
-    params = ISAPIParameters()
-    # Setup all filters - these are global to the site.
-    params.Filters = [
-        FilterParameters(Name="PythonRedirector", Description=Filter.__doc__),
-    ]
-    # Setup the virtual directories - this is a list of directories our
-    # extension uses - in this case only 1.
-    # Each extension has a "script map" - this is the mapping of ISAPI
-    # extensions.
-    sm = [ScriptMapParams(Extension="*", Flags=0)]
-    vd = VirtualDirParameters(
-        Name=virtualdir[1:],
-        Description=Extension.__doc__,
-        ScriptMaps=sm,
-        ScriptMapUpdate="replace",
-    )
-    params.VirtualDirs = [vd]
-    HandleCommandLine(params)

py2docfx/venv/venv1/Lib/site-packages/isapi/samples/test.py

@@ -1,195 +0,0 @@
-# This extension is used mainly for testing purposes - it is not
-# designed to be a simple sample, but instead is a hotch-potch of things
-# that attempts to exercise the framework.
-
-import os
-import stat
-import sys
-
-from isapi import isapicon
-from isapi.simple import SimpleExtension
-
-if hasattr(sys, "isapidllhandle"):
-    import win32traceutil
-
-# We use the same reload support as 'advanced.py' demonstrates.
-import threading
-
-import win32con
-import win32event
-import win32file
-import winerror
-
-from isapi import InternalReloadException
-
-
-# A watcher thread that checks for __file__ changing.
-# When it detects it, it simply sets "change_detected" to true.
-class ReloadWatcherThread(threading.Thread):
-    def __init__(self):
-        self.change_detected = False
-        self.filename = __file__
-        if self.filename.endswith("c") or self.filename.endswith("o"):
-            self.filename = self.filename[:-1]
-        self.handle = win32file.FindFirstChangeNotification(
-            os.path.dirname(self.filename),
-            False,  # watch tree?
-            win32con.FILE_NOTIFY_CHANGE_LAST_WRITE,
-        )
-        threading.Thread.__init__(self)
-
-    def run(self):
-        last_time = os.stat(self.filename)[stat.ST_MTIME]
-        while 1:
-            try:
-                rc = win32event.WaitForSingleObject(self.handle, win32event.INFINITE)
-                win32file.FindNextChangeNotification(self.handle)
-            except win32event.error as details:
-                # handle closed - thread should terminate.
-                if details.winerror != winerror.ERROR_INVALID_HANDLE:
-                    raise
-                break
-            this_time = os.stat(self.filename)[stat.ST_MTIME]
-            if this_time != last_time:
-                print("Detected file change - flagging for reload.")
-                self.change_detected = True
-                last_time = this_time
-
-    def stop(self):
-        win32file.FindCloseChangeNotification(self.handle)
-
-
-def TransmitFileCallback(ecb, hFile, cbIO, errCode):
-    print("Transmit complete!")
-    ecb.close()
-
-
-# The ISAPI extension - handles requests in our virtual dir, and sends the
-# response to the client.
-class Extension(SimpleExtension):
-    "Python test Extension"
-
-    def __init__(self):
-        self.reload_watcher = ReloadWatcherThread()
-        self.reload_watcher.start()
-
-    def HttpExtensionProc(self, ecb):
-        # NOTE: If you use a ThreadPoolExtension, you must still perform
-        # this check in HttpExtensionProc - raising the exception from
-        # The "Dispatch" method will just cause the exception to be
-        # rendered to the browser.
-        if self.reload_watcher.change_detected:
-            print("Doing reload")
-            raise InternalReloadException
-
-        if ecb.GetServerVariable("UNICODE_URL").endswith("test.py"):
-            file_flags = (
-                win32con.FILE_FLAG_SEQUENTIAL_SCAN | win32con.FILE_FLAG_OVERLAPPED
-            )
-            hfile = win32file.CreateFile(
-                __file__,
-                win32con.GENERIC_READ,
-                0,
-                None,
-                win32con.OPEN_EXISTING,
-                file_flags,
-                None,
-            )
-            flags = (
-                isapicon.HSE_IO_ASYNC
-                | isapicon.HSE_IO_DISCONNECT_AFTER_SEND
-                | isapicon.HSE_IO_SEND_HEADERS
-            )
-            # We pass hFile to the callback simply as a way of keeping it alive
-            # for the duration of the transmission
-            try:
-                ecb.TransmitFile(
-                    TransmitFileCallback,
-                    hfile,
-                    int(hfile),
-                    "200 OK",
-                    0,
-                    0,
-                    None,
-                    None,
-                    flags,
-                )
-            except:
-                # Errors keep this source file open!
-                hfile.Close()
-                raise
-        else:
-            # default response
-            ecb.SendResponseHeaders("200 OK", "Content-Type: text/html\r\n\r\n", 0)
-            print("<HTML><BODY>", file=ecb)
-            print("The root of this site is at", ecb.MapURLToPath("/"), file=ecb)
-            print("</BODY></HTML>", file=ecb)
-            ecb.close()
-        return isapicon.HSE_STATUS_SUCCESS
-
-    def TerminateExtension(self, status):
-        self.reload_watcher.stop()
-
-
-# The entry points for the ISAPI extension.
-def __ExtensionFactory__():
-    return Extension()
-
-
-# Our special command line customization.
-# Pre-install hook for our virtual directory.
-def PreInstallDirectory(params, options):
-    # If the user used our special '--description' option,
-    # then we override our default.
-    if options.description:
-        params.Description = options.description
-
-
-# Post install hook for our entire script
-def PostInstall(params, options):
-    print()
-    print("The sample has been installed.")
-    print("Point your browser to /PyISAPITest")
-
-
-# Handler for our custom 'status' argument.
-def status_handler(options, log, arg):
-    "Query the status of something"
-    print("Everything seems to be fine!")
-
-
-custom_arg_handlers = {"status": status_handler}
-
-if __name__ == "__main__":
-    # If run from the command-line, install ourselves.
-    from isapi.install import *
-
-    params = ISAPIParameters(PostInstall=PostInstall)
-    # Setup the virtual directories - this is a list of directories our
-    # extension uses - in this case only 1.
-    # Each extension has a "script map" - this is the mapping of ISAPI
-    # extensions.
-    sm = [ScriptMapParams(Extension="*", Flags=0)]
-    vd = VirtualDirParameters(
-        Name="PyISAPITest",
-        Description=Extension.__doc__,
-        ScriptMaps=sm,
-        ScriptMapUpdate="replace",
-        # specify the pre-install hook.
-        PreInstall=PreInstallDirectory,
-    )
-    params.VirtualDirs = [vd]
-    # Setup our custom option parser.
-    from optparse import OptionParser
-
-    parser = OptionParser("")  # blank usage, so isapi sets it.
-    parser.add_option(
-        "",
-        "--description",
-        action="store",
-        help="custom description to use for the virtual directory",
-    )
-
-    HandleCommandLine(
-        params, opt_parser=parser, custom_arg_handlers=custom_arg_handlers
-    )

py2docfx/venv/venv1/Lib/site-packages/isapi/simple.py

@@ -1,73 +0,0 @@
-"""Simple base-classes for extensions and filters.
-
-None of the filter and extension functions are considered 'optional' by the
-framework.  These base-classes provide simple implementations for the
-Initialize and Terminate functions, allowing you to omit them,
-
-It is not necessary to use these base-classes - but if you don't, you
-must ensure each of the required methods are implemented.
-"""
-
-from __future__ import annotations
-
-
-class SimpleExtension:
-    "Base class for a simple ISAPI extension"
-
-    def __init__(self):
-        pass
-
-    def GetExtensionVersion(self, vi):
-        """Called by the ISAPI framework to get the extension version
-
-        The default implementation uses the classes docstring to
-        set the extension description."""
-        # nod to our reload capability - vi is None when we are reloaded.
-        if vi is not None:
-            vi.ExtensionDesc = self.__doc__
-
-    def HttpExtensionProc(self, control_block):
-        """Called by the ISAPI framework for each extension request.
-
-        sub-classes must provide an implementation for this method.
-        """
-        raise NotImplementedError("sub-classes should override HttpExtensionProc")
-
-    def TerminateExtension(self, status):
-        """Called by the ISAPI framework as the extension terminates."""
-        pass
-
-
-class SimpleFilter:
-    "Base class for a a simple ISAPI filter"
-
-    filter_flags: int | None = None
-
-    def __init__(self):
-        pass
-
-    def GetFilterVersion(self, fv):
-        """Called by the ISAPI framework to get the extension version
-
-        The default implementation uses the classes docstring to
-        set the extension description, and uses the classes
-        filter_flags attribute to set the ISAPI filter flags - you
-        must specify filter_flags in your class.
-        """
-        if self.filter_flags is None:
-            raise RuntimeError("You must specify the filter flags")
-        # nod to our reload capability - fv is None when we are reloaded.
-        if fv is not None:
-            fv.Flags = self.filter_flags
-            fv.FilterDesc = self.__doc__
-
-    def HttpFilterProc(self, fc):
-        """Called by the ISAPI framework for each filter request.
-
-        sub-classes must provide an implementation for this method.
-        """
-        raise NotImplementedError("sub-classes should override HttpExtensionProc")
-
-    def TerminateFilter(self, status):
-        """Called by the ISAPI framework as the filter terminates."""
-        pass

py2docfx/venv/venv1/Lib/site-packages/isapi/test/extension_simple.py

@@ -1,114 +0,0 @@
-# This is an ISAPI extension purely for testing purposes.  It is NOT
-# a 'demo' (even though it may be useful!)
-#
-# Install this extension, then point your browser to:
-# "http://localhost/pyisapi_test/test1"
-# This will execute the method 'test1' below.  See below for the list of
-# test methods that are acceptable.
-
-# If we have no console (eg, am running from inside IIS), redirect output
-# somewhere useful - in this case, the standard win32 trace collector.
-import win32api
-import winerror
-
-from isapi import ExtensionError, threaded_extension
-
-try:
-    win32api.GetConsoleTitle()
-except win32api.error:
-    # No console - redirect
-    import win32traceutil
-
-
-# The ISAPI extension - handles requests in our virtual dir, and sends the
-# response to the client.
-class Extension(threaded_extension.ThreadPoolExtension):
-    "Python ISAPI Tester"
-
-    def Dispatch(self, ecb):
-        print('Tester dispatching "{}"'.format(ecb.GetServerVariable("URL")))
-        url = ecb.GetServerVariable("URL")
-        test_name = url.split("/")[-1]
-        meth = getattr(self, test_name, None)
-        if meth is None:
-            raise AttributeError(f"No test named '{test_name}'")
-        result = meth(ecb)
-        if result is None:
-            # This means the test finalized everything
-            return
-        ecb.SendResponseHeaders("200 OK", "Content-type: text/html\r\n\r\n", False)
-        print("<HTML><BODY>Finished running test <i>", test_name, "</i>", file=ecb)
-        print("<pre>", file=ecb)
-        print(result, file=ecb)
-        print("</pre>", file=ecb)
-        print("</BODY></HTML>", file=ecb)
-        ecb.DoneWithSession()
-
-    def test1(self, ecb):
-        try:
-            ecb.GetServerVariable("foo bar")
-            raise AssertionError("should have failed!")
-        except ExtensionError as err:
-            assert err.errno == winerror.ERROR_INVALID_INDEX, err
-        return "worked!"
-
-    def test_long_vars(self, ecb):
-        qs = ecb.GetServerVariable("QUERY_STRING")
-        # Our implementation has a default buffer size of 8k - so we test
-        # the code that handles an overflow by ensuring there are more
-        # than 8k worth of chars in the URL.
-        expected_query = "x" * 8500
-        if len(qs) == 0:
-            # Just the URL with no query part - redirect to myself, but with
-            # a huge query portion.
-            me = ecb.GetServerVariable("URL")
-            headers = "Location: " + me + "?" + expected_query + "\r\n\r\n"
-            ecb.SendResponseHeaders("301 Moved", headers)
-            ecb.DoneWithSession()
-            return None
-        if qs == expected_query:
-            return "Total length of variable is %d - test worked!" % (len(qs),)
-        else:
-            return "Unexpected query portion!  Got %d chars, expected %d" % (
-                len(qs),
-                len(expected_query),
-            )
-
-    def test_unicode_vars(self, ecb):
-        # We need to check that we are running IIS6!  This seems the only
-        # effective way from an extension.
-        ver = float(ecb.GetServerVariable("SERVER_SOFTWARE").split("/")[1])
-        if ver < 6.0:
-            return "This is IIS version %g - unicode only works in IIS6 and later" % ver
-
-        us = ecb.GetServerVariable("UNICODE_SERVER_NAME")
-        assert isinstance(us, str), "unexpected type!"
-        assert us == str(
-            ecb.GetServerVariable("SERVER_NAME")
-        ), "Unicode and non-unicode values were not the same"
-        return "worked!"
-
-
-# The entry points for the ISAPI extension.
-def __ExtensionFactory__():
-    return Extension()
-
-
-if __name__ == "__main__":
-    # If run from the command-line, install ourselves.
-    from isapi.install import *
-
-    params = ISAPIParameters()
-    # Setup the virtual directories - this is a list of directories our
-    # extension uses - in this case only 1.
-    # Each extension has a "script map" - this is the mapping of ISAPI
-    # extensions.
-    sm = [ScriptMapParams(Extension="*", Flags=0)]
-    vd = VirtualDirParameters(
-        Name="pyisapi_test",
-        Description=Extension.__doc__,
-        ScriptMaps=sm,
-        ScriptMapUpdate="replace",
-    )
-    params.VirtualDirs = [vd]
-    HandleCommandLine(params)