dcap-qvl 0.3.9__cp38-abi3-win_amd64.whl

dcap_qvl/__init__.py

@@ -0,0 +1,130 @@
+"""
+DCAP Quote Verification Library
+
+This package provides Python bindings for the DCAP (Data Center Attestation Primitives)
+quote verification library implemented in Rust.
+
+Main classes:
+- QuoteCollateralV3: Represents quote collateral data
+- VerifiedReport: Contains verification results
+
+Main functions:
+- verify: Verify a quote with collateral data
+- get_collateral: Get collateral from PCCS URL
+- get_collateral_from_pcs: Get collateral from Intel PCS
+- get_collateral_and_verify: Get collateral and verify quote
+"""
+
+import time
+from importlib.metadata import version
+from typing import Optional
+
+from ._dcap_qvl import (
+    PyQuoteCollateralV3 as QuoteCollateralV3,
+    PyVerifiedReport as VerifiedReport,
+    PyQuote as Quote,
+    py_verify as verify,
+    py_verify_with_root_ca as verify_with_root_ca,
+    parse_quote,
+    get_collateral_for_fmspc,
+)
+
+# Default PCCS URL (Phala Network's PCCS server - recommended)
+PHALA_PCCS_URL = "https://pccs.phala.network"
+
+# Intel's official PCS URL
+INTEL_PCS_URL = "https://api.trustedservices.intel.com"
+
+# Backward compatibility alias
+PCS_URL = INTEL_PCS_URL
+
+
+async def get_collateral(pccs_url: str, raw_quote: bytes) -> QuoteCollateralV3:
+    """Get collateral from PCCS URL.
+
+    Args:
+        pccs_url: PCCS server URL
+        raw_quote: Raw quote bytes
+
+    Returns:
+        QuoteCollateralV3: Quote collateral data
+
+    Raises:
+        ValueError: If quote is invalid or FMSPC cannot be extracted
+        RuntimeError: If network request fails
+    """
+    if not isinstance(raw_quote, (bytes, bytearray)):
+        raise TypeError("raw_quote must be bytes")
+
+    quote = Quote.parse(raw_quote)
+    fmspc = quote.fmspc()
+    is_sgx = quote.is_sgx()
+    ca = quote.ca()
+    return await get_collateral_for_fmspc(pccs_url, fmspc, ca, is_sgx)
+
+
+async def get_collateral_from_pcs(raw_quote: bytes) -> QuoteCollateralV3:
+    """Get collateral from Intel PCS.
+
+    Use this function to explicitly fetch collateral from Intel's
+    Provisioning Certification Service. For most use cases,
+    use get_collateral() with PHALA_PCCS_URL instead.
+
+    Args:
+        raw_quote: Raw quote bytes
+
+    Returns:
+        QuoteCollateralV3: Quote collateral data
+
+    Raises:
+        ValueError: If quote is invalid or FMSPC cannot be extracted
+        RuntimeError: If network request fails
+    """
+    return await get_collateral(INTEL_PCS_URL, raw_quote)
+
+
+async def get_collateral_and_verify(
+    raw_quote: bytes, pccs_url: Optional[str] = None
+) -> VerifiedReport:
+    """Get collateral and verify the quote.
+
+    Args:
+        raw_quote: Raw quote bytes
+        pccs_url: Optional PCCS URL (defaults to Phala PCCS)
+
+    Returns:
+        VerifiedReport: Verification result
+
+    Raises:
+        ValueError: If quote is invalid or verification fails
+        RuntimeError: If network request fails
+    """
+    url = (pccs_url or "").strip() or PHALA_PCCS_URL
+
+    # Get collateral
+    collateral = await get_collateral(url, raw_quote)
+
+    # Get current time
+    now_secs = int(time.time())
+
+    # Verify quote
+    return verify(raw_quote, collateral, now_secs)
+
+
+__all__ = [
+    "QuoteCollateralV3",
+    "VerifiedReport",
+    "Quote",
+    "verify",
+    "verify_with_root_ca",
+    "get_collateral",
+    "get_collateral_from_pcs",
+    "get_collateral_and_verify",
+    "get_collateral_for_fmspc",
+    "parse_quote",
+    "PHALA_PCCS_URL",
+    "INTEL_PCS_URL",
+    "PCS_URL",
+]
+
+__version__ = version("dcap-qvl")

dcap_qvl/_dcap_qvl.pyi

