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

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

@@ -1,96 +1,96 @@
-#  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 parallel computation on multiple cores.
-
-Introduced in Python-RSA 3.1.
-
-.. note::
-
-    Requires Python 2.6 or newer.
-
-"""
-
-import multiprocessing as mp
-from multiprocessing.connection import Connection
-
-import rsa.prime
-import rsa.randnum
-
-
-def _find_prime(nbits: int, pipe: Connection) -> None:
-    while True:
-        integer = rsa.randnum.read_random_odd_int(nbits)
-
-        # Test for primeness
-        if rsa.prime.is_prime(integer):
-            pipe.send(integer)
-            return
-
-
-def getprime(nbits: int, poolsize: int) -> int:
-    """Returns a prime number that can be stored in 'nbits' bits.
-
-    Works in multiple threads at the same time.
-
-    >>> p = getprime(128, 3)
-    >>> rsa.prime.is_prime(p-1)
-    False
-    >>> rsa.prime.is_prime(p)
-    True
-    >>> rsa.prime.is_prime(p+1)
-    False
-
-    >>> from rsa import common
-    >>> common.bit_size(p) == 128
-    True
-
-    """
-
-    (pipe_recv, pipe_send) = mp.Pipe(duplex=False)
-
-    # Create processes
-    try:
-        procs = [mp.Process(target=_find_prime, args=(nbits, pipe_send)) for _ in range(poolsize)]
-        # Start processes
-        for p in procs:
-            p.start()
-
-        result = pipe_recv.recv()
-    finally:
-        pipe_recv.close()
-        pipe_send.close()
-
-    # Terminate processes
-    for p in procs:
-        p.terminate()
-
-    return result
-
-
-__all__ = ["getprime"]
-
-if __name__ == "__main__":
-    print("Running doctests 1000x or until failure")
-    import doctest
-
-    for count in range(100):
-        (failures, tests) = doctest.testmod()
-        if failures:
-            break
-
-        if count % 10 == 0 and count:
-            print("%i times" % count)
-
-    print("Doctests done")
+#  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 parallel computation on multiple cores.
+
+Introduced in Python-RSA 3.1.
+
+.. note::
+
+    Requires Python 2.6 or newer.
+
+"""
+
+import multiprocessing as mp
+from multiprocessing.connection import Connection
+
+import rsa.prime
+import rsa.randnum
+
+
+def _find_prime(nbits: int, pipe: Connection) -> None:
+    while True:
+        integer = rsa.randnum.read_random_odd_int(nbits)
+
+        # Test for primeness
+        if rsa.prime.is_prime(integer):
+            pipe.send(integer)
+            return
+
+
+def getprime(nbits: int, poolsize: int) -> int:
+    """Returns a prime number that can be stored in 'nbits' bits.
+
+    Works in multiple threads at the same time.
+
+    >>> p = getprime(128, 3)
+    >>> rsa.prime.is_prime(p-1)
+    False
+    >>> rsa.prime.is_prime(p)
+    True
+    >>> rsa.prime.is_prime(p+1)
+    False
+
+    >>> from rsa import common
+    >>> common.bit_size(p) == 128
+    True
+
+    """
+
+    (pipe_recv, pipe_send) = mp.Pipe(duplex=False)
+
+    # Create processes
+    try:
+        procs = [mp.Process(target=_find_prime, args=(nbits, pipe_send)) for _ in range(poolsize)]
+        # Start processes
+        for p in procs:
+            p.start()
+
+        result = pipe_recv.recv()
+    finally:
+        pipe_recv.close()
+        pipe_send.close()
+
+    # Terminate processes
+    for p in procs:
+        p.terminate()
+
+    return result
+
+
+__all__ = ["getprime"]
+
+if __name__ == "__main__":
+    print("Running doctests 1000x or until failure")
+    import doctest
+
+    for count in range(100):
+        (failures, tests) = doctest.testmod()
+        if failures:
+            break
+
+        if count % 10 == 0 and count:
+            print("%i times" % count)
+
+    print("Doctests done")

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

