Add files using upload-large-folder tool

miniconda3/lib/python3.13/site-packages/conda_package_streaming-0.12.0.dist-info/INSTALLER

@@ -0,0 +1 @@
+conda

miniconda3/lib/python3.13/site-packages/conda_package_streaming-0.12.0.dist-info/METADATA

@@ -0,0 +1,125 @@
+Metadata-Version: 2.4
+Name: conda_package_streaming
+Version: 0.12.0
+Summary: An efficient library to read from new and old format .conda and .tar.bz2 conda packages.
+Author-email: "Anaconda, Inc. & Contributors" <conda@continuum.io>
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+License-File: LICENSE
+Requires-Dist: requests
+Requires-Dist: zstandard >=0.15
+Requires-Dist: furo ; extra == "docs"
+Requires-Dist: sphinx ; extra == "docs"
+Requires-Dist: myst-parser ; extra == "docs"
+Requires-Dist: mdit-py-plugins>=0.3.0 ; extra == "docs"
+Requires-Dist: pytest >=7 ; extra == "test"
+Requires-Dist: pytest-cov ; extra == "test"
+Requires-Dist: pytest-mock ; extra == "test"
+Requires-Dist: boto3 ; extra == "test"
+Requires-Dist: boto3-stubs[essential] ; extra == "test"
+Requires-Dist: bottle ; extra == "test"
+Requires-Dist: conda ; extra == "test"
+Requires-Dist: conda-package-handling >=2 ; extra == "test"
+Requires-Dist: responses ; extra == "test"
+Project-URL: Documentation, https://conda.github.io/conda-package-streaming/
+Project-URL: Home, https://github.com/conda/conda-package-streaming
+Provides-Extra: docs
+Provides-Extra: test
+
+# conda-package-streaming
+
+[![pre-commit.ci status](https://results.pre-commit.ci/badge/github/conda/conda-package-streaming/main.svg)](https://results.pre-commit.ci/latest/github/conda/conda-package-streaming/main)
+
+An efficient library to read from new and old format .conda and .tar.bz2 conda
+packages.
+
+Download conda metadata from packages without transferring entire file. Get
+metadata from local `.tar.bz2` packages without reading entire files.
+
+Uses enhanced pip `lazy_wheel` to fetch a file out of `.conda` with no more than
+3 range requests, but usually 2.
+
+Uses `tar = tarfile.open(fileobj=...)` to stream remote `.tar.bz2`. Closes the
+HTTP request once desired files have been seen.
+
+# Quickstart
+
+The basic API yields (tarfile, member) tuples from conda files as tarfile is
+needed to extract member. Note the `.tar.bz2` format yields all members, not
+just `info/`, from `stream_conda_info` / `stream_conda_component`, while the
+`.conda` format yields members from the requested inner archive — allowing the
+caller to decide when to stop reading.
+
+From a url,
+```python
+from conda_package_streaming.url import stream_conda_info
+# url = (ends with .conda or .tar.bz2)
+for tar, member in stream_conda_info(url):
+    if member.name == "info/index.json":
+        index_json = json.load(tar.extractfile(member))
+        break
+```
+
+From s3,
+```python
+client = boto3.client("s3")
+from conda_package_streaming.s3 import stream_conda_info
+# key = (ends with .conda or .tar.bz2)
+for tar, member in stream_conda_info(client, bucket, key):
+    if member.name == "info/index.json":
+        index_json = json.load(tar.extractfile(member))
+        break
+```
+
+From a filename,
+```python
+from conda_package_streaming import package_streaming
+# filename = (ends with .conda or .tar.bz2)
+for tar, member in package_streaming.stream_conda_info(filename):
+    if member.name == "info/index.json":
+        index_json = json.load(tar.extractfile(member))
+        break
+```
+
+From a file-like object,
+```python
+from contextlib import closing
+
+from conda_package_streaming.url import conda_reader_for_url
+from conda_package_streaming.package_streaming import stream_conda_component
+filename, conda = conda_reader_for_url(url)
+
+# file object must be seekable for `.conda` format, but merely readable for `.tar.bz2`
+with closing(conda):
+    for tar, member in stream_conda_component(filename, conda, component="info"):
+        if member.name == "info/index.json":
+            index_json = json.load(tar.extractfile(member))
+            break
+```
+
+If you need the entire package, download it first and use the file-based APIs.
+The URL-based APIs are more efficient if you only need to access package
+metadata.
+
+# Package goals
+
+* Extract conda packages (both formats)
+* Easy to install from pypi or conda
+* Do the least amount of I/O possible (no temporary files, transfer partial packages)
+* Open files from the network / standard HTTP / s3
+
+* Continue using conda-package-handling to create .conda packages
+
+# Generating documentation
+
+Uses markdown, furo theme. Requires newer mdit-py-plugins.
+
+`pip install conda-package-streaming[docs]`
+
+One time:
+`sphinx-apidoc -o docs .`
+

miniconda3/lib/python3.13/site-packages/conda_package_streaming-0.12.0.dist-info/RECORD

@@ -0,0 +1,25 @@
+conda_package_streaming-0.12.0.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+conda_package_streaming-0.12.0.dist-info/METADATA,sha256=lCyDK_zdW7svxhrpb4hh3-Z0u5jWULDb3Iio88SWl-M,4557
+conda_package_streaming-0.12.0.dist-info/RECORD,,
+conda_package_streaming-0.12.0.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+conda_package_streaming-0.12.0.dist-info/WHEEL,sha256=G2gURzTEtmeR8nrdXUJfNiB3VYVxigPQ-bEQujpNiNs,82
+conda_package_streaming-0.12.0.dist-info/direct_url.json,sha256=YjtlnLGPvwoJwtWoAtXcSU6g8U6tbPaVLW9QX9be--U,113
+conda_package_streaming-0.12.0.dist-info/licenses/LICENSE,sha256=WPOScO-I9aoJgXok_DebNZN-PZhtB13xi1WqU0iqrWY,2670
+conda_package_streaming/__init__.py,sha256=eHjt9DPsMbptabS2yGx9Yhbyzq5hFSUHXb7zc8Q_8-o,23
+conda_package_streaming/__pycache__/__init__.cpython-313.pyc,,
+conda_package_streaming/__pycache__/create.cpython-313.pyc,,
+conda_package_streaming/__pycache__/exceptions.cpython-313.pyc,,
+conda_package_streaming/__pycache__/extract.cpython-313.pyc,,
+conda_package_streaming/__pycache__/lazy_wheel.cpython-313.pyc,,
+conda_package_streaming/__pycache__/package_streaming.cpython-313.pyc,,
+conda_package_streaming/__pycache__/s3.cpython-313.pyc,,
+conda_package_streaming/__pycache__/transmute.cpython-313.pyc,,
+conda_package_streaming/__pycache__/url.cpython-313.pyc,,
+conda_package_streaming/create.py,sha256=7TvCl0HvJBnH5bO0RmUKab4avAIYg-xEp3bb-j48_8A,6142
+conda_package_streaming/exceptions.py,sha256=7fG4CNtukkSRWAGh9Zg2DCNkhw-wNo-Oi35c2jf0VsQ,677
+conda_package_streaming/extract.py,sha256=GoCq9CWukzycCHggFyhT-QVeSw56Yg4KfDgIKtZ7A3g,2935
+conda_package_streaming/lazy_wheel.py,sha256=dCz7-BpEVCyVfpsQNtcesRpz0d9dZsM1ABwxXGJ-ZHU,12172
+conda_package_streaming/package_streaming.py,sha256=DD7Pvrv1aH95lmAMHacBfCgElefq4Ojt443nlpRzXMU,5107
+conda_package_streaming/s3.py,sha256=ygm59wSPpixvwkO4QqSgvalNUjAk1FzEXW0JNj45cgI,2286
+conda_package_streaming/transmute.py,sha256=YUrjsuJl0wNK_RlCG8a80WxzF65o9zPaVOXMJMLCg-M,5540
+conda_package_streaming/url.py,sha256=bZ_fO_BLWbz--Sc1QjAY4gRxMtGc8BEGqc8yBGAWPnE,3219

miniconda3/lib/python3.13/site-packages/conda_package_streaming-0.12.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: flit 3.12.0
+Root-Is-Purelib: true
+Tag: py3-none-any

miniconda3/lib/python3.13/site-packages/conda_package_streaming-0.12.0.dist-info/direct_url.json

@@ -0,0 +1 @@
+{"dir_info": {}, "url": "file:///home/task_176236152622180/conda-bld/conda-package-streaming_1762361633858/work"}

miniconda3/lib/python3.13/site-packages/conda_package_streaming-0.12.0.dist-info/licenses/LICENSE

@@ -0,0 +1,53 @@
+BSD 3-Clause License
+
+Copyright (c) 2022, Anaconda, Inc.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+lazy_wheel.py:
+
+Copyright (c) 2008-present The pip developers (see
+https://github.com/pypa/pip/blob/main/AUTHORS.txt file)
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

miniconda3/lib/python3.13/site-packages/conda_package_streaming/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.12.0"

miniconda3/lib/python3.13/site-packages/conda_package_streaming/create.py

@@ -0,0 +1,191 @@
+"""
+Tools for creating ``.conda``-format archives.
+
+Uses ``tempfile.SpooledTemporaryFile`` to buffer ``pkg-*.tar`` and
+``info-*.tar``, then compress directly into an open `ZipFile` at the end.
+`SpooledTemporaryFile` buffers the first 10MB of the package and its metadata in
+memory, but writes out to disk for larger packages.
+
+Uses more disk space than ``conda-package-handling`` (temporary uncompressed
+tarballs of the package contents) but accepts streams instead of just
+files-on-the-filesystem.
+"""
+
+from __future__ import annotations
+
+import json
+import shutil
+import tarfile
+import tempfile
+import zipfile
+from collections.abc import Iterator
+from contextlib import contextmanager
+from pathlib import Path
+from typing import Callable
+
+import zstandard
+
+# increase to reduce speed and increase compression (levels above 19 use much
+# more memory)
+ZSTD_COMPRESS_LEVEL = 19
+# increase to reduce compression and increase speed
+ZSTD_COMPRESS_THREADS = 1
+
+CONDA_PACKAGE_FORMAT_VERSION = 2
+
+# Account for growth from "2 GB of /dev/urandom" to not exceed ZIP64_LIMIT after
+# compression
+CONDA_ZIP64_LIMIT = zipfile.ZIP64_LIMIT - (1 << 18) - 1
+
+
+def anonymize(tarinfo: tarfile.TarInfo):
+    """
+    Pass to ``tarfile.add(..., filter=anonymize)`` to anonymize uid/gid.
+
+    Does not anonymize mtime or any other field.
+    """
+    tarinfo.uid = tarinfo.gid = 0
+    tarinfo.uname = tarinfo.gname = ""
+    return tarinfo
+
+
+class CondaTarFile(tarfile.TarFile):
+    """
+    Subclass of :external+python:py:class:`tarfile.TarFile` that adds members to
+    a second ``info`` tar if they match ``is_info(name)``.
+
+    Create this with ``conda_builder(...)`` which sets up the component
+    archives, then wraps them into a ``.conda`` on exit.
+
+    Only useful for creating, not extracting ``.conda``.
+    """
+
+    info_tar: tarfile.TarFile
+    is_info: Callable
+
+    def __init__(
+        self,
+        *args,
+        info_tar: tarfile.TarFile,
+        is_info=lambda name: name.startswith("info/"),
+        **kwargs,
+    ):
+        super().__init__(*args, **kwargs)
+        self.info_tar = info_tar
+        self.is_info = is_info
+
+    def addfile(self, tarinfo, fileobj=None):
+        """
+        Add the TarInfo object ``tarinfo`` to the archive. If ``fileobj`` is
+        given, it should be a binary file, and tarinfo.size bytes are read from
+        it and added to the archive. You can create TarInfo objects directly, or
+        by using ``gettarinfo()``.
+
+        If ``self.is_info(tarinfo.name)`` returns ``True``, add ``tarinfo`` to
+        ``self.info_tar`` instead.
+        """
+        if self.is_info(tarinfo.name):
+            return self.info_tar.addfile(tarinfo, fileobj=fileobj)
+        else:
+            return super().addfile(tarinfo, fileobj)
+
+
+@contextmanager
+def conda_builder(
+    stem,
+    path,
+    *,
+    compressor: Callable[
+        [], zstandard.ZstdCompressor
+    ] = lambda: zstandard.ZstdCompressor(
+        level=ZSTD_COMPRESS_LEVEL, threads=ZSTD_COMPRESS_THREADS
+    ),
+    is_info: Callable[[str], bool] = lambda filename: filename.startswith("info/"),
+    encoding="utf-8",
+) -> Iterator[CondaTarFile]:
+    """
+    Produce a ``TarFile`` subclass used to build a ``.conda`` package. The
+    subclass delegates ``addfile()`` to the ``info-`` component when ``is_info``
+    returns True.
+
+    When the context manager exits, ``{path}/{stem}.conda`` is written with
+    the component tar archives.
+
+    Args:
+        stem: output filename without extension
+
+        path: destination path for transmuted .conda package compressor: A
+            function that creates instances of ``zstandard.ZstdCompressor()``.
+
+        encoding: passed to TarFile constructor. Keep default "utf-8" for valid
+            .conda.
+
+    Yields:
+        ``CondaTarFile``
+    """
+    output_path = Path(path, f"{stem}.conda")
+    with (
+        tempfile.SpooledTemporaryFile() as info_file,
+        tempfile.SpooledTemporaryFile() as pkg_file,
+    ):
+        with (
+            tarfile.TarFile(fileobj=info_file, mode="w", encoding=encoding) as info_tar,
+            CondaTarFile(
+                fileobj=pkg_file,
+                mode="w",
+                info_tar=info_tar,
+                is_info=is_info,
+                encoding=encoding,
+            ) as pkg_tar,
+        ):
+            # If we wanted to compress these at a low setting to save temporary
+            # space, we could insert a file object that counts bytes written in
+            # front of a zstd (level between 1..3) compressor.
+            yield pkg_tar
+
+            info_tar.close()
+            pkg_tar.close()
+
+            info_size = info_file.tell()
+            pkg_size = pkg_file.tell()
+
+            info_file.seek(0)
+            pkg_file.seek(0)
+
+        with zipfile.ZipFile(
+            output_path,
+            "x",  # x to not append to existing
+            compresslevel=zipfile.ZIP_STORED,
+        ) as conda_file:
+            # Use a maximum of one Zstd compressor, stream_writer at a time to save
+            # # memory.
+            data_compress = compressor()
+
+            pkg_metadata = {"conda_pkg_format_version": CONDA_PACKAGE_FORMAT_VERSION}
+            conda_file.writestr("metadata.json", json.dumps(pkg_metadata))
+
+            with (
+                conda_file.open(
+                    f"pkg-{stem}.tar.zst",
+                    "w",
+                    force_zip64=(pkg_size > CONDA_ZIP64_LIMIT),
+                ) as pkg_file_zip,
+                data_compress.stream_writer(
+                    pkg_file_zip, size=pkg_size, closefd=False
+                ) as pkg_stream,
+            ):
+                shutil.copyfileobj(pkg_file._file, pkg_stream)
+
+            with (
+                conda_file.open(
+                    f"info-{stem}.tar.zst",
+                    "w",
+                    force_zip64=(info_size > CONDA_ZIP64_LIMIT),
+                ) as info_file_zip,
+                data_compress.stream_writer(
+                    info_file_zip,
+                    size=info_size,
+                    closefd=False,
+                ) as info_stream,
+            ):
+                shutil.copyfileobj(info_file._file, info_stream)

miniconda3/lib/python3.13/site-packages/conda_package_streaming/exceptions.py

@@ -0,0 +1,19 @@
+import tarfile
+
+
+class SafetyError(tarfile.TarError):
+    def __init__(self, msg, *args, **kw):
+        msg = f"Error with archive. {msg}"
+        super().__init__(msg)
+
+
+class CaseInsensitiveFileSystemError(OSError):
+    def __init__(self):
+        message = """\
+Cannot extract package to a case-insensitive file system. Your install
+destination does not differentiate between upper and lowercase characters, and
+this breaks things. Try installing to a location that is case-sensitive. Windows
+drives are usually the culprit here - can you install to a native Unix drive, or
+turn on case sensitivity for this (Windows) location?
+        """
+        super().__init__(message)

miniconda3/lib/python3.13/site-packages/conda_package_streaming/extract.py

@@ -0,0 +1,93 @@
+"""
+Extract package to directory, with checks against tar members extracting outside
+the target directory.
+"""
+
+from __future__ import annotations
+
+import os
+import tarfile
+from collections.abc import Generator
+from errno import ELOOP
+from pathlib import Path
+
+from . import exceptions, package_streaming
+
+__all__ = ["extract_stream", "extract"]
+HAS_TAR_FILTER = hasattr(tarfile, "tar_filter")
+
+
+def extract_stream(
+    stream: Generator[tuple[tarfile.TarFile, tarfile.TarInfo]],
+    dest_dir: Path | str,
+    tar_filter: str | None = None,
+):
+    """
+    Pipe ``stream_conda_component`` output here to extract every member into
+    dest_dir.
+
+    For ``.conda`` will need to be called twice (for info and pkg components);
+    for ``.tar.bz2`` every member is extracted.
+    """
+    dest_dir = os.path.realpath(dest_dir)
+
+    def is_within_dest_dir(name):
+        abs_target = os.path.realpath(os.path.join(dest_dir, name))
+        prefix = os.path.commonpath((dest_dir, abs_target))
+        return prefix == dest_dir
+
+    for tar_file, _ in stream:
+        # careful not to seek backwards
+        def checked_members():
+            # from conda_package_handling
+            for member in tar_file:
+                if not is_within_dest_dir(member.name):
+                    raise exceptions.SafetyError(f"contains unsafe path: {member.name}")
+                yield member
+
+        try:
+            # Drop checked_members() when HAS_TAR_FILTER once we are 100%
+            # certain the stdlib filter maintains same permissions as
+            # checked_members().
+            tar_args = {"path": dest_dir, "members": checked_members()}
+            if HAS_TAR_FILTER:
+                tar_args["filter"] = tar_filter or "fully_trusted"
+            tar_file.extractall(**tar_args)
+        except OSError as e:
+            if e.errno == ELOOP:
+                raise exceptions.CaseInsensitiveFileSystemError() from e
+            raise
+
+        # next iteraton of for loop raises GeneratorExit in stream
+        stream.close()
+
+
+def extract(filename, dest_dir=None, fileobj=None):
+    """
+    Extract all components of conda package to dest_dir.
+
+    fileobj: must be seekable if provided, if a ``.conda`` package.
+    """
+    assert dest_dir, "dest_dir is required"
+    if str(filename).endswith(".conda"):
+        components = [
+            package_streaming.CondaComponent.pkg,
+            package_streaming.CondaComponent.info,
+        ]
+    else:  # .tar.bz2 doesn't filter by component
+        components = [package_streaming.CondaComponent.pkg]
+
+    closefd = False
+    if not fileobj:
+        fileobj = open(filename, "rb")
+        closefd = True
+
+    try:
+        for component in components:
+            stream = package_streaming.stream_conda_component(
+                filename, fileobj, component=component
+            )
+            extract_stream(stream, dest_dir)
+    finally:
+        if closefd:
+            fileobj.close()

miniconda3/lib/python3.13/site-packages/conda_package_streaming/lazy_wheel.py

@@ -0,0 +1,331 @@
+"""Lazy ZIP over HTTP"""
+
+from __future__ import annotations
+
+import logging
+import zipfile
+from bisect import bisect_left, bisect_right
+from collections.abc import Iterator
+from contextlib import contextmanager
+from tempfile import NamedTemporaryFile
+from typing import Any
+from zipfile import BadZipfile, ZipFile
+
+from requests import HTTPError, Session
+from requests.models import CONTENT_CHUNK_SIZE, Response
+
+# from pip 22.0.3 with fixes & remove imports from pip
+
+
+log = logging.getLogger(__name__)
+
+# If-Match (etag) to detect file changed during fetch would also be nice
+HEADERS = {"Accept-Encoding": "identity"}
+
+
+class HTTPRangeRequestUnsupported(Exception):
+    pass
+
+
+class LazyZipOverHTTP:
+    """File-like object mapped to a ZIP file over HTTP.
+
+    This uses HTTP range requests to lazily fetch the file's content,
+    which is supposed to be fed to ZipFile.  If such requests are not
+    supported by the server, raise HTTPRangeRequestUnsupported
+    during initialization.
+    """
+
+    def __init__(
+        self,
+        url: str,
+        session: Session,
+        chunk_size: int = CONTENT_CHUNK_SIZE,
+        fall_back_to_full_download: bool = False,
+    ) -> None:
+        """
+        Initialize a LazyZipOverHTTP object.
+
+        :param session: The session to use for web requests.
+        :param chunk_size: The chunk size to use for downloading.
+        :param fall_back_to_full_download: If true, we fall back to downloading
+        the whole file if the server incorrectly responds with 416
+        (Range Not Satisfiable) to an HTTP range request.
+        """
+        # if CONTENT_CHUNK_SIZE is bigger than the file:
+        # In [8]: response.headers["Content-Range"]
+        # Out[8]: 'bytes 0-3133374/3133375'
+
+        self._request_count = 0
+
+        self._session, self._url, self._chunk_size = session, url, chunk_size
+
+        self._fall_back_to_full_download: bool = fall_back_to_full_download
+        self._has_streaming_support: bool = True
+
+        # If the server returns 416 (Range Not Satisfiable) and the fallback is
+        # enabled, we request the whole file and set this to False. Some package
+        # servers incorrectly respond with 416 (Range Not Satisfiable) if the
+        # file is smaller than the range requested.
+
+        # initial range request for the end of the file
+        # if the server does not support range requests, this sets
+        # _has_streaming_support to False
+        tail = self._stream_response(start="", end=CONTENT_CHUNK_SIZE)
+        # e.g. {'accept-ranges': 'bytes', 'content-length': '10240',
+        # 'content-range': 'bytes 12824-23063/23064', 'last-modified': 'Sat, 16
+        # Apr 2022 13:03:02 GMT', 'date': 'Thu, 21 Apr 2022 11:34:04 GMT'}
+
+        if self._has_streaming_support and tail.status_code != 206:
+            raise HTTPRangeRequestUnsupported("range request is not supported")
+
+        if self._has_streaming_support:
+            # lowercase content-range to support s3
+            self._length = int(tail.headers["content-range"].partition("/")[-1])
+        else:
+            # the file is already downloaded
+            self._length = len(tail.content)
+
+        self._file = NamedTemporaryFile()
+        self.truncate(self._length)
+
+        # length is also in Content-Length and Content-Range header
+        with self._stay():
+            if self._has_streaming_support:
+                content_length = int(tail.headers["content-length"])
+                if hasattr(tail, "content"):
+                    assert content_length == len(tail.content)
+            else:
+                content_length = len(tail.content)
+            self.seek(self._length - content_length)
+            for chunk in tail.iter_content(self._chunk_size):
+                self._file.write(chunk)
+        self._left: list[int] = [self._length - content_length]
+        self._right: list[int] = [self._length - 1]
+
+    @property
+    def mode(self) -> str:
+        """Opening mode, which is always rb."""
+        return "rb"
+
+    @property
+    def name(self) -> str:
+        """Path to the underlying file."""
+        return self._file.name
+
+    def seekable(self) -> bool:
+        """Return whether random access is supported, which is True."""
+        return True
+
+    def close(self) -> None:
+        """Close the file."""
+        self._file.close()
+
+    @property
+    def closed(self) -> bool:
+        """Whether the file is closed."""
+        return self._file.closed
+
+    def read(self, size: int = -1) -> bytes:
+        """Read up to size bytes from the object and return them.
+
+        As a convenience, if size is unspecified or -1,
+        all bytes until EOF are returned.  Fewer than
+        size bytes may be returned if EOF is reached.
+        """
+        # BUG does not download correctly if size is unspecified
+        download_size = size
+        start, length = self.tell(), self._length
+        stop = length if size < 0 else min(start + download_size, length)
+        start = max(0, stop - download_size)
+        self._download(start, stop - 1)
+        return self._file.read(size)
+
+    def readable(self) -> bool:
+        """Return whether the file is readable, which is True."""
+        return True
+
+    def seek(self, offset: int, whence: int = 0) -> int:
+        """Change stream position and return the new absolute position.
+
+        Seek to offset relative position indicated by whence:
+        * 0: Start of stream (the default).  pos should be >= 0;
+        * 1: Current position - pos may be negative;
+        * 2: End of stream - pos usually negative.
+        """
+        return self._file.seek(offset, whence)
+
+    def tell(self) -> int:
+        """Return the current position."""
+        return self._file.tell()
+
+    def truncate(self, size: int | None = None) -> int:
+        """Resize the stream to the given size in bytes.
+
+        If size is unspecified resize to the current position.
+        The current stream position isn't changed.
+
+        Return the new file size.
+        """
+        return self._file.truncate(size)
+
+    def writable(self) -> bool:
+        """Return False."""
+        return False
+
+    def __enter__(self) -> LazyZipOverHTTP:
+        self._file.__enter__()
+        return self
+
+    def __exit__(self, *exc: Any) -> bool | None:
+        return self._file.__exit__(*exc)
+
+    @contextmanager
+    def _stay(self) -> Iterator[None]:
+        """Return a context manager keeping the position.
+
+        At the end of the block, seek back to original position.
+        """
+        pos = self.tell()
+        try:
+            yield
+        finally:
+            self.seek(pos)
+
+    def _check_zip(self) -> None:
+        """Check and download until the file is a valid ZIP."""
+        end = self._length - 1
+        for start in reversed(range(0, end, self._chunk_size)):
+            self._download(start, end)
+            with self._stay():
+                try:
+                    # For read-only ZIP files, ZipFile only needs
+                    # methods read, seek, seekable and tell.
+                    ZipFile(self)  # type: ignore
+                except BadZipfile:
+                    pass
+                else:
+                    break
+
+    def _stream_response(
+        self, start: int | str, end: int, base_headers: dict[str, str] = HEADERS
+    ) -> Response:
+        """
+        Return HTTP response to a range request from start to end.
+        If the does not support range requests, the whole file is requested.
+
+        :param start: if "", request `end` bytes from end of file.
+        """
+        headers = base_headers.copy()
+        headers["Range"] = f"bytes={start}-{end}"
+        log.debug("%s", headers["Range"])
+        # TODO: Get range requests to be correctly cached
+        headers["Cache-Control"] = "no-cache"
+        self._request_count += 1
+
+        if self._has_streaming_support:
+            response = self._session.get(self._url, headers=headers, stream=True)
+
+            if response.status_code == 416 and self._fall_back_to_full_download:
+                # Range Not Satisfiable -> enable fallback
+                self._has_streaming_support = False
+            elif response.status_code == 416:
+                # fallback disabled, print helpful error message
+                raise HTTPError(
+                    "The server returned 416 (Range Not Satisfiable). "
+                    "This can occur on a buggy server if the file is smaller "
+                    "than the range requested. Set the fall_back_to_full_download flag "
+                    "to work around this issue.",
+                    response=response,
+                )
+            else:
+                response.raise_for_status()
+                return response
+
+        # no streaming support, try to get the whole file
+        del headers["Range"]
+        response = self._session.get(self._url, headers=headers, stream=True)
+
+        response.raise_for_status()
+        return response
+
+    def _merge(
+        self, start: int, end: int, left: int, right: int
+    ) -> Iterator[tuple[int, int]]:
+        """Return an iterator of intervals to be fetched.
+
+        Args:
+            start (int): Start of needed interval
+            end (int): End of needed interval
+            left (int): Index of first overlapping downloaded data
+            right (int): Index after last overlapping downloaded data
+        """
+        lslice, rslice = self._left[left:right], self._right[left:right]
+        i = start = min([start] + lslice[:1])
+        end = max([end] + rslice[-1:])
+        for j, k in zip(lslice, rslice):
+            if j > i:
+                yield i, j - 1
+            i = k + 1
+        if i <= end:
+            yield i, end
+        self._left[left:right], self._right[left:right] = [start], [end]
+
+    def _download(self, start: int, end: int) -> None:
+        """
+        Download bytes from start to end inclusively. If the server does not support
+        streaming for this file, this does nothing as the entire file is already
+        downloaded.
+        """
+        # these assertions should hold, but read() violates them
+        # assert 0 <= start <= end
+        # assert end < self._length
+
+        with self._stay():
+            left = bisect_left(self._right, start)
+            right = bisect_right(self._left, end)
+            for start, end in self._merge(start, end, left, right):
+                response = self._stream_response(start, end)
+                self.seek(start)
+                for chunk in response.iter_content(self._chunk_size):
+                    self._file.write(chunk)
+
+
+class LazyConda(LazyZipOverHTTP):
+    def prefetch(self, conda_file_id):
+        """
+        Conda fork specific. Prefetch the `.info` range from the remote archive.
+        Reduces number of Range requests to 2 or 3 (1 or 2 for the directory, 1
+        for the file).
+
+        conda_file_id: name of .conda without path or `.conda` extension
+        """
+        target_file = f"info-{conda_file_id}.tar.zst"
+        with self._stay():  # not strictly necessary
+            # try to read entire conda info in one request
+            zf = zipfile.ZipFile(self)
+            infolist = zf.infolist()
+            for i, info in enumerate(infolist):
+                if info.filename == target_file:
+                    # could be incorrect if zipfile was concatenated to another
+                    # file (not likely for .conda)
+                    start = info.header_offset
+                    try:
+                        end = infolist[i + 1].header_offset
+                        # or info.header_offset
+                        # + len(info.filename)
+                        # + len(info.extra)
+                        # + info.compress_size
+                        # (unless Zip64)
+                    except IndexError:
+                        end = zf.start_dir
+                    self.seek(start)
+                    self.read(end - start)
+                    log.debug(
+                        "prefetch %s-%s",
+                        info.header_offset,
+                        end,
+                    )
+                    break
+            else:
+                log.debug("no zip prefetch")

miniconda3/lib/python3.13/site-packages/conda_package_streaming/package_streaming.py

@@ -0,0 +1,154 @@
+"""
+Unpack conda packages without using a temporary file.
+"""
+
+from __future__ import annotations
+
+import bz2
+import os
+import os.path
+import tarfile
+import zipfile
+from collections.abc import Generator
+from enum import Enum
+
+# acquire umask taking advantage of import system lock, instead of possibly in
+# multiple threads at once.
+UMASK = os.umask(0)
+os.umask(UMASK)
+
+try:
+    import zstandard
+except ImportError:
+    import warnings
+
+    warnings.warn("zstandard could not be imported. Running without .conda support.")
+
+    zstandard = None
+
+
+class CondaComponent(Enum):
+    pkg = "pkg"
+    info = "info"
+
+    def __str__(self):
+        return self.value
+
+
+class TarfileNoSameOwner(tarfile.TarFile):
+    def __init__(self, *args, umask: int | None = None, **kwargs):
+        """Open an (uncompressed) tar archive `name'. `mode' is either 'r' to
+        read from an existing archive, 'a' to append data to an existing
+        file or 'w' to create a new file overwriting an existing one. `mode'
+        defaults to 'r'.
+        If `fileobj' is given, it is used for reading or writing data. If it
+        can be determined, `mode' is overridden by `fileobj's mode.
+        `fileobj' is not closed, when TarFile is closed.
+        """
+        super().__init__(*args, **kwargs)
+        self.umask = umask if umask is not None else UMASK
+
+    def chown(self, tarinfo, targetpath, numeric_owner):
+        """
+        Override chown to be a no-op, since we don't want to preserve ownership
+        here. (tarfile.TarFile only lets us toggle all of (chown, chmod, mtime))
+        """
+        return
+
+    def chmod(self, tarinfo, targetpath):
+        """
+        Set file permissions of targetpath according to tarinfo, respecting
+        umask.
+        """
+        if tarinfo.mode is None:
+            return
+
+        try:
+            os.chmod(targetpath, tarinfo.mode & (-1 & (~self.umask)))
+        except OSError as e:
+            raise tarfile.ExtractError("could not change mode") from e
+
+
+def tar_generator(
+    fileobj, tarfile_open=TarfileNoSameOwner.open, closefd=False, *, encoding="utf-8"
+) -> Generator[tuple[tarfile.TarFile, tarfile.TarInfo]]:
+    """
+    Yield (tar, member) from fileobj.
+
+    Args:
+        fileobj: file-like object
+
+        encoding: "utf-8" passed to TarFile.open(); can be changed for testing.
+    """
+    # tarfile will not close fileobj because _extfileobj is True
+    # caller should take care to close files all the way back to the http request...
+    try:
+        with tarfile_open(fileobj=fileobj, mode="r|", encoding=encoding) as tar:
+            for member in tar:
+                yield tar, member
+    finally:
+        if closefd:
+            fileobj.close()
+
+
+def stream_conda_info(
+    filename, fileobj=None
+) -> Generator[tuple[tarfile.TarFile, tarfile.TarInfo]]:
+    """
+    Yield members from conda's embedded info/ tarball.
+
+    For .tar.bz2 packages, yield all members.
+
+    Yields (tar, member) tuples. You must only use the current member to
+    prevent tar seeks and scans.
+
+    To extract to disk, it's possible to call ``tar.extractall(path)`` on the
+    first result and then ignore the rest of this generator. ``extractall`` takes
+    care of some directory permissions/mtime issues, compared to ``extract`` or
+    writing out the file objects yourself.
+    """
+    component = "info"
+    return stream_conda_component(filename, fileobj, component)
+
+
+def stream_conda_component(
+    filename,
+    fileobj=None,
+    component: CondaComponent | str = CondaComponent.pkg,
+    *,
+    encoding="utf-8",
+) -> Generator[tuple[tarfile.TarFile, tarfile.TarInfo]]:
+    """
+    Yield members from .conda's embedded {component}- tarball. "info" or "pkg".
+
+    For .tar.bz2 packages, yield all members.
+
+    Yields (tar, member) tuples. You must only use the current member to
+    prevent tar seeks and scans.
+
+    To extract to disk, it's possible to call ``tar.extractall(path)`` on the
+    first result and then ignore the rest of this generator. ``extractall`` takes
+    care of some directory permissions/mtime issues, compared to ``extract`` or
+    writing out the file objects yourself.
+    """
+    if str(filename).endswith(".conda"):
+        if zstandard is None:
+            raise RuntimeError("Cannot unpack `.conda` without zstandard")
+
+        zf = zipfile.ZipFile(fileobj or filename)
+        stem, _, _ = os.path.basename(filename).rpartition(".")
+        component_name = f"{component}-{stem}"
+        component_filename = [
+            info for info in zf.infolist() if info.filename.startswith(component_name)
+        ]
+        if not component_filename:
+            raise LookupError(f"didn't find {component_name} component in {filename}")
+        assert len(component_filename) == 1
+        reader = zstandard.ZstdDecompressor().stream_reader(
+            zf.open(component_filename[0])
+        )
+    elif str(filename).endswith(".tar.bz2"):
+        reader = bz2.open(fileobj or filename, mode="rb")
+    else:
+        raise ValueError("unsupported file extension")
+    return tar_generator(reader, closefd=fileobj is None, encoding=encoding)

miniconda3/lib/python3.13/site-packages/conda_package_streaming/s3.py

@@ -0,0 +1,83 @@
+"""
+Adapt s3 to package_streaming
+"""
+
+from __future__ import annotations
+
+import typing
+from contextlib import closing
+from typing import Any
+
+from . import package_streaming
+
+if typing.TYPE_CHECKING:  # pragma: no cover
+    from mypy_boto3_s3 import Client
+    from mypy_boto3_s3.type_defs import GetObjectOutputTypeDef
+else:
+    Client = GetObjectOutputTypeDef = None
+
+from .url import conda_reader_for_url
+
+__all__ = ["stream_conda_info", "conda_reader_for_s3"]
+
+
+class ResponseFacade:
+    def __init__(self, response: GetObjectOutputTypeDef):
+        self.response = response
+        self.raw: Any = response["Body"]
+
+    def raise_for_status(self):
+        # s3 get_object raises automatically?
+        pass
+
+    @property
+    def status_code(self):
+        return self.response["ResponseMetadata"]["HTTPStatusCode"]
+
+    @property
+    def headers(self):
+        # a case-sensitive dict; keys may be lowercased always?
+        return self.response["ResponseMetadata"]["HTTPHeaders"]
+
+    def iter_content(self, n: int):
+        return iter(lambda: self.raw.read(n), b"")
+
+
+class SessionFacade:
+    """
+    Make s3 client look just enough like a requests.session for LazyZipOverHTTP
+    """
+
+    def __init__(self, client: Client, bucket: str, key: str):
+        self.client = client
+        self.bucket = bucket
+        self.key = key
+
+    def get(self, url, *, headers: dict | None = None, stream=True):
+        if headers and "Range" in headers:
+            response = self.client.get_object(
+                Bucket=self.bucket, Key=self.key, Range=headers["Range"]
+            )
+        else:
+            response = self.client.get_object(Bucket=self.bucket, Key=self.key)
+        return ResponseFacade(response)
+
+
+def stream_conda_info(client, bucket, key):
+    """
+    Yield (tar, member) for conda package.
+
+    Just "info/" for .conda, all members for tar.
+    """
+    filename, conda = conda_reader_for_s3(client, bucket, key)
+
+    with closing(conda):
+        yield from package_streaming.stream_conda_info(filename, conda)
+
+
+def conda_reader_for_s3(client: Client, bucket: str, key: str):
+    """
+    Return (name, file_like) suitable for package_streaming APIs
+    """
+    session: Any = SessionFacade(client, bucket, key)
+    return conda_reader_for_url(key, session)

miniconda3/lib/python3.13/site-packages/conda_package_streaming/transmute.py

@@ -0,0 +1,162 @@
+"""
+Convert .tar.bz2 to .conda
+
+Uses ``tempfile.SpooledTemporaryFile`` to buffer ``pkg-*.tar`` and
+``info-*.tar``, then compress directly into an open `ZipFile` at the end.
+`SpooledTemporaryFile` buffers the first 10MB of the package and its metadata in
+memory, but writes out to disk for larger packages.
+"""
+
+from __future__ import annotations
+
+import os
+import tarfile
+from collections.abc import Iterator
+from pathlib import Path
+from typing import Callable
+
+import zstandard
+
+from .create import ZSTD_COMPRESS_LEVEL, ZSTD_COMPRESS_THREADS, conda_builder
+
+# streams everything in .tar.bz2 mode
+from .package_streaming import CondaComponent, stream_conda_component
+
+
+def transmute(
+    package,
+    path,
+    *,
+    compressor: Callable[
+        [], zstandard.ZstdCompressor
+    ] = lambda: zstandard.ZstdCompressor(
+        level=ZSTD_COMPRESS_LEVEL, threads=ZSTD_COMPRESS_THREADS
+    ),
+    is_info: Callable[[str], bool] = lambda filename: filename.startswith("info/"),
+) -> Path:
+    """
+    Convert .tar.bz2 conda package to .conda-format under path.
+
+    :param package: path to .tar.bz2 conda package
+    :param path: destination path for transmuted .conda package
+    :param compressor: A function that creates instances of
+        ``zstandard.ZstdCompressor()`` to override defaults.
+    :param is_info: A function that returns True if a file belongs in the
+        ``info`` component of a `.conda` package.  ``conda-package-handling``
+        (not this package ``conda-package-streaming``) uses a set of regular
+        expressions to keep expected items in the info- component, while other
+        items starting with ``info/`` wind up in the pkg- component.
+
+    :return: Path to transmuted package.
+    """
+    assert package.endswith(".tar.bz2"), "can only convert .tar.bz2 to .conda"
+    assert os.path.isdir(path)
+    stem = os.path.basename(package)[: -len(".tar.bz2")]
+    package_stream = stream_conda_component(package)
+
+    return transmute_stream(
+        stem,
+        path,
+        compressor=compressor,
+        is_info=is_info,
+        package_stream=package_stream,
+    )
+
+
+def transmute_stream(
+    stem,
+    path,
+    *,
+    compressor: Callable[
+        [], zstandard.ZstdCompressor
+    ] = lambda: zstandard.ZstdCompressor(
+        level=ZSTD_COMPRESS_LEVEL, threads=ZSTD_COMPRESS_THREADS
+    ),
+    is_info: Callable[[str], bool] = lambda filename: filename.startswith("info/"),
+    package_stream: Iterator[tuple[tarfile.TarFile, tarfile.TarInfo]],
+):
+    """
+    Convert (TarFile, TarInfo) iterator like those produced by
+    ``stream_conda_component`` to .conda-format under path. Allows for more
+    creative data sources.
+
+    e.g. recompress ``.conda``:
+
+    .. code-block:: python
+
+        transmute_stream(..., package_stream=itertools.chain(
+            stream_conda_component("package.conda",
+            component=CondaComponent.pkg),
+            stream_conda_component("package.conda",
+            component=CondaComponent.info),
+        ))
+
+    This example could move files between the ``pkg-`` and ``info-`` components
+    depending on the ``is_info`` function.
+
+    :param stem: output filename without extension
+    :param path: destination path for transmuted .conda package
+    :param compressor: A function that creates instances of
+        ``zstandard.ZstdCompressor()`` to override defaults.
+    :param is_info: A function that returns True if a file belongs in the
+        ``info`` component of a `.conda` package.  ``conda-package-handling``
+        (not this package ``conda-package-streaming``) uses a set of regular
+        expressions to keep expected items in the info- component, while other
+        items starting with ``info/`` wind up in the pkg- component.
+    :param package_stream: Iterator of (Tarfile, TarInfo) tuples.
+
+    :return: Path to transmuted package.
+    """
+    output_path = Path(path, f"{stem}.conda")
+    with conda_builder(stem, path, compressor=compressor, is_info=is_info) as conda_tar:
+        for tar, member in package_stream:
+            if member.isfile():
+                conda_tar.addfile(member, tar.extractfile(member))
+            else:
+                conda_tar.addfile(member)
+
+    return output_path
+
+
+def transmute_tar_bz2(
+    package: str,
+    path,
+) -> Path:
+    """
+    Convert .conda package to .tar.bz2 format under path.
+
+    Can recompress .tar.bz2 packages.
+
+    Args:
+        package: path to .conda or .tar.bz2 package.
+        path: destination path for transmuted package.
+
+    Returns:
+        Path to transmuted package.
+    """
+    assert package.endswith((".tar.bz2", ".conda")), "Unknown extension"
+    assert os.path.isdir(path)
+
+    incoming_format = ".conda" if package.endswith(".conda") else ".tar.bz2"
+
+    file_id = os.path.basename(package)[: -len(incoming_format)]
+
+    if incoming_format == ".conda":
+        # .tar.bz2 MUST place info/ first.
+        components = [CondaComponent.info, CondaComponent.pkg]
+    else:
+        # .tar.bz2 doesn't filter by component
+        components = [CondaComponent.pkg]
+
+    output_path = Path(path, f"{file_id}.tar.bz2")
+
+    with open(package, "rb") as fileobj, tarfile.open(output_path, "x:bz2") as pkg_tar:
+        for component in components:
+            stream = iter(stream_conda_component(package, fileobj, component=component))
+            for tar, member in stream:
+                if member.isfile():
+                    pkg_tar.addfile(member, tar.extractfile(member))
+                else:
+                    pkg_tar.addfile(member)
+
+    return output_path

miniconda3/lib/python3.13/site-packages/conda_package_streaming/url.py

@@ -0,0 +1,100 @@
+"""
+Fetch metadata from remote .conda or .tar.bz2 package.
+
+Try to fetch less than the whole file if possible.
+
+This module should only be used to make *partial* reads against a remote
+package, typically just the ``info`` portion. If a full ``.conda`` format
+package is needed, it is more efficient to download locally first and then use
+the file-based API.
+"""
+
+import logging
+import sys
+import urllib.parse
+from pathlib import Path
+
+import requests
+
+from . import package_streaming
+
+# Excellent HTTP Range request file-like object
+from .lazy_wheel import LazyConda
+
+log = logging.getLogger(__name__)
+
+session = requests.Session()
+session.headers["User-Agent"] = "conda-package-streaming/0.1.0"
+
+
+METADATA_CHECKLIST = frozenset({"info/index.json", "info/recipe/meta.yaml"})
+
+
+def extract_conda_info(url, destdir, checklist=METADATA_CHECKLIST, session=session):
+    """
+    Extract info/index.json and info/recipe/meta.yaml from url to destdir; close
+    url as soon as those files are found.
+    """
+    checklist = set(checklist)
+    stream = stream_conda_info(url, session=session)
+    for tar, member in stream:
+        if member.name in checklist:
+            tar.extract(member, destdir)
+            checklist.remove(member.name)
+        if not checklist:
+            stream.close()
+            # next iteraton of for loop raises GeneratorExit in stream
+
+
+def stream_conda_info(url, session=session):
+    """
+    Yield (tar, member) for conda package at url
+
+    Just "info/" for .conda, all members for tar.
+    """
+    filename, conda = conda_reader_for_url(url, session=session)
+
+    try:
+        yield from package_streaming.stream_conda_info(filename, conda)
+    finally:
+        if hasattr(conda, "release_conn"):
+            # For .tar.bz2. Take extra care to drop connections after we are
+            # done reading a partial response.
+            conda.release_conn()
+        conda.close()
+
+
+def conda_reader_for_url(
+    url, session: requests.Session = session, fall_back_to_full_download: bool = False
+):
+    """
+    Return (name, file_like) suitable for package_streaming APIs
+
+    :param url: URL to conda package
+    :param session: The session to use for web requests.
+    :param fall_back_to_full_download: If true, fall back to downloading the entire
+    package instead of streaming it in the case of a specific issue where the server
+    incorrectly responds with 416 (Range Not Satisfiable). See LazyZipOverHTTP for
+    more details.
+    """
+    parsed_url = urllib.parse.urlparse(url)
+    *_, filename = parsed_url.path.rsplit("/", 1)
+    if filename.endswith(".conda"):
+        file_id = filename[: -len(".conda")]
+        conda = LazyConda(
+            url, session, fall_back_to_full_download=fall_back_to_full_download
+        )
+        conda.prefetch(file_id)
+    elif filename.endswith(".tar.bz2"):
+        response = session.get(url, stream=True, headers={"Connection": "close"})
+        conda = response.raw
+    else:
+        raise ValueError("Unsupported extension %s", url)
+    return filename, conda
+
+
+if __name__ == "__main__":  # pragma: no cover
+    import logging
+
+    logging.basicConfig(level=logging.DEBUG)
+    extract_conda_info(sys.argv[1], Path(sys.argv[2]).absolute())

miniconda3/lib/python3.13/site-packages/cryptography-46.0.5.dist-info/INSTALLER

@@ -0,0 +1 @@
+conda

miniconda3/lib/python3.13/site-packages/cryptography-46.0.5.dist-info/METADATA

@@ -0,0 +1,139 @@
+Metadata-Version: 2.4
+Name: cryptography
+Version: 46.0.5
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Natural Language :: English
+Classifier: Operating System :: MacOS :: MacOS X
+Classifier: Operating System :: POSIX
+Classifier: Operating System :: POSIX :: BSD
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Classifier: Programming Language :: Python :: Free Threading :: 3 - Stable
+Classifier: Topic :: Security :: Cryptography
+Requires-Dist: cffi>=1.14 ; python_full_version == '3.8.*' and platform_python_implementation != 'PyPy'
+Requires-Dist: cffi>=2.0.0 ; python_full_version >= '3.9' and platform_python_implementation != 'PyPy'
+Requires-Dist: typing-extensions>=4.13.2 ; python_full_version < '3.11'
+Requires-Dist: sphinx>=5.3.0 ; extra == 'docs'
+Requires-Dist: sphinx-rtd-theme>=3.0.0 ; extra == 'docs'
+Requires-Dist: sphinx-inline-tabs ; extra == 'docs'
+Requires-Dist: pyenchant>=3 ; extra == 'docstest'
+Requires-Dist: readme-renderer>=30.0 ; extra == 'docstest'
+Requires-Dist: sphinxcontrib-spelling>=7.3.1 ; extra == 'docstest'
+Requires-Dist: nox[uv]>=2024.4.15 ; extra == 'nox'
+Requires-Dist: ruff>=0.11.11 ; extra == 'pep8test'
+Requires-Dist: mypy>=1.14 ; extra == 'pep8test'
+Requires-Dist: check-sdist ; extra == 'pep8test'
+Requires-Dist: click>=8.0.1 ; extra == 'pep8test'
+Requires-Dist: build>=1.0.0 ; extra == 'sdist'
+Requires-Dist: bcrypt>=3.1.5 ; extra == 'ssh'
+Requires-Dist: cryptography-vectors==46.0.5 ; extra == 'test'
+Requires-Dist: pytest>=7.4.0 ; extra == 'test'
+Requires-Dist: pytest-benchmark>=4.0 ; extra == 'test'
+Requires-Dist: pytest-cov>=2.10.1 ; extra == 'test'
+Requires-Dist: pytest-xdist>=3.5.0 ; extra == 'test'
+Requires-Dist: pretend>=0.7 ; extra == 'test'
+Requires-Dist: certifi>=2024 ; extra == 'test'
+Requires-Dist: pytest-randomly ; extra == 'test-randomorder'
+Provides-Extra: docs
+Provides-Extra: docstest
+Provides-Extra: nox
+Provides-Extra: pep8test
+Provides-Extra: sdist
+Provides-Extra: ssh
+Provides-Extra: test
+Provides-Extra: test-randomorder
+License-File: LICENSE
+License-File: LICENSE.APACHE
+License-File: LICENSE.BSD
+Summary: cryptography is a package which provides cryptographic recipes and primitives to Python developers.
+Author-email: The Python Cryptographic Authority and individual contributors <cryptography-dev@python.org>
+License-Expression: Apache-2.0 OR BSD-3-Clause
+Requires-Python: >=3.8, !=3.9.0, !=3.9.1
+Description-Content-Type: text/x-rst; charset=UTF-8
+Project-URL: changelog, https://cryptography.io/en/latest/changelog/
+Project-URL: documentation, https://cryptography.io/
+Project-URL: homepage, https://github.com/pyca/cryptography
+Project-URL: issues, https://github.com/pyca/cryptography/issues
+Project-URL: source, https://github.com/pyca/cryptography/
+
+pyca/cryptography
+=================
+
+.. image:: https://img.shields.io/pypi/v/cryptography.svg
+    :target: https://pypi.org/project/cryptography/
+    :alt: Latest Version
+
+.. image:: https://readthedocs.org/projects/cryptography/badge/?version=latest
+    :target: https://cryptography.io
+    :alt: Latest Docs
+
+.. image:: https://github.com/pyca/cryptography/actions/workflows/ci.yml/badge.svg
+    :target: https://github.com/pyca/cryptography/actions/workflows/ci.yml?query=branch%3Amain
+
+``cryptography`` is a package which provides cryptographic recipes and
+primitives to Python developers. Our goal is for it to be your "cryptographic
+standard library". It supports Python 3.8+ and PyPy3 7.3.11+.
+
+``cryptography`` includes both high level recipes and low level interfaces to
+common cryptographic algorithms such as symmetric ciphers, message digests, and
+key derivation functions. For example, to encrypt something with
+``cryptography``'s high level symmetric encryption recipe:
+
+.. code-block:: pycon
+
+    >>> from cryptography.fernet import Fernet
+    >>> # Put this somewhere safe!
+    >>> key = Fernet.generate_key()
+    >>> f = Fernet(key)
+    >>> token = f.encrypt(b"A really secret message. Not for prying eyes.")
+    >>> token
+    b'...'
+    >>> f.decrypt(token)
+    b'A really secret message. Not for prying eyes.'
+
+You can find more information in the `documentation`_.
+
+You can install ``cryptography`` with:
+
+.. code-block:: console
+
+    $ pip install cryptography
+
+For full details see `the installation documentation`_.
+
+Discussion
+~~~~~~~~~~
+
+If you run into bugs, you can file them in our `issue tracker`_.
+
+We maintain a `cryptography-dev`_ mailing list for development discussion.
+
+You can also join ``#pyca`` on ``irc.libera.chat`` to ask questions or get
+involved.
+
+Security
+~~~~~~~~
+
+Need to report a security issue? Please consult our `security reporting`_
+documentation.
+
+
+.. _`documentation`: https://cryptography.io/
+.. _`the installation documentation`: https://cryptography.io/en/latest/installation/
+.. _`issue tracker`: https://github.com/pyca/cryptography/issues
+.. _`cryptography-dev`: https://mail.python.org/mailman/listinfo/cryptography-dev
+.. _`security reporting`: https://cryptography.io/en/latest/security/
+

miniconda3/lib/python3.13/site-packages/cryptography-46.0.5.dist-info/RECORD

@@ -0,0 +1,182 @@
+cryptography-46.0.5.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+cryptography-46.0.5.dist-info/METADATA,sha256=p5LozbTBtaE0kjWTceUsqAM-uyB-WVbiFji7RXpzzpE,5748
+cryptography-46.0.5.dist-info/RECORD,,
+cryptography-46.0.5.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cryptography-46.0.5.dist-info/WHEEL,sha256=cyD-4T7RQHgO12DUEFwAZAE61yBu0epJyI7tq0T7IUU,99
+cryptography-46.0.5.dist-info/direct_url.json,sha256=E9VjsRq187Ay5OEfC7MfqeDfofaDlEhllpzF37fMVcc,104
+cryptography-46.0.5.dist-info/licenses/LICENSE,sha256=Pgx8CRqUi4JTO6mP18u0BDLW8amsv4X1ki0vmak65rs,197
+cryptography-46.0.5.dist-info/licenses/LICENSE.APACHE,sha256=qsc7MUj20dcRHbyjIJn2jSbGRMaBOuHk8F9leaomY_4,11360
+cryptography-46.0.5.dist-info/licenses/LICENSE.BSD,sha256=YCxMdILeZHndLpeTzaJ15eY9dz2s0eymiSMqtwCPtPs,1532
+cryptography/__about__.py,sha256=GWg4NAxg4vsSKUwmDy1HjUeAOhqTA46wIhiY6i03NSU,445
+cryptography/__init__.py,sha256=mthuUrTd4FROCpUYrTIqhjz6s6T9djAZrV7nZ1oMm2o,364
+cryptography/__pycache__/__about__.cpython-313.pyc,,
+cryptography/__pycache__/__init__.cpython-313.pyc,,
+cryptography/__pycache__/exceptions.cpython-313.pyc,,
+cryptography/__pycache__/fernet.cpython-313.pyc,,
+cryptography/__pycache__/utils.cpython-313.pyc,,
+cryptography/exceptions.py,sha256=835EWILc2fwxw-gyFMriciC2SqhViETB10LBSytnDIc,1087
+cryptography/fernet.py,sha256=3Cvxkh0KJSbX8HbnCHu4wfCW7U0GgfUA3v_qQ8a8iWc,6963
+cryptography/hazmat/__init__.py,sha256=5IwrLWrVp0AjEr_4FdWG_V057NSJGY_W4egNNsuct0g,455
+cryptography/hazmat/__pycache__/__init__.cpython-313.pyc,,
+cryptography/hazmat/__pycache__/_oid.cpython-313.pyc,,
+cryptography/hazmat/_oid.py,sha256=p8ThjwJB56Ci_rAIrjyJ1f8VjgD6e39es2dh8JIUBOw,17240
+cryptography/hazmat/asn1/__init__.py,sha256=hS_EWx3wVvZzfbCcNV8hzcDnyMM8H-BhIoS1TipUosk,293
+cryptography/hazmat/asn1/__pycache__/__init__.cpython-313.pyc,,
+cryptography/hazmat/asn1/__pycache__/asn1.cpython-313.pyc,,
+cryptography/hazmat/asn1/asn1.py,sha256=eMEThEXa19LQjcyVofgHsW6tsZnjp3ddH7bWkkcxfLM,3860
+cryptography/hazmat/backends/__init__.py,sha256=O5jvKFQdZnXhKeqJ-HtulaEL9Ni7mr1mDzZY5kHlYhI,361
+cryptography/hazmat/backends/__pycache__/__init__.cpython-313.pyc,,
+cryptography/hazmat/backends/openssl/__init__.py,sha256=p3jmJfnCag9iE5sdMrN6VvVEu55u46xaS_IjoI0SrmA,305
+cryptography/hazmat/backends/openssl/__pycache__/__init__.cpython-313.pyc,,
+cryptography/hazmat/backends/openssl/__pycache__/backend.cpython-313.pyc,,
+cryptography/hazmat/backends/openssl/backend.py,sha256=tV5AxBoFJ2GfA0DMWSY-0TxQJrpQoexzI9R4Kybb--4,10215
+cryptography/hazmat/bindings/__init__.py,sha256=s9oKCQ2ycFdXoERdS1imafueSkBsL9kvbyfghaauZ9Y,180
+cryptography/hazmat/bindings/__pycache__/__init__.cpython-313.pyc,,
+cryptography/hazmat/bindings/_rust.abi3.so,sha256=v4i_FkVhfTY8Injr-EjGsmRefofnuLLTBplffI0inDs,5194896
+cryptography/hazmat/bindings/_rust/__init__.pyi,sha256=KhqLhXFPArPzzJ7DYO9Fl8FoXB_BagAd_r4Dm_Ze9Xo,1257
+cryptography/hazmat/bindings/_rust/_openssl.pyi,sha256=mpNJLuYLbCVrd5i33FBTmWwL_55Dw7JPkSLlSX9Q7oI,230
+cryptography/hazmat/bindings/_rust/asn1.pyi,sha256=BrGjC8J6nwuS-r3EVcdXJB8ndotfY9mbQYOfpbPG0HA,354
+cryptography/hazmat/bindings/_rust/declarative_asn1.pyi,sha256=2ECFmYue1EPkHEE2Bm7aLwkjB0mSUTpr23v9MN4pri4,892
+cryptography/hazmat/bindings/_rust/exceptions.pyi,sha256=exXr2xw_0pB1kk93cYbM3MohbzoUkjOms1ZMUi0uQZE,640
+cryptography/hazmat/bindings/_rust/ocsp.pyi,sha256=VPVWuKHI9EMs09ZLRYAGvR0Iz0mCMmEzXAkgJHovpoM,4020
+cryptography/hazmat/bindings/_rust/openssl/__init__.pyi,sha256=iOAMDyHoNwwCSZfZzuXDr64g4GpGUeDgEN-LjXqdrBM,1522
+cryptography/hazmat/bindings/_rust/openssl/aead.pyi,sha256=4Nddw6-ynzIB3w2W86WvkGKTLlTDk_6F5l54RHCuy3E,2688
+cryptography/hazmat/bindings/_rust/openssl/ciphers.pyi,sha256=LhPzHWSXJq4grAJXn6zSvSSdV-aYIIscHDwIPlJGGPs,1315
+cryptography/hazmat/bindings/_rust/openssl/cmac.pyi,sha256=nPH0X57RYpsAkRowVpjQiHE566ThUTx7YXrsadmrmHk,564
+cryptography/hazmat/bindings/_rust/openssl/dh.pyi,sha256=Z3TC-G04-THtSdAOPLM1h2G7ml5bda1ElZUcn5wpuhk,1564
+cryptography/hazmat/bindings/_rust/openssl/dsa.pyi,sha256=qBtkgj2albt2qFcnZ9UDrhzoNhCVO7HTby5VSf1EXMI,1299
+cryptography/hazmat/bindings/_rust/openssl/ec.pyi,sha256=zJy0pRa5n-_p2dm45PxECB_-B6SVZyNKfjxFDpPqT38,1691
+cryptography/hazmat/bindings/_rust/openssl/ed25519.pyi,sha256=VXfXd5G6hUivg399R1DYdmW3eTb0EebzDTqjRC2gaRw,532
+cryptography/hazmat/bindings/_rust/openssl/ed448.pyi,sha256=Yx49lqdnjsD7bxiDV1kcaMrDktug5evi5a6zerMiy2s,514
+cryptography/hazmat/bindings/_rust/openssl/hashes.pyi,sha256=OWZvBx7xfo_HJl41Nc--DugVyCVPIprZ3HlOPTSWH9g,984
+cryptography/hazmat/bindings/_rust/openssl/hmac.pyi,sha256=BXZn7NDjL3JAbYW0SQ8pg1iyC5DbQXVhUAiwsi8DFR8,702
+cryptography/hazmat/bindings/_rust/openssl/kdf.pyi,sha256=xXfFBb9QehHfDtEaxV_65Z0YK7NquOVIChpTLkgAs_k,2029
+cryptography/hazmat/bindings/_rust/openssl/keys.pyi,sha256=teIt8M6ZEMJrn4s3W0UnW0DZ-30Jd68WnSsKKG124l0,912
+cryptography/hazmat/bindings/_rust/openssl/poly1305.pyi,sha256=_SW9NtQ5FDlAbdclFtWpT4lGmxKIKHpN-4j8J2BzYfQ,585
+cryptography/hazmat/bindings/_rust/openssl/rsa.pyi,sha256=2OQCNSXkxgc-3uw1xiCCloIQTV6p9_kK79Yu0rhZgPc,1364
+cryptography/hazmat/bindings/_rust/openssl/x25519.pyi,sha256=ewn4GpQyb7zPwE-ni7GtyQgMC0A1mLuqYsSyqv6nI_s,523
+cryptography/hazmat/bindings/_rust/openssl/x448.pyi,sha256=juTZTmli8jO_5Vcufg-vHvx_tCyezmSLIh_9PU3TczI,505
+cryptography/hazmat/bindings/_rust/pkcs12.pyi,sha256=vEEd5wDiZvb8ZGFaziLCaWLzAwoG_tvPUxLQw5_uOl8,1605
+cryptography/hazmat/bindings/_rust/pkcs7.pyi,sha256=txGBJijqZshEcqra6byPNbnisIdlxzOSIHP2hl9arPs,1601
+cryptography/hazmat/bindings/_rust/test_support.pyi,sha256=PPhld-WkO743iXFPebeG0LtgK0aTzGdjcIsay1Gm5GE,757
+cryptography/hazmat/bindings/_rust/x509.pyi,sha256=n9X0IQ6ICbdIi-ExdCFZoBgeY6njm3QOVAVZwDQdnbk,9784
+cryptography/hazmat/bindings/openssl/__init__.py,sha256=s9oKCQ2ycFdXoERdS1imafueSkBsL9kvbyfghaauZ9Y,180
+cryptography/hazmat/bindings/openssl/__pycache__/__init__.cpython-313.pyc,,
+cryptography/hazmat/bindings/openssl/__pycache__/_conditional.cpython-313.pyc,,
+cryptography/hazmat/bindings/openssl/__pycache__/binding.cpython-313.pyc,,
+cryptography/hazmat/bindings/openssl/_conditional.py,sha256=DMOpA_XN4l70zTc5_J9DpwlbQeUBRTWpfIJ4yRIn1-U,5791
+cryptography/hazmat/bindings/openssl/binding.py,sha256=x8eocEmukO4cm7cHqfVmOoYY7CCXdoF1v1WhZQt9neo,4610
+cryptography/hazmat/decrepit/__init__.py,sha256=wHCbWfaefa-fk6THSw9th9fJUsStJo7245wfFBqmduA,216
+cryptography/hazmat/decrepit/__pycache__/__init__.cpython-313.pyc,,
+cryptography/hazmat/decrepit/ciphers/__init__.py,sha256=wHCbWfaefa-fk6THSw9th9fJUsStJo7245wfFBqmduA,216
+cryptography/hazmat/decrepit/ciphers/__pycache__/__init__.cpython-313.pyc,,
+cryptography/hazmat/decrepit/ciphers/__pycache__/algorithms.cpython-313.pyc,,
+cryptography/hazmat/decrepit/ciphers/algorithms.py,sha256=YrKgHS4MfwWaMmPBYRymRRlC0phwWp9ycICFezeJPGk,2595
+cryptography/hazmat/primitives/__init__.py,sha256=s9oKCQ2ycFdXoERdS1imafueSkBsL9kvbyfghaauZ9Y,180
+cryptography/hazmat/primitives/__pycache__/__init__.cpython-313.pyc,,
+cryptography/hazmat/primitives/__pycache__/_asymmetric.cpython-313.pyc,,
+cryptography/hazmat/primitives/__pycache__/_cipheralgorithm.cpython-313.pyc,,
+cryptography/hazmat/primitives/__pycache__/_serialization.cpython-313.pyc,,
+cryptography/hazmat/primitives/__pycache__/cmac.cpython-313.pyc,,
+cryptography/hazmat/primitives/__pycache__/constant_time.cpython-313.pyc,,
+cryptography/hazmat/primitives/__pycache__/hashes.cpython-313.pyc,,
+cryptography/hazmat/primitives/__pycache__/hmac.cpython-313.pyc,,
+cryptography/hazmat/primitives/__pycache__/keywrap.cpython-313.pyc,,
+cryptography/hazmat/primitives/__pycache__/padding.cpython-313.pyc,,
+cryptography/hazmat/primitives/__pycache__/poly1305.cpython-313.pyc,,
+cryptography/hazmat/primitives/_asymmetric.py,sha256=RhgcouUB6HTiFDBrR1LxqkMjpUxIiNvQ1r_zJjRG6qQ,532
+cryptography/hazmat/primitives/_cipheralgorithm.py,sha256=Eh3i7lwedHfi0eLSsH93PZxQKzY9I6lkK67vL4V5tOc,1522
+cryptography/hazmat/primitives/_serialization.py,sha256=chgPCSF2jxI2Cr5gB-qbWXOvOfupBh4CARS0KAhv9AM,5123
+cryptography/hazmat/primitives/asymmetric/__init__.py,sha256=s9oKCQ2ycFdXoERdS1imafueSkBsL9kvbyfghaauZ9Y,180
+cryptography/hazmat/primitives/asymmetric/__pycache__/__init__.cpython-313.pyc,,
+cryptography/hazmat/primitives/asymmetric/__pycache__/dh.cpython-313.pyc,,
+cryptography/hazmat/primitives/asymmetric/__pycache__/dsa.cpython-313.pyc,,
+cryptography/hazmat/primitives/asymmetric/__pycache__/ec.cpython-313.pyc,,
+cryptography/hazmat/primitives/asymmetric/__pycache__/ed25519.cpython-313.pyc,,
+cryptography/hazmat/primitives/asymmetric/__pycache__/ed448.cpython-313.pyc,,
+cryptography/hazmat/primitives/asymmetric/__pycache__/padding.cpython-313.pyc,,
+cryptography/hazmat/primitives/asymmetric/__pycache__/rsa.cpython-313.pyc,,
+cryptography/hazmat/primitives/asymmetric/__pycache__/types.cpython-313.pyc,,
+cryptography/hazmat/primitives/asymmetric/__pycache__/utils.cpython-313.pyc,,
+cryptography/hazmat/primitives/asymmetric/__pycache__/x25519.cpython-313.pyc,,
+cryptography/hazmat/primitives/asymmetric/__pycache__/x448.cpython-313.pyc,,
+cryptography/hazmat/primitives/asymmetric/dh.py,sha256=0v_vEFFz5pQ1QG-FkWDyvgv7IfuVZSH5Q6LyFI5A8rg,3645
+cryptography/hazmat/primitives/asymmetric/dsa.py,sha256=Ld_bbbqQFz12dObHxIkzEQzX0SWWP41RLSWkYSaKhqE,4213
+cryptography/hazmat/primitives/asymmetric/ec.py,sha256=dj0ZR_jTVI1wojjipjbXNVccPSIRObWxSZcTGQKGbHc,13437
+cryptography/hazmat/primitives/asymmetric/ed25519.py,sha256=jZW5cs472wXXV3eB0sE1b8w64gdazwwU0_MT5UOTiXs,3700
+cryptography/hazmat/primitives/asymmetric/ed448.py,sha256=yAetgn2f2JYf0BO8MapGzXeThsvSMG5LmUCrxVOidAA,3729
+cryptography/hazmat/primitives/asymmetric/padding.py,sha256=vQ6l6gOg9HqcbOsvHrSiJRVLdEj9L4m4HkRGYziTyFA,2854
+cryptography/hazmat/primitives/asymmetric/rsa.py,sha256=ZnKOo2f34MCCOupC03Y1uR-_jiSG5IrelHEmxaME3D4,8303
+cryptography/hazmat/primitives/asymmetric/types.py,sha256=LnsOJym-wmPUJ7Knu_7bCNU3kIiELCd6krOaW_JU08I,2996
+cryptography/hazmat/primitives/asymmetric/utils.py,sha256=DPTs6T4F-UhwzFQTh-1fSEpQzazH2jf2xpIro3ItF4o,790
+cryptography/hazmat/primitives/asymmetric/x25519.py,sha256=_4nQeZ3yJ3Lg0RpXnaqA-1yt6vbx1F-wzLcaZHwSpeE,3613
+cryptography/hazmat/primitives/asymmetric/x448.py,sha256=WKBLtuVfJqiBRro654fGaQAlvsKbqbNkK7c4A_ZCdV0,3642
+cryptography/hazmat/primitives/ciphers/__init__.py,sha256=eyEXmjk6_CZXaOPYDr7vAYGXr29QvzgWL2-4CSolLFs,680
+cryptography/hazmat/primitives/ciphers/__pycache__/__init__.cpython-313.pyc,,
+cryptography/hazmat/primitives/ciphers/__pycache__/aead.cpython-313.pyc,,
+cryptography/hazmat/primitives/ciphers/__pycache__/algorithms.cpython-313.pyc,,
+cryptography/hazmat/primitives/ciphers/__pycache__/base.cpython-313.pyc,,
+cryptography/hazmat/primitives/ciphers/__pycache__/modes.cpython-313.pyc,,
+cryptography/hazmat/primitives/ciphers/aead.py,sha256=Fzlyx7w8KYQakzDp1zWgJnIr62zgZrgVh1u2h4exB54,634
+cryptography/hazmat/primitives/ciphers/algorithms.py,sha256=Q7ZJwcsx83Mgxv5y7r6CyJKSdsOwC-my-5A67-ma2vw,3407
+cryptography/hazmat/primitives/ciphers/base.py,sha256=aBC7HHBBoixebmparVr0UlODs3VD0A7B6oz_AaRjDv8,4253
+cryptography/hazmat/primitives/ciphers/modes.py,sha256=20stpwhDtbAvpH0SMf9EDHIciwmTF-JMBUOZ9bU8WiQ,8318
+cryptography/hazmat/primitives/cmac.py,sha256=sz_s6H_cYnOvx-VNWdIKhRhe3Ymp8z8J0D3CBqOX3gg,338
+cryptography/hazmat/primitives/constant_time.py,sha256=xdunWT0nf8OvKdcqUhhlFKayGp4_PgVJRU2W1wLSr_A,422
+cryptography/hazmat/primitives/hashes.py,sha256=M8BrlKB3U6DEtHvWTV5VRjpteHv1kS3Zxm_Bsk04cr8,5184
+cryptography/hazmat/primitives/hmac.py,sha256=RpB3z9z5skirCQrm7zQbtnp9pLMnAjrlTUvKqF5aDDc,423
+cryptography/hazmat/primitives/kdf/__init__.py,sha256=4XibZnrYq4hh5xBjWiIXzaYW6FKx8hPbVaa_cB9zS64,750
+cryptography/hazmat/primitives/kdf/__pycache__/__init__.cpython-313.pyc,,
+cryptography/hazmat/primitives/kdf/__pycache__/argon2.cpython-313.pyc,,
+cryptography/hazmat/primitives/kdf/__pycache__/concatkdf.cpython-313.pyc,,
+cryptography/hazmat/primitives/kdf/__pycache__/hkdf.cpython-313.pyc,,
+cryptography/hazmat/primitives/kdf/__pycache__/kbkdf.cpython-313.pyc,,
+cryptography/hazmat/primitives/kdf/__pycache__/pbkdf2.cpython-313.pyc,,
+cryptography/hazmat/primitives/kdf/__pycache__/scrypt.cpython-313.pyc,,
+cryptography/hazmat/primitives/kdf/__pycache__/x963kdf.cpython-313.pyc,,
+cryptography/hazmat/primitives/kdf/argon2.py,sha256=UFDNXG0v-rw3DqAQTB1UQAsQC2M5Ejg0k_6OCyhLKus,460
+cryptography/hazmat/primitives/kdf/concatkdf.py,sha256=Ua8KoLXXnzgsrAUmHpyKymaPt8aPRP0EHEaBz7QCQ9I,3737
+cryptography/hazmat/primitives/kdf/hkdf.py,sha256=M0lAEfRoc4kpp4-nwDj9yB-vNZukIOYEQrUlWsBNn9o,543
+cryptography/hazmat/primitives/kdf/kbkdf.py,sha256=oZepvo4evhKkkJQWRDwaPoIbyTaFmDc5NPimxg6lfKg,9165
+cryptography/hazmat/primitives/kdf/pbkdf2.py,sha256=1WIwhELR0w8ztTpTu8BrFiYWmK3hUfJq08I79TxwieE,1957
+cryptography/hazmat/primitives/kdf/scrypt.py,sha256=XyWUdUUmhuI9V6TqAPOvujCSMGv1XQdg0a21IWCmO-U,590
+cryptography/hazmat/primitives/kdf/x963kdf.py,sha256=zLTcF665QFvXX2f8TS7fmBZTteXpFjKahzfjjQcCJyw,1999
+cryptography/hazmat/primitives/keywrap.py,sha256=XV4Pj2fqSeD-RqZVvY2cA3j5_7RwJSFygYuLfk2ujCo,5650
+cryptography/hazmat/primitives/padding.py,sha256=QT-U-NvV2eQGO1wVPbDiNGNSc9keRDS-ig5cQOrLz0E,1865
+cryptography/hazmat/primitives/poly1305.py,sha256=P5EPQV-RB_FJPahpg01u0Ts4S_PnAmsroxIGXbGeRRo,355
+cryptography/hazmat/primitives/serialization/__init__.py,sha256=Q7uTgDlt7n3WfsMT6jYwutC6DIg_7SEeoAm1GHZ5B5E,1705
+cryptography/hazmat/primitives/serialization/__pycache__/__init__.cpython-313.pyc,,
+cryptography/hazmat/primitives/serialization/__pycache__/base.cpython-313.pyc,,
+cryptography/hazmat/primitives/serialization/__pycache__/pkcs12.cpython-313.pyc,,
+cryptography/hazmat/primitives/serialization/__pycache__/pkcs7.cpython-313.pyc,,
+cryptography/hazmat/primitives/serialization/__pycache__/ssh.cpython-313.pyc,,
+cryptography/hazmat/primitives/serialization/base.py,sha256=ikq5MJIwp_oUnjiaBco_PmQwOTYuGi-XkYUYHKy8Vo0,615
+cryptography/hazmat/primitives/serialization/pkcs12.py,sha256=mS9cFNG4afzvseoc5e1MWoY2VskfL8N8Y_OFjl67luY,5104
+cryptography/hazmat/primitives/serialization/pkcs7.py,sha256=5OR_Tkysxaprn4FegvJIfbep9rJ9wok6FLWvWwQ5-Mg,13943
+cryptography/hazmat/primitives/serialization/ssh.py,sha256=hPV5obFznz0QhFfXFPOeQ8y6MsurA0xVMQiLnLESEs8,53700
+cryptography/hazmat/primitives/twofactor/__init__.py,sha256=tmMZGB-g4IU1r7lIFqASU019zr0uPp_wEBYcwdDCKCA,258
+cryptography/hazmat/primitives/twofactor/__pycache__/__init__.cpython-313.pyc,,
+cryptography/hazmat/primitives/twofactor/__pycache__/hotp.cpython-313.pyc,,
+cryptography/hazmat/primitives/twofactor/__pycache__/totp.cpython-313.pyc,,
+cryptography/hazmat/primitives/twofactor/hotp.py,sha256=ivZo5BrcCGWLsqql4nZV0XXCjyGPi_iHfDFltGlOJwk,3256
+cryptography/hazmat/primitives/twofactor/totp.py,sha256=m5LPpRL00kp4zY8gTjr55Hfz9aMlPS53kHmVkSQCmdY,1652
+cryptography/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cryptography/utils.py,sha256=nFHkPQZycOQGeBtBRkWSA4WjOHFo7pwummQt-PPSkZc,4349
+cryptography/x509/__init__.py,sha256=xloN0swseNx-m2WFZmCA17gOoxQWqeU82UVjEdJBePQ,8257
+cryptography/x509/__pycache__/__init__.cpython-313.pyc,,
+cryptography/x509/__pycache__/base.cpython-313.pyc,,
+cryptography/x509/__pycache__/certificate_transparency.cpython-313.pyc,,
+cryptography/x509/__pycache__/extensions.cpython-313.pyc,,
+cryptography/x509/__pycache__/general_name.cpython-313.pyc,,
+cryptography/x509/__pycache__/name.cpython-313.pyc,,
+cryptography/x509/__pycache__/ocsp.cpython-313.pyc,,
+cryptography/x509/__pycache__/oid.cpython-313.pyc,,
+cryptography/x509/__pycache__/verification.cpython-313.pyc,,
+cryptography/x509/base.py,sha256=OrmTw3y8B6AE_nGXQPN8x9kq-d7rDWeH13gCq6T6D6U,27997
+cryptography/x509/certificate_transparency.py,sha256=JqoOIDhlwInrYMFW6IFn77WJ0viF-PB_rlZV3vs9MYc,797
+cryptography/x509/extensions.py,sha256=QxYrqR6SF1qzR9ZraP8wDiIczlEVlAFuwDRVcltB6Tk,77724
+cryptography/x509/general_name.py,sha256=sP_rV11Qlpsk4x3XXGJY_Mv0Q_s9dtjeLckHsjpLQoQ,7836
+cryptography/x509/name.py,sha256=ty0_xf0LnHwZAdEf-d8FLO1K4hGqx_7DsD3CHwoLJiY,15101
+cryptography/x509/ocsp.py,sha256=Yey6NdFV1MPjop24Mj_VenjEpg3kUaMopSWOK0AbeBs,12699
+cryptography/x509/oid.py,sha256=BUzgXXGVWilkBkdKPTm9R4qElE9gAGHgdYPMZAp7PJo,931
+cryptography/x509/verification.py,sha256=gR2C2c-XZQtblZhT5T5vjSKOtCb74ef2alPVmEcwFlM,958

miniconda3/lib/python3.13/site-packages/cryptography-46.0.5.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: maturin (1.11.5)
+Root-Is-Purelib: false
+Tag: cp313-abi3-linux_x86_64

miniconda3/lib/python3.13/site-packages/cryptography-46.0.5.dist-info/direct_url.json

@@ -0,0 +1 @@
+{"dir_info": {}, "url": "file:///home/task_177247526678653/croot/cryptography-split_1772475308901/work"}

miniconda3/lib/python3.13/site-packages/cryptography-46.0.5.dist-info/licenses/LICENSE

@@ -0,0 +1,3 @@
+This software is made available under the terms of *either* of the licenses
+found in LICENSE.APACHE or LICENSE.BSD. Contributions to cryptography are made
+under the terms of *both* these licenses.

miniconda3/lib/python3.13/site-packages/cryptography-46.0.5.dist-info/licenses/LICENSE.APACHE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        https://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   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.

miniconda3/lib/python3.13/site-packages/cryptography-46.0.5.dist-info/licenses/LICENSE.BSD

@@ -0,0 +1,27 @@
+Copyright (c) Individual contributors.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+    1. Redistributions of source code must retain the above copyright notice,
+       this list of conditions and the following disclaimer.
+
+    2. Redistributions in binary form must reproduce the above copyright
+       notice, this list of conditions and the following disclaimer in the
+       documentation and/or other materials provided with the distribution.
+
+    3. Neither the name of PyCA Cryptography nor the names of its contributors
+       may be used to endorse or promote products derived from this software
+       without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

miniconda3/lib/python3.13/site-packages/cryptography/__about__.py

@@ -0,0 +1,17 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+
+from __future__ import annotations
+
+__all__ = [
+    "__author__",
+    "__copyright__",
+    "__version__",
+]
+
+__version__ = "46.0.5"
+
+
+__author__ = "The Python Cryptographic Authority and individual contributors"
+__copyright__ = f"Copyright 2013-2025 {__author__}"

miniconda3/lib/python3.13/site-packages/cryptography/__init__.py

@@ -0,0 +1,13 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+
+from __future__ import annotations
+
+from cryptography.__about__ import __author__, __copyright__, __version__
+
+__all__ = [
+    "__author__",
+    "__copyright__",
+    "__version__",
+]

miniconda3/lib/python3.13/site-packages/cryptography/exceptions.py

@@ -0,0 +1,52 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+
+from __future__ import annotations
+
+import typing
+
+from cryptography.hazmat.bindings._rust import exceptions as rust_exceptions
+
+if typing.TYPE_CHECKING:
+    from cryptography.hazmat.bindings._rust import openssl as rust_openssl
+
+_Reasons = rust_exceptions._Reasons
+
+
+class UnsupportedAlgorithm(Exception):
+    def __init__(self, message: str, reason: _Reasons | None = None) -> None:
+        super().__init__(message)
+        self._reason = reason
+
+
+class AlreadyFinalized(Exception):
+    pass
+
+
+class AlreadyUpdated(Exception):
+    pass
+
+
+class NotYetFinalized(Exception):
+    pass
+
+
+class InvalidTag(Exception):
+    pass
+
+
+class InvalidSignature(Exception):
+    pass
+
+
+class InternalError(Exception):
+    def __init__(
+        self, msg: str, err_code: list[rust_openssl.OpenSSLError]
+    ) -> None:
+        super().__init__(msg)
+        self.err_code = err_code
+
+
+class InvalidKey(Exception):
+    pass

miniconda3/lib/python3.13/site-packages/cryptography/fernet.py

@@ -0,0 +1,224 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+
+from __future__ import annotations
+
+import base64
+import binascii
+import os
+import time
+import typing
+from collections.abc import Iterable
+
+from cryptography import utils
+from cryptography.exceptions import InvalidSignature
+from cryptography.hazmat.primitives import hashes, padding
+from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
+from cryptography.hazmat.primitives.hmac import HMAC
+
+
+class InvalidToken(Exception):
+    pass
+
+
+_MAX_CLOCK_SKEW = 60
+
+
+class Fernet:
+    def __init__(
+        self,
+        key: bytes | str,
+        backend: typing.Any = None,
+    ) -> None:
+        try:
+            key = base64.urlsafe_b64decode(key)
+        except binascii.Error as exc:
+            raise ValueError(
+                "Fernet key must be 32 url-safe base64-encoded bytes."
+            ) from exc
+        if len(key) != 32:
+            raise ValueError(
+                "Fernet key must be 32 url-safe base64-encoded bytes."
+            )
+
+        self._signing_key = key[:16]
+        self._encryption_key = key[16:]
+
+    @classmethod
+    def generate_key(cls) -> bytes:
+        return base64.urlsafe_b64encode(os.urandom(32))
+
+    def encrypt(self, data: bytes) -> bytes:
+        return self.encrypt_at_time(data, int(time.time()))
+
+    def encrypt_at_time(self, data: bytes, current_time: int) -> bytes:
+        iv = os.urandom(16)
+        return self._encrypt_from_parts(data, current_time, iv)
+
+    def _encrypt_from_parts(
+        self, data: bytes, current_time: int, iv: bytes
+    ) -> bytes:
+        utils._check_bytes("data", data)
+
+        padder = padding.PKCS7(algorithms.AES.block_size).padder()
+        padded_data = padder.update(data) + padder.finalize()
+        encryptor = Cipher(
+            algorithms.AES(self._encryption_key),
+            modes.CBC(iv),
+        ).encryptor()
+        ciphertext = encryptor.update(padded_data) + encryptor.finalize()
+
+        basic_parts = (
+            b"\x80"
+            + current_time.to_bytes(length=8, byteorder="big")
+            + iv
+            + ciphertext
+        )
+
+        h = HMAC(self._signing_key, hashes.SHA256())
+        h.update(basic_parts)
+        hmac = h.finalize()
+        return base64.urlsafe_b64encode(basic_parts + hmac)
+
+    def decrypt(self, token: bytes | str, ttl: int | None = None) -> bytes:
+        timestamp, data = Fernet._get_unverified_token_data(token)
+        if ttl is None:
+            time_info = None
+        else:
+            time_info = (ttl, int(time.time()))
+        return self._decrypt_data(data, timestamp, time_info)
+
+    def decrypt_at_time(
+        self, token: bytes | str, ttl: int, current_time: int
+    ) -> bytes:
+        if ttl is None:
+            raise ValueError(
+                "decrypt_at_time() can only be used with a non-None ttl"
+            )
+        timestamp, data = Fernet._get_unverified_token_data(token)
+        return self._decrypt_data(data, timestamp, (ttl, current_time))
+
+    def extract_timestamp(self, token: bytes | str) -> int:
+        timestamp, data = Fernet._get_unverified_token_data(token)
+        # Verify the token was not tampered with.
+        self._verify_signature(data)
+        return timestamp
+
+    @staticmethod
+    def _get_unverified_token_data(token: bytes | str) -> tuple[int, bytes]:
+        if not isinstance(token, (str, bytes)):
+            raise TypeError("token must be bytes or str")
+
+        try:
+            data = base64.urlsafe_b64decode(token)
+        except (TypeError, binascii.Error):
+            raise InvalidToken
+
+        if not data or data[0] != 0x80:
+            raise InvalidToken
+
+        if len(data) < 9:
+            raise InvalidToken
+
+        timestamp = int.from_bytes(data[1:9], byteorder="big")
+        return timestamp, data
+
+    def _verify_signature(self, data: bytes) -> None:
+        h = HMAC(self._signing_key, hashes.SHA256())
+        h.update(data[:-32])
+        try:
+            h.verify(data[-32:])
+        except InvalidSignature:
+            raise InvalidToken
+
+    def _decrypt_data(
+        self,
+        data: bytes,
+        timestamp: int,
+        time_info: tuple[int, int] | None,
+    ) -> bytes:
+        if time_info is not None:
+            ttl, current_time = time_info
+            if timestamp + ttl < current_time:
+                raise InvalidToken
+
+            if current_time + _MAX_CLOCK_SKEW < timestamp:
+                raise InvalidToken
+
+        self._verify_signature(data)
+
+        iv = data[9:25]
+        ciphertext = data[25:-32]
+        decryptor = Cipher(
+            algorithms.AES(self._encryption_key), modes.CBC(iv)
+        ).decryptor()
+        plaintext_padded = decryptor.update(ciphertext)
+        try:
+            plaintext_padded += decryptor.finalize()
+        except ValueError:
+            raise InvalidToken
+        unpadder = padding.PKCS7(algorithms.AES.block_size).unpadder()
+
+        unpadded = unpadder.update(plaintext_padded)
+        try:
+            unpadded += unpadder.finalize()
+        except ValueError:
+            raise InvalidToken
+        return unpadded
+
+
+class MultiFernet:
+    def __init__(self, fernets: Iterable[Fernet]):
+        fernets = list(fernets)
+        if not fernets:
+            raise ValueError(
+                "MultiFernet requires at least one Fernet instance"
+            )
+        self._fernets = fernets
+
+    def encrypt(self, msg: bytes) -> bytes:
+        return self.encrypt_at_time(msg, int(time.time()))
+
+    def encrypt_at_time(self, msg: bytes, current_time: int) -> bytes:
+        return self._fernets[0].encrypt_at_time(msg, current_time)
+
+    def rotate(self, msg: bytes | str) -> bytes:
+        timestamp, data = Fernet._get_unverified_token_data(msg)
+        for f in self._fernets:
+            try:
+                p = f._decrypt_data(data, timestamp, None)
+                break
+            except InvalidToken:
+                pass
+        else:
+            raise InvalidToken
+
+        iv = os.urandom(16)
+        return self._fernets[0]._encrypt_from_parts(p, timestamp, iv)
+
+    def decrypt(self, msg: bytes | str, ttl: int | None = None) -> bytes:
+        for f in self._fernets:
+            try:
+                return f.decrypt(msg, ttl)
+            except InvalidToken:
+                pass
+        raise InvalidToken
+
+    def decrypt_at_time(
+        self, msg: bytes | str, ttl: int, current_time: int
+    ) -> bytes:
+        for f in self._fernets:
+            try:
+                return f.decrypt_at_time(msg, ttl, current_time)
+            except InvalidToken:
+                pass
+        raise InvalidToken
+
+    def extract_timestamp(self, msg: bytes | str) -> int:
+        for f in self._fernets:
+            try:
+                return f.extract_timestamp(msg)
+            except InvalidToken:
+                pass
+        raise InvalidToken

miniconda3/lib/python3.13/site-packages/cryptography/hazmat/__init__.py

@@ -0,0 +1,13 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+
+from __future__ import annotations
+
+"""
+Hazardous Materials
+
+This is a "Hazardous Materials" module. You should ONLY use it if you're
+100% absolutely sure that you know what you're doing because this module
+is full of land mines, dragons, and dinosaurs with laser guns.
+"""

miniconda3/lib/python3.13/site-packages/cryptography/hazmat/_oid.py

@@ -0,0 +1,356 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+
+from __future__ import annotations
+
+from cryptography.hazmat.bindings._rust import (
+    ObjectIdentifier as ObjectIdentifier,
+)
+from cryptography.hazmat.primitives import hashes
+
+
+class ExtensionOID:
+    SUBJECT_DIRECTORY_ATTRIBUTES = ObjectIdentifier("2.5.29.9")
+    SUBJECT_KEY_IDENTIFIER = ObjectIdentifier("2.5.29.14")
+    KEY_USAGE = ObjectIdentifier("2.5.29.15")
+    PRIVATE_KEY_USAGE_PERIOD = ObjectIdentifier("2.5.29.16")
+    SUBJECT_ALTERNATIVE_NAME = ObjectIdentifier("2.5.29.17")
+    ISSUER_ALTERNATIVE_NAME = ObjectIdentifier("2.5.29.18")
+    BASIC_CONSTRAINTS = ObjectIdentifier("2.5.29.19")
+    NAME_CONSTRAINTS = ObjectIdentifier("2.5.29.30")
+    CRL_DISTRIBUTION_POINTS = ObjectIdentifier("2.5.29.31")
+    CERTIFICATE_POLICIES = ObjectIdentifier("2.5.29.32")
+    POLICY_MAPPINGS = ObjectIdentifier("2.5.29.33")
+    AUTHORITY_KEY_IDENTIFIER = ObjectIdentifier("2.5.29.35")
+    POLICY_CONSTRAINTS = ObjectIdentifier("2.5.29.36")
+    EXTENDED_KEY_USAGE = ObjectIdentifier("2.5.29.37")
+    FRESHEST_CRL = ObjectIdentifier("2.5.29.46")
+    INHIBIT_ANY_POLICY = ObjectIdentifier("2.5.29.54")
+    ISSUING_DISTRIBUTION_POINT = ObjectIdentifier("2.5.29.28")
+    AUTHORITY_INFORMATION_ACCESS = ObjectIdentifier("1.3.6.1.5.5.7.1.1")
+    SUBJECT_INFORMATION_ACCESS = ObjectIdentifier("1.3.6.1.5.5.7.1.11")
+    OCSP_NO_CHECK = ObjectIdentifier("1.3.6.1.5.5.7.48.1.5")
+    TLS_FEATURE = ObjectIdentifier("1.3.6.1.5.5.7.1.24")
+    CRL_NUMBER = ObjectIdentifier("2.5.29.20")
+    DELTA_CRL_INDICATOR = ObjectIdentifier("2.5.29.27")
+    PRECERT_SIGNED_CERTIFICATE_TIMESTAMPS = ObjectIdentifier(
+        "1.3.6.1.4.1.11129.2.4.2"
+    )
+    PRECERT_POISON = ObjectIdentifier("1.3.6.1.4.1.11129.2.4.3")
+    SIGNED_CERTIFICATE_TIMESTAMPS = ObjectIdentifier("1.3.6.1.4.1.11129.2.4.5")
+    MS_CERTIFICATE_TEMPLATE = ObjectIdentifier("1.3.6.1.4.1.311.21.7")
+    ADMISSIONS = ObjectIdentifier("1.3.36.8.3.3")
+
+
+class OCSPExtensionOID:
+    NONCE = ObjectIdentifier("1.3.6.1.5.5.7.48.1.2")
+    ACCEPTABLE_RESPONSES = ObjectIdentifier("1.3.6.1.5.5.7.48.1.4")
+
+
+class CRLEntryExtensionOID:
+    CERTIFICATE_ISSUER = ObjectIdentifier("2.5.29.29")
+    CRL_REASON = ObjectIdentifier("2.5.29.21")
+    INVALIDITY_DATE = ObjectIdentifier("2.5.29.24")
+
+
+class NameOID:
+    COMMON_NAME = ObjectIdentifier("2.5.4.3")
+    COUNTRY_NAME = ObjectIdentifier("2.5.4.6")
+    LOCALITY_NAME = ObjectIdentifier("2.5.4.7")
+    STATE_OR_PROVINCE_NAME = ObjectIdentifier("2.5.4.8")
+    STREET_ADDRESS = ObjectIdentifier("2.5.4.9")
+    ORGANIZATION_IDENTIFIER = ObjectIdentifier("2.5.4.97")
+    ORGANIZATION_NAME = ObjectIdentifier("2.5.4.10")
+    ORGANIZATIONAL_UNIT_NAME = ObjectIdentifier("2.5.4.11")
+    SERIAL_NUMBER = ObjectIdentifier("2.5.4.5")
+    SURNAME = ObjectIdentifier("2.5.4.4")
+    GIVEN_NAME = ObjectIdentifier("2.5.4.42")
+    TITLE = ObjectIdentifier("2.5.4.12")
+    INITIALS = ObjectIdentifier("2.5.4.43")
+    GENERATION_QUALIFIER = ObjectIdentifier("2.5.4.44")
+    X500_UNIQUE_IDENTIFIER = ObjectIdentifier("2.5.4.45")
+    DN_QUALIFIER = ObjectIdentifier("2.5.4.46")
+    PSEUDONYM = ObjectIdentifier("2.5.4.65")
+    USER_ID = ObjectIdentifier("0.9.2342.19200300.100.1.1")
+    DOMAIN_COMPONENT = ObjectIdentifier("0.9.2342.19200300.100.1.25")
+    EMAIL_ADDRESS = ObjectIdentifier("1.2.840.113549.1.9.1")
+    JURISDICTION_COUNTRY_NAME = ObjectIdentifier("1.3.6.1.4.1.311.60.2.1.3")
+    JURISDICTION_LOCALITY_NAME = ObjectIdentifier("1.3.6.1.4.1.311.60.2.1.1")
+    JURISDICTION_STATE_OR_PROVINCE_NAME = ObjectIdentifier(
+        "1.3.6.1.4.1.311.60.2.1.2"
+    )
+    BUSINESS_CATEGORY = ObjectIdentifier("2.5.4.15")
+    POSTAL_ADDRESS = ObjectIdentifier("2.5.4.16")
+    POSTAL_CODE = ObjectIdentifier("2.5.4.17")
+    INN = ObjectIdentifier("1.2.643.3.131.1.1")
+    OGRN = ObjectIdentifier("1.2.643.100.1")
+    SNILS = ObjectIdentifier("1.2.643.100.3")
+    UNSTRUCTURED_NAME = ObjectIdentifier("1.2.840.113549.1.9.2")
+
+
+class SignatureAlgorithmOID:
+    RSA_WITH_MD5 = ObjectIdentifier("1.2.840.113549.1.1.4")
+    RSA_WITH_SHA1 = ObjectIdentifier("1.2.840.113549.1.1.5")
+    # This is an alternate OID for RSA with SHA1 that is occasionally seen
+    _RSA_WITH_SHA1 = ObjectIdentifier("1.3.14.3.2.29")
+    RSA_WITH_SHA224 = ObjectIdentifier("1.2.840.113549.1.1.14")
+    RSA_WITH_SHA256 = ObjectIdentifier("1.2.840.113549.1.1.11")
+    RSA_WITH_SHA384 = ObjectIdentifier("1.2.840.113549.1.1.12")
+    RSA_WITH_SHA512 = ObjectIdentifier("1.2.840.113549.1.1.13")
+    RSA_WITH_SHA3_224 = ObjectIdentifier("2.16.840.1.101.3.4.3.13")
+    RSA_WITH_SHA3_256 = ObjectIdentifier("2.16.840.1.101.3.4.3.14")
+    RSA_WITH_SHA3_384 = ObjectIdentifier("2.16.840.1.101.3.4.3.15")
+    RSA_WITH_SHA3_512 = ObjectIdentifier("2.16.840.1.101.3.4.3.16")
+    RSASSA_PSS = ObjectIdentifier("1.2.840.113549.1.1.10")
+    ECDSA_WITH_SHA1 = ObjectIdentifier("1.2.840.10045.4.1")
+    ECDSA_WITH_SHA224 = ObjectIdentifier("1.2.840.10045.4.3.1")
+    ECDSA_WITH_SHA256 = ObjectIdentifier("1.2.840.10045.4.3.2")
+    ECDSA_WITH_SHA384 = ObjectIdentifier("1.2.840.10045.4.3.3")
+    ECDSA_WITH_SHA512 = ObjectIdentifier("1.2.840.10045.4.3.4")
+    ECDSA_WITH_SHA3_224 = ObjectIdentifier("2.16.840.1.101.3.4.3.9")
+    ECDSA_WITH_SHA3_256 = ObjectIdentifier("2.16.840.1.101.3.4.3.10")
+    ECDSA_WITH_SHA3_384 = ObjectIdentifier("2.16.840.1.101.3.4.3.11")
+    ECDSA_WITH_SHA3_512 = ObjectIdentifier("2.16.840.1.101.3.4.3.12")
+    DSA_WITH_SHA1 = ObjectIdentifier("1.2.840.10040.4.3")
+    DSA_WITH_SHA224 = ObjectIdentifier("2.16.840.1.101.3.4.3.1")
+    DSA_WITH_SHA256 = ObjectIdentifier("2.16.840.1.101.3.4.3.2")
+    DSA_WITH_SHA384 = ObjectIdentifier("2.16.840.1.101.3.4.3.3")
+    DSA_WITH_SHA512 = ObjectIdentifier("2.16.840.1.101.3.4.3.4")
+    ED25519 = ObjectIdentifier("1.3.101.112")
+    ED448 = ObjectIdentifier("1.3.101.113")
+    GOSTR3411_94_WITH_3410_2001 = ObjectIdentifier("1.2.643.2.2.3")
+    GOSTR3410_2012_WITH_3411_2012_256 = ObjectIdentifier("1.2.643.7.1.1.3.2")
+    GOSTR3410_2012_WITH_3411_2012_512 = ObjectIdentifier("1.2.643.7.1.1.3.3")
+
+
+_SIG_OIDS_TO_HASH: dict[ObjectIdentifier, hashes.HashAlgorithm | None] = {
+    SignatureAlgorithmOID.RSA_WITH_MD5: hashes.MD5(),
+    SignatureAlgorithmOID.RSA_WITH_SHA1: hashes.SHA1(),
+    SignatureAlgorithmOID._RSA_WITH_SHA1: hashes.SHA1(),
+    SignatureAlgorithmOID.RSA_WITH_SHA224: hashes.SHA224(),
+    SignatureAlgorithmOID.RSA_WITH_SHA256: hashes.SHA256(),
+    SignatureAlgorithmOID.RSA_WITH_SHA384: hashes.SHA384(),
+    SignatureAlgorithmOID.RSA_WITH_SHA512: hashes.SHA512(),
+    SignatureAlgorithmOID.RSA_WITH_SHA3_224: hashes.SHA3_224(),
+    SignatureAlgorithmOID.RSA_WITH_SHA3_256: hashes.SHA3_256(),
+    SignatureAlgorithmOID.RSA_WITH_SHA3_384: hashes.SHA3_384(),
+    SignatureAlgorithmOID.RSA_WITH_SHA3_512: hashes.SHA3_512(),
+    SignatureAlgorithmOID.ECDSA_WITH_SHA1: hashes.SHA1(),
+    SignatureAlgorithmOID.ECDSA_WITH_SHA224: hashes.SHA224(),
+    SignatureAlgorithmOID.ECDSA_WITH_SHA256: hashes.SHA256(),
+    SignatureAlgorithmOID.ECDSA_WITH_SHA384: hashes.SHA384(),
+    SignatureAlgorithmOID.ECDSA_WITH_SHA512: hashes.SHA512(),
+    SignatureAlgorithmOID.ECDSA_WITH_SHA3_224: hashes.SHA3_224(),
+    SignatureAlgorithmOID.ECDSA_WITH_SHA3_256: hashes.SHA3_256(),
+    SignatureAlgorithmOID.ECDSA_WITH_SHA3_384: hashes.SHA3_384(),
+    SignatureAlgorithmOID.ECDSA_WITH_SHA3_512: hashes.SHA3_512(),
+    SignatureAlgorithmOID.DSA_WITH_SHA1: hashes.SHA1(),
+    SignatureAlgorithmOID.DSA_WITH_SHA224: hashes.SHA224(),
+    SignatureAlgorithmOID.DSA_WITH_SHA256: hashes.SHA256(),
+    SignatureAlgorithmOID.ED25519: None,
+    SignatureAlgorithmOID.ED448: None,
+    SignatureAlgorithmOID.GOSTR3411_94_WITH_3410_2001: None,
+    SignatureAlgorithmOID.GOSTR3410_2012_WITH_3411_2012_256: None,
+    SignatureAlgorithmOID.GOSTR3410_2012_WITH_3411_2012_512: None,
+}
+
+
+class HashAlgorithmOID:
+    SHA1 = ObjectIdentifier("1.3.14.3.2.26")
+    SHA224 = ObjectIdentifier("2.16.840.1.101.3.4.2.4")
+    SHA256 = ObjectIdentifier("2.16.840.1.101.3.4.2.1")
+    SHA384 = ObjectIdentifier("2.16.840.1.101.3.4.2.2")
+    SHA512 = ObjectIdentifier("2.16.840.1.101.3.4.2.3")
+    SHA3_224 = ObjectIdentifier("1.3.6.1.4.1.37476.3.2.1.99.7.224")
+    SHA3_256 = ObjectIdentifier("1.3.6.1.4.1.37476.3.2.1.99.7.256")
+    SHA3_384 = ObjectIdentifier("1.3.6.1.4.1.37476.3.2.1.99.7.384")
+    SHA3_512 = ObjectIdentifier("1.3.6.1.4.1.37476.3.2.1.99.7.512")
+    SHA3_224_NIST = ObjectIdentifier("2.16.840.1.101.3.4.2.7")
+    SHA3_256_NIST = ObjectIdentifier("2.16.840.1.101.3.4.2.8")
+    SHA3_384_NIST = ObjectIdentifier("2.16.840.1.101.3.4.2.9")
+    SHA3_512_NIST = ObjectIdentifier("2.16.840.1.101.3.4.2.10")
+
+
+class PublicKeyAlgorithmOID:
+    DSA = ObjectIdentifier("1.2.840.10040.4.1")
+    EC_PUBLIC_KEY = ObjectIdentifier("1.2.840.10045.2.1")
+    RSAES_PKCS1_v1_5 = ObjectIdentifier("1.2.840.113549.1.1.1")
+    RSASSA_PSS = ObjectIdentifier("1.2.840.113549.1.1.10")
+    X25519 = ObjectIdentifier("1.3.101.110")
+    X448 = ObjectIdentifier("1.3.101.111")
+    ED25519 = ObjectIdentifier("1.3.101.112")
+    ED448 = ObjectIdentifier("1.3.101.113")
+
+
+class ExtendedKeyUsageOID:
+    SERVER_AUTH = ObjectIdentifier("1.3.6.1.5.5.7.3.1")
+    CLIENT_AUTH = ObjectIdentifier("1.3.6.1.5.5.7.3.2")
+    CODE_SIGNING = ObjectIdentifier("1.3.6.1.5.5.7.3.3")
+    EMAIL_PROTECTION = ObjectIdentifier("1.3.6.1.5.5.7.3.4")
+    TIME_STAMPING = ObjectIdentifier("1.3.6.1.5.5.7.3.8")
+    OCSP_SIGNING = ObjectIdentifier("1.3.6.1.5.5.7.3.9")
+    ANY_EXTENDED_KEY_USAGE = ObjectIdentifier("2.5.29.37.0")
+    SMARTCARD_LOGON = ObjectIdentifier("1.3.6.1.4.1.311.20.2.2")
+    KERBEROS_PKINIT_KDC = ObjectIdentifier("1.3.6.1.5.2.3.5")
+    IPSEC_IKE = ObjectIdentifier("1.3.6.1.5.5.7.3.17")
+    BUNDLE_SECURITY = ObjectIdentifier("1.3.6.1.5.5.7.3.35")
+    CERTIFICATE_TRANSPARENCY = ObjectIdentifier("1.3.6.1.4.1.11129.2.4.4")
+
+
+class OtherNameFormOID:
+    PERMANENT_IDENTIFIER = ObjectIdentifier("1.3.6.1.5.5.7.8.3")
+    HW_MODULE_NAME = ObjectIdentifier("1.3.6.1.5.5.7.8.4")
+    DNS_SRV = ObjectIdentifier("1.3.6.1.5.5.7.8.7")
+    NAI_REALM = ObjectIdentifier("1.3.6.1.5.5.7.8.8")
+    SMTP_UTF8_MAILBOX = ObjectIdentifier("1.3.6.1.5.5.7.8.9")
+    ACP_NODE_NAME = ObjectIdentifier("1.3.6.1.5.5.7.8.10")
+    BUNDLE_EID = ObjectIdentifier("1.3.6.1.5.5.7.8.11")
+
+
+class AuthorityInformationAccessOID:
+    CA_ISSUERS = ObjectIdentifier("1.3.6.1.5.5.7.48.2")
+    OCSP = ObjectIdentifier("1.3.6.1.5.5.7.48.1")
+
+
+class SubjectInformationAccessOID:
+    CA_REPOSITORY = ObjectIdentifier("1.3.6.1.5.5.7.48.5")
+
+
+class CertificatePoliciesOID:
+    CPS_QUALIFIER = ObjectIdentifier("1.3.6.1.5.5.7.2.1")
+    CPS_USER_NOTICE = ObjectIdentifier("1.3.6.1.5.5.7.2.2")
+    ANY_POLICY = ObjectIdentifier("2.5.29.32.0")
+
+
+class AttributeOID:
+    CHALLENGE_PASSWORD = ObjectIdentifier("1.2.840.113549.1.9.7")
+    UNSTRUCTURED_NAME = ObjectIdentifier("1.2.840.113549.1.9.2")
+
+
+_OID_NAMES = {
+    NameOID.COMMON_NAME: "commonName",
+    NameOID.COUNTRY_NAME: "countryName",
+    NameOID.LOCALITY_NAME: "localityName",
+    NameOID.STATE_OR_PROVINCE_NAME: "stateOrProvinceName",
+    NameOID.STREET_ADDRESS: "streetAddress",
+    NameOID.ORGANIZATION_NAME: "organizationName",
+    NameOID.ORGANIZATIONAL_UNIT_NAME: "organizationalUnitName",
+    NameOID.SERIAL_NUMBER: "serialNumber",
+    NameOID.SURNAME: "surname",
+    NameOID.GIVEN_NAME: "givenName",
+    NameOID.TITLE: "title",
+    NameOID.GENERATION_QUALIFIER: "generationQualifier",
+    NameOID.X500_UNIQUE_IDENTIFIER: "x500UniqueIdentifier",
+    NameOID.DN_QUALIFIER: "dnQualifier",
+    NameOID.PSEUDONYM: "pseudonym",
+    NameOID.USER_ID: "userID",
+    NameOID.DOMAIN_COMPONENT: "domainComponent",
+    NameOID.EMAIL_ADDRESS: "emailAddress",
+    NameOID.JURISDICTION_COUNTRY_NAME: "jurisdictionCountryName",
+    NameOID.JURISDICTION_LOCALITY_NAME: "jurisdictionLocalityName",
+    NameOID.JURISDICTION_STATE_OR_PROVINCE_NAME: (
+        "jurisdictionStateOrProvinceName"
+    ),
+    NameOID.BUSINESS_CATEGORY: "businessCategory",
+    NameOID.POSTAL_ADDRESS: "postalAddress",
+    NameOID.POSTAL_CODE: "postalCode",
+    NameOID.INN: "INN",
+    NameOID.OGRN: "OGRN",
+    NameOID.SNILS: "SNILS",
+    NameOID.UNSTRUCTURED_NAME: "unstructuredName",
+    SignatureAlgorithmOID.RSA_WITH_MD5: "md5WithRSAEncryption",
+    SignatureAlgorithmOID.RSA_WITH_SHA1: "sha1WithRSAEncryption",
+    SignatureAlgorithmOID.RSA_WITH_SHA224: "sha224WithRSAEncryption",
+    SignatureAlgorithmOID.RSA_WITH_SHA256: "sha256WithRSAEncryption",
+    SignatureAlgorithmOID.RSA_WITH_SHA384: "sha384WithRSAEncryption",
+    SignatureAlgorithmOID.RSA_WITH_SHA512: "sha512WithRSAEncryption",
+    SignatureAlgorithmOID.RSASSA_PSS: "rsassaPss",
+    SignatureAlgorithmOID.ECDSA_WITH_SHA1: "ecdsa-with-SHA1",
+    SignatureAlgorithmOID.ECDSA_WITH_SHA224: "ecdsa-with-SHA224",
+    SignatureAlgorithmOID.ECDSA_WITH_SHA256: "ecdsa-with-SHA256",
+    SignatureAlgorithmOID.ECDSA_WITH_SHA384: "ecdsa-with-SHA384",
+    SignatureAlgorithmOID.ECDSA_WITH_SHA512: "ecdsa-with-SHA512",
+    SignatureAlgorithmOID.DSA_WITH_SHA1: "dsa-with-sha1",
+    SignatureAlgorithmOID.DSA_WITH_SHA224: "dsa-with-sha224",
+    SignatureAlgorithmOID.DSA_WITH_SHA256: "dsa-with-sha256",
+    SignatureAlgorithmOID.ED25519: "ed25519",
+    SignatureAlgorithmOID.ED448: "ed448",
+    SignatureAlgorithmOID.GOSTR3411_94_WITH_3410_2001: (
+        "GOST R 34.11-94 with GOST R 34.10-2001"
+    ),
+    SignatureAlgorithmOID.GOSTR3410_2012_WITH_3411_2012_256: (
+        "GOST R 34.10-2012 with GOST R 34.11-2012 (256 bit)"
+    ),
+    SignatureAlgorithmOID.GOSTR3410_2012_WITH_3411_2012_512: (
+        "GOST R 34.10-2012 with GOST R 34.11-2012 (512 bit)"
+    ),
+    HashAlgorithmOID.SHA1: "sha1",
+    HashAlgorithmOID.SHA224: "sha224",
+    HashAlgorithmOID.SHA256: "sha256",
+    HashAlgorithmOID.SHA384: "sha384",
+    HashAlgorithmOID.SHA512: "sha512",
+    HashAlgorithmOID.SHA3_224: "sha3_224",
+    HashAlgorithmOID.SHA3_256: "sha3_256",
+    HashAlgorithmOID.SHA3_384: "sha3_384",
+    HashAlgorithmOID.SHA3_512: "sha3_512",
+    HashAlgorithmOID.SHA3_224_NIST: "sha3_224",
+    HashAlgorithmOID.SHA3_256_NIST: "sha3_256",
+    HashAlgorithmOID.SHA3_384_NIST: "sha3_384",
+    HashAlgorithmOID.SHA3_512_NIST: "sha3_512",
+    PublicKeyAlgorithmOID.DSA: "dsaEncryption",
+    PublicKeyAlgorithmOID.EC_PUBLIC_KEY: "id-ecPublicKey",
+    PublicKeyAlgorithmOID.RSAES_PKCS1_v1_5: "rsaEncryption",
+    PublicKeyAlgorithmOID.X25519: "X25519",
+    PublicKeyAlgorithmOID.X448: "X448",
+    ExtendedKeyUsageOID.SERVER_AUTH: "serverAuth",
+    ExtendedKeyUsageOID.CLIENT_AUTH: "clientAuth",
+    ExtendedKeyUsageOID.CODE_SIGNING: "codeSigning",
+    ExtendedKeyUsageOID.EMAIL_PROTECTION: "emailProtection",
+    ExtendedKeyUsageOID.TIME_STAMPING: "timeStamping",
+    ExtendedKeyUsageOID.OCSP_SIGNING: "OCSPSigning",
+    ExtendedKeyUsageOID.SMARTCARD_LOGON: "msSmartcardLogin",
+    ExtendedKeyUsageOID.KERBEROS_PKINIT_KDC: "pkInitKDC",
+    ExtensionOID.SUBJECT_DIRECTORY_ATTRIBUTES: "subjectDirectoryAttributes",
+    ExtensionOID.SUBJECT_KEY_IDENTIFIER: "subjectKeyIdentifier",
+    ExtensionOID.KEY_USAGE: "keyUsage",
+    ExtensionOID.PRIVATE_KEY_USAGE_PERIOD: "privateKeyUsagePeriod",
+    ExtensionOID.SUBJECT_ALTERNATIVE_NAME: "subjectAltName",
+    ExtensionOID.ISSUER_ALTERNATIVE_NAME: "issuerAltName",
+    ExtensionOID.BASIC_CONSTRAINTS: "basicConstraints",
+    ExtensionOID.PRECERT_SIGNED_CERTIFICATE_TIMESTAMPS: (
+        "signedCertificateTimestampList"
+    ),
+    ExtensionOID.SIGNED_CERTIFICATE_TIMESTAMPS: (
+        "signedCertificateTimestampList"
+    ),
+    ExtensionOID.PRECERT_POISON: "ctPoison",
+    ExtensionOID.MS_CERTIFICATE_TEMPLATE: "msCertificateTemplate",
+    ExtensionOID.ADMISSIONS: "Admissions",
+    CRLEntryExtensionOID.CRL_REASON: "cRLReason",
+    CRLEntryExtensionOID.INVALIDITY_DATE: "invalidityDate",
+    CRLEntryExtensionOID.CERTIFICATE_ISSUER: "certificateIssuer",
+    ExtensionOID.NAME_CONSTRAINTS: "nameConstraints",
+    ExtensionOID.CRL_DISTRIBUTION_POINTS: "cRLDistributionPoints",
+    ExtensionOID.CERTIFICATE_POLICIES: "certificatePolicies",
+    ExtensionOID.POLICY_MAPPINGS: "policyMappings",
+    ExtensionOID.AUTHORITY_KEY_IDENTIFIER: "authorityKeyIdentifier",
+    ExtensionOID.POLICY_CONSTRAINTS: "policyConstraints",
+    ExtensionOID.EXTENDED_KEY_USAGE: "extendedKeyUsage",
+    ExtensionOID.FRESHEST_CRL: "freshestCRL",
+    ExtensionOID.INHIBIT_ANY_POLICY: "inhibitAnyPolicy",
+    ExtensionOID.ISSUING_DISTRIBUTION_POINT: "issuingDistributionPoint",
+    ExtensionOID.AUTHORITY_INFORMATION_ACCESS: "authorityInfoAccess",
+    ExtensionOID.SUBJECT_INFORMATION_ACCESS: "subjectInfoAccess",
+    ExtensionOID.OCSP_NO_CHECK: "OCSPNoCheck",
+    ExtensionOID.CRL_NUMBER: "cRLNumber",
+    ExtensionOID.DELTA_CRL_INDICATOR: "deltaCRLIndicator",
+    ExtensionOID.TLS_FEATURE: "TLSFeature",
+    AuthorityInformationAccessOID.OCSP: "OCSP",
+    AuthorityInformationAccessOID.CA_ISSUERS: "caIssuers",
+    SubjectInformationAccessOID.CA_REPOSITORY: "caRepository",
+    CertificatePoliciesOID.CPS_QUALIFIER: "id-qt-cps",
+    CertificatePoliciesOID.CPS_USER_NOTICE: "id-qt-unotice",
+    OCSPExtensionOID.NONCE: "OCSPNonce",
+    AttributeOID.CHALLENGE_PASSWORD: "challengePassword",
+}

miniconda3/lib/python3.13/site-packages/cryptography/hazmat/asn1/__init__.py

@@ -0,0 +1,10 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+
+from cryptography.hazmat.asn1.asn1 import encode_der, sequence
+
+__all__ = [
+    "encode_der",
+    "sequence",
+]

miniconda3/lib/python3.13/site-packages/cryptography/hazmat/asn1/asn1.py

@@ -0,0 +1,116 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+
+from __future__ import annotations
+
+import dataclasses
+import sys
+import typing
+
+if sys.version_info < (3, 11):
+    import typing_extensions
+
+    # We use the `include_extras` parameter of `get_type_hints`, which was
+    # added in Python 3.9. This can be replaced by the `typing` version
+    # once the min version is >= 3.9
+    if sys.version_info < (3, 9):
+        get_type_hints = typing_extensions.get_type_hints
+    else:
+        get_type_hints = typing.get_type_hints
+else:
+    get_type_hints = typing.get_type_hints
+
+from cryptography.hazmat.bindings._rust import declarative_asn1
+
+T = typing.TypeVar("T", covariant=True)
+U = typing.TypeVar("U")
+
+
+encode_der = declarative_asn1.encode_der
+
+
+def _normalize_field_type(
+    field_type: typing.Any, field_name: str
+) -> declarative_asn1.AnnotatedType:
+    annotation = declarative_asn1.Annotation()
+
+    if hasattr(field_type, "__asn1_root__"):
+        annotated_root = field_type.__asn1_root__
+        if not isinstance(annotated_root, declarative_asn1.AnnotatedType):
+            raise TypeError(f"unsupported root type: {annotated_root}")
+        return annotated_root
+    else:
+        rust_field_type = declarative_asn1.non_root_python_to_rust(field_type)
+
+    return declarative_asn1.AnnotatedType(rust_field_type, annotation)
+
+
+def _annotate_fields(
+    raw_fields: dict[str, type],
+) -> dict[str, declarative_asn1.AnnotatedType]:
+    fields = {}
+    for field_name, field_type in raw_fields.items():
+        # Recursively normalize the field type into something that the
+        # Rust code can understand.
+        annotated_field_type = _normalize_field_type(field_type, field_name)
+        fields[field_name] = annotated_field_type
+
+    return fields
+
+
+def _register_asn1_sequence(cls: type[U]) -> None:
+    raw_fields = get_type_hints(cls, include_extras=True)
+    root = declarative_asn1.AnnotatedType(
+        declarative_asn1.Type.Sequence(cls, _annotate_fields(raw_fields)),
+        declarative_asn1.Annotation(),
+    )
+
+    setattr(cls, "__asn1_root__", root)
+
+
+# Due to https://github.com/python/mypy/issues/19731, we can't define an alias
+# for `dataclass_transform` that conditionally points to `typing` or
+# `typing_extensions` depending on the Python version (like we do for
+# `get_type_hints`).
+# We work around it by making the whole decorated class conditional on the
+# Python version.
+if sys.version_info < (3, 11):
+
+    @typing_extensions.dataclass_transform(kw_only_default=True)
+    def sequence(cls: type[U]) -> type[U]:
+        # We use `dataclasses.dataclass` to add an __init__ method
+        # to the class with keyword-only parameters.
+        if sys.version_info >= (3, 10):
+            dataclass_cls = dataclasses.dataclass(
+                repr=False,
+                eq=False,
+                # `match_args` was added in Python 3.10 and defaults
+                # to True
+                match_args=False,
+                # `kw_only` was added in Python 3.10 and defaults to
+                # False
+                kw_only=True,
+            )(cls)
+        else:
+            dataclass_cls = dataclasses.dataclass(
+                repr=False,
+                eq=False,
+            )(cls)
+        _register_asn1_sequence(dataclass_cls)
+        return dataclass_cls
+
+else:
+
+    @typing.dataclass_transform(kw_only_default=True)
+    def sequence(cls: type[U]) -> type[U]:
+        # Only add an __init__ method, with keyword-only
+        # parameters.
+        dataclass_cls = dataclasses.dataclass(
+            repr=False,
+            eq=False,
+            match_args=False,
+            kw_only=True,
+        )(cls)
+        _register_asn1_sequence(dataclass_cls)
+        return dataclass_cls

miniconda3/lib/python3.13/site-packages/cryptography/hazmat/backends/__init__.py

@@ -0,0 +1,13 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+
+from __future__ import annotations
+
+from typing import Any
+
+
+def default_backend() -> Any:
+    from cryptography.hazmat.backends.openssl.backend import backend
+
+    return backend

miniconda3/lib/python3.13/site-packages/cryptography/hazmat/backends/openssl/__init__.py

@@ -0,0 +1,9 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+
+from __future__ import annotations
+
+from cryptography.hazmat.backends.openssl.backend import backend
+
+__all__ = ["backend"]

miniconda3/lib/python3.13/site-packages/cryptography/hazmat/backends/openssl/backend.py

@@ -0,0 +1,302 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+
+from __future__ import annotations
+
+from cryptography.hazmat.bindings._rust import openssl as rust_openssl
+from cryptography.hazmat.bindings.openssl import binding
+from cryptography.hazmat.primitives import hashes
+from cryptography.hazmat.primitives._asymmetric import AsymmetricPadding
+from cryptography.hazmat.primitives.asymmetric import ec
+from cryptography.hazmat.primitives.asymmetric import utils as asym_utils
+from cryptography.hazmat.primitives.asymmetric.padding import (
+    MGF1,
+    OAEP,
+    PSS,
+    PKCS1v15,
+)
+from cryptography.hazmat.primitives.ciphers import (
+    CipherAlgorithm,
+)
+from cryptography.hazmat.primitives.ciphers.algorithms import (
+    AES,
+)
+from cryptography.hazmat.primitives.ciphers.modes import (
+    CBC,
+    Mode,
+)
+
+
+class Backend:
+    """
+    OpenSSL API binding interfaces.
+    """
+
+    name = "openssl"
+
+    # TripleDES encryption is disallowed/deprecated throughout 2023 in
+    # FIPS 140-3. To keep it simple we denylist any use of TripleDES (TDEA).
+    _fips_ciphers = (AES,)
+    # Sometimes SHA1 is still permissible. That logic is contained
+    # within the various *_supported methods.
+    _fips_hashes = (
+        hashes.SHA224,
+        hashes.SHA256,
+        hashes.SHA384,
+        hashes.SHA512,
+        hashes.SHA512_224,
+        hashes.SHA512_256,
+        hashes.SHA3_224,
+        hashes.SHA3_256,
+        hashes.SHA3_384,
+        hashes.SHA3_512,
+        hashes.SHAKE128,
+        hashes.SHAKE256,
+    )
+    _fips_ecdh_curves = (
+        ec.SECP224R1,
+        ec.SECP256R1,
+        ec.SECP384R1,
+        ec.SECP521R1,
+    )
+    _fips_rsa_min_key_size = 2048
+    _fips_rsa_min_public_exponent = 65537
+    _fips_dsa_min_modulus = 1 << 2048
+    _fips_dh_min_key_size = 2048
+    _fips_dh_min_modulus = 1 << _fips_dh_min_key_size
+
+    def __init__(self) -> None:
+        self._binding = binding.Binding()
+        self._ffi = self._binding.ffi
+        self._lib = self._binding.lib
+        self._fips_enabled = rust_openssl.is_fips_enabled()
+
+    def __repr__(self) -> str:
+        return (
+            f"<OpenSSLBackend(version: {self.openssl_version_text()}, "
+            f"FIPS: {self._fips_enabled}, "
+            f"Legacy: {rust_openssl._legacy_provider_loaded})>"
+        )
+
+    def openssl_assert(self, ok: bool) -> None:
+        return binding._openssl_assert(ok)
+
+    def _enable_fips(self) -> None:
+        # This function enables FIPS mode for OpenSSL 3.0.0 on installs that
+        # have the FIPS provider installed properly.
+        rust_openssl.enable_fips(rust_openssl._providers)
+        assert rust_openssl.is_fips_enabled()
+        self._fips_enabled = rust_openssl.is_fips_enabled()
+
+    def openssl_version_text(self) -> str:
+        """
+        Friendly string name of the loaded OpenSSL library. This is not
+        necessarily the same version as it was compiled against.
+
+        Example: OpenSSL 3.2.1 30 Jan 2024
+        """
+        return rust_openssl.openssl_version_text()
+
+    def openssl_version_number(self) -> int:
+        return rust_openssl.openssl_version()
+
+    def hash_supported(self, algorithm: hashes.HashAlgorithm) -> bool:
+        if self._fips_enabled and not isinstance(algorithm, self._fips_hashes):
+            return False
+
+        return rust_openssl.hashes.hash_supported(algorithm)
+
+    def signature_hash_supported(
+        self, algorithm: hashes.HashAlgorithm
+    ) -> bool:
+        # Dedicated check for hashing algorithm use in message digest for
+        # signatures, e.g. RSA PKCS#1 v1.5 SHA1 (sha1WithRSAEncryption).
+        if self._fips_enabled and isinstance(algorithm, hashes.SHA1):
+            return False
+        return self.hash_supported(algorithm)
+
+    def scrypt_supported(self) -> bool:
+        if self._fips_enabled:
+            return False
+        else:
+            return hasattr(rust_openssl.kdf.Scrypt, "derive")
+
+    def argon2_supported(self) -> bool:
+        if self._fips_enabled:
+            return False
+        else:
+            return hasattr(rust_openssl.kdf.Argon2id, "derive")
+
+    def hmac_supported(self, algorithm: hashes.HashAlgorithm) -> bool:
+        # FIPS mode still allows SHA1 for HMAC
+        if self._fips_enabled and isinstance(algorithm, hashes.SHA1):
+            return True
+        if rust_openssl.CRYPTOGRAPHY_IS_AWSLC:
+            return isinstance(
+                algorithm,
+                (
+                    hashes.SHA1,
+                    hashes.SHA224,
+                    hashes.SHA256,
+                    hashes.SHA384,
+                    hashes.SHA512,
+                    hashes.SHA512_224,
+                    hashes.SHA512_256,
+                ),
+            )
+        return self.hash_supported(algorithm)
+
+    def cipher_supported(self, cipher: CipherAlgorithm, mode: Mode) -> bool:
+        if self._fips_enabled:
+            # FIPS mode requires AES. TripleDES is disallowed/deprecated in
+            # FIPS 140-3.
+            if not isinstance(cipher, self._fips_ciphers):
+                return False
+
+        return rust_openssl.ciphers.cipher_supported(cipher, mode)
+
+    def pbkdf2_hmac_supported(self, algorithm: hashes.HashAlgorithm) -> bool:
+        return self.hmac_supported(algorithm)
+
+    def _consume_errors(self) -> list[rust_openssl.OpenSSLError]:
+        return rust_openssl.capture_error_stack()
+
+    def _oaep_hash_supported(self, algorithm: hashes.HashAlgorithm) -> bool:
+        if self._fips_enabled and isinstance(algorithm, hashes.SHA1):
+            return False
+
+        return isinstance(
+            algorithm,
+            (
+                hashes.SHA1,
+                hashes.SHA224,
+                hashes.SHA256,
+                hashes.SHA384,
+                hashes.SHA512,
+            ),
+        )
+
+    def rsa_padding_supported(self, padding: AsymmetricPadding) -> bool:
+        if isinstance(padding, PKCS1v15):
+            return True
+        elif isinstance(padding, PSS) and isinstance(padding._mgf, MGF1):
+            # FIPS 186-4 only allows salt length == digest length for PSS
+            # It is technically acceptable to set an explicit salt length
+            # equal to the digest length and this will incorrectly fail, but
+            # since we don't do that in the tests and this method is
+            # private, we'll ignore that until we need to do otherwise.
+            if (
+                self._fips_enabled
+                and padding._salt_length != PSS.DIGEST_LENGTH
+            ):
+                return False
+            return self.hash_supported(padding._mgf._algorithm)
+        elif isinstance(padding, OAEP) and isinstance(padding._mgf, MGF1):
+            return self._oaep_hash_supported(
+                padding._mgf._algorithm
+            ) and self._oaep_hash_supported(padding._algorithm)
+        else:
+            return False
+
+    def rsa_encryption_supported(self, padding: AsymmetricPadding) -> bool:
+        if self._fips_enabled and isinstance(padding, PKCS1v15):
+            return False
+        else:
+            return self.rsa_padding_supported(padding)
+
+    def dsa_supported(self) -> bool:
+        return (
+            not rust_openssl.CRYPTOGRAPHY_IS_BORINGSSL
+            and not self._fips_enabled
+        )
+
+    def dsa_hash_supported(self, algorithm: hashes.HashAlgorithm) -> bool:
+        if not self.dsa_supported():
+            return False
+        return self.signature_hash_supported(algorithm)
+
+    def cmac_algorithm_supported(self, algorithm) -> bool:
+        return self.cipher_supported(
+            algorithm, CBC(b"\x00" * algorithm.block_size)
+        )
+
+    def elliptic_curve_supported(self, curve: ec.EllipticCurve) -> bool:
+        if self._fips_enabled and not isinstance(
+            curve, self._fips_ecdh_curves
+        ):
+            return False
+
+        return rust_openssl.ec.curve_supported(curve)
+
+    def elliptic_curve_signature_algorithm_supported(
+        self,
+        signature_algorithm: ec.EllipticCurveSignatureAlgorithm,
+        curve: ec.EllipticCurve,
+    ) -> bool:
+        # We only support ECDSA right now.
+        if not isinstance(signature_algorithm, ec.ECDSA):
+            return False
+
+        return self.elliptic_curve_supported(curve) and (
+            isinstance(signature_algorithm.algorithm, asym_utils.Prehashed)
+            or self.hash_supported(signature_algorithm.algorithm)
+        )
+
+    def elliptic_curve_exchange_algorithm_supported(
+        self, algorithm: ec.ECDH, curve: ec.EllipticCurve
+    ) -> bool:
+        return self.elliptic_curve_supported(curve) and isinstance(
+            algorithm, ec.ECDH
+        )
+
+    def dh_supported(self) -> bool:
+        return (
+            not rust_openssl.CRYPTOGRAPHY_IS_BORINGSSL
+            and not rust_openssl.CRYPTOGRAPHY_IS_AWSLC
+        )
+
+    def dh_x942_serialization_supported(self) -> bool:
+        return self._lib.Cryptography_HAS_EVP_PKEY_DHX == 1
+
+    def x25519_supported(self) -> bool:
+        return not self._fips_enabled
+
+    def x448_supported(self) -> bool:
+        if self._fips_enabled:
+            return False
+        return (
+            not rust_openssl.CRYPTOGRAPHY_IS_LIBRESSL
+            and not rust_openssl.CRYPTOGRAPHY_IS_BORINGSSL
+            and not rust_openssl.CRYPTOGRAPHY_IS_AWSLC
+        )
+
+    def ed25519_supported(self) -> bool:
+        return not self._fips_enabled
+
+    def ed448_supported(self) -> bool:
+        if self._fips_enabled:
+            return False
+        return (
+            not rust_openssl.CRYPTOGRAPHY_IS_LIBRESSL
+            and not rust_openssl.CRYPTOGRAPHY_IS_BORINGSSL
+            and not rust_openssl.CRYPTOGRAPHY_IS_AWSLC
+        )
+
+    def ecdsa_deterministic_supported(self) -> bool:
+        return (
+            rust_openssl.CRYPTOGRAPHY_OPENSSL_320_OR_GREATER
+            and not self._fips_enabled
+        )
+
+    def poly1305_supported(self) -> bool:
+        return not self._fips_enabled
+
+    def pkcs7_supported(self) -> bool:
+        return (
+            not rust_openssl.CRYPTOGRAPHY_IS_BORINGSSL
+            and not rust_openssl.CRYPTOGRAPHY_IS_AWSLC
+        )
+
+
+backend = Backend()

miniconda3/lib/python3.13/site-packages/cryptography/hazmat/bindings/__init__.py

@@ -0,0 +1,3 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.

miniconda3/lib/python3.13/site-packages/cryptography/hazmat/bindings/_rust/__init__.pyi

@@ -0,0 +1,37 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+
+import typing
+
+from cryptography.hazmat.primitives import padding
+from cryptography.utils import Buffer
+
+class PKCS7PaddingContext(padding.PaddingContext):
+    def __init__(self, block_size: int) -> None: ...
+    def update(self, data: Buffer) -> bytes: ...
+    def finalize(self) -> bytes: ...
+
+class ANSIX923PaddingContext(padding.PaddingContext):
+    def __init__(self, block_size: int) -> None: ...
+    def update(self, data: Buffer) -> bytes: ...
+    def finalize(self) -> bytes: ...
+
+class PKCS7UnpaddingContext(padding.PaddingContext):
+    def __init__(self, block_size: int) -> None: ...
+    def update(self, data: Buffer) -> bytes: ...
+    def finalize(self) -> bytes: ...
+
+class ANSIX923UnpaddingContext(padding.PaddingContext):
+    def __init__(self, block_size: int) -> None: ...
+    def update(self, data: Buffer) -> bytes: ...
+    def finalize(self) -> bytes: ...
+
+class ObjectIdentifier:
+    def __init__(self, value: str) -> None: ...
+    @property
+    def dotted_string(self) -> str: ...
+    @property
+    def _name(self) -> str: ...
+
+T = typing.TypeVar("T")

miniconda3/lib/python3.13/site-packages/cryptography/hazmat/bindings/_rust/_openssl.pyi

@@ -0,0 +1,8 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+
+import typing
+
+lib = typing.Any
+ffi = typing.Any

miniconda3/lib/python3.13/site-packages/cryptography/hazmat/bindings/_rust/asn1.pyi

@@ -0,0 +1,7 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+
+def decode_dss_signature(signature: bytes) -> tuple[int, int]: ...
+def encode_dss_signature(r: int, s: int) -> bytes: ...
+def parse_spki_for_data(data: bytes) -> bytes: ...

miniconda3/lib/python3.13/site-packages/cryptography/hazmat/bindings/_rust/declarative_asn1.pyi

@@ -0,0 +1,32 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+import typing
+
+def encode_der(value: typing.Any) -> bytes: ...
+def non_root_python_to_rust(cls: type) -> Type: ...
+
+# Type is a Rust enum with tuple variants. For now, we express the type
+# annotations like this:
+class Type:
+    Sequence: typing.ClassVar[type]
+    PyInt: typing.ClassVar[type]
+
+class Annotation:
+    def __new__(
+        cls,
+    ) -> Annotation: ...
+
+class AnnotatedType:
+    inner: Type
+    annotation: Annotation
+
+    def __new__(cls, inner: Type, annotation: Annotation) -> AnnotatedType: ...
+
+class AnnotatedTypeObject:
+    annotated_type: AnnotatedType
+    value: typing.Any
+
+    def __new__(
+        cls, annotated_type: AnnotatedType, value: typing.Any
+    ) -> AnnotatedTypeObject: ...

miniconda3/lib/python3.13/site-packages/cryptography/hazmat/bindings/_rust/exceptions.pyi

@@ -0,0 +1,17 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+
+class _Reasons:
+    BACKEND_MISSING_INTERFACE: _Reasons
+    UNSUPPORTED_HASH: _Reasons
+    UNSUPPORTED_CIPHER: _Reasons
+    UNSUPPORTED_PADDING: _Reasons
+    UNSUPPORTED_MGF: _Reasons
+    UNSUPPORTED_PUBLIC_KEY_ALGORITHM: _Reasons
+    UNSUPPORTED_ELLIPTIC_CURVE: _Reasons
+    UNSUPPORTED_SERIALIZATION: _Reasons
+    UNSUPPORTED_X509: _Reasons
+    UNSUPPORTED_EXCHANGE_ALGORITHM: _Reasons
+    UNSUPPORTED_DIFFIE_HELLMAN: _Reasons
+    UNSUPPORTED_MAC: _Reasons

miniconda3/lib/python3.13/site-packages/cryptography/hazmat/bindings/_rust/ocsp.pyi

@@ -0,0 +1,117 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+
+import datetime
+from collections.abc import Iterator
+
+from cryptography import x509
+from cryptography.hazmat.primitives import hashes, serialization
+from cryptography.hazmat.primitives.asymmetric.types import PrivateKeyTypes
+from cryptography.x509 import ocsp
+
+class OCSPRequest:
+    @property
+    def issuer_key_hash(self) -> bytes: ...
+    @property
+    def issuer_name_hash(self) -> bytes: ...
+    @property
+    def hash_algorithm(self) -> hashes.HashAlgorithm: ...
+    @property
+    def serial_number(self) -> int: ...
+    def public_bytes(self, encoding: serialization.Encoding) -> bytes: ...
+    @property
+    def extensions(self) -> x509.Extensions: ...
+
+class OCSPResponse:
+    @property
+    def responses(self) -> Iterator[OCSPSingleResponse]: ...
+    @property
+    def response_status(self) -> ocsp.OCSPResponseStatus: ...
+    @property
+    def signature_algorithm_oid(self) -> x509.ObjectIdentifier: ...
+    @property
+    def signature_hash_algorithm(
+        self,
+    ) -> hashes.HashAlgorithm | None: ...
+    @property
+    def signature(self) -> bytes: ...
+    @property
+    def tbs_response_bytes(self) -> bytes: ...
+    @property
+    def certificates(self) -> list[x509.Certificate]: ...
+    @property
+    def responder_key_hash(self) -> bytes | None: ...
+    @property
+    def responder_name(self) -> x509.Name | None: ...
+    @property
+    def produced_at(self) -> datetime.datetime: ...
+    @property
+    def produced_at_utc(self) -> datetime.datetime: ...
+    @property
+    def certificate_status(self) -> ocsp.OCSPCertStatus: ...
+    @property
+    def revocation_time(self) -> datetime.datetime | None: ...
+    @property
+    def revocation_time_utc(self) -> datetime.datetime | None: ...
+    @property
+    def revocation_reason(self) -> x509.ReasonFlags | None: ...
+    @property
+    def this_update(self) -> datetime.datetime: ...
+    @property
+    def this_update_utc(self) -> datetime.datetime: ...
+    @property
+    def next_update(self) -> datetime.datetime | None: ...
+    @property
+    def next_update_utc(self) -> datetime.datetime | None: ...
+    @property
+    def issuer_key_hash(self) -> bytes: ...
+    @property
+    def issuer_name_hash(self) -> bytes: ...
+    @property
+    def hash_algorithm(self) -> hashes.HashAlgorithm: ...
+    @property
+    def serial_number(self) -> int: ...
+    @property
+    def extensions(self) -> x509.Extensions: ...
+    @property
+    def single_extensions(self) -> x509.Extensions: ...
+    def public_bytes(self, encoding: serialization.Encoding) -> bytes: ...
+
+class OCSPSingleResponse:
+    @property
+    def certificate_status(self) -> ocsp.OCSPCertStatus: ...
+    @property
+    def revocation_time(self) -> datetime.datetime | None: ...
+    @property
+    def revocation_time_utc(self) -> datetime.datetime | None: ...
+    @property
+    def revocation_reason(self) -> x509.ReasonFlags | None: ...
+    @property
+    def this_update(self) -> datetime.datetime: ...
+    @property
+    def this_update_utc(self) -> datetime.datetime: ...
+    @property
+    def next_update(self) -> datetime.datetime | None: ...
+    @property
+    def next_update_utc(self) -> datetime.datetime | None: ...
+    @property
+    def issuer_key_hash(self) -> bytes: ...
+    @property
+    def issuer_name_hash(self) -> bytes: ...
+    @property
+    def hash_algorithm(self) -> hashes.HashAlgorithm: ...
+    @property
+    def serial_number(self) -> int: ...
+
+def load_der_ocsp_request(data: bytes) -> ocsp.OCSPRequest: ...
+def load_der_ocsp_response(data: bytes) -> ocsp.OCSPResponse: ...
+def create_ocsp_request(
+    builder: ocsp.OCSPRequestBuilder,
+) -> ocsp.OCSPRequest: ...
+def create_ocsp_response(
+    status: ocsp.OCSPResponseStatus,
+    builder: ocsp.OCSPResponseBuilder | None,
+    private_key: PrivateKeyTypes | None,
+    hash_algorithm: hashes.HashAlgorithm | None,
+) -> ocsp.OCSPResponse: ...

miniconda3/lib/python3.13/site-packages/cryptography/hazmat/bindings/_rust/openssl/__init__.pyi

@@ -0,0 +1,75 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+
+import typing
+
+from cryptography.hazmat.bindings._rust.openssl import (
+    aead,
+    ciphers,
+    cmac,
+    dh,
+    dsa,
+    ec,
+    ed448,
+    ed25519,
+    hashes,
+    hmac,
+    kdf,
+    keys,
+    poly1305,
+    rsa,
+    x448,
+    x25519,
+)
+
+__all__ = [
+    "aead",
+    "ciphers",
+    "cmac",
+    "dh",
+    "dsa",
+    "ec",
+    "ed448",
+    "ed25519",
+    "hashes",
+    "hmac",
+    "kdf",
+    "keys",
+    "openssl_version",
+    "openssl_version_text",
+    "poly1305",
+    "raise_openssl_error",
+    "rsa",
+    "x448",
+    "x25519",
+]
+
+CRYPTOGRAPHY_IS_LIBRESSL: bool
+CRYPTOGRAPHY_IS_BORINGSSL: bool
+CRYPTOGRAPHY_IS_AWSLC: bool
+CRYPTOGRAPHY_OPENSSL_300_OR_GREATER: bool
+CRYPTOGRAPHY_OPENSSL_309_OR_GREATER: bool
+CRYPTOGRAPHY_OPENSSL_320_OR_GREATER: bool
+CRYPTOGRAPHY_OPENSSL_330_OR_GREATER: bool
+CRYPTOGRAPHY_OPENSSL_350_OR_GREATER: bool
+
+class Providers: ...
+
+_legacy_provider_loaded: bool
+_providers: Providers
+
+def openssl_version() -> int: ...
+def openssl_version_text() -> str: ...
+def raise_openssl_error() -> typing.NoReturn: ...
+def capture_error_stack() -> list[OpenSSLError]: ...
+def is_fips_enabled() -> bool: ...
+def enable_fips(providers: Providers) -> None: ...
+
+class OpenSSLError:
+    @property
+    def lib(self) -> int: ...
+    @property
+    def reason(self) -> int: ...
+    @property
+    def reason_text(self) -> bytes: ...

miniconda3/lib/python3.13/site-packages/cryptography/hazmat/bindings/_rust/openssl/aead.pyi

@@ -0,0 +1,107 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+
+from collections.abc import Sequence
+
+from cryptography.utils import Buffer
+
+class AESGCM:
+    def __init__(self, key: Buffer) -> None: ...
+    @staticmethod
+    def generate_key(bit_length: int) -> bytes: ...
+    def encrypt(
+        self,
+        nonce: Buffer,
+        data: Buffer,
+        associated_data: Buffer | None,
+    ) -> bytes: ...
+    def decrypt(
+        self,
+        nonce: Buffer,
+        data: Buffer,
+        associated_data: Buffer | None,
+    ) -> bytes: ...
+
+class ChaCha20Poly1305:
+    def __init__(self, key: Buffer) -> None: ...
+    @staticmethod
+    def generate_key() -> bytes: ...
+    def encrypt(
+        self,
+        nonce: Buffer,
+        data: Buffer,
+        associated_data: Buffer | None,
+    ) -> bytes: ...
+    def decrypt(
+        self,
+        nonce: Buffer,
+        data: Buffer,
+        associated_data: Buffer | None,
+    ) -> bytes: ...
+
+class AESCCM:
+    def __init__(self, key: Buffer, tag_length: int = 16) -> None: ...
+    @staticmethod
+    def generate_key(bit_length: int) -> bytes: ...
+    def encrypt(
+        self,
+        nonce: Buffer,
+        data: Buffer,
+        associated_data: Buffer | None,
+    ) -> bytes: ...
+    def decrypt(
+        self,
+        nonce: Buffer,
+        data: Buffer,
+        associated_data: Buffer | None,
+    ) -> bytes: ...
+
+class AESSIV:
+    def __init__(self, key: Buffer) -> None: ...
+    @staticmethod
+    def generate_key(bit_length: int) -> bytes: ...
+    def encrypt(
+        self,
+        data: Buffer,
+        associated_data: Sequence[Buffer] | None,
+    ) -> bytes: ...
+    def decrypt(
+        self,
+        data: Buffer,
+        associated_data: Sequence[Buffer] | None,
+    ) -> bytes: ...
+
+class AESOCB3:
+    def __init__(self, key: Buffer) -> None: ...
+    @staticmethod
+    def generate_key(bit_length: int) -> bytes: ...
+    def encrypt(
+        self,
+        nonce: Buffer,
+        data: Buffer,
+        associated_data: Buffer | None,
+    ) -> bytes: ...
+    def decrypt(
+        self,
+        nonce: Buffer,
+        data: Buffer,
+        associated_data: Buffer | None,
+    ) -> bytes: ...
+
+class AESGCMSIV:
+    def __init__(self, key: Buffer) -> None: ...
+    @staticmethod
+    def generate_key(bit_length: int) -> bytes: ...
+    def encrypt(
+        self,
+        nonce: Buffer,
+        data: Buffer,
+        associated_data: Buffer | None,
+    ) -> bytes: ...
+    def decrypt(
+        self,
+        nonce: Buffer,
+        data: Buffer,
+        associated_data: Buffer | None,
+    ) -> bytes: ...

miniconda3/lib/python3.13/site-packages/cryptography/hazmat/bindings/_rust/openssl/ciphers.pyi

@@ -0,0 +1,38 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+
+import typing
+
+from cryptography.hazmat.primitives import ciphers
+from cryptography.hazmat.primitives.ciphers import modes
+
+@typing.overload
+def create_encryption_ctx(
+    algorithm: ciphers.CipherAlgorithm, mode: modes.ModeWithAuthenticationTag
+) -> ciphers.AEADEncryptionContext: ...
+@typing.overload
+def create_encryption_ctx(
+    algorithm: ciphers.CipherAlgorithm, mode: modes.Mode | None
+) -> ciphers.CipherContext: ...
+@typing.overload
+def create_decryption_ctx(
+    algorithm: ciphers.CipherAlgorithm, mode: modes.ModeWithAuthenticationTag
+) -> ciphers.AEADDecryptionContext: ...
+@typing.overload
+def create_decryption_ctx(
+    algorithm: ciphers.CipherAlgorithm, mode: modes.Mode | None
+) -> ciphers.CipherContext: ...
+def cipher_supported(
+    algorithm: ciphers.CipherAlgorithm, mode: modes.Mode
+) -> bool: ...
+def _advance(
+    ctx: ciphers.AEADEncryptionContext | ciphers.AEADDecryptionContext, n: int
+) -> None: ...
+def _advance_aad(
+    ctx: ciphers.AEADEncryptionContext | ciphers.AEADDecryptionContext, n: int
+) -> None: ...
+
+class CipherContext: ...
+class AEADEncryptionContext: ...
+class AEADDecryptionContext: ...

miniconda3/lib/python3.13/site-packages/cryptography/hazmat/bindings/_rust/openssl/cmac.pyi

@@ -0,0 +1,18 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+
+import typing
+
+from cryptography.hazmat.primitives import ciphers
+
+class CMAC:
+    def __init__(
+        self,
+        algorithm: ciphers.BlockCipherAlgorithm,
+        backend: typing.Any = None,
+    ) -> None: ...
+    def update(self, data: bytes) -> None: ...
+    def finalize(self) -> bytes: ...
+    def verify(self, signature: bytes) -> None: ...
+    def copy(self) -> CMAC: ...

miniconda3/lib/python3.13/site-packages/cryptography/hazmat/bindings/_rust/openssl/dh.pyi

@@ -0,0 +1,51 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+
+import typing
+
+from cryptography.hazmat.primitives.asymmetric import dh
+
+MIN_MODULUS_SIZE: int
+
+class DHPrivateKey: ...
+class DHPublicKey: ...
+class DHParameters: ...
+
+class DHPrivateNumbers:
+    def __init__(self, x: int, public_numbers: DHPublicNumbers) -> None: ...
+    def private_key(self, backend: typing.Any = None) -> dh.DHPrivateKey: ...
+    @property
+    def x(self) -> int: ...
+    @property
+    def public_numbers(self) -> DHPublicNumbers: ...
+
+class DHPublicNumbers:
+    def __init__(
+        self, y: int, parameter_numbers: DHParameterNumbers
+    ) -> None: ...
+    def public_key(self, backend: typing.Any = None) -> dh.DHPublicKey: ...
+    @property
+    def y(self) -> int: ...
+    @property
+    def parameter_numbers(self) -> DHParameterNumbers: ...
+
+class DHParameterNumbers:
+    def __init__(self, p: int, g: int, q: int | None = None) -> None: ...
+    def parameters(self, backend: typing.Any = None) -> dh.DHParameters: ...
+    @property
+    def p(self) -> int: ...
+    @property
+    def g(self) -> int: ...
+    @property
+    def q(self) -> int | None: ...
+
+def generate_parameters(
+    generator: int, key_size: int, backend: typing.Any = None
+) -> dh.DHParameters: ...
+def from_pem_parameters(
+    data: bytes, backend: typing.Any = None
+) -> dh.DHParameters: ...
+def from_der_parameters(
+    data: bytes, backend: typing.Any = None
+) -> dh.DHParameters: ...

miniconda3/lib/python3.13/site-packages/cryptography/hazmat/bindings/_rust/openssl/dsa.pyi

@@ -0,0 +1,41 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+
+import typing
+
+from cryptography.hazmat.primitives.asymmetric import dsa
+
+class DSAPrivateKey: ...
+class DSAPublicKey: ...
+class DSAParameters: ...
+
+class DSAPrivateNumbers:
+    def __init__(self, x: int, public_numbers: DSAPublicNumbers) -> None: ...
+    @property
+    def x(self) -> int: ...
+    @property
+    def public_numbers(self) -> DSAPublicNumbers: ...
+    def private_key(self, backend: typing.Any = None) -> dsa.DSAPrivateKey: ...
+
+class DSAPublicNumbers:
+    def __init__(
+        self, y: int, parameter_numbers: DSAParameterNumbers
+    ) -> None: ...
+    @property
+    def y(self) -> int: ...
+    @property
+    def parameter_numbers(self) -> DSAParameterNumbers: ...
+    def public_key(self, backend: typing.Any = None) -> dsa.DSAPublicKey: ...
+
+class DSAParameterNumbers:
+    def __init__(self, p: int, q: int, g: int) -> None: ...
+    @property
+    def p(self) -> int: ...
+    @property
+    def q(self) -> int: ...
+    @property
+    def g(self) -> int: ...
+    def parameters(self, backend: typing.Any = None) -> dsa.DSAParameters: ...
+
+def generate_parameters(key_size: int) -> dsa.DSAParameters: ...

miniconda3/lib/python3.13/site-packages/cryptography/hazmat/bindings/_rust/openssl/ec.pyi

@@ -0,0 +1,52 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+
+import typing
+
+from cryptography.hazmat.primitives.asymmetric import ec
+
+class ECPrivateKey: ...
+class ECPublicKey: ...
+
+class EllipticCurvePrivateNumbers:
+    def __init__(
+        self, private_value: int, public_numbers: EllipticCurvePublicNumbers
+    ) -> None: ...
+    def private_key(
+        self, backend: typing.Any = None
+    ) -> ec.EllipticCurvePrivateKey: ...
+    @property
+    def private_value(self) -> int: ...
+    @property
+    def public_numbers(self) -> EllipticCurvePublicNumbers: ...
+
+class EllipticCurvePublicNumbers:
+    def __init__(self, x: int, y: int, curve: ec.EllipticCurve) -> None: ...
+    def public_key(
+        self, backend: typing.Any = None
+    ) -> ec.EllipticCurvePublicKey: ...
+    @property
+    def x(self) -> int: ...
+    @property
+    def y(self) -> int: ...
+    @property
+    def curve(self) -> ec.EllipticCurve: ...
+    def __eq__(self, other: object) -> bool: ...
+
+def curve_supported(curve: ec.EllipticCurve) -> bool: ...
+def generate_private_key(
+    curve: ec.EllipticCurve, backend: typing.Any = None
+) -> ec.EllipticCurvePrivateKey: ...
+def from_private_numbers(
+    numbers: ec.EllipticCurvePrivateNumbers,
+) -> ec.EllipticCurvePrivateKey: ...
+def from_public_numbers(
+    numbers: ec.EllipticCurvePublicNumbers,
+) -> ec.EllipticCurvePublicKey: ...
+def from_public_bytes(
+    curve: ec.EllipticCurve, data: bytes
+) -> ec.EllipticCurvePublicKey: ...
+def derive_private_key(
+    private_value: int, curve: ec.EllipticCurve
+) -> ec.EllipticCurvePrivateKey: ...