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

py2docfx/venv/venv1/Lib/site-packages/pythonwin/pywin/framework/startup.py

@@ -1,70 +0,0 @@
-# startup.py
-#
-"The main application startup code for PythonWin."
-
-#
-# This does the basic command line handling.
-
-# Keep this as short as possible, cos error output is only redirected if
-# this runs OK.  Errors in imported modules are much better - the messages go somewhere (not any more :-)
-
-import os
-import sys
-
-import win32api
-import win32ui
-
-if not sys.argv:
-    # Initialize sys.argv from commandline. When sys.argv is empty list (
-    # different from [''] meaning "no cmd line arguments" ), then C
-    # bootstrapping or another method of invocation failed to initialize
-    # sys.argv and it will be done here. ( This was a workaround for a bug in
-    # win32ui but is retained for other situations. )
-    argv = win32api.CommandLineToArgv(win32api.GetCommandLine())
-    sys.argv = argv[1:]
-    if os.getcwd() not in sys.path and "." not in sys.path:
-        sys.path.insert(0, os.getcwd())
-
-# You may wish to redirect error output somewhere useful if you have startup errors.
-# eg, 'import win32traceutil' will do this for you.
-# import win32traceutil # Just uncomment this line to see error output!
-
-# An old class I used to use - generally only useful if Pythonwin is running under MSVC
-# class DebugOutput:
-# 	softspace=1
-# 	def write(self,message):
-# 		win32ui.OutputDebug(message)
-# sys.stderr=sys.stdout=DebugOutput()
-
-# To fix a problem with Pythonwin when started from the Pythonwin directory,
-# we update the pywin path to ensure it is absolute.
-# If it is indeed relative, it will be relative to our current directory.
-# If it's already absolute, then this will have no affect.
-import pywin
-import pywin.framework
-
-# Ensure we're working on __path__ as list, not Iterable
-pywin.__path__ = list(pywin.__path__)
-pywin.framework.__path__ = list(pywin.framework.__path__)
-
-pywin.__path__[0] = win32ui.FullPath(pywin.__path__[0])
-pywin.framework.__path__[0] = win32ui.FullPath(pywin.framework.__path__[0])
-
-# make a few weird sys values.  This is so later we can clobber sys.argv to trick
-# scripts when running under a GUI environment.
-
-moduleName = "pywin.framework.intpyapp"
-sys.appargvoffset = 0
-sys.appargv = sys.argv[:]
-# Must check for /app param here.
-if len(sys.argv) >= 2 and sys.argv[0].lower() in ("/app", "-app"):
-    from . import cmdline
-
-    moduleName = cmdline.FixArgFileName(sys.argv[1])
-    sys.appargvoffset = 2
-    newargv = sys.argv[sys.appargvoffset :]
-    # 	newargv.insert(0, sys.argv[0])
-    sys.argv = newargv
-
-# Import the application module.
-__import__(moduleName)

py2docfx/venv/venv1/Lib/site-packages/pythonwin/pywin/framework/stdin.py

