wsba-hockey 1.1.9__py3-none-any.whl → 1.2.1__py3-none-any.whl

wsba_hockey/evidence/weakside-breakout/node_modules/flatted/python/flatted.py

@@ -1,149 +0,0 @@
-# ISC License
-#
-# Copyright (c) 2018-2021, Andrea Giammarchi, @WebReflection
-#
-# Permission to use, copy, modify, and/or distribute this software for any
-# purpose with or without fee is hereby granted, provided that the above
-# copyright notice and this permission notice appear in all copies.
-#
-# THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-# REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-# AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-# INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-# LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
-# OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-# PERFORMANCE OF THIS SOFTWARE.
-
-import json as _json
-
-class _Known:
-    def __init__(self):
-        self.key = []
-        self.value = []
-
-class _String:
-    def __init__(self, value):
-        self.value = value
-
-
-def _array_keys(value):
-    keys = []
-    i = 0
-    for _ in value:
-        keys.append(i)
-        i += 1
-    return keys
-
-def _object_keys(value):
-    keys = []
-    for key in value:
-        keys.append(key)
-    return keys
-
-def _is_array(value):
-    return isinstance(value, list) or isinstance(value, tuple)
-
-def _is_object(value):
-    return isinstance(value, dict)
-
-def _is_string(value):
-    return isinstance(value, str)
-
-def _index(known, input, value):
-    input.append(value)
-    index = str(len(input) - 1)
-    known.key.append(value)
-    known.value.append(index)
-    return index
-
-def _loop(keys, input, known, output):
-    for key in keys:
-        value = output[key]
-        if isinstance(value, _String):
-            _ref(key, input[int(value.value)], input, known, output)
-
-    return output
-
-def _ref(key, value, input, known, output):
-    if _is_array(value) and not value in known:
-        known.append(value)
-        value = _loop(_array_keys(value), input, known, value)
-    elif _is_object(value) and not value in known:
-        known.append(value)
-        value = _loop(_object_keys(value), input, known, value)
-
-    output[key] = value
-
-def _relate(known, input, value):
-    if _is_string(value) or _is_array(value) or _is_object(value):
-        try:
-            return known.value[known.key.index(value)]
-        except:
-            return _index(known, input, value)
-
-    return value
-
-def _transform(known, input, value):
-    if _is_array(value):
-        output = []
-        for val in value:
-            output.append(_relate(known, input, val))
-        return output
-
-    if _is_object(value):
-        obj = {}
-        for key in value:
-            obj[key] = _relate(known, input, value[key])
-        return obj
-
-    return value
-
-def _wrap(value):
-    if _is_string(value):
-        return _String(value)
-
-    if _is_array(value):
-        i = 0
-        for val in value:
-            value[i] = _wrap(val)
-            i += 1
-
-    elif _is_object(value):
-        for key in value:
-            value[key] = _wrap(value[key])
-
-    return value
-
-def parse(value, *args, **kwargs):
-    json = _json.loads(value, *args, **kwargs)
-    wrapped = []
-    for value in json:
-        wrapped.append(_wrap(value))
-
-    input = []
-    for value in wrapped:
-        if isinstance(value, _String):
-            input.append(value.value)
-        else:
-            input.append(value)
-
-    value = input[0]
-
-    if _is_array(value):
-        return _loop(_array_keys(value), input, [value], value)
-
-    if _is_object(value):
-        return _loop(_object_keys(value), input, [value], value)
-
-    return value
-
-
-def stringify(value, *args, **kwargs):
-    known = _Known()
-    input = []
-    output = []
-    i = int(_index(known, input, value))
-    while i < len(input):
-        output.append(_transform(known, input, input[i]))
-        i += 1
-    return _json.dumps(output, *args, **kwargs)

wsba_hockey/evidence/weakside-breakout/node_modules/flatted/python/test.py

