wsba-hockey 1.1.8__py3-none-any.whl → 1.2.0__py3-none-any.whl

wsba_hockey/evidence/weakside-breakout/node_modules/sqlite3/node_modules/node-gyp/gyp/pylib/gyp/xml_fix.py

@@ -1,65 +0,0 @@
-# Copyright (c) 2011 Google Inc. All rights reserved.
-# Use of this source code is governed by a BSD-style license that can be
-# found in the LICENSE file.
-
-"""Applies a fix to CR LF TAB handling in xml.dom.
-
-Fixes this: http://code.google.com/p/chromium/issues/detail?id=76293
-Working around this: http://bugs.python.org/issue5752
-TODO(bradnelson): Consider dropping this when we drop XP support.
-"""
-
-
-import xml.dom.minidom
-
-
-def _Replacement_write_data(writer, data, is_attrib=False):
-    """Writes datachars to writer."""
-    data = data.replace("&", "&amp;").replace("<", "&lt;")
-    data = data.replace('"', "&quot;").replace(">", "&gt;")
-    if is_attrib:
-        data = data.replace("\r", "&#xD;").replace("\n", "&#xA;").replace("\t", "&#x9;")
-    writer.write(data)
-
-
-def _Replacement_writexml(self, writer, indent="", addindent="", newl=""):
-    # indent = current indentation
-    # addindent = indentation to add to higher levels
-    # newl = newline string
-    writer.write(indent + "<" + self.tagName)
-
-    attrs = self._get_attributes()
-    a_names = sorted(attrs.keys())
-
-    for a_name in a_names:
-        writer.write(' %s="' % a_name)
-        _Replacement_write_data(writer, attrs[a_name].value, is_attrib=True)
-        writer.write('"')
-    if self.childNodes:
-        writer.write(">%s" % newl)
-        for node in self.childNodes:
-            node.writexml(writer, indent + addindent, addindent, newl)
-        writer.write(f"{indent}</{self.tagName}>{newl}")
-    else:
-        writer.write("/>%s" % newl)
-
-
-class XmlFix:
-    """Object to manage temporary patching of xml.dom.minidom."""
-
-    def __init__(self):
-        # Preserve current xml.dom.minidom functions.
-        self.write_data = xml.dom.minidom._write_data
-        self.writexml = xml.dom.minidom.Element.writexml
-        # Inject replacement versions of a function and a method.
-        xml.dom.minidom._write_data = _Replacement_write_data
-        xml.dom.minidom.Element.writexml = _Replacement_writexml
-
-    def Cleanup(self):
-        if self.write_data:
-            xml.dom.minidom._write_data = self.write_data
-            xml.dom.minidom.Element.writexml = self.writexml
-            self.write_data = None
-
-    def __del__(self):
-        self.Cleanup()

wsba_hockey/evidence/weakside-breakout/node_modules/sqlite3/node_modules/node-gyp/gyp/setup.py

@@ -1,42 +0,0 @@
-#!/usr/bin/env python3
-
-# Copyright (c) 2009 Google Inc. All rights reserved.
-# Use of this source code is governed by a BSD-style license that can be
-# found in the LICENSE file.
-
-from os import path
-
-from setuptools import setup
-
-here = path.abspath(path.dirname(__file__))
-# Get the long description from the README file
-with open(path.join(here, "README.md")) as in_file:
-    long_description = in_file.read()
-
-setup(
-    name="gyp-next",
-    version="0.10.0",
-    description="A fork of the GYP build system for use in the Node.js projects",
-    long_description=long_description,
-    long_description_content_type="text/markdown",
-    author="Node.js contributors",
-    author_email="ryzokuken@disroot.org",
-    url="https://github.com/nodejs/gyp-next",
-    package_dir={"": "pylib"},
-    packages=["gyp", "gyp.generator"],
-    entry_points={"console_scripts": ["gyp=gyp:script_main"]},
-    python_requires=">=3.6",
-    classifiers=[
-        "Development Status :: 3 - Alpha",
-        "Environment :: Console",
-        "Intended Audience :: Developers",
-        "License :: OSI Approved :: BSD License",
-        "Natural Language :: English",
-        "Programming Language :: Python",
-        "Programming Language :: Python :: 3",
-        "Programming Language :: Python :: 3.6",
-        "Programming Language :: Python :: 3.7",
-        "Programming Language :: Python :: 3.8",
-        "Programming Language :: Python :: 3.9",
-    ],
-)

