py2docfx 0.1.15.dev2025501__py3-none-any.whl → 0.1.15.dev2038808__py3-none-any.whl

py2docfx/venv/venv1/Lib/site-packages/win32/scripts/VersionStamp/bulkstamp.py

@@ -1,156 +0,0 @@
-#
-# bulkstamp.py:
-#    Stamp versions on all files that can be found in a given tree.
-#
-# USAGE: python bulkstamp.py <version> <root directory> <descriptions>
-#
-# Example: python bulkstamp.py 103 ..\win32\Build\ desc.txt
-#
-# <version> corresponds to the build number. It will be concatenated with
-# the major and minor version numbers found in the description file.
-#
-# Description information is pulled from an input text file with lines of
-# the form:
-#
-#    <basename> <white space> <description>
-#
-# For example:
-#
-#    PyWinTypes.dll Common types for Python on Win32
-#    etc
-#
-# The product's name, major, and minor versions are specified as:
-#
-#    name <white space> <value>
-#    major <white space> <value>
-#    minor <white space> <value>
-#
-# The tags are case-sensitive.
-#
-# Any line beginning with "#" will be ignored. Empty lines are okay.
-#
-
-import fnmatch
-import os
-import sys
-from collections.abc import Mapping
-from optparse import Values
-
-try:
-    import win32verstamp
-except ModuleNotFoundError:
-    # If run with pywin32 not already installed
-    sys.path.append(os.path.abspath(__file__ + "/../../../Lib"))
-    import win32verstamp
-
-g_patterns = [
-    "*.dll",
-    "*.pyd",
-    "*.exe",
-    "*.ocx",
-]
-
-
-def walk(vars: Mapping[str, str], debug, descriptions, dirname, names) -> int:
-    """Returns the number of stamped files."""
-    numStamped = 0
-    for name in names:
-        for pat in g_patterns:
-            if fnmatch.fnmatch(name, pat):
-                # Handle the "_d" thing.
-                pathname = os.path.join(dirname, name)
-                base, ext = os.path.splitext(name)
-                if base.endswith("_d"):
-                    name = base[:-2] + ext
-                is_dll = ext.lower() != ".exe"
-                if os.path.normcase(name) in descriptions:
-                    description = descriptions[os.path.normcase(name)]
-                    try:
-                        options = Values(
-                            {**vars, "description": description, "dll": is_dll}
-                        )
-                        win32verstamp.stamp(pathname, options)
-                        numStamped += 1
-                    except OSError as exc:
-                        print(
-                            "Could not stamp",
-                            pathname,
-                            "Error",
-                            exc.winerror,
-                            "-",
-                            exc.strerror,
-                        )
-                else:
-                    print("WARNING: description not provided for:", name)
-                    # skip branding this - assume already branded or handled elsewhere
-    return numStamped
-
-
-# print("Stamped", pathname)
-
-
-def load_descriptions(fname, vars):
-    retvars: dict[str, str] = {}
-    descriptions = {}
-
-    lines = open(fname, "r").readlines()
-
-    for i in range(len(lines)):
-        line = lines[i].strip()
-        if line != "" and line[0] != "#":
-            idx1 = line.find(" ")
-            idx2 = line.find("\t")
-            if idx1 == -1 or idx2 < idx1:
-                idx1 = idx2
-            if idx1 == -1:
-                print("ERROR: bad syntax in description file at line %d." % (i + 1))
-                sys.exit(1)
-
-            key = line[:idx1]
-            val = line[idx1:].strip()
-            if key in vars:
-                retvars[key] = val
-            else:
-                descriptions[key] = val
-
-    if "product" not in retvars:
-        print("ERROR: description file is missing the product name.")
-        sys.exit(1)
-    if "major" not in retvars:
-        print("ERROR: description file is missing the major version number.")
-        sys.exit(1)
-    if "minor" not in retvars:
-        print("ERROR: description file is missing the minor version number.")
-        sys.exit(1)
-
-    return retvars, descriptions
-
-
-def scan(build, root: str, desc, **custom_vars):
-    try:
-        build = int(build)
-    except ValueError:
-        print("ERROR: build number is not a number: %s" % build)
-        sys.exit(1)
-
-    debug = 0  ### maybe fix this one day
-
-    varList = ["major", "minor", "sub", "company", "copyright", "trademarks", "product"]
-
-    vars, descriptions = load_descriptions(desc, varList)
-    vars["build"] = build
-    vars.update(custom_vars)
-
-    numStamped = 0
-    for directory, dirnames, filenames in os.walk(root):
-        numStamped += walk(vars, debug, descriptions, directory, filenames)
-
-    print(f"Stamped {numStamped} files.")
-
-
-if __name__ == "__main__":
-    if len(sys.argv) != 4:
-        print("ERROR: incorrect invocation. See script's header comments.")
-        sys.exit(1)
-
-    scan(*sys.argv[1:])