@@ -1,134 +1,134 @@
-#  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 that load and write PEM-encoded files."""
-
-import base64
-import typing
-
-# Should either be ASCII strings or bytes.
-FlexiText = typing.Union[str, bytes]
-
-
-def _markers(pem_marker: FlexiText) -> typing.Tuple[bytes, bytes]:
-    """
-    Returns the start and end PEM markers, as bytes.
-    """
-
-    if not isinstance(pem_marker, bytes):
-        pem_marker = pem_marker.encode("ascii")
-
-    return (
-        b"-----BEGIN " + pem_marker + b"-----",
-        b"-----END " + pem_marker + b"-----",
-    )
-
-
-def _pem_lines(contents: bytes, pem_start: bytes, pem_end: bytes) -> typing.Iterator[bytes]:
-    """Generator over PEM lines between pem_start and pem_end."""
-
-    in_pem_part = False
-    seen_pem_start = False
-
-    for line in contents.splitlines():
-        line = line.strip()
-
-        # Skip empty lines
-        if not line:
-            continue
-
-        # Handle start marker
-        if line == pem_start:
-            if in_pem_part:
-                raise ValueError('Seen start marker "%r" twice' % pem_start)
-
-            in_pem_part = True
-            seen_pem_start = True
-            continue
-
-        # Skip stuff before first marker
-        if not in_pem_part:
-            continue
-
-        # Handle end marker
-        if in_pem_part and line == pem_end:
-            in_pem_part = False
-            break
-
-        # Load fields
-        if b":" in line:
-            continue
-
-        yield line
-
-    # Do some sanity checks
-    if not seen_pem_start:
-        raise ValueError('No PEM start marker "%r" found' % pem_start)
-
-    if in_pem_part:
-        raise ValueError('No PEM end marker "%r" found' % pem_end)
-
-
-def load_pem(contents: FlexiText, pem_marker: FlexiText) -> bytes:
-    """Loads a PEM file.
-
-    :param contents: the contents of the file to interpret
-    :param pem_marker: the marker of the PEM content, such as 'RSA PRIVATE KEY'
-        when your file has '-----BEGIN RSA PRIVATE KEY-----' and
-        '-----END RSA PRIVATE KEY-----' markers.
-
-    :return: the base64-decoded content between the start and end markers.
-
-    @raise ValueError: when the content is invalid, for example when the start
-        marker cannot be found.
-
-    """
-
-    # We want bytes, not text. If it's text, it can be converted to ASCII bytes.
-    if not isinstance(contents, bytes):
-        contents = contents.encode("ascii")
-
-    (pem_start, pem_end) = _markers(pem_marker)
-    pem_lines = [line for line in _pem_lines(contents, pem_start, pem_end)]
-
-    # Base64-decode the contents
-    pem = b"".join(pem_lines)
-    return base64.standard_b64decode(pem)
-
-
-def save_pem(contents: bytes, pem_marker: FlexiText) -> bytes:
-    """Saves a PEM file.
-
-    :param contents: the contents to encode in PEM format
-    :param pem_marker: the marker of the PEM content, such as 'RSA PRIVATE KEY'
-        when your file has '-----BEGIN RSA PRIVATE KEY-----' and
-        '-----END RSA PRIVATE KEY-----' markers.
-
-    :return: the base64-encoded content between the start and end markers, as bytes.
-
-    """
-
-    (pem_start, pem_end) = _markers(pem_marker)
-
-    b64 = base64.standard_b64encode(contents).replace(b"\n", b"")
-    pem_lines = [pem_start]
-
-    for block_start in range(0, len(b64), 64):
-        block = b64[block_start : block_start + 64]
-        pem_lines.append(block)
-
-    pem_lines.append(pem_end)
-    pem_lines.append(b"")
-
-    return b"\n".join(pem_lines)
+#  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 that load and write PEM-encoded files."""
+
+import base64
+import typing
+
+# Should either be ASCII strings or bytes.
+FlexiText = typing.Union[str, bytes]
+
+
+def _markers(pem_marker: FlexiText) -> typing.Tuple[bytes, bytes]:
+    """
+    Returns the start and end PEM markers, as bytes.
+    """
+
+    if not isinstance(pem_marker, bytes):
+        pem_marker = pem_marker.encode("ascii")
+
+    return (
+        b"-----BEGIN " + pem_marker + b"-----",
+        b"-----END " + pem_marker + b"-----",
+    )
+
+
+def _pem_lines(contents: bytes, pem_start: bytes, pem_end: bytes) -> typing.Iterator[bytes]:
+    """Generator over PEM lines between pem_start and pem_end."""
+
+    in_pem_part = False
+    seen_pem_start = False
+
+    for line in contents.splitlines():
+        line = line.strip()
+
+        # Skip empty lines
+        if not line:
+            continue
+
+        # Handle start marker
+        if line == pem_start:
+            if in_pem_part:
+                raise ValueError('Seen start marker "%r" twice' % pem_start)
+
+            in_pem_part = True
+            seen_pem_start = True
+            continue
+
+        # Skip stuff before first marker
+        if not in_pem_part:
+            continue
+
+        # Handle end marker
+        if in_pem_part and line == pem_end:
+            in_pem_part = False
+            break
+
+        # Load fields
+        if b":" in line:
+            continue
+
+        yield line
+
+    # Do some sanity checks
+    if not seen_pem_start:
+        raise ValueError('No PEM start marker "%r" found' % pem_start)
+
+    if in_pem_part:
+        raise ValueError('No PEM end marker "%r" found' % pem_end)
+
+
+def load_pem(contents: FlexiText, pem_marker: FlexiText) -> bytes:
+    """Loads a PEM file.
+
+    :param contents: the contents of the file to interpret
+    :param pem_marker: the marker of the PEM content, such as 'RSA PRIVATE KEY'
+        when your file has '-----BEGIN RSA PRIVATE KEY-----' and
+        '-----END RSA PRIVATE KEY-----' markers.
+
+    :return: the base64-decoded content between the start and end markers.
+
+    @raise ValueError: when the content is invalid, for example when the start
+        marker cannot be found.
+
+    """
+
+    # We want bytes, not text. If it's text, it can be converted to ASCII bytes.
+    if not isinstance(contents, bytes):
+        contents = contents.encode("ascii")
+
+    (pem_start, pem_end) = _markers(pem_marker)
+    pem_lines = [line for line in _pem_lines(contents, pem_start, pem_end)]
+
+    # Base64-decode the contents
+    pem = b"".join(pem_lines)
+    return base64.standard_b64decode(pem)
+
+
+def save_pem(contents: bytes, pem_marker: FlexiText) -> bytes:
+    """Saves a PEM file.
+
+    :param contents: the contents to encode in PEM format
+    :param pem_marker: the marker of the PEM content, such as 'RSA PRIVATE KEY'
+        when your file has '-----BEGIN RSA PRIVATE KEY-----' and
+        '-----END RSA PRIVATE KEY-----' markers.
+
+    :return: the base64-encoded content between the start and end markers, as bytes.
+
+    """
+
+    (pem_start, pem_end) = _markers(pem_marker)
+
+    b64 = base64.standard_b64encode(contents).replace(b"\n", b"")
+    pem_lines = [pem_start]
+
+    for block_start in range(0, len(b64), 64):
+        block = b64[block_start : block_start + 64]
+        pem_lines.append(block)
+
+    pem_lines.append(pem_end)
+    pem_lines.append(b"")
+
+    return b"\n".join(pem_lines)