py2docfx 0.1.16.dev2064350__py3-none-any.whl → 0.1.17__py3-none-any.whl

py2docfx/venv/venv1/Lib/site-packages/rsa/randnum.py

@@ -1,95 +1,95 @@
-#  Copyright 2011 Sybren A. Stüvel <sybren@stuvel.eu>
-#
-#  Licensed under the Apache License, Version 2.0 (the "License");
-#  you may not use this file except in compliance with the License.
-#  You may obtain a copy of the License at
-#
-#      https://www.apache.org/licenses/LICENSE-2.0
-#
-#  Unless required by applicable law or agreed to in writing, software
-#  distributed under the License is distributed on an "AS IS" BASIS,
-#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-#  See the License for the specific language governing permissions and
-#  limitations under the License.
-
-"""Functions for generating random numbers."""
-
-# Source inspired by code by Yesudeep Mangalapilly <yesudeep@gmail.com>
-
-import os
-import struct
-
-from rsa import common, transform
-
-
-def read_random_bits(nbits: int) -> bytes:
-    """Reads 'nbits' random bits.
-
-    If nbits isn't a whole number of bytes, an extra byte will be appended with
-    only the lower bits set.
-    """
-
-    nbytes, rbits = divmod(nbits, 8)
-
-    # Get the random bytes
-    randomdata = os.urandom(nbytes)
-
-    # Add the remaining random bits
-    if rbits > 0:
-        randomvalue = ord(os.urandom(1))
-        randomvalue >>= 8 - rbits
-        randomdata = struct.pack("B", randomvalue) + randomdata
-
-    return randomdata
-
-
-def read_random_int(nbits: int) -> int:
-    """Reads a random integer of approximately nbits bits."""
-
-    randomdata = read_random_bits(nbits)
-    value = transform.bytes2int(randomdata)
-
-    # Ensure that the number is large enough to just fill out the required
-    # number of bits.
-    value |= 1 << (nbits - 1)
-
-    return value
-
-
-def read_random_odd_int(nbits: int) -> int:
-    """Reads a random odd integer of approximately nbits bits.
-
-    >>> read_random_odd_int(512) & 1
-    1
-    """
-
-    value = read_random_int(nbits)
-
-    # Make sure it's odd
-    return value | 1
-
-
-def randint(maxvalue: int) -> int:
-    """Returns a random integer x with 1 <= x <= maxvalue
-
-    May take a very long time in specific situations. If maxvalue needs N bits
-    to store, the closer maxvalue is to (2 ** N) - 1, the faster this function
-    is.
-    """
-
-    bit_size = common.bit_size(maxvalue)
-
-    tries = 0
-    while True:
-        value = read_random_int(bit_size)
-        if value <= maxvalue:
-            break
-
-        if tries % 10 == 0 and tries:
-            # After a lot of tries to get the right number of bits but still
-            # smaller than maxvalue, decrease the number of bits by 1. That'll
-            # dramatically increase the chances to get a large enough number.
-            bit_size -= 1
-        tries += 1
-
-    return value
+#  Copyright 2011 Sybren A. Stüvel <sybren@stuvel.eu>
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#      https://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+"""Functions for generating random numbers."""
+
+# Source inspired by code by Yesudeep Mangalapilly <yesudeep@gmail.com>
+
+import os
+import struct
+
+from rsa import common, transform
+
+
+def read_random_bits(nbits: int) -> bytes:
+    """Reads 'nbits' random bits.
+
+    If nbits isn't a whole number of bytes, an extra byte will be appended with
+    only the lower bits set.
+    """
+
+    nbytes, rbits = divmod(nbits, 8)
+
+    # Get the random bytes
+    randomdata = os.urandom(nbytes)
+
+    # Add the remaining random bits
+    if rbits > 0:
+        randomvalue = ord(os.urandom(1))
+        randomvalue >>= 8 - rbits
+        randomdata = struct.pack("B", randomvalue) + randomdata
+
+    return randomdata
+
+
+def read_random_int(nbits: int) -> int:
+    """Reads a random integer of approximately nbits bits."""
+
+    randomdata = read_random_bits(nbits)
+    value = transform.bytes2int(randomdata)
+
+    # Ensure that the number is large enough to just fill out the required
+    # number of bits.
+    value |= 1 << (nbits - 1)
+
+    return value
+
+
+def read_random_odd_int(nbits: int) -> int:
+    """Reads a random odd integer of approximately nbits bits.
+
+    >>> read_random_odd_int(512) & 1
+    1
+    """
+
+    value = read_random_int(nbits)
+
+    # Make sure it's odd
+    return value | 1
+
+
+def randint(maxvalue: int) -> int:
+    """Returns a random integer x with 1 <= x <= maxvalue
+
+    May take a very long time in specific situations. If maxvalue needs N bits
+    to store, the closer maxvalue is to (2 ** N) - 1, the faster this function
+    is.
+    """
+
+    bit_size = common.bit_size(maxvalue)
+
+    tries = 0
+    while True:
+        value = read_random_int(bit_size)
+        if value <= maxvalue:
+            break
+
+        if tries % 10 == 0 and tries:
+            # After a lot of tries to get the right number of bits but still
+            # smaller than maxvalue, decrease the number of bits by 1. That'll
+            # dramatically increase the chances to get a large enough number.
+            bit_size -= 1
+        tries += 1
+
+    return value