@@ -1,172 +0,0 @@
-# Copyright (c) 2000 David Abrahams. Permission to copy, use, modify, sell
-# and distribute this software is granted provided this copyright
-# notice appears in all copies. This software is provided "as is" without
-# express or implied warranty, and with no claim as to its suitability for
-# any purpose.
-"""Provides a class Stdin which can be used to emulate the regular old
-sys.stdin for the PythonWin interactive window. Right now it just pops
-up a input() dialog. With luck, someone will integrate it into the
-actual PythonWin interactive window someday.
-
-WARNING: Importing this file automatically replaces sys.stdin with an
-instance of Stdin (below). This is useful because you can just open
-Stdin.py in PythonWin and hit the import button to get it set up right
-if you don't feel like changing PythonWin's source. To put things back
-the way they were, simply use this magic incantation:
-    import sys
-    sys.stdin = sys.stdin.real_file
-"""
-
-import sys
-
-get_input_line = input
-
-
-class Stdin:
-    def __init__(self):
-        self.real_file = sys.stdin  # NOTE: Likely to be None
-        self.buffer = ""
-        self.closed = False
-
-    def __getattr__(self, name):
-        """Forward most functions to the real sys.stdin for absolute realism."""
-        if self.real_file is None:
-            raise AttributeError(name)
-        return getattr(self.real_file, name)
-
-    def isatty(self):
-        """Return 1 if the file is connected to a tty(-like) device, else 0."""
-        return 1
-
-    def read(self, size=-1):
-        """Read at most size bytes from the file (less if the read
-        hits EOF or no more data is immediately available on a pipe,
-        tty or similar device). If the size argument is negative or
-        omitted, read all data until EOF is reached. The bytes are
-        returned as a string object. An empty string is returned when
-        EOF is encountered immediately. (For certain files, like ttys,
-        it makes sense to continue reading after an EOF is hit.)"""
-        result_size = self.__get_lines(size)
-        return self.__extract_from_buffer(result_size)
-
-    def readline(self, size=-1):
-        """Read one entire line from the file. A trailing newline
-        character is kept in the string2.6 (but may be absent when a file ends
-        with an incomplete line). If the size argument is present and
-        non-negative, it is a maximum byte count (including the trailing
-        newline) and an incomplete line may be returned. An empty string is
-        returned when EOF is hit immediately. Note: unlike stdio's fgets(),
-        the returned string contains null characters ('\0') if they occurred
-        in the input.
-        """
-        maximum_result_size = self.__get_lines(size, lambda buffer: "\n" in buffer)
-
-        if "\n" in self.buffer[:maximum_result_size]:
-            result_size = self.buffer.find("\n", 0, maximum_result_size) + 1
-            assert result_size > 0
-        else:
-            result_size = maximum_result_size
-
-        return self.__extract_from_buffer(result_size)
-
-    def __extract_from_buffer(self, character_count):
-        """Remove the first character_count characters from the internal buffer and
-        return them.
-        """
-        result = self.buffer[:character_count]
-        self.buffer = self.buffer[character_count:]
-        return result
-
-    def __get_lines(self, desired_size, done_reading=lambda buffer: False):
-        """Keep adding lines to our internal buffer until done_reading(self.buffer)
-        is true or EOF has been reached or we have desired_size bytes in the buffer.
-        If desired_size < 0, we are never satisfied until we reach EOF. If done_reading
-        is not supplied, it is not consulted.
-
-        If desired_size < 0, returns the length of the internal buffer. Otherwise,
-        returns desired_size.
-        """
-        while not done_reading(self.buffer) and (
-            desired_size < 0 or len(self.buffer) < desired_size
-        ):
-            try:
-                self.__get_line()
-            except (
-                EOFError,
-                KeyboardInterrupt,
-            ):  # deal with cancellation of get_input_line dialog
-                desired_size = len(self.buffer)  # Be satisfied!
-
-        if desired_size < 0:
-            return len(self.buffer)
-        else:
-            return desired_size
-
-    def __get_line(self):
-        """Grab one line from get_input_line() and append it to the buffer."""
-        line = get_input_line()
-        print(">>>", line)  # echo input to console
-        self.buffer = self.buffer + line + "\n"
-
-    def readlines(self, *sizehint):
-        """Read until EOF using readline() and return a list containing the lines
-        thus read. If the optional sizehint argument is present, instead of
-        reading up to EOF, whole lines totalling approximately sizehint bytes
-        (possibly after rounding up to an internal buffer size) are read.
-        """
-        result = []
-        total_read = 0
-        while sizehint == () or total_read < sizehint[0]:
-            line = self.readline()
-            if line == "":
-                break
-            total_read += len(line)
-            result.append(line)
-        return result
-
-
-if __name__ == "__main__":
-    test_input = r"""this is some test
-input that I am hoping
-~
-will be very instructive
-and when I am done
-I will have tested everything.
-Twelve and twenty blackbirds
-baked in a pie. Patty cake
-patty cake so am I.
-~
-Thirty-five niggling idiots!
-Sell you soul to the devil, baby
-"""
-
-    def fake_input(prompt=None):
-        """Replacement for input() which pulls lines out of global test_input.
-        For testing only!
-        """
-        global test_input
-        if "\n" not in test_input:
-            end_of_line_pos = len(test_input)
-        else:
-            end_of_line_pos = test_input.find("\n")
-        result = test_input[:end_of_line_pos]
-        test_input = test_input[end_of_line_pos + 1 :]
-        if len(result) == 0 or result[0] == "~":
-            raise EOFError
-        return result
-
-    get_input_line = fake_input
-
-    # Some completely inadequate tests, just to make sure the code's not totally broken
-    try:
-        x = Stdin()
-        print(x.read())
-        print(x.readline())
-        print(x.read(12))
-        print(x.readline(47))
-        print(x.readline(3))
-        print(x.readlines())
-    finally:
-        get_input_line = input
-else:
-    sys.stdin = Stdin()