py2docfx/venv/venv1/Lib/site-packages/win32/scripts/VersionStamp/vssutil.py

@@ -1,201 +0,0 @@
-import time
-import traceback
-
-import pythoncom
-import win32com.client
-import win32com.client.gencache
-import win32con
-
-constants = win32com.client.constants
-
-win32com.client.gencache.EnsureModule("{783CD4E0-9D54-11CF-B8EE-00608CC9A71F}", 0, 5, 0)
-
-
-def GetSS():
-    ss = win32com.client.Dispatch("SourceSafe")
-    # SS seems a bit weird.  It defaults the arguments as empty strings, but
-    # then complains when they are used - so we pass "Missing"
-    ss.Open(pythoncom.Missing, pythoncom.Missing, pythoncom.Missing)
-    return ss
-
-
-def test(projectName):
-    ss = GetSS()
-    project = ss.VSSItem(projectName)
-
-    for item in project.GetVersions(constants.VSSFLAG_RECURSYES):
-        print(item.VSSItem.Name, item.VersionNumber, item.Action)
-
-    # item=i.Versions[0].VSSItem
-    # for h in i.Versions:
-    #     print("h.Comment", h.Action, h.VSSItem.Name)
-
-
-def SubstituteInString(inString, evalEnv):
-    substChar = "$"
-    fields = inString.split(substChar)
-    newFields = []
-    for i in range(len(fields)):
-        didSubst = 0
-        strVal = fields[i]
-        if i % 2 != 0:
-            try:
-                strVal = eval(strVal, evalEnv[0], evalEnv[1])
-                newFields.append(strVal)
-                didSubst = 1
-            except:
-                traceback.print_exc()
-                print("Could not substitute", strVal)
-        if not didSubst:
-            newFields.append(strVal)
-    return "".join(map(str, newFields))
-
-
-def SubstituteInFile(inName, outName, evalEnv):
-    inFile = open(inName, "r")
-    try:
-        outFile = open(outName, "w")
-        try:
-            while 1:
-                line = inFile.read()
-                if not line:
-                    break
-                outFile.write(SubstituteInString(line, evalEnv))
-        finally:
-            outFile.close()
-    finally:
-        inFile.close()
-
-
-def VssLog(project, linePrefix="", noLabels=5, maxItems=150):
-    lines = []
-    num = 0
-    labelNum = 0
-    for i in project.GetVersions(constants.VSSFLAG_RECURSYES):
-        num += 1
-        if num > maxItems:
-            break
-        commentDesc = itemDesc = ""
-        if i.Action[:5] == "Added":
-            continue
-        if len(i.Label):
-            labelNum += 1
-            itemDesc = i.Action
-        else:
-            itemDesc = i.VSSItem.Name
-            if str(itemDesc[-4:]) == ".dsp":
-                continue
-        if i.Comment:
-            commentDesc = f"\n{linePrefix}\t{i.Comment}"
-        lines.append(
-            "{}{}\t{}{}".format(
-                linePrefix,
-                time.asctime(time.localtime(int(i.Date))),
-                itemDesc,
-                commentDesc,
-            )
-        )
-        if labelNum > noLabels:
-            break
-    return "\n".join(lines)
-
-
-def SubstituteVSSInFile(projectName, inName, outName):
-    import win32api
-
-    if win32api.GetFullPathName(inName) == win32api.GetFullPathName(outName):
-        raise RuntimeError("The input and output filenames can not be the same")
-    sourceSafe = GetSS()
-    project = sourceSafe.VSSItem(projectName)
-    # Find the last label
-    label = None
-    for version in project.Versions:
-        if version.Label:
-            break
-    else:
-        print("Couldn't find a label in the sourcesafe project!")
-        return
-    # Setup some local helpers for the conversion strings.
-    vss_label = version.Label
-    vss_date = time.asctime(time.localtime(int(version.Date)))
-    now = time.asctime(time.localtime(time.time()))
-    SubstituteInFile(inName, outName, (locals(), globals()))
-
-
-def CountCheckouts(item):
-    num = 0
-    if item.Type == constants.VSSITEM_PROJECT:
-        for sub in item.Items:
-            num += CountCheckouts(sub)
-    else:
-        if item.IsCheckedOut:
-            num += 1
-    return num
-
-
-def GetLastBuildNo(project):
-    i = GetSS().VSSItem(project)
-    # Find the last label
-    lab = None
-    for version in i.Versions:
-        lab = str(version.Label)
-        if lab:
-            return lab
-    return None
-
-
-def MakeNewBuildNo(project, buildDesc=None, auto=0, bRebrand=0):
-    if buildDesc is None:
-        buildDesc = "Created by Python"
-    ss = GetSS()
-    i = ss.VSSItem(project)
-    num = CountCheckouts(i)
-    if num > 0:
-        msg = (
-            "This project has %d items checked out\r\n\r\nDo you still want to continue?"
-            % num
-        )
-        import win32ui
-
-        if win32ui.MessageBox(msg, project, win32con.MB_YESNO) != win32con.IDYES:
-            return
-
-    oldBuild = buildNo = GetLastBuildNo(project)
-    if buildNo is None:
-        buildNo = "1"
-        oldBuild = "<None>"
-    else:
-        try:
-            buildNo = int(buildNo)
-            if not bRebrand:
-                buildNo += 1
-            buildNo = str(buildNo)
-        except ValueError as error:
-            raise ValueError(
-                f"The previous label could not be incremented: {oldBuild}"
-            ) from error
-
-    if not auto:
-        from pywin.mfc import dialog
-
-        buildNo = dialog.GetSimpleInput(
-            "Enter new build number", buildNo, f"{project} - Prev: {oldBuild}"
-        )
-        if buildNo is None:
-            return
-    i.Label(buildNo, f"Build {buildNo}: {buildDesc}")
-    if auto:
-        print(f"Branded project {project} with label {buildNo}")
-    return buildNo
-
-
-if __name__ == "__main__":
-    # 	UpdateWiseExeName("PyWiseTest.wse", "PyWiseTest-10.exe")
-
-    # 	MakeVersion()
-    # 	test(tp)
-    # 	MakeNewBuildNo(tp)
-    tp = "\\Python\\Python Win32 Extensions"
-    SubstituteVSSInFile(
-        tp, "d:\\src\\pythonex\\win32\\win32.txt", "d:\\temp\\win32.txt"
-    )