py2docfx/venv/venv1/Lib/site-packages/rsa/transform.py

@@ -1,72 +1,72 @@
-#  Copyright 2011 Sybren A. Stüvel <sybren@stuvel.eu>
-#
-#  Licensed under the Apache License, Version 2.0 (the "License");
-#  you may not use this file except in compliance with the License.
-#  You may obtain a copy of the License at
-#
-#      https://www.apache.org/licenses/LICENSE-2.0
-#
-#  Unless required by applicable law or agreed to in writing, software
-#  distributed under the License is distributed on an "AS IS" BASIS,
-#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-#  See the License for the specific language governing permissions and
-#  limitations under the License.
-
-"""Data transformation functions.
-
-From bytes to a number, number to bytes, etc.
-"""
-
-import math
-
-
-def bytes2int(raw_bytes: bytes) -> int:
-    r"""Converts a list of bytes or an 8-bit string to an integer.
-
-    When using unicode strings, encode it to some encoding like UTF8 first.
-
-    >>> (((128 * 256) + 64) * 256) + 15
-    8405007
-    >>> bytes2int(b'\x80@\x0f')
-    8405007
-
-    """
-    return int.from_bytes(raw_bytes, "big", signed=False)
-
-
-def int2bytes(number: int, fill_size: int = 0) -> bytes:
-    """
-    Convert an unsigned integer to bytes (big-endian)::
-
-    Does not preserve leading zeros if you don't specify a fill size.
-
-    :param number:
-        Integer value
-    :param fill_size:
-        If the optional fill size is given the length of the resulting
-        byte string is expected to be the fill size and will be padded
-        with prefix zero bytes to satisfy that length.
-    :returns:
-        Raw bytes (base-256 representation).
-    :raises:
-        ``OverflowError`` when fill_size is given and the number takes up more
-        bytes than fit into the block. This requires the ``overflow``
-        argument to this function to be set to ``False`` otherwise, no
-        error will be raised.
-    """
-
-    if number < 0:
-        raise ValueError("Number must be an unsigned integer: %d" % number)
-
-    bytes_required = max(1, math.ceil(number.bit_length() / 8))
-
-    if fill_size > 0:
-        return number.to_bytes(fill_size, "big")
-
-    return number.to_bytes(bytes_required, "big")
-
-
-if __name__ == "__main__":
-    import doctest
-
-    doctest.testmod()
+#  Copyright 2011 Sybren A. Stüvel <sybren@stuvel.eu>
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#      https://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+"""Data transformation functions.
+
+From bytes to a number, number to bytes, etc.
+"""
+
+import math
+
+
+def bytes2int(raw_bytes: bytes) -> int:
+    r"""Converts a list of bytes or an 8-bit string to an integer.
+
+    When using unicode strings, encode it to some encoding like UTF8 first.
+
+    >>> (((128 * 256) + 64) * 256) + 15
+    8405007
+    >>> bytes2int(b'\x80@\x0f')
+    8405007
+
+    """
+    return int.from_bytes(raw_bytes, "big", signed=False)
+
+
+def int2bytes(number: int, fill_size: int = 0) -> bytes:
+    """
+    Convert an unsigned integer to bytes (big-endian)::
+
+    Does not preserve leading zeros if you don't specify a fill size.
+
+    :param number:
+        Integer value
+    :param fill_size:
+        If the optional fill size is given the length of the resulting
+        byte string is expected to be the fill size and will be padded
+        with prefix zero bytes to satisfy that length.
+    :returns:
+        Raw bytes (base-256 representation).
+    :raises:
+        ``OverflowError`` when fill_size is given and the number takes up more
+        bytes than fit into the block. This requires the ``overflow``
+        argument to this function to be set to ``False`` otherwise, no
+        error will be raised.
+    """
+
+    if number < 0:
+        raise ValueError("Number must be an unsigned integer: %d" % number)
+
+    bytes_required = max(1, math.ceil(number.bit_length() / 8))
+
+    if fill_size > 0:
+        return number.to_bytes(fill_size, "big")
+
+    return number.to_bytes(bytes_required, "big")
+
+
+if __name__ == "__main__":
+    import doctest
+
+    doctest.testmod()

py2docfx/venv/venv1/Lib/site-packages/rsa/util.py

@@ -1,97 +1,97 @@
-#  Copyright 2011 Sybren A. Stüvel <sybren@stuvel.eu>
-#
-#  Licensed under the Apache License, Version 2.0 (the "License");
-#  you may not use this file except in compliance with the License.
-#  You may obtain a copy of the License at
-#
-#      https://www.apache.org/licenses/LICENSE-2.0
-#
-#  Unless required by applicable law or agreed to in writing, software
-#  distributed under the License is distributed on an "AS IS" BASIS,
-#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-#  See the License for the specific language governing permissions and
-#  limitations under the License.
-
-"""Utility functions."""
-
-import sys
-from optparse import OptionParser
-
-import rsa.key
-
-
-def private_to_public() -> None:
-    """Reads a private key and outputs the corresponding public key."""
-
-    # Parse the CLI options
-    parser = OptionParser(
-        usage="usage: %prog [options]",
-        description="Reads a private key and outputs the "
-        "corresponding public key. Both private and public keys use "
-        "the format described in PKCS#1 v1.5",
-    )
-
-    parser.add_option(
-        "-i",
-        "--input",
-        dest="infilename",
-        type="string",
-        help="Input filename. Reads from stdin if not specified",
-    )
-    parser.add_option(
-        "-o",
-        "--output",
-        dest="outfilename",
-        type="string",
-        help="Output filename. Writes to stdout of not specified",
-    )
-
-    parser.add_option(
-        "--inform",
-        dest="inform",
-        help="key format of input - default PEM",
-        choices=("PEM", "DER"),
-        default="PEM",
-    )
-
-    parser.add_option(
-        "--outform",
-        dest="outform",
-        help="key format of output - default PEM",
-        choices=("PEM", "DER"),
-        default="PEM",
-    )
-
-    (cli, cli_args) = parser.parse_args(sys.argv)
-
-    # Read the input data
-    if cli.infilename:
-        print(
-            "Reading private key from %s in %s format" % (cli.infilename, cli.inform),
-            file=sys.stderr,
-        )
-        with open(cli.infilename, "rb") as infile:
-            in_data = infile.read()
-    else:
-        print("Reading private key from stdin in %s format" % cli.inform, file=sys.stderr)
-        in_data = sys.stdin.read().encode("ascii")
-
-    assert type(in_data) == bytes, type(in_data)
-
-    # Take the public fields and create a public key
-    priv_key = rsa.key.PrivateKey.load_pkcs1(in_data, cli.inform)
-    pub_key = rsa.key.PublicKey(priv_key.n, priv_key.e)
-
-    # Save to the output file
-    out_data = pub_key.save_pkcs1(cli.outform)
-
-    if cli.outfilename:
-        print(
-            "Writing public key to %s in %s format" % (cli.outfilename, cli.outform),
-            file=sys.stderr,
-        )
-        with open(cli.outfilename, "wb") as outfile:
-            outfile.write(out_data)
-    else:
-        print("Writing public key to stdout in %s format" % cli.outform, file=sys.stderr)
-        sys.stdout.write(out_data.decode("ascii"))
+#  Copyright 2011 Sybren A. Stüvel <sybren@stuvel.eu>
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#      https://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+"""Utility functions."""
+
+import sys
+from optparse import OptionParser
+
+import rsa.key
+
+
+def private_to_public() -> None:
+    """Reads a private key and outputs the corresponding public key."""
+
+    # Parse the CLI options
+    parser = OptionParser(
+        usage="usage: %prog [options]",
+        description="Reads a private key and outputs the "
+        "corresponding public key. Both private and public keys use "
+        "the format described in PKCS#1 v1.5",
+    )
+
+    parser.add_option(
+        "-i",
+        "--input",
+        dest="infilename",
+        type="string",
+        help="Input filename. Reads from stdin if not specified",
+    )
+    parser.add_option(
+        "-o",
+        "--output",
+        dest="outfilename",
+        type="string",
+        help="Output filename. Writes to stdout of not specified",
+    )
+
+    parser.add_option(
+        "--inform",
+        dest="inform",
+        help="key format of input - default PEM",
+        choices=("PEM", "DER"),
+        default="PEM",
+    )
+
+    parser.add_option(
+        "--outform",
+        dest="outform",
+        help="key format of output - default PEM",
+        choices=("PEM", "DER"),
+        default="PEM",
+    )
+
+    (cli, cli_args) = parser.parse_args(sys.argv)
+
+    # Read the input data
+    if cli.infilename:
+        print(
+            "Reading private key from %s in %s format" % (cli.infilename, cli.inform),
+            file=sys.stderr,
+        )
+        with open(cli.infilename, "rb") as infile:
+            in_data = infile.read()
+    else:
+        print("Reading private key from stdin in %s format" % cli.inform, file=sys.stderr)
+        in_data = sys.stdin.read().encode("ascii")
+
+    assert type(in_data) == bytes, type(in_data)
+
+    # Take the public fields and create a public key
+    priv_key = rsa.key.PrivateKey.load_pkcs1(in_data, cli.inform)
+    pub_key = rsa.key.PublicKey(priv_key.n, priv_key.e)
+
+    # Save to the output file
+    out_data = pub_key.save_pkcs1(cli.outform)
+
+    if cli.outfilename:
+        print(
+            "Writing public key to %s in %s format" % (cli.outfilename, cli.outform),
+            file=sys.stderr,
+        )
+        with open(cli.outfilename, "wb") as outfile:
+            outfile.write(out_data)
+    else:
+        print("Writing public key to stdout in %s format" % cli.outform, file=sys.stderr)
+        sys.stdout.write(out_data.decode("ascii"))

py2docfx/venv/venv1/Lib/site-packages/setuptools/__init__.py

@@ -9,7 +9,6 @@ from __future__ import annotations
 
 import functools
 import os
-import re
 import sys
 from abc import abstractmethod
 from collections.abc import Mapping
@@ -30,7 +29,6 @@ from .version import __version__ as __version__
 from .warnings import SetuptoolsDeprecationWarning
 
 import distutils.core
-from distutils.errors import DistutilsOptionError
 
 __all__ = [
     'setup',
@@ -175,42 +173,6 @@ class Command(_Command):
         super().__init__(dist)
         vars(self).update(kw)
 
-    def _ensure_stringlike(self, option, what, default=None):
-        val = getattr(self, option)
-        if val is None:
-            setattr(self, option, default)
-            return default
-        elif not isinstance(val, str):
-            raise DistutilsOptionError(f"'{option}' must be a {what} (got `{val}`)")
-        return val
-
-    def ensure_string_list(self, option: str) -> None:
-        r"""Ensure that 'option' is a list of strings.  If 'option' is
-        currently a string, we split it either on /,\s*/ or /\s+/, so
-        "foo bar baz", "foo,bar,baz", and "foo,   bar baz" all become
-        ["foo", "bar", "baz"].
-
-        ..
-           TODO: This method seems to be similar to the one in ``distutils.cmd``
-           Probably it is just here for backward compatibility with old Python versions?
-
-        :meta private:
-        """
-        val = getattr(self, option)
-        if val is None:
-            return
-        elif isinstance(val, str):
-            setattr(self, option, re.split(r',\s*|\s+', val))
-        else:
-            if isinstance(val, list):
-                ok = all(isinstance(v, str) for v in val)
-            else:
-                ok = False
-            if not ok:
-                raise DistutilsOptionError(
-                    f"'{option}' must be a list of strings (got {val!r})"
-                )
-
     @overload
     def reinitialize_command(
         self, command: str, reinit_subcommands: bool = False, **kw

py2docfx/venv/venv1/Lib/site-packages/setuptools/_discovery.py

@@ -0,0 +1,33 @@
+import functools
+import operator
+
+import packaging.requirements
+
+
+# from coherent.build.discovery
+def extras_from_dep(dep):
+    try:
+        markers = packaging.requirements.Requirement(dep).marker._markers
+    except AttributeError:
+        markers = ()
+    return set(
+        marker[2].value
+        for marker in markers
+        if isinstance(marker, tuple) and marker[0].value == 'extra'
+    )
+
+
+def extras_from_deps(deps):
+    """
+    >>> extras_from_deps(['requests'])
+    set()
+    >>> extras_from_deps(['pytest; extra == "test"'])
+    {'test'}
+    >>> sorted(extras_from_deps([
+    ...     'requests',
+    ...     'pytest; extra == "test"',
+    ...     'pytest-cov; extra == "test"',
+    ...     'sphinx; extra=="doc"']))
+    ['doc', 'test']
+    """
+    return functools.reduce(operator.or_, map(extras_from_dep, deps), set())

py2docfx/venv/venv1/Lib/site-packages/setuptools/_distutils/command/build_scripts.py

@@ -106,7 +106,7 @@ class build_scripts(Command):
             log.info("copying and adjusting %s -> %s", script, self.build_dir)
             if not self.dry_run:
                 post_interp = shebang_match.group(1) or ''
-                shebang = f"#!python{post_interp}\n"
+                shebang = "#!" + self.executable + post_interp + "\n"
                 self._validate_shebang(shebang, f.encoding)
                 with open(outfile, "w", encoding=f.encoding) as outf:
                     outf.write(shebang)

py2docfx/venv/venv1/Lib/site-packages/setuptools/_distutils/command/config.py

@@ -89,8 +89,6 @@ class config(Command):
         """Check that 'self.compiler' really is a CCompiler object;
         if not, make it one.
         """
-        # We do this late, and only on-demand, because this is an expensive
-        # import.
         if not isinstance(self.compiler, CCompiler):
             self.compiler = new_compiler(
                 compiler=self.compiler, dry_run=self.dry_run, force=True