wsba_hockey/evidence/weakside-breakout/node_modules/sqlite3/node_modules/node-gyp/gyp/test_gyp.py

@@ -1,260 +0,0 @@
-#!/usr/bin/env python3
-# Copyright (c) 2012 Google Inc. All rights reserved.
-# Use of this source code is governed by a BSD-style license that can be
-# found in the LICENSE file.
-
-"""gyptest.py -- test runner for GYP tests."""
-
-
-import argparse
-import os
-import platform
-import subprocess
-import sys
-import time
-
-
-def is_test_name(f):
-    return f.startswith("gyptest") and f.endswith(".py")
-
-
-def find_all_gyptest_files(directory):
-    result = []
-    for root, dirs, files in os.walk(directory):
-        result.extend([os.path.join(root, f) for f in files if is_test_name(f)])
-    result.sort()
-    return result
-
-
-def main(argv=None):
-    if argv is None:
-        argv = sys.argv
-
-    parser = argparse.ArgumentParser()
-    parser.add_argument("-a", "--all", action="store_true", help="run all tests")
-    parser.add_argument("-C", "--chdir", action="store", help="change to directory")
-    parser.add_argument(
-        "-f",
-        "--format",
-        action="store",
-        default="",
-        help="run tests with the specified formats",
-    )
-    parser.add_argument(
-        "-G",
-        "--gyp_option",
-        action="append",
-        default=[],
-        help="Add -G options to the gyp command line",
-    )
-    parser.add_argument(
-        "-l", "--list", action="store_true", help="list available tests and exit"
-    )
-    parser.add_argument(
-        "-n",
-        "--no-exec",
-        action="store_true",
-        help="no execute, just print the command line",
-    )
-    parser.add_argument(
-        "--path", action="append", default=[], help="additional $PATH directory"
-    )
-    parser.add_argument(
-        "-q",
-        "--quiet",
-        action="store_true",
-        help="quiet, don't print anything unless there are failures",
-    )
-    parser.add_argument(
-        "-v",
-        "--verbose",
-        action="store_true",
-        help="print configuration info and test results.",
-    )
-    parser.add_argument("tests", nargs="*")
-    args = parser.parse_args(argv[1:])
-
-    if args.chdir:
-        os.chdir(args.chdir)
-
-    if args.path:
-        extra_path = [os.path.abspath(p) for p in args.path]
-        extra_path = os.pathsep.join(extra_path)
-        os.environ["PATH"] = extra_path + os.pathsep + os.environ["PATH"]
-
-    if not args.tests:
-        if not args.all:
-            sys.stderr.write("Specify -a to get all tests.\n")
-            return 1
-        args.tests = ["test"]
-
-    tests = []
-    for arg in args.tests:
-        if os.path.isdir(arg):
-            tests.extend(find_all_gyptest_files(os.path.normpath(arg)))
-        else:
-            if not is_test_name(os.path.basename(arg)):
-                print(arg, "is not a valid gyp test name.", file=sys.stderr)
-                sys.exit(1)
-            tests.append(arg)
-
-    if args.list:
-        for test in tests:
-            print(test)
-        sys.exit(0)
-
-    os.environ["PYTHONPATH"] = os.path.abspath("test/lib")
-
-    if args.verbose:
-        print_configuration_info()
-
-    if args.gyp_option and not args.quiet:
-        print("Extra Gyp options: %s\n" % args.gyp_option)
-
-    if args.format:
-        format_list = args.format.split(",")
-    else:
-        format_list = {
-            "aix5": ["make"],
-            "freebsd7": ["make"],
-            "freebsd8": ["make"],
-            "openbsd5": ["make"],
-            "cygwin": ["msvs"],
-            "win32": ["msvs", "ninja"],
-            "linux": ["make", "ninja"],
-            "linux2": ["make", "ninja"],
-            "linux3": ["make", "ninja"],
-            # TODO: Re-enable xcode-ninja.
-            # https://bugs.chromium.org/p/gyp/issues/detail?id=530
-            # 'darwin':   ['make', 'ninja', 'xcode', 'xcode-ninja'],
-            "darwin": ["make", "ninja", "xcode"],
-        }[sys.platform]
-
-    gyp_options = []
-    for option in args.gyp_option:
-        gyp_options += ["-G", option]
-
-    runner = Runner(format_list, tests, gyp_options, args.verbose)
-    runner.run()
-
-    if not args.quiet:
-        runner.print_results()
-
-    return 1 if runner.failures else 0
-
-
-def print_configuration_info():
-    print("Test configuration:")
-    if sys.platform == "darwin":
-        sys.path.append(os.path.abspath("test/lib"))
-        import TestMac
-
-        print(f"  Mac {platform.mac_ver()[0]} {platform.mac_ver()[2]}")
-        print(f"  Xcode {TestMac.Xcode.Version()}")
-    elif sys.platform == "win32":
-        sys.path.append(os.path.abspath("pylib"))
-        import gyp.MSVSVersion
-
-        print("  Win %s %s\n" % platform.win32_ver()[0:2])
-        print("  MSVS %s" % gyp.MSVSVersion.SelectVisualStudioVersion().Description())
-    elif sys.platform in ("linux", "linux2"):
-        print("  Linux %s" % " ".join(platform.linux_distribution()))
-    print(f"  Python {platform.python_version()}")
-    print(f"  PYTHONPATH={os.environ['PYTHONPATH']}")
-    print()
-
-
-class Runner:
-    def __init__(self, formats, tests, gyp_options, verbose):
-        self.formats = formats
-        self.tests = tests
-        self.verbose = verbose
-        self.gyp_options = gyp_options
-        self.failures = []
-        self.num_tests = len(formats) * len(tests)
-        num_digits = len(str(self.num_tests))
-        self.fmt_str = "[%%%dd/%%%dd] (%%s) %%s" % (num_digits, num_digits)
-        self.isatty = sys.stdout.isatty() and not self.verbose
-        self.env = os.environ.copy()
-        self.hpos = 0
-
-    def run(self):
-        run_start = time.time()
-
-        i = 1
-        for fmt in self.formats:
-            for test in self.tests:
-                self.run_test(test, fmt, i)
-                i += 1
-
-        if self.isatty:
-            self.erase_current_line()
-
-        self.took = time.time() - run_start
-
-    def run_test(self, test, fmt, i):
-        if self.isatty:
-            self.erase_current_line()
-
-        msg = self.fmt_str % (i, self.num_tests, fmt, test)
-        self.print_(msg)
-
-        start = time.time()
-        cmd = [sys.executable, test] + self.gyp_options
-        self.env["TESTGYP_FORMAT"] = fmt
-        proc = subprocess.Popen(
-            cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, env=self.env
-        )
-        proc.wait()
-        took = time.time() - start
-
-        stdout = proc.stdout.read().decode("utf8")
-        if proc.returncode == 2:
-            res = "skipped"
-        elif proc.returncode:
-            res = "failed"
-            self.failures.append(f"({test}) {fmt}")
-        else:
-            res = "passed"
-        res_msg = f" {res} {took:.3f}s"
-        self.print_(res_msg)
-
-        if stdout and not stdout.endswith(("PASSED\n", "NO RESULT\n")):
-            print()
-            print("\n".join(f"    {line}" for line in stdout.splitlines()))
-        elif not self.isatty:
-            print()
-
-    def print_(self, msg):
-        print(msg, end="")
-        index = msg.rfind("\n")
-        if index == -1:
-            self.hpos += len(msg)
-        else:
-            self.hpos = len(msg) - index
-        sys.stdout.flush()
-
-    def erase_current_line(self):
-        print("\b" * self.hpos + " " * self.hpos + "\b" * self.hpos, end="")
-        sys.stdout.flush()
-        self.hpos = 0
-
-    def print_results(self):
-        num_failures = len(self.failures)
-        if num_failures:
-            print()
-            if num_failures == 1:
-                print("Failed the following test:")
-            else:
-                print("Failed the following %d tests:" % num_failures)
-            print("\t" + "\n\t".join(sorted(self.failures)))
-            print()
-        print(
-            "Ran %d tests in %.3fs, %d failed."
-            % (self.num_tests, self.took, num_failures)
-        )
-        print()
-
-
-if __name__ == "__main__":
-    sys.exit(main())