py2docfx/venv/venv1/Lib/site-packages/win32/scripts/backupEventLog.py

@@ -1,46 +0,0 @@
-# Generate a base file name
-import os
-import time
-
-import win32api
-import win32evtlog
-
-
-def BackupClearLog(logType):
-    datePrefix = time.strftime("%Y%m%d", time.localtime(time.time()))
-    fileExists = 1
-    retry = 0
-    while fileExists:
-        if retry == 0:
-            index = ""
-        else:
-            index = "-%d" % retry
-        try:
-            fname = os.path.join(
-                win32api.GetTempPath(),
-                f"{datePrefix}{index}-{logType}" + ".evt",
-            )
-            os.stat(fname)
-        except OSError:
-            fileExists = 0
-        retry += 1
-    # OK - have unique file name.
-    try:
-        hlog = win32evtlog.OpenEventLog(None, logType)
-    except win32evtlog.error as details:
-        print("Could not open the event log", details)
-        return
-    try:
-        if win32evtlog.GetNumberOfEventLogRecords(hlog) == 0:
-            print("No records in event log %s - not backed up" % logType)
-            return
-        win32evtlog.ClearEventLog(hlog, fname)
-        print(f"Backed up {logType} log to {fname}")
-    finally:
-        win32evtlog.CloseEventLog(hlog)
-
-
-if __name__ == "__main__":
-    BackupClearLog("Application")
-    BackupClearLog("System")
-    BackupClearLog("Security")

py2docfx/venv/venv1/Lib/site-packages/win32/scripts/h2py.py