py2docfx/venv/venv1/Lib/site-packages/pythonwin/pywin/framework/toolmenu.py

@@ -1,279 +0,0 @@
-# toolmenu.py
-
-import sys
-
-import win32api
-import win32con
-import win32ui
-
-tools = {}
-idPos = 100
-
-# The default items should no tools menu exist in the INI file.
-defaultToolMenuItems = [
-    ("Browser", "win32ui.GetApp().OnViewBrowse(0,0)"),
-    (
-        "Browse PythonPath",
-        "from pywin.tools import browseProjects;browseProjects.Browse()",
-    ),
-    ("Edit Python Path", "from pywin.tools import regedit;regedit.EditRegistry()"),
-    ("COM Makepy utility", "from win32com.client import makepy;makepy.main()"),
-    (
-        "COM Browser",
-        "from win32com.client import combrowse;combrowse.main(modal=False)",
-    ),
-    (
-        "Trace Collector Debugging tool",
-        "from pywin.tools import TraceCollector;TraceCollector.MakeOutputWindow()",
-    ),
-]
-
-
-def LoadToolMenuItems():
-    # Load from the registry.
-    items = []
-    lookNo = 1
-    while 1:
-        menu = win32ui.GetProfileVal("Tools Menu\\%s" % lookNo, "", "")
-        if menu == "":
-            break
-        cmd = win32ui.GetProfileVal("Tools Menu\\%s" % lookNo, "Command", "")
-        items.append((menu, cmd))
-        lookNo += 1
-
-    if len(items) == 0:
-        items = defaultToolMenuItems
-    return items
-
-
-def WriteToolMenuItems(items):
-    # Items is a list of (menu, command)
-    # Delete the entire registry tree.
-    try:
-        mainKey = win32ui.GetAppRegistryKey()
-        toolKey = win32api.RegOpenKey(mainKey, "Tools Menu")
-    except win32ui.error:
-        toolKey = None
-    if toolKey is not None:
-        while 1:
-            try:
-                subkey = win32api.RegEnumKey(toolKey, 0)
-            except win32api.error:
-                break
-            win32api.RegDeleteKey(toolKey, subkey)
-    # Keys are now removed - write the new ones.
-    # But first check if we have the defaults - and if so, don't write anything!
-    if items == defaultToolMenuItems:
-        return
-    itemNo = 1
-    for menu, cmd in items:
-        win32ui.WriteProfileVal("Tools Menu\\%s" % itemNo, "", menu)
-        win32ui.WriteProfileVal("Tools Menu\\%s" % itemNo, "Command", cmd)
-        itemNo += 1
-
-
-def SetToolsMenu(menu, menuPos=None):
-    global tools
-    global idPos
-
-    # todo - check the menu does not already exist.
-    # Create the new menu
-    toolsMenu = win32ui.CreatePopupMenu()
-
-    # Load from the ini file.
-    items = LoadToolMenuItems()
-    for menuString, cmd in items:
-        tools[idPos] = (menuString, cmd, menuString)
-        toolsMenu.AppendMenu(
-            win32con.MF_ENABLED | win32con.MF_STRING, idPos, menuString
-        )
-        win32ui.GetMainFrame().HookCommand(HandleToolCommand, idPos)
-        idPos += 1
-
-    # Find the correct spot to insert the new tools menu.
-    if menuPos is None:
-        menuPos = menu.GetMenuItemCount() - 2
-        if menuPos < 0:
-            menuPos = 0
-
-    menu.InsertMenu(
-        menuPos,
-        win32con.MF_BYPOSITION
-        | win32con.MF_ENABLED
-        | win32con.MF_STRING
-        | win32con.MF_POPUP,
-        toolsMenu.GetHandle(),
-        "&Tools",
-    )
-
-
-def HandleToolCommand(cmd, code):
-    import re
-    import traceback
-
-    global tools
-    (menuString, pyCmd, desc) = tools[cmd]
-    win32ui.SetStatusText("Executing tool %s" % desc, 1)
-    pyCmd = re.sub(r"\\n", "\n", pyCmd)
-    win32ui.DoWaitCursor(1)
-    oldFlag = None
-    try:
-        oldFlag = sys.stdout.template.writeQueueing
-        sys.stdout.template.writeQueueing = 0
-    except (NameError, AttributeError):
-        pass
-
-    try:
-        exec("%s\n" % pyCmd)
-        worked = 1
-    except SystemExit:
-        # The program raised a SystemExit - ignore it.
-        worked = 1
-    except:
-        print("Failed to execute command:\n%s" % pyCmd)
-        traceback.print_exc()
-        worked = 0
-    if oldFlag is not None:
-        sys.stdout.template.writeQueueing = oldFlag
-    win32ui.DoWaitCursor(0)
-    if worked:
-        text = "Completed successfully."
-    else:
-        text = "Error executing %s." % desc
-    win32ui.SetStatusText(text, 1)
-
-
-# The property page for maintaing the items on the Tools menu.
-import commctrl
-from pywin.mfc import dialog
-
-LVN_ENDLABELEDIT = commctrl.LVN_ENDLABELEDITW
-
-
-class ToolMenuPropPage(dialog.PropertyPage):
-    def __init__(self):
-        self.bImChangingEditControls = 0  # Am I programatically changing the controls?
-        dialog.PropertyPage.__init__(self, win32ui.IDD_PP_TOOLMENU)
-
-    def OnInitDialog(self):
-        self.editMenuCommand = self.GetDlgItem(win32ui.IDC_EDIT2)
-        self.butNew = self.GetDlgItem(win32ui.IDC_BUTTON3)
-
-        # Now hook the change notification messages for the edit controls.
-        self.HookCommand(self.OnCommandEditControls, win32ui.IDC_EDIT1)
-        self.HookCommand(self.OnCommandEditControls, win32ui.IDC_EDIT2)
-
-        self.HookNotify(self.OnNotifyListControl, commctrl.LVN_ITEMCHANGED)
-        self.HookNotify(self.OnNotifyListControlEndLabelEdit, commctrl.LVN_ENDLABELEDIT)
-
-        # Hook the button clicks.
-        self.HookCommand(self.OnButtonNew, win32ui.IDC_BUTTON3)  # New Item
-        self.HookCommand(self.OnButtonDelete, win32ui.IDC_BUTTON4)  # Delete item
-        self.HookCommand(self.OnButtonMove, win32ui.IDC_BUTTON1)  # Move up
-        self.HookCommand(self.OnButtonMove, win32ui.IDC_BUTTON2)  # Move down
-
-        # Setup the columns in the list control
-        lc = self.GetDlgItem(win32ui.IDC_LIST1)
-        rect = lc.GetWindowRect()
-        cx = rect[2] - rect[0]
-        colSize = cx / 2 - win32api.GetSystemMetrics(win32con.SM_CXBORDER) - 1
-
-        item = commctrl.LVCFMT_LEFT, colSize, "Menu Text"
-        lc.InsertColumn(0, item)
-
-        item = commctrl.LVCFMT_LEFT, colSize, "Python Command"
-        lc.InsertColumn(1, item)
-
-        # Insert the existing tools menu
-        itemNo = 0
-        for desc, cmd in LoadToolMenuItems():
-            lc.InsertItem(itemNo, desc)
-            lc.SetItemText(itemNo, 1, cmd)
-            itemNo += 1
-
-        self.listControl = lc
-        return dialog.PropertyPage.OnInitDialog(self)
-
-    def OnOK(self):
-        # Write the menu back to the registry.
-        items = []
-        itemLook = 0
-        while 1:
-            try:
-                text = self.listControl.GetItemText(itemLook, 0)
-                if not text:
-                    break
-                items.append((text, self.listControl.GetItemText(itemLook, 1)))
-            except win32ui.error:
-                # no more items!
-                break
-            itemLook += 1
-        WriteToolMenuItems(items)
-        return self._obj_.OnOK()
-
-    def OnCommandEditControls(self, id, cmd):
-        # print("OnEditControls", id, cmd)
-        if cmd == win32con.EN_CHANGE and not self.bImChangingEditControls:
-            itemNo = self.listControl.GetNextItem(-1, commctrl.LVNI_SELECTED)
-            newText = self.editMenuCommand.GetWindowText()
-            self.listControl.SetItemText(itemNo, 1, newText)
-
-        return 0
-
-    def OnNotifyListControlEndLabelEdit(self, id, cmd):
-        newText = self.listControl.GetEditControl().GetWindowText()
-        itemNo = self.listControl.GetNextItem(-1, commctrl.LVNI_SELECTED)
-        self.listControl.SetItemText(itemNo, 0, newText)
-
-    def OnNotifyListControl(self, id, cmd):
-        # print(id, cmd)
-        try:
-            itemNo = self.listControl.GetNextItem(-1, commctrl.LVNI_SELECTED)
-        except win32ui.error:  # No selection!
-            return
-
-        self.bImChangingEditControls = 1
-        try:
-            item = self.listControl.GetItem(itemNo, 1)
-            self.editMenuCommand.SetWindowText(item[4])
-        finally:
-            self.bImChangingEditControls = 0
-
-        return 0  # we have handled this!
-
-    def OnButtonNew(self, id, cmd):
-        if cmd == win32con.BN_CLICKED:
-            newIndex = self.listControl.GetItemCount()
-            self.listControl.InsertItem(newIndex, "Click to edit the text")
-            self.listControl.EnsureVisible(newIndex, 0)
-
-    def OnButtonMove(self, id, cmd):
-        if cmd == win32con.BN_CLICKED:
-            try:
-                itemNo = self.listControl.GetNextItem(-1, commctrl.LVNI_SELECTED)
-            except win32ui.error:
-                return
-            menu = self.listControl.GetItemText(itemNo, 0)
-            cmd = self.listControl.GetItemText(itemNo, 1)
-            if id == win32ui.IDC_BUTTON1:
-                # Move up
-                if itemNo > 0:
-                    self.listControl.DeleteItem(itemNo)
-                    # reinsert it.
-                    self.listControl.InsertItem(itemNo - 1, menu)
-                    self.listControl.SetItemText(itemNo - 1, 1, cmd)
-            else:
-                # Move down.
-                if itemNo < self.listControl.GetItemCount() - 1:
-                    self.listControl.DeleteItem(itemNo)
-                    # reinsert it.
-                    self.listControl.InsertItem(itemNo + 1, menu)
-                    self.listControl.SetItemText(itemNo + 1, 1, cmd)
-
-    def OnButtonDelete(self, id, cmd):
-        if cmd == win32con.BN_CLICKED:
-            try:
-                itemNo = self.listControl.GetNextItem(-1, commctrl.LVNI_SELECTED)
-            except win32ui.error:  # No selection!
-                return
-            self.listControl.DeleteItem(itemNo)

py2docfx/venv/venv1/Lib/site-packages/pythonwin/pywin/framework/window.py

@@ -1,14 +0,0 @@
-# Framework Window classes.
-
-# Most Pythonwin windows should use these classes rather than
-# the raw MFC ones if they want Pythonwin specific functionality.
-import pywin.mfc.window
-import win32con
-
-
-class MDIChildWnd(pywin.mfc.window.MDIChildWnd):
-    def AutoRestore(self):
-        "If the window is minimised or maximised, restore it."
-        p = self.GetWindowPlacement()
-        if p[1] == win32con.SW_MINIMIZE or p[1] == win32con.SW_SHOWMINIMIZED:
-            self.SetWindowPlacement(p[0], win32con.SW_RESTORE, p[2], p[3], p[4])