wsba_hockey/evidence/weakside-breakout/node_modules/sqlite3/node_modules/node-gyp/gyp/tools/graphviz.py

@@ -1,102 +0,0 @@
-#!/usr/bin/env python3
-
-# Copyright (c) 2011 Google Inc. All rights reserved.
-# Use of this source code is governed by a BSD-style license that can be
-# found in the LICENSE file.
-
-"""Using the JSON dumped by the dump-dependency-json generator,
-generate input suitable for graphviz to render a dependency graph of
-targets."""
-
-
-import collections
-import json
-import sys
-
-
-def ParseTarget(target):
-    target, _, suffix = target.partition("#")
-    filename, _, target = target.partition(":")
-    return filename, target, suffix
-
-
-def LoadEdges(filename, targets):
-    """Load the edges map from the dump file, and filter it to only
-  show targets in |targets| and their depedendents."""
-
-    file = open("dump.json")
-    edges = json.load(file)
-    file.close()
-
-    # Copy out only the edges we're interested in from the full edge list.
-    target_edges = {}
-    to_visit = targets[:]
-    while to_visit:
-        src = to_visit.pop()
-        if src in target_edges:
-            continue
-        target_edges[src] = edges[src]
-        to_visit.extend(edges[src])
-
-    return target_edges
-
-
-def WriteGraph(edges):
-    """Print a graphviz graph to stdout.
-  |edges| is a map of target to a list of other targets it depends on."""
-
-    # Bucket targets by file.
-    files = collections.defaultdict(list)
-    for src, dst in edges.items():
-        build_file, target_name, toolset = ParseTarget(src)
-        files[build_file].append(src)
-
-    print("digraph D {")
-    print("  fontsize=8")  # Used by subgraphs.
-    print("  node [fontsize=8]")
-
-    # Output nodes by file.  We must first write out each node within
-    # its file grouping before writing out any edges that may refer
-    # to those nodes.
-    for filename, targets in files.items():
-        if len(targets) == 1:
-            # If there's only one node for this file, simplify
-            # the display by making it a box without an internal node.
-            target = targets[0]
-            build_file, target_name, toolset = ParseTarget(target)
-            print(
-                f'  "{target}" [shape=box, label="{filename}\\n{target_name}"]'
-            )
-        else:
-            # Group multiple nodes together in a subgraph.
-            print('  subgraph "cluster_%s" {' % filename)
-            print('    label = "%s"' % filename)
-            for target in targets:
-                build_file, target_name, toolset = ParseTarget(target)
-                print(f'    "{target}" [label="{target_name}"]')
-            print("  }")
-
-    # Now that we've placed all the nodes within subgraphs, output all
-    # the edges between nodes.
-    for src, dsts in edges.items():
-        for dst in dsts:
-            print(f'  "{src}" -> "{dst}"')
-
-    print("}")
-
-
-def main():
-    if len(sys.argv) < 2:
-        print(__doc__, file=sys.stderr)
-        print(file=sys.stderr)
-        print("usage: %s target1 target2..." % (sys.argv[0]), file=sys.stderr)
-        return 1
-
-    edges = LoadEdges("dump.json", sys.argv[1:])
-
-    WriteGraph(edges)
-    return 0
-
-
-if __name__ == "__main__":
-    sys.exit(main())

wsba_hockey/evidence/weakside-breakout/node_modules/sqlite3/node_modules/node-gyp/gyp/tools/pretty_gyp.py

@@ -1,156 +0,0 @@
-#!/usr/bin/env python3
-
-# Copyright (c) 2012 Google Inc. All rights reserved.
-# Use of this source code is governed by a BSD-style license that can be
-# found in the LICENSE file.
-
-"""Pretty-prints the contents of a GYP file."""
-
-
-import sys
-import re
-
-
-# Regex to remove comments when we're counting braces.
-COMMENT_RE = re.compile(r"\s*#.*")
-
-# Regex to remove quoted strings when we're counting braces.
-# It takes into account quoted quotes, and makes sure that the quotes match.
-# NOTE: It does not handle quotes that span more than one line, or
-# cases where an escaped quote is preceded by an escaped backslash.
-QUOTE_RE_STR = r'(?P<q>[\'"])(.*?)(?<![^\\][\\])(?P=q)'
-QUOTE_RE = re.compile(QUOTE_RE_STR)
-
-
-def comment_replace(matchobj):
-    return matchobj.group(1) + matchobj.group(2) + "#" * len(matchobj.group(3))
-
-
-def mask_comments(input):
-    """Mask the quoted strings so we skip braces inside quoted strings."""
-    search_re = re.compile(r"(.*?)(#)(.*)")
-    return [search_re.sub(comment_replace, line) for line in input]
-
-
-def quote_replace(matchobj):
-    return "{}{}{}{}".format(
-        matchobj.group(1),
-        matchobj.group(2),
-        "x" * len(matchobj.group(3)),
-        matchobj.group(2),
-    )
-
-
-def mask_quotes(input):
-    """Mask the quoted strings so we skip braces inside quoted strings."""
-    search_re = re.compile(r"(.*?)" + QUOTE_RE_STR)
-    return [search_re.sub(quote_replace, line) for line in input]
-
-
-def do_split(input, masked_input, search_re):
-    output = []
-    mask_output = []
-    for (line, masked_line) in zip(input, masked_input):
-        m = search_re.match(masked_line)
-        while m:
-            split = len(m.group(1))
-            line = line[:split] + r"\n" + line[split:]
-            masked_line = masked_line[:split] + r"\n" + masked_line[split:]
-            m = search_re.match(masked_line)
-        output.extend(line.split(r"\n"))
-        mask_output.extend(masked_line.split(r"\n"))
-    return (output, mask_output)
-
-
-def split_double_braces(input):
-    """Masks out the quotes and comments, and then splits appropriate
-  lines (lines that matche the double_*_brace re's above) before
-  indenting them below.
-
-  These are used to split lines which have multiple braces on them, so
-  that the indentation looks prettier when all laid out (e.g. closing
-  braces make a nice diagonal line).
-  """
-    double_open_brace_re = re.compile(r"(.*?[\[\{\(,])(\s*)([\[\{\(])")
-    double_close_brace_re = re.compile(r"(.*?[\]\}\)],?)(\s*)([\]\}\)])")
-
-    masked_input = mask_quotes(input)
-    masked_input = mask_comments(masked_input)
-
-    (output, mask_output) = do_split(input, masked_input, double_open_brace_re)
-    (output, mask_output) = do_split(output, mask_output, double_close_brace_re)
-
-    return output
-
-
-def count_braces(line):
-    """keeps track of the number of braces on a given line and returns the result.
-
-  It starts at zero and subtracts for closed braces, and adds for open braces.
-  """
-    open_braces = ["[", "(", "{"]
-    close_braces = ["]", ")", "}"]
-    closing_prefix_re = re.compile(r"(.*?[^\s\]\}\)]+.*?)([\]\}\)],?)\s*$")
-    cnt = 0
-    stripline = COMMENT_RE.sub(r"", line)
-    stripline = QUOTE_RE.sub(r"''", stripline)
-    for char in stripline:
-        for brace in open_braces:
-            if char == brace:
-                cnt += 1
-        for brace in close_braces:
-            if char == brace:
-                cnt -= 1
-
-    after = False
-    if cnt > 0:
-        after = True
-
-    # This catches the special case of a closing brace having something
-    # other than just whitespace ahead of it -- we don't want to
-    # unindent that until after this line is printed so it stays with
-    # the previous indentation level.
-    if cnt < 0 and closing_prefix_re.match(stripline):
-        after = True
-    return (cnt, after)
-
-
-def prettyprint_input(lines):
-    """Does the main work of indenting the input based on the brace counts."""
-    indent = 0
-    basic_offset = 2
-    for line in lines:
-        if COMMENT_RE.match(line):
-            print(line)
-        else:
-            line = line.strip("\r\n\t ")  # Otherwise doesn't strip \r on Unix.
-            if len(line) > 0:
-                (brace_diff, after) = count_braces(line)
-                if brace_diff != 0:
-                    if after:
-                        print(" " * (basic_offset * indent) + line)
-                        indent += brace_diff
-                    else:
-                        indent += brace_diff
-                        print(" " * (basic_offset * indent) + line)
-                else:
-                    print(" " * (basic_offset * indent) + line)
-            else:
-                print("")
-
-
-def main():
-    if len(sys.argv) > 1:
-        data = open(sys.argv[1]).read().splitlines()
-    else:
-        data = sys.stdin.read().splitlines()
-    # Split up the double braces.
-    lines = split_double_braces(data)
-
-    # Indent and print the output.
-    prettyprint_input(lines)
-    return 0
-
-
-if __name__ == "__main__":
-    sys.exit(main())