@@ -1,194 +0,0 @@
-#! /usr/bin/env python3
-"""
-Vendored from https://github.com/python/cpython/blob/3.8/Tools/scripts/h2py.py
-
-Changes since vendored version:
-- Minimal changes to satisfy our checkers.
-- Rename `p_hex` to `p_signed_hex` and improve to include lowercase l
-- Fixed `pytify` to remove leftover L after numbers and actually compute negative hexadecimal constants
-- Added `p_int_cast` and `p_literal_constant`
-
----
-
-Read #define's and translate to Python code.
-Handle #include statements.
-Handle #define macros with one argument.
-Anything that isn't recognized or doesn't translate into valid
-Python is ignored.
-
-Without filename arguments, acts as a filter.
-If one or more filenames are given, output is written to corresponding
-filenames in the local directory, translated to all uppercase, with
-the extension replaced by ".py".
-
-By passing one or more options of the form "-i regular_expression"
-you can specify additional strings to be ignored.  This is useful
-e.g. to ignore casts to u_long: simply specify "-i '(u_long)'".
-"""
-
-# XXX To do:
-# - turn trailing C comments into Python comments
-# - turn C Boolean operators "&& || !" into Python "and or not"
-# - what to do about #if(def)?
-# - what to do about macros with multiple parameters?
-from __future__ import annotations
-
-import ctypes
-import getopt
-import os
-import re
-import sys
-
-p_define = re.compile(r"^[\t ]*#[\t ]*define[\t ]+([a-zA-Z0-9_]+)[\t ]+")
-
-p_macro = re.compile(
-    r"^[\t ]*#[\t ]*define[\t ]+" r"([a-zA-Z0-9_]+)\(([_a-zA-Z][_a-zA-Z0-9]*)\)[\t ]+"
-)
-
-p_include = re.compile(r"^[\t ]*#[\t ]*include[\t ]+<([^>\n]+)>")
-
-p_comment = re.compile(r"/\*([^*]+|\*+[^/])*(\*+/)?")
-p_cpp_comment = re.compile("//.*")
-# Maybe we want these to cause integer truncation instead?
-p_int_cast = re.compile(r"\((DWORD|HRESULT|SCODE|LONG|HWND|HANDLE|int|HBITMAP)\)")
-
-ignores = [p_comment, p_cpp_comment, p_int_cast]
-
-p_char = re.compile(r"'(\\.[^\\]*|[^\\])'")
-p_signed_hex = re.compile(r"0x([0-9a-fA-F]+)[lL]?")
-p_literal_constant = re.compile(r"((0x[0-9a-fA-F]+?)|([0-9]+?))[uUlL]")
-
-filedict: dict[str, None] = {}
-importable: dict[str, str] = {}
-
-try:
-    searchdirs = os.environ["include"].split(";")
-except KeyError:
-    try:
-        searchdirs = os.environ["INCLUDE"].split(";")
-    except KeyError:
-        searchdirs = ["/usr/include"]
-        try:
-            searchdirs.insert(0, os.path.join("/usr/include", os.environ["MULTIARCH"]))
-        except KeyError:
-            pass
-
-
-def main():
-    global filedict
-    opts, args = getopt.getopt(sys.argv[1:], "i:")
-    for o, a in opts:
-        if o == "-i":
-            ignores.append(re.compile(a))
-    if not args:
-        args = ["-"]
-    for filename in args:
-        if filename == "-":
-            sys.stdout.write("# Generated by h2py from stdin\n")
-            process(sys.stdin, sys.stdout)
-        else:
-            with open(filename) as fp:
-                outfile = os.path.basename(filename)
-                i = outfile.rfind(".")
-                if i > 0:
-                    outfile = outfile[:i]
-                modname = outfile.upper()
-                outfile = modname + ".py"
-                with open(outfile, "w") as outfp:
-                    outfp.write("# Generated by h2py from %s\n" % filename)
-                    filedict = {}
-                    for dir in searchdirs:
-                        if filename[: len(dir)] == dir:
-                            filedict[filename[len(dir) + 1 :]] = None  # no '/' trailing
-                            importable[filename[len(dir) + 1 :]] = modname
-                            break
-                    process(fp, outfp)
-
-
-def pytify(body):
-    # replace ignored patterns by spaces
-    for p in ignores:
-        body = p.sub(" ", body)
-    # replace char literals by ord(...)
-    body = p_char.sub("ord('\\1')", body)
-    # Compute negative hexadecimal constants
-    start = 0
-    while 1:
-        m = p_signed_hex.search(body, start)
-        if not m:
-            break
-        s, e = m.span()
-        val = ctypes.c_int32(int(body[slice(*m.span(1))], 16)).value
-        if val < 0:
-            body = body[:s] + "(" + str(val) + ")" + body[e:]
-        start = s + 1
-    # remove literal constant indicator (u U l L)
-    body = p_literal_constant.sub("\\1", body)
-    return body
-
-
-def process(fp, outfp, env={}):
-    lineno = 0
-    while 1:
-        line = fp.readline()
-        if not line:
-            break
-        lineno = lineno + 1
-        match = p_define.match(line)
-        if match:
-            # gobble up continuation lines
-            while line[-2:] == "\\\n":
-                nextline = fp.readline()
-                if not nextline:
-                    break
-                lineno = lineno + 1
-                line = line + nextline
-            name = match.group(1)
-            body = line[match.end() :]
-            body = pytify(body)
-            ok = 0
-            stmt = "%s = %s\n" % (name, body.strip())
-            try:
-                exec(stmt, env)
-            except:
-                sys.stderr.write("Skipping: %s" % stmt)
-            else:
-                outfp.write(stmt)
-        match = p_macro.match(line)
-        if match:
-            macro, arg = match.group(1, 2)
-            body = line[match.end() :]
-            body = pytify(body)
-            stmt = "def %s(%s): return %s\n" % (macro, arg, body)
-            try:
-                exec(stmt, env)
-            except:
-                sys.stderr.write("Skipping: %s" % stmt)
-            else:
-                outfp.write(stmt)
-        match = p_include.match(line)
-        if match:
-            regs = match.regs
-            a, b = regs[1]
-            filename = line[a:b]
-            if filename in importable:
-                outfp.write("from %s import *\n" % importable[filename])
-            elif filename not in filedict:
-                filedict[filename] = None
-                inclfp = None
-                for dir in searchdirs:
-                    try:
-                        inclfp = open(dir + "/" + filename)
-                        break
-                    except IOError:
-                        pass
-                if inclfp:
-                    with inclfp:
-                        outfp.write("\n# Included from %s\n" % filename)
-                        process(inclfp, outfp, env)
-                else:
-                    sys.stderr.write("Warning - could not find file %s\n" % filename)
-
-
-if __name__ == "__main__":
-    main()