@@ -1,63 +0,0 @@
-from flatted import stringify as _stringify, parse
-
-def stringify(value):
-    return _stringify(value, separators=(',', ':'))
-
-assert stringify([None, None]) == '[[null,null]]'
-
-a = []
-o = {}
-
-assert stringify(a) == '[[]]'
-assert stringify(o) == '[{}]'
-
-a.append(a)
-o['o'] = o
-
-assert stringify(a) == '[["0"]]'
-assert stringify(o) == '[{"o":"0"}]'
-
-b = parse(stringify(a))
-assert isinstance(b, list) and b[0] == b
-
-a.append(1)
-a.append('two')
-a.append(True)
-o['one'] = 1
-o['two'] = 'two'
-o['three'] = True
-
-assert stringify(a) == '[["0",1,"1",true],"two"]'
-assert stringify(o) == '[{"o":"0","one":1,"two":"1","three":true},"two"]'
-
-a.append(o)
-o['a'] = a
-
-assert stringify(a) == '[["0",1,"1",true,"2"],"two",{"o":"2","one":1,"two":"1","three":true,"a":"0"}]'
-assert stringify(o) == '[{"o":"0","one":1,"two":"1","three":true,"a":"2"},"two",["2",1,"1",true,"0"]]'
-
-a.append({'test': 'OK'})
-a.append([1, 2, 3])
-
-o['test'] = {'test': 'OK'}
-o['array'] = [1, 2, 3]
-
-assert stringify(a) == '[["0",1,"1",true,"2","3","4"],"two",{"o":"2","one":1,"two":"1","three":true,"a":"0","test":"3","array":"4"},{"test":"5"},[1,2,3],"OK"]'
-assert stringify(o) == '[{"o":"0","one":1,"two":"1","three":true,"a":"2","test":"3","array":"4"},"two",["2",1,"1",true,"0","3","4"],{"test":"5"},[1,2,3],"OK"]'
-
-a2 = parse(stringify(a));
-o2 = parse(stringify(o));
-
-assert a2[0] == a2
-assert o2['o'] == o2
-
-assert a2[1] == 1 and a2[2] == 'two' and a2[3] == True and isinstance(a2[4], dict)
-assert a2[4] == a2[4]['o'] and a2 == a2[4]['o']['a']
-
-str = parse('[{"prop":"1","a":"2","b":"3"},{"value":123},["4","5"],{"e":"6","t":"7","p":4},{},{"b":"8"},"f",{"a":"9"},["10"],"sup",{"a":1,"d":2,"c":"7","z":"11","h":1},{"g":2,"a":"7","b":"12","f":6},{"r":4,"u":"7","c":5}]')
-assert str['b']['t']['a'] == 'sup' and str['a'][1]['b'][0]['c'] == str['b']['t']
-
-oo = parse('[{"a":"1","b":"0","c":"2"},{"aa":"3"},{"ca":"4","cb":"5","cc":"6","cd":"7","ce":"8","cf":"9"},{"aaa":"10"},{"caa":"4"},{"cba":"5"},{"cca":"2"},{"cda":"4"},"value2","value3","value1"]');
-assert oo['a']['aa']['aaa'] == 'value1' and oo == oo['b'] and oo['c']['ca']['caa'] == oo['c']['ca']
-
-print('OK')

wsba_hockey/evidence/weakside-breakout/node_modules/node-gyp/gyp/gyp_main.py

@@ -1,45 +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.
-
-import os
-import sys
-import subprocess
-
-
-def IsCygwin():
-    # Function copied from pylib/gyp/common.py
-    try:
-        out = subprocess.Popen(
-            "uname", stdout=subprocess.PIPE, stderr=subprocess.STDOUT
-        )
-        stdout, _ = out.communicate()
-        return "CYGWIN" in stdout.decode("utf-8")
-    except Exception:
-        return False
-
-
-def UnixifyPath(path):
-    try:
-        if not IsCygwin():
-            return path
-        out = subprocess.Popen(
-            ["cygpath", "-u", path], stdout=subprocess.PIPE, stderr=subprocess.STDOUT
-        )
-        stdout, _ = out.communicate()
-        return stdout.decode("utf-8")
-    except Exception:
-        return path
-
-
-# Make sure we're using the version of pylib in this repo, not one installed
-# elsewhere on the system. Also convert to Unix style path on Cygwin systems,
-# else the 'gyp' library will not be found
-path = UnixifyPath(sys.argv[0])
-sys.path.insert(0, os.path.join(os.path.dirname(path), "pylib"))
-import gyp  # noqa: E402
-
-if __name__ == "__main__":
-    sys.exit(gyp.script_main())

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

@@ -1,367 +0,0 @@
-# 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.
-
-"""New implementation of Visual Studio project generation."""
-
-import hashlib
-import os
-import random
-from operator import attrgetter
-
-import gyp.common
-
-
-def cmp(x, y):
-    return (x > y) - (x < y)
-
-
-# Initialize random number generator
-random.seed()
-
-# GUIDs for project types
-ENTRY_TYPE_GUIDS = {
-    "project": "{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}",
-    "folder": "{2150E333-8FDC-42A3-9474-1A3956D46DE8}",
-}
-
-# ------------------------------------------------------------------------------
-# Helper functions
-
-
-def MakeGuid(name, seed="msvs_new"):
-    """Returns a GUID for the specified target name.
-
-  Args:
-    name: Target name.
-    seed: Seed for MD5 hash.
-  Returns:
-    A GUID-line string calculated from the name and seed.
-
-  This generates something which looks like a GUID, but depends only on the
-  name and seed.  This means the same name/seed will always generate the same
-  GUID, so that projects and solutions which refer to each other can explicitly
-  determine the GUID to refer to explicitly.  It also means that the GUID will
-  not change when the project for a target is rebuilt.
-  """
-    # Calculate a MD5 signature for the seed and name.
-    d = hashlib.md5((str(seed) + str(name)).encode("utf-8")).hexdigest().upper()
-    # Convert most of the signature to GUID form (discard the rest)
-    guid = (
-        "{"
-        + d[:8]
-        + "-"
-        + d[8:12]
-        + "-"
-        + d[12:16]
-        + "-"
-        + d[16:20]
-        + "-"
-        + d[20:32]
-        + "}"
-    )
-    return guid
-
-
-# ------------------------------------------------------------------------------
-
-
-class MSVSSolutionEntry:
-    def __cmp__(self, other):
-        # Sort by name then guid (so things are in order on vs2008).
-        return cmp((self.name, self.get_guid()), (other.name, other.get_guid()))
-
-
-class MSVSFolder(MSVSSolutionEntry):
-    """Folder in a Visual Studio project or solution."""
-
-    def __init__(self, path, name=None, entries=None, guid=None, items=None):
-        """Initializes the folder.
-
-    Args:
-      path: Full path to the folder.
-      name: Name of the folder.
-      entries: List of folder entries to nest inside this folder.  May contain
-          Folder or Project objects.  May be None, if the folder is empty.
-      guid: GUID to use for folder, if not None.
-      items: List of solution items to include in the folder project.  May be
-          None, if the folder does not directly contain items.
-    """
-        if name:
-            self.name = name
-        else:
-            # Use last layer.
-            self.name = os.path.basename(path)
-
-        self.path = path
-        self.guid = guid
-
-        # Copy passed lists (or set to empty lists)
-        self.entries = sorted(entries or [], key=attrgetter("path"))
-        self.items = list(items or [])
-
-        self.entry_type_guid = ENTRY_TYPE_GUIDS["folder"]
-
-    def get_guid(self):
-        if self.guid is None:
-            # Use consistent guids for folders (so things don't regenerate).
-            self.guid = MakeGuid(self.path, seed="msvs_folder")
-        return self.guid
-
-
-# ------------------------------------------------------------------------------
-
-
-class MSVSProject(MSVSSolutionEntry):
-    """Visual Studio project."""
-
-    def __init__(
-        self,
-        path,
-        name=None,
-        dependencies=None,
-        guid=None,
-        spec=None,
-        build_file=None,
-        config_platform_overrides=None,
-        fixpath_prefix=None,
-    ):
-        """Initializes the project.
-
-    Args:
-      path: Absolute path to the project file.
-      name: Name of project.  If None, the name will be the same as the base
-          name of the project file.
-      dependencies: List of other Project objects this project is dependent
-          upon, if not None.
-      guid: GUID to use for project, if not None.
-      spec: Dictionary specifying how to build this project.
-      build_file: Filename of the .gyp file that the vcproj file comes from.
-      config_platform_overrides: optional dict of configuration platforms to
-          used in place of the default for this target.
-      fixpath_prefix: the path used to adjust the behavior of _fixpath
-    """
-        self.path = path
-        self.guid = guid
-        self.spec = spec
-        self.build_file = build_file
-        # Use project filename if name not specified
-        self.name = name or os.path.splitext(os.path.basename(path))[0]
-
-        # Copy passed lists (or set to empty lists)
-        self.dependencies = list(dependencies or [])
-
-        self.entry_type_guid = ENTRY_TYPE_GUIDS["project"]
-
-        if config_platform_overrides:
-            self.config_platform_overrides = config_platform_overrides
-        else:
-            self.config_platform_overrides = {}
-        self.fixpath_prefix = fixpath_prefix
-        self.msbuild_toolset = None
-
-    def set_dependencies(self, dependencies):
-        self.dependencies = list(dependencies or [])
-
-    def get_guid(self):
-        if self.guid is None:
-            # Set GUID from path
-            # TODO(rspangler): This is fragile.
-            # 1. We can't just use the project filename sans path, since there could
-            #    be multiple projects with the same base name (for example,
-            #    foo/unittest.vcproj and bar/unittest.vcproj).
-            # 2. The path needs to be relative to $SOURCE_ROOT, so that the project
-            #    GUID is the same whether it's included from base/base.sln or
-            #    foo/bar/baz/baz.sln.
-            # 3. The GUID needs to be the same each time this builder is invoked, so
-            #    that we don't need to rebuild the solution when the project changes.
-            # 4. We should be able to handle pre-built project files by reading the
-            #    GUID from the files.
-            self.guid = MakeGuid(self.name)
-        return self.guid
-
-    def set_msbuild_toolset(self, msbuild_toolset):
-        self.msbuild_toolset = msbuild_toolset
-
-
-# ------------------------------------------------------------------------------
-
-
-class MSVSSolution:
-    """Visual Studio solution."""
-
-    def __init__(
-        self, path, version, entries=None, variants=None, websiteProperties=True
-    ):
-        """Initializes the solution.
-
-    Args:
-      path: Path to solution file.
-      version: Format version to emit.
-      entries: List of entries in solution.  May contain Folder or Project
-          objects.  May be None, if the folder is empty.
-      variants: List of build variant strings.  If none, a default list will
-          be used.
-      websiteProperties: Flag to decide if the website properties section
-          is generated.
-    """
-        self.path = path
-        self.websiteProperties = websiteProperties
-        self.version = version
-
-        # Copy passed lists (or set to empty lists)
-        self.entries = list(entries or [])
-
-        if variants:
-            # Copy passed list
-            self.variants = variants[:]
-        else:
-            # Use default
-            self.variants = ["Debug|Win32", "Release|Win32"]
-        # TODO(rspangler): Need to be able to handle a mapping of solution config
-        # to project config.  Should we be able to handle variants being a dict,
-        # or add a separate variant_map variable?  If it's a dict, we can't
-        # guarantee the order of variants since dict keys aren't ordered.
-
-        # TODO(rspangler): Automatically write to disk for now; should delay until
-        # node-evaluation time.
-        self.Write()
-
-    def Write(self, writer=gyp.common.WriteOnDiff):
-        """Writes the solution file to disk.
-
-    Raises:
-      IndexError: An entry appears multiple times.
-    """
-        # Walk the entry tree and collect all the folders and projects.
-        all_entries = set()
-        entries_to_check = self.entries[:]
-        while entries_to_check:
-            e = entries_to_check.pop(0)
-
-            # If this entry has been visited, nothing to do.
-            if e in all_entries:
-                continue
-
-            all_entries.add(e)
-
-            # If this is a folder, check its entries too.
-            if isinstance(e, MSVSFolder):
-                entries_to_check += e.entries
-
-        all_entries = sorted(all_entries, key=attrgetter("path"))
-
-        # Open file and print header
-        f = writer(self.path)
-        f.write(
-            "Microsoft Visual Studio Solution File, "
-            "Format Version %s\r\n" % self.version.SolutionVersion()
-        )
-        f.write("# %s\r\n" % self.version.Description())
-
-        # Project entries
-        sln_root = os.path.split(self.path)[0]
-        for e in all_entries:
-            relative_path = gyp.common.RelativePath(e.path, sln_root)
-            # msbuild does not accept an empty folder_name.
-            # use '.' in case relative_path is empty.
-            folder_name = relative_path.replace("/", "\\") or "."
-            f.write(
-                'Project("%s") = "%s", "%s", "%s"\r\n'
-                % (
-                    e.entry_type_guid,  # Entry type GUID
-                    e.name,  # Folder name
-                    folder_name,  # Folder name (again)
-                    e.get_guid(),  # Entry GUID
-                )
-            )
-
-            # TODO(rspangler): Need a way to configure this stuff
-            if self.websiteProperties:
-                f.write(
-                    "\tProjectSection(WebsiteProperties) = preProject\r\n"
-                    '\t\tDebug.AspNetCompiler.Debug = "True"\r\n'
-                    '\t\tRelease.AspNetCompiler.Debug = "False"\r\n'
-                    "\tEndProjectSection\r\n"
-                )
-
-            if isinstance(e, MSVSFolder):
-                if e.items:
-                    f.write("\tProjectSection(SolutionItems) = preProject\r\n")
-                    for i in e.items:
-                        f.write(f"\t\t{i} = {i}\r\n")
-                    f.write("\tEndProjectSection\r\n")
-
-            if isinstance(e, MSVSProject):
-                if e.dependencies:
-                    f.write("\tProjectSection(ProjectDependencies) = postProject\r\n")
-                    for d in e.dependencies:
-                        f.write(f"\t\t{d.get_guid()} = {d.get_guid()}\r\n")
-                    f.write("\tEndProjectSection\r\n")
-
-            f.write("EndProject\r\n")
-
-        # Global section
-        f.write("Global\r\n")
-
-        # Configurations (variants)
-        f.write("\tGlobalSection(SolutionConfigurationPlatforms) = preSolution\r\n")
-        for v in self.variants:
-            f.write(f"\t\t{v} = {v}\r\n")
-        f.write("\tEndGlobalSection\r\n")
-
-        # Sort config guids for easier diffing of solution changes.
-        config_guids = []
-        config_guids_overrides = {}
-        for e in all_entries:
-            if isinstance(e, MSVSProject):
-                config_guids.append(e.get_guid())
-                config_guids_overrides[e.get_guid()] = e.config_platform_overrides
-        config_guids.sort()
-
-        f.write("\tGlobalSection(ProjectConfigurationPlatforms) = postSolution\r\n")
-        for g in config_guids:
-            for v in self.variants:
-                nv = config_guids_overrides[g].get(v, v)
-                # Pick which project configuration to build for this solution
-                # configuration.
-                f.write(
-                    "\t\t%s.%s.ActiveCfg = %s\r\n"
-                    % (
-                        g,  # Project GUID
-                        v,  # Solution build configuration
-                        nv,  # Project build config for that solution config
-                    )
-                )
-
-                # Enable project in this solution configuration.
-                f.write(
-                    "\t\t%s.%s.Build.0 = %s\r\n"
-                    % (
-                        g,  # Project GUID
-                        v,  # Solution build configuration
-                        nv,  # Project build config for that solution config
-                    )
-                )
-        f.write("\tEndGlobalSection\r\n")
-
-        # TODO(rspangler): Should be able to configure this stuff too (though I've
-        # never seen this be any different)
-        f.write("\tGlobalSection(SolutionProperties) = preSolution\r\n")
-        f.write("\t\tHideSolutionNode = FALSE\r\n")
-        f.write("\tEndGlobalSection\r\n")
-
-        # Folder mappings
-        # Omit this section if there are no folders
-        if any([e.entries for e in all_entries if isinstance(e, MSVSFolder)]):
-            f.write("\tGlobalSection(NestedProjects) = preSolution\r\n")
-            for e in all_entries:
-                if not isinstance(e, MSVSFolder):
-                    continue  # Does not apply to projects, only folders
-                for subentry in e.entries:
-                    f.write(f"\t\t{subentry.get_guid()} = {e.get_guid()}\r\n")
-            f.write("\tEndGlobalSection\r\n")
-
-        f.write("EndGlobal\r\n")
-
-        f.close()