@@ -0,0 +1,328 @@
+"""
+Type stubs for the _dcap_qvl C extension module.
+
+This file provides detailed type hints for the compiled Rust extension,
+enabling better IDE support, type checking with mypy, and improved
+developer experience.
+"""
+
+from typing import List
+
+class PyQuoteCollateralV3:
+    """
+    Represents quote collateral data required for DCAP quote verification.
+
+    This class contains all the necessary certificate chains, CRLs, and
+    attestation information needed to verify an SGX or TDX quote.
+    """
+
+    def __init__(
+        self,
+        pck_crl_issuer_chain: str,
+        root_ca_crl: bytes,
+        pck_crl: bytes,
+        tcb_info_issuer_chain: str,
+        tcb_info: str,
+        tcb_info_signature: bytes,
+        qe_identity_issuer_chain: str,
+        qe_identity: str,
+        qe_identity_signature: bytes,
+    ) -> None:
+        """
+        Create a new PyQuoteCollateralV3 instance.
+
+        Args:
+            pck_crl_issuer_chain: PCK CRL issuer certificate chain (PEM format)
+            root_ca_crl: Root CA certificate revocation list
+            pck_crl: PCK certificate revocation list
+            tcb_info_issuer_chain: TCB info issuer certificate chain (PEM format)
+            tcb_info: TCB (Trusted Computing Base) information (JSON string)
+            tcb_info_signature: Signature for the TCB info
+            qe_identity_issuer_chain: QE identity issuer certificate chain (PEM format)
+            qe_identity: Quoting Enclave identity information (JSON string)
+            qe_identity_signature: Signature for the QE identity
+        """
+        ...
+
+    @property
+    def pck_crl_issuer_chain(self) -> str:
+        """PCK CRL issuer certificate chain in PEM format."""
+        ...
+
+    @property
+    def root_ca_crl(self) -> bytes:
+        """Root CA certificate revocation list."""
+        ...
+
+    @property
+    def pck_crl(self) -> bytes:
+        """PCK certificate revocation list."""
+        ...
+
+    @property
+    def tcb_info_issuer_chain(self) -> str:
+        """TCB info issuer certificate chain in PEM format."""
+        ...
+
+    @property
+    def tcb_info(self) -> str:
+        """TCB (Trusted Computing Base) information as JSON string."""
+        ...
+
+    @property
+    def tcb_info_signature(self) -> bytes:
+        """Signature for the TCB info."""
+        ...
+
+    @property
+    def qe_identity_issuer_chain(self) -> str:
+        """QE identity issuer certificate chain in PEM format."""
+        ...
+
+    @property
+    def qe_identity(self) -> str:
+        """Quoting Enclave identity information as JSON string."""
+        ...
+
+    @property
+    def qe_identity_signature(self) -> bytes:
+        """Signature for the QE identity."""
+        ...
+
+    def to_json(self) -> str:
+        """
+        Serialize the collateral to a JSON string.
+
+        Returns:
+            JSON string representation of the collateral data
+
+        Raises:
+            ValueError: If serialization fails
+        """
+        ...
+
+    @staticmethod
+    def from_json(json_str: str) -> "PyQuoteCollateralV3":
+        """
+        Create a PyQuoteCollateralV3 instance from a JSON string.
+
+        Args:
+            json_str: JSON string containing collateral data
+
+        Returns:
+            New PyQuoteCollateralV3 instance
+
+        Raises:
+            ValueError: If JSON parsing fails or data is invalid
+        """
+        ...
+
+class PyVerifiedReport:
+    """
+    Contains the results of DCAP quote verification.
+
+    This class holds the verification status and any security advisories
+    that were found during the quote verification process.
+    """
+
+    @property
+    def status(self) -> str:
+        """
+        Verification status string.
+
+        Common values include:
+        - "OK": Verification successful, no issues
+        - "SW_HARDENING_NEEDED": Software hardening recommended
+        - "CONFIGURATION_NEEDED": Platform configuration required
+        - "OUT_OF_DATE": TCB is out of date
+        - "REVOKED": Certificate or key has been revoked
+        """
+        ...
+
+    @property
+    def advisory_ids(self) -> List[str]:
+        """
+        List of security advisory IDs that apply to this quote.
+
+        These are Intel security advisory identifiers (e.g., "INTEL-SA-00334")
+        that indicate known security issues affecting the attested platform.
+        """
+        ...
+
+    def to_json(self) -> str:
+        """
+        Serialize the verification report to a JSON string.
+
+        Returns:
+            JSON string representation of the verification report
+
+        Raises:
+            ValueError: If serialization fails
+        """
+        ...
+
+class PyQuote:
+    """
+    Represents a parsed SGX or TDX quote.
+
+    This class provides access to quote metadata and identifiers
+    without requiring collateral data for verification.
+    """
+
+    @staticmethod
+    def parse(raw_quote: bytes) -> "PyQuote":
+        """
+        Parse a raw quote from bytes.
+
+        Args:
+            raw_quote: Raw quote data as bytes (SGX or TDX format)
+
+        Returns:
+            PyQuote instance with parsed quote data
+
+        Raises:
+            ValueError: If quote parsing fails due to invalid format or corrupted data
+        """
+        ...
+
+    def fmspc(self) -> str:
+        """
+        Extract the FMSPC (Family-Model-Stepping-Platform-CustomSKU) identifier.
+
+        The FMSPC is a 6-byte identifier that uniquely identifies the
+        platform's TCB level and is used for collateral retrieval.
+
+        Returns:
+            FMSPC as uppercase hexadecimal string (12 characters)
+
+        Raises:
+            ValueError: If FMSPC cannot be extracted from the quote
+        """
+        ...
+
+    def ca(self) -> str:
+        """
+        Extract the CA (Certificate Authority) identifier.
+
+        The CA identifier indicates which certificate authority
+        should be used for quote verification.
+
+        Returns:
+            CA identifier as string
+
+        Raises:
+            ValueError: If CA identifier cannot be extracted from the quote
+        """
+        ...
+
+    def is_tdx(self) -> bool:
+        """
+        Check if this is a TDX (Trust Domain Extensions) quote.
+
+        Returns:
+            True if the quote is TDX format, False if SGX format
+        """
+        ...
+
+    def is_sgx(self) -> bool:
+        """
+        Check if this is an SGX quote.
+
+        Returns:
+            True if the quote is SGX format, False if TDX format
+        """
+        ...
+
+    def quote_type(self) -> str:
+        """
+        Get the quote type as a string.
+
+        Returns:
+            "TDX" for TDX quotes, "SGX" for SGX quotes
+        """
+        ...
+
+def py_verify(
+    raw_quote: bytes, collateral: PyQuoteCollateralV3, now_secs: int
+) -> PyVerifiedReport:
+    """
+    Verify an SGX or TDX quote with the provided collateral data.
+
+    This function performs cryptographic verification of the quote against
+    the provided collateral information, checking certificates, signatures,
+    and revocation status.
+
+    Args:
+        raw_quote: Raw quote data as bytes (SGX or TDX format)
+        collateral: Quote collateral containing certificates and attestation data
+        now_secs: Current timestamp in seconds since Unix epoch for time-based checks
+
+    Returns:
+        PyVerifiedReport containing verification status and advisory information
+
+    Raises:
+        ValueError: If verification fails due to invalid data, expired certificates,
+                   revoked keys, or other verification errors
+    """
+    ...
+
+def py_verify_with_root_ca(
+    raw_quote: bytes,
+    collateral: PyQuoteCollateralV3,
+    root_ca_der: bytes,
+    now_secs: int
+) -> PyVerifiedReport:
+    """
+    Verify an SGX or TDX quote with the provided collateral data and custom root CA.
+
+    Args:
+        raw_quote: Raw quote data as bytes (SGX or TDX format)
+        collateral: Quote collateral containing certificates and attestation data
+        root_ca_der: Custom root CA certificate in DER format
+        now_secs: Current timestamp in seconds since Unix epoch for time-based checks
+
+    Returns:
+        PyVerifiedReport containing verification status and advisory information
+
+    Raises:
+        ValueError: If verification fails
+    """
+    ...
+
+def parse_quote(raw_quote: bytes) -> PyQuote:
+    """
+    Parse a raw quote from bytes (convenience function).
+
+    This is a convenience function that calls PyQuote.parse() directly.
+
+    Args:
+        raw_quote: Raw quote data as bytes (SGX or TDX format)
+
+    Returns:
+        PyQuote instance with parsed quote data
+
+    Raises:
+        ValueError: If quote parsing fails due to invalid format or corrupted data
+    """
+    ...
+
+async def get_collateral_for_fmspc(
+    pccs_url: str, fmspc: str, ca: str, is_sgx: bool
+) -> PyQuoteCollateralV3:
+    """
+    Get collateral for a specific FMSPC from PCCS URL.
+
+    Args:
+        pccs_url: PCCS server URL
+        fmspc: FMSPC identifier as hex string
+        ca: Certificate authority identifier
+        is_sgx: True for SGX, False for TDX
+
+    Returns:
+        PyQuoteCollateralV3 with collateral data
+
+    Raises:
+        ValueError: If FMSPC is invalid
+        RuntimeError: If network request fails
+    """
+    ...

dcap_qvl-0.3.9.dist-info/METADATA

@@ -0,0 +1,389 @@
+Metadata-Version: 2.4
+Name: dcap-qvl
+Version: 0.3.9
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+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 :: Rust
+Classifier: Topic :: Security :: Cryptography
+Classifier: Topic :: Software Development :: Libraries
+Summary: Python bindings for DCAP (Data Center Attestation Primitives) quote verification library
+Keywords: sgx,tdx,dcap,attestation,verification,cryptography
+Author-email: Kevin Wang <wy721@qq.com>
+License: MIT
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
+Project-URL: Homepage, https://github.com/Phala-Network/dcap-qvl
+Project-URL: Repository, https://github.com/Phala-Network/dcap-qvl
+Project-URL: Issues, https://github.com/Phala-Network/dcap-qvl/issues
+
+# Python Bindings for DCAP-QVL
+
+This package provides Python bindings for the DCAP (Data Center Attestation Primitives) quote verification library implemented in Rust.
+
+## Quick Start
+
+```bash
+# Install from PyPI
+pip install dcap-qvl
+
+# Basic usage
+python -c "
+import dcap_qvl
+print('DCAP-QVL Python bindings successfully installed!')
+print(f'Available functions: {dcap_qvl.__all__}')
+"
+```
+
+## Features
+
+- Verify SGX and TDX quotes
+- Handle quote collateral data
+- Parse verification results
+- Pure Rust implementation with Python bindings
+- Cross-platform compatibility (Linux, macOS, Windows)
+- Asynchronous collateral fetching from PCCS/PCS with async/await support
+- Compatible with Python 3.8+
+
+## Installation
+
+### From PyPI (recommended)
+
+```bash
+pip install dcap-qvl
+```
+
+### Using uv
+
+```bash
+uv add dcap-qvl
+```
+
+## Usage
+
+### Basic Quote Verification
+
+```python
+import dcap_qvl
+import json
+import time
+
+# Load quote data (binary)
+with open("path/to/quote", "rb") as f:
+    quote_data = f.read()
+
+# Load collateral data (JSON)
+with open("path/to/collateral.json", "r") as f:
+    collateral_json = json.load(f)
+
+# Create collateral object
+collateral = dcap_qvl.QuoteCollateralV3.from_json(json.dumps(collateral_json))
+
+# Verify the quote
+now = int(time.time())
+try:
+    result = dcap_qvl.verify(quote_data, collateral, now)
+    print(f"Verification successful! Status: {result.status}")
+    print(f"Advisory IDs: {result.advisory_ids}")
+except ValueError as e:
+    print(f"Verification failed: {e}")
+```
+
+### Working with Collateral Data
+
+```python
+# Create collateral manually
+collateral = dcap_qvl.QuoteCollateralV3(
+    pck_crl_issuer_chain="...",
+    root_ca_crl=b"...",  # bytes
+    pck_crl=b"...",      # bytes
+    tcb_info_issuer_chain="...",
+    tcb_info="...",      # JSON string
+    tcb_info_signature=b"...",  # bytes
+    qe_identity_issuer_chain="...",
+    qe_identity="...",   # JSON string
+    qe_identity_signature=b"...",  # bytes
+)
+
+# Serialize to JSON
+json_str = collateral.to_json()
+
+# Deserialize from JSON
+collateral = dcap_qvl.QuoteCollateralV3.from_json(json_str)
+```
+
+## API Reference
+
+### Async Collateral Functions
+
+All collateral functions are asynchronous and must be awaited. They use the Rust async runtime for optimal performance.
+
+#### `async get_collateral_for_fmspc(pccs_url: str, fmspc: str, ca: str, is_sgx: bool) -> QuoteCollateralV3`
+
+Get collateral for a specific FMSPC directly from PCCS URL (Rust async export).
+
+**Parameters:**
+- `pccs_url`: PCCS URL (e.g., "https://api.trustedservices.intel.com")
+- `fmspc`: FMSPC value as hex string (e.g., "B0C06F000000")
+- `ca`: Certificate Authority ("processor" or "platform")
+- `is_sgx`: True for SGX quotes, False for TDX quotes
+
+**Returns:**
+- `QuoteCollateralV3`: Quote collateral data
+
+**Raises:**
+- `ValueError`: If FMSPC is invalid or collateral cannot be retrieved
+- `RuntimeError`: If network request fails
+
+**Example:**
+```python
+import asyncio
+import dcap_qvl
+
+async def main():
+    collateral = await dcap_qvl.get_collateral_for_fmspc(
+        pccs_url="https://api.trustedservices.intel.com",
+        fmspc="B0C06F000000",
+        ca="processor",
+        is_sgx=True
+    )
+    print(f"Got collateral: {len(collateral.tcb_info)} chars")
+
+asyncio.run(main())
+```
+
+#### `async get_collateral(pccs_url: str, raw_quote: bytes) -> QuoteCollateralV3`
+
+Get collateral from a custom PCCS URL by parsing the quote.
+
+**Parameters:**
+- `pccs_url`: PCCS URL (e.g., "https://api.trustedservices.intel.com")
+- `raw_quote`: Raw quote data as bytes
+
+**Returns:**
+- `QuoteCollateralV3`: Quote collateral data
+
+**Raises:**
+- `ValueError`: If quote is invalid or FMSPC cannot be extracted
+- `RuntimeError`: If network request fails
+
+**Example:**
+```python
+import asyncio
+import dcap_qvl
+
+async def main():
+    pccs_url = "https://api.trustedservices.intel.com"
+    quote_data = open("quote.bin", "rb").read()
+    collateral = await dcap_qvl.get_collateral(pccs_url, quote_data)
+    print(f"Got collateral: {len(collateral.tcb_info)} chars")
+
+asyncio.run(main())
+```
+
+#### `async get_collateral_from_pcs(raw_quote: bytes) -> QuoteCollateralV3`
+
+Get collateral from Intel's PCS (default).
+
+**Parameters:**
+- `raw_quote`: Raw quote data as bytes
+
+**Returns:**
+- `QuoteCollateralV3`: Quote collateral data
+
+**Raises:**
+- `ValueError`: If quote is invalid or FMSPC cannot be extracted
+- `RuntimeError`: If network request fails
+
+**Example:**
+```python
+import asyncio
+import dcap_qvl
+
+async def main():
+    quote_data = open("quote.bin", "rb").read()
+    collateral = await dcap_qvl.get_collateral_from_pcs(quote_data)
+    print(f"Got collateral from Intel PCS")
+
+asyncio.run(main())
+```
+
+#### `async get_collateral_and_verify(raw_quote: bytes, pccs_url: Optional[str] = None) -> VerifiedReport`
+
+Get collateral and verify quote in one step.
+
+**Parameters:**
+- `raw_quote`: Raw quote data as bytes
+- `pccs_url`: Optional PCCS URL (uses Intel PCS if None)
+
+**Returns:**
+- `VerifiedReport`: Verification results
+
+**Raises:**
+- `ValueError`: If quote is invalid or verification fails
+- `RuntimeError`: If network request fails
+
+**Example:**
+```python
+import asyncio
+import dcap_qvl
+
+async def main():
+    quote_data = open("quote.bin", "rb").read()
+    result = await dcap_qvl.get_collateral_and_verify(quote_data)
+    print(f"Status: {result.status}")
+    print(f"Advisory IDs: {result.advisory_ids}")
+
+asyncio.run(main())
+```
+
+### Classes
+
+#### `QuoteCollateralV3`
+
+Represents quote collateral data required for verification.
+
+**Constructor:**
+```python
+QuoteCollateralV3(
+    pck_crl_issuer_chain: str,
+    root_ca_crl: bytes,
+    pck_crl: bytes,
+    tcb_info_issuer_chain: str,
+    tcb_info: str,
+    tcb_info_signature: bytes,
+    qe_identity_issuer_chain: str,
+    qe_identity: str,
+    qe_identity_signature: bytes,
+)
+```
+
+**Methods:**
+- `to_json() -> str`: Serialize to JSON string
+- `from_json(json_str: str) -> QuoteCollateralV3`: Create from JSON string (static method)
+
+**Properties:**
+- `pck_crl_issuer_chain: str`
+- `root_ca_crl: bytes`
+- `pck_crl: bytes`
+- `tcb_info_issuer_chain: str`
+- `tcb_info: str`
+- `tcb_info_signature: bytes`
+- `qe_identity_issuer_chain: str`
+- `qe_identity: str`
+- `qe_identity_signature: bytes`
+
+#### `VerifiedReport`
+
+Contains the results of quote verification.
+
+**Properties:**
+- `status: str`: Verification status
+- `advisory_ids: List[str]`: List of advisory IDs
+
+**Methods:**
+- `to_json() -> str`: Serialize to JSON string
+
+### Functions
+
+#### `verify(raw_quote: bytes, collateral: QuoteCollateralV3, now_secs: int) -> VerifiedReport`
+
+Verify a quote with the provided collateral data.
+
+**Parameters:**
+- `raw_quote`: Raw quote data as bytes
+- `collateral`: Quote collateral data
+- `now_secs`: Current timestamp in seconds since Unix epoch
+
+**Returns:**
+- `VerifiedReport`: Verification results
+
+**Raises:**
+- `ValueError`: If verification fails
+
+## Development
+
+### Building from Source
+
+If you want to build from source or contribute to development:
+
+```bash
+# Clone the repository
+git clone https://github.com/Phala-Network/dcap-qvl.git
+cd dcap-qvl/python-bindings
+
+# Install development dependencies (including maturin)
+uv sync
+
+# Build and install the Python extension in development mode
+uv run maturin develop --features python
+
+# Run tests
+uv run python -m pytest tests/test_python_bindings.py
+```
+
+**Note:** maturin is only required for building from source. Regular users installing from PyPI don't need maturin.
+
+### Running Examples
+
+After installing the package, you can run the examples:
+
+```bash
+# Download the examples from the repository
+git clone https://github.com/Phala-Network/dcap-qvl.git
+cd dcap-qvl/python-bindings
+
+# Basic functionality test
+python examples/basic_test.py
+
+# Full example (requires sample data files)
+python examples/python_example.py
+```
+
+Or if you're using uv for development:
+
+```bash
+# Basic functionality test
+uv run python examples/basic_test.py
+
+# Full example (requires sample data files)
+uv run python examples/python_example.py
+```
+
+### Testing Across Python Versions
+
+The project includes comprehensive testing across all supported Python versions:
+
+```bash
+# Quick test across all Python versions
+make test_python_versions
+
+# Test current Python version only
+make test_python
+```
+
+See [PYTHON_TESTING.md](PYTHON_TESTING.md) for detailed information about Python version compatibility testing.
+
+## Requirements
+
+### For regular usage (installing from PyPI):
+- Python 3.8+
+
+### For development (building from source):
+- Python 3.8+
+- Rust toolchain (rustc, cargo)
+- maturin (automatically installed with `uv sync`)
+
+## License
+
+MIT License - see [LICENSE](../../LICENSE) for details.
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.

dcap_qvl-0.3.9.dist-info/RECORD

@@ -0,0 +1,6 @@
+dcap_qvl-0.3.9.dist-info/METADATA,sha256=sI1IjeYz9mzoj3V_DjiwvWxZ4jdx9mw7MX4-GbZhyu0,10248
+dcap_qvl-0.3.9.dist-info/WHEEL,sha256=lMUAg5cfi6g8a7v52pog4330UzKeSSlNI3fLvrdVzVU,94
+dcap_qvl/__init__.py,sha256=4xmJtn_20NzAmQAshf2TE8cdmJ-mnq-aJ19l_4tS2ow,3580
+dcap_qvl/_dcap_qvl.pyd,sha256=6FjMO0ZFFgWoaqfLeFVd48lfblTYzI6-v1-2m6_wq1s,6440448
+dcap_qvl/_dcap_qvl.pyi,sha256=xSN4Y3qgeoBW0czSUiDumpdLLAC45CYiywlEW4hURZA,9497
+dcap_qvl-0.3.9.dist-info/RECORD,,

dcap_qvl-0.3.9.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: maturin (1.9.2)
+Root-Is-Purelib: false
+Tag: cp38-abi3-win_amd64