py2docfx/venv/venv1/Lib/site-packages/win32/scripts/killProcName.py

@@ -1,62 +0,0 @@
-# Kills a process by process name
-#
-# Uses the Performance Data Helper to locate the PID, then kills it.
-# Will only kill the process if there is only one process of that name
-# (eg, attempting to kill "Python.exe" will only work if there is only
-# one Python.exe running.  (Note that the current process does not
-# count - ie, if Python.exe is hosting this script, you can still kill
-# another Python.exe (as long as there is only one other Python.exe)
-
-# Really just a demo for the win32pdh(util) module, which allows you
-# to get all sorts of information about a running process and many
-# other aspects of your system.
-
-import sys
-
-import win32api
-import win32con
-import win32pdhutil
-
-
-def killProcName(procname):
-    # Change suggested by Dan Knierim, who found that this performed a
-    # "refresh", allowing us to kill processes created since this was run
-    # for the first time.
-    try:
-        win32pdhutil.GetPerformanceAttributes("Process", "ID Process", procname)
-    except:
-        pass
-
-    pids = win32pdhutil.FindPerformanceAttributesByName(procname)
-
-    # If _my_ pid in there, remove it!
-    try:
-        pids.remove(win32api.GetCurrentProcessId())
-    except ValueError:
-        pass
-
-    if len(pids) == 0:
-        result = "Can't find %s" % procname
-    elif len(pids) > 1:
-        result = f"Found too many {procname}'s - pids=`{pids}`"
-    else:
-        handle = win32api.OpenProcess(win32con.PROCESS_TERMINATE, 0, pids[0])
-        win32api.TerminateProcess(handle, 0)
-        win32api.CloseHandle(handle)
-        result = ""
-
-    return result
-
-
-if __name__ == "__main__":
-    if len(sys.argv) > 1:
-        for procname in sys.argv[1:]:
-            result = killProcName(procname)
-            if result:
-                print(result)
-                print("Dumping all processes...")
-                win32pdhutil.ShowAllProcesses()
-            else:
-                print("Killed %s" % procname)
-    else:
-        print("Usage: killProcName.py procname ...")