pyvelv 0.1.0__py3-none-any.whl

pyvelv/__init__.py

@@ -0,0 +1,22 @@
+"""
+Pyvelv — Async Python SDK for the Velvpay payment gateway.
+
+Usage:
+    from pyvelv import Velvpay
+
+    async with Velvpay(secret_key="sk_...") as client:
+        link = await client.payment_links.create(...)
+"""
+
+from pyvelv.client import VelvpayClient
+
+# Ergonomic alias so users can do: from pyvelv import Velvpay
+Velvpay = VelvpayClient
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "Velvpay",
+    "VelvpayClient",
+    "__version__",
+]

pyvelv/client.py

@@ -0,0 +1,203 @@
+"""
+Async HTTP client for the Velvpay payment gateway.
+
+Usage::
+
+    async with VelvpayClient(
+        secret_key="sk_...",
+        public_key="pk_...",
+        encryption_key="enc_...",
+    ) as client:
+        link = await client.payment_links.create(...)
+"""
+
+from __future__ import annotations
+
+from typing import Any
+import uuid
+
+import httpx
+
+from pyvelv.crypto import generate_api_key_header
+from pyvelv.exceptions import VelvpayAPIError, VelvpayAuthError
+
+
+class VelvpayClient:
+    """
+    Asynchronous client for the Velvpay API.
+
+    Args:
+        secret_key: Your Velvpay merchant secret key.
+        public_key: Your Velvpay merchant public key.
+        encryption_key: Your Velvpay encryption key/passphrase.
+        base_url: API base URL. If not provided, it is chosen based on the sandbox flag.
+        sandbox: If True, uses the test sandbox base URL.
+        timeout: Request timeout in seconds.
+    """
+
+    _PRODUCTION_BASE_URL = "https://api.velvpay.com/api/v1/service"
+    _SANDBOX_BASE_URL = "https://testapi.velpay.io"
+
+    def __init__(
+        self,
+        secret_key: str,
+        public_key: str,
+        encryption_key: str,
+        *,
+        base_url: str | None = None,
+        sandbox: bool = False,
+        timeout: float = 30.0,
+    ) -> None:
+        if not secret_key:
+            raise ValueError("secret_key must not be empty")
+        if not public_key:
+            raise ValueError("public_key must not be empty")
+        if not encryption_key:
+            raise ValueError("encryption_key must not be empty")
+
+        self._secret_key = secret_key
+        self._public_key = public_key
+        self._encryption_key = encryption_key
+
+
+
+        if base_url:
+            self._base_url = base_url.rstrip("/")
+        else:
+            self._base_url = (self._SANDBOX_BASE_URL if sandbox else self._PRODUCTION_BASE_URL).rstrip("/")
+
+        self._timeout = timeout
+        self._http: httpx.AsyncClient | None = None
+
+        # Lazily-initialised resource namespaces
+        self._payment_links: PaymentLinksResource | None = None
+        self._transactions: TransactionsResource | None = None
+
+    # ------------------------------------------------------------------
+    # HTTP transport helpers
+    # ------------------------------------------------------------------
+
+    @property
+    def http(self) -> httpx.AsyncClient:
+        """Return (or lazily create) the underlying ``httpx.AsyncClient``."""
+        if self._http is None or self._http.is_closed:
+            self._http = httpx.AsyncClient(
+                base_url=self._base_url,
+                timeout=self._timeout,
+            )
+        return self._http
+
+    async def _request(
+        self,
+        method: str,
+        path: str,
+        *,
+        json: Any | None = None,
+        params: dict[str, Any] | None = None,
+    ) -> dict[str, Any]:
+        """
+        Send an authenticated request to the Velvpay API.
+
+        Dynamic headers including the encrypted `api-key` and `reference-id`
+        are generated for each call.
+        """
+        reference_id = f"ref_{uuid.uuid4().hex}"
+        api_key = generate_api_key_header(
+            secret_key=self._secret_key,
+            public_key=self._public_key,
+            reference_id=reference_id,
+            encryption_key=self._encryption_key,
+        )
+
+        headers = {
+            "Content-Type": "application/json",
+            "api-key": api_key,
+            "public-key": self._public_key,
+            "reference-id": reference_id,
+        }
+
+        if method.upper() == "POST":
+            headers["idempotencykey"] = str(uuid.uuid4())
+
+        response = await self.http.request(
+            method,
+            path,
+            json=json,
+            params=params,
+            headers=headers,
+        )
+
+        # --- Error handling ---
+        if response.status_code in (401, 403):
+            body = self._safe_json(response)
+            raise VelvpayAuthError(
+                message=body.get("reason", "Authentication failed") if isinstance(body, dict) else "Authentication failed",
+                status_code=response.status_code,
+                response_body=body,
+            )
+
+        if not (200 <= response.status_code < 300):
+            body = self._safe_json(response)
+            msg = None
+            if isinstance(body, dict):
+                msg = body.get("reason") or body.get("msg") or body.get("err") or body.get("message")
+            raise VelvpayAPIError(
+                message=msg or response.reason_phrase or "API request failed",
+                status_code=response.status_code,
+                response_body=body,
+            )
+
+        return response.json()
+
+    @staticmethod
+    def _safe_json(response: httpx.Response) -> Any:
+        """Attempt to parse JSON from a response, falling back to the raw text."""
+        try:
+            return response.json()
+        except Exception:
+            return response.text
+
+    # ------------------------------------------------------------------
+    # Resource namespaces (lazy properties)
+    # ------------------------------------------------------------------
+
+    @property
+    def payment_links(self) -> PaymentLinksResource:
+        """Access payment link operations."""
+        if self._payment_links is None:
+            from pyvelv.resources.payment_links import PaymentLinksResource
+            self._payment_links = PaymentLinksResource(self)
+        return self._payment_links
+
+    @property
+    def transactions(self) -> TransactionsResource:
+        """Access transaction operations."""
+        if self._transactions is None:
+            from pyvelv.resources.transactions import TransactionsResource
+            self._transactions = TransactionsResource(self)
+        return self._transactions
+
+    # ------------------------------------------------------------------
+    # Context manager & lifecycle
+    # ------------------------------------------------------------------
+
+    async def close(self) -> None:
+        """Close the underlying HTTP client and release resources."""
+        if self._http and not self._http.is_closed:
+            await self._http.aclose()
+
+    async def __aenter__(self) -> VelvpayClient:
+        return self
+
+    async def __aexit__(self, exc_type: Any, exc_val: Any, exc_tb: Any) -> None:
+        await self.close()
+
+    def __repr__(self) -> str:
+        return f"<VelvpayClient base_url={self._base_url!r}>"
+
+
+# Forward-reference imports so the type annotations above resolve at runtime.
+# Actual classes are imported lazily inside the properties to avoid circular
+# imports.
+from pyvelv.resources.payment_links import PaymentLinksResource  # noqa: E402
+from pyvelv.resources.transactions import TransactionsResource  # noqa: E402

pyvelv/crypto.py

@@ -0,0 +1,140 @@
+"""
+Crypto module for Velvpay API key header generation.
+
+Implements the legacy OpenSSL EVP_BytesToKey key derivation routine
+for AES-256-CBC encryption. The generated ciphertext is used as the
+`api-key` header value on every API request.
+
+OpenSSL envelope format:
+    base64( b"Salted__" + salt(8 bytes) + ciphertext )
+"""
+
+from __future__ import annotations
+
+import base64
+import hashlib
+import json
+import os
+from typing import Any
+
+from Crypto.Cipher import AES
+from Crypto.Util.Padding import pad, unpad
+
+
+def _evp_bytes_to_key(
+    password: bytes,
+    salt: bytes | None,
+    key_len: int = 32,
+    iv_len: int = 16,
+) -> tuple[bytes, bytes]:
+    """
+    Derive key and IV using the OpenSSL EVP_BytesToKey algorithm.
+
+    This replicates the behaviour of ``openssl enc -aes-256-cbc`` with MD5 as
+    the digest function.
+
+    Args:
+        password: The passphrase as raw bytes.
+        salt: An 8-byte salt, or ``None`` for unsalted derivation.
+        key_len: Desired key length in bytes (32 for AES-256).
+        iv_len: Desired IV length in bytes (16 for AES-CBC).
+
+    Returns:
+        A ``(key, iv)`` tuple of the derived key and initialisation vector.
+    """
+    d_tot = b""
+    d_list: list[bytes] = []
+
+    while len(d_tot) < (key_len + iv_len):
+        prev = d_list[-1] if d_list else b""
+        d_i = hashlib.md5(prev + password + (salt or b"")).digest()
+        d_tot += d_i
+        d_list.append(d_i)
+
+    return d_tot[:key_len], d_tot[key_len : key_len + iv_len]
+
+
+def encrypt_aes_256_cbc(plaintext: str, passphrase: str) -> str:
+    """
+    Encrypt *plaintext* with AES-256-CBC using the OpenSSL envelope format.
+
+    1. Generate a random 8-byte salt.
+    2. Derive ``(key, iv)`` via :func:`_evp_bytes_to_key`.
+    3. PKCS#7-pad the plaintext and encrypt.
+    4. Return ``base64(b"Salted__" + salt + ciphertext)``.
+
+    Args:
+        plaintext: The data to encrypt (UTF-8 string).
+        passphrase: The secret passphrase used for key derivation.
+
+    Returns:
+        A base64-encoded string in the standard OpenSSL format.
+    """
+    salt = os.urandom(8)
+    key, iv = _evp_bytes_to_key(passphrase.encode("utf-8"), salt)
+
+    cipher = AES.new(key, AES.MODE_CBC, iv)
+    padded = pad(plaintext.encode("utf-8"), AES.block_size)
+    ciphertext = cipher.encrypt(padded)
+
+    # OpenSSL envelope: "Salted__" magic + salt + ciphertext
+    envelope = b"Salted__" + salt + ciphertext
+    return base64.b64encode(envelope).decode("ascii")
+
+
+def decrypt_aes_256_cbc(encoded: str, passphrase: str) -> str:
+    """
+    Decrypt an OpenSSL-format AES-256-CBC ciphertext.
+
+    This is the inverse of :func:`encrypt_aes_256_cbc` and is provided
+    primarily for testing round-trip correctness.
+
+    Args:
+        encoded: The base64-encoded OpenSSL envelope.
+        passphrase: The passphrase that was used for encryption.
+
+    Returns:
+        The original plaintext string.
+
+    Raises:
+        ValueError: If the envelope does not start with ``Salted__``.
+    """
+    raw = base64.b64decode(encoded)
+
+    if not raw.startswith(b"Salted__"):
+        raise ValueError("Invalid OpenSSL envelope: missing 'Salted__' magic header")
+
+    salt = raw[8:16]
+    ciphertext = raw[16:]
+
+    key, iv = _evp_bytes_to_key(passphrase.encode("utf-8"), salt)
+    cipher = AES.new(key, AES.MODE_CBC, iv)
+    plaintext = unpad(cipher.decrypt(ciphertext), AES.block_size)
+
+    return plaintext.decode("utf-8")
+
+
+def generate_api_key_header(
+    secret_key: str,
+    public_key: str,
+    reference_id: str,
+    encryption_key: str,
+) -> str:
+    """
+    Generate the ``api-key`` header value for a Velvpay API request.
+
+    The payload (secretKey + publicKey + referenceId) is encrypted
+    using AES-256-CBC with the merchant's encryption key.
+
+    Args:
+        secret_key: The merchant's Velvpay secret key.
+        public_key: The merchant's Velvpay public key.
+        reference_id: The unique reference ID for the request.
+        encryption_key: The merchant's Velvpay encryption key.
+
+    Returns:
+        A base64-encoded encrypted string suitable for the ``api-key`` header.
+    """
+    payload = secret_key + public_key + reference_id
+    return encrypt_aes_256_cbc(payload, encryption_key)
+

pyvelv/exceptions.py

@@ -0,0 +1,67 @@
+"""
+Exception hierarchy for the Pyvelv SDK.
+
+All exceptions inherit from :class:`VelvpayError` so callers can catch
+a single base class for broad error handling.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+
+class VelvpayError(Exception):
+    """Base exception for all Velvpay SDK errors."""
+
+    def __init__(self, message: str = "An unexpected Velvpay error occurred") -> None:
+        self.message = message
+        super().__init__(self.message)
+
+
+class VelvpayAPIError(VelvpayError):
+    """
+    Raised when the Velvpay API returns a non-2xx HTTP response.
+
+    Attributes:
+        status_code: The HTTP status code.
+        response_body: The raw response body (decoded JSON or string).
+    """
+
+    def __init__(
+        self,
+        message: str,
+        status_code: int,
+        response_body: Any = None,
+    ) -> None:
+        self.status_code = status_code
+        self.response_body = response_body
+        super().__init__(f"[HTTP {status_code}] {message}")
+
+
+class VelvpayAuthError(VelvpayAPIError):
+    """
+    Raised when the API rejects the request due to authentication failure.
+
+    Triggered by HTTP 401 (Unauthorized) and 403 (Forbidden) responses.
+    """
+
+    def __init__(
+        self,
+        message: str = "Authentication failed",
+        status_code: int = 401,
+        response_body: Any = None,
+    ) -> None:
+        super().__init__(message, status_code, response_body)
+
+
+class VelvpayValidationError(VelvpayError):
+    """
+    Raised when request data fails Pydantic validation before being sent.
+
+    Attributes:
+        errors: The list of validation error details from Pydantic.
+    """
+
+    def __init__(self, message: str, errors: list[Any] | None = None) -> None:
+        self.errors = errors or []
+        super().__init__(message)

pyvelv/models.py

@@ -0,0 +1,137 @@
+"""
+Pydantic v2 schemas for Velvpay API request and response payloads.
+
+All models use ``populate_by_name=True`` so they accept both the Python
+attribute name and the optional JSON alias.
+"""
+
+from __future__ import annotations
+
+from decimal import Decimal
+from typing import Any, Generic, TypeVar
+
+from pydantic import BaseModel, ConfigDict, Field
+
+T = TypeVar("T")
+
+
+# ---------------------------------------------------------------------------
+# Generic API response wrapper
+# ---------------------------------------------------------------------------
+
+class APIResponse(BaseModel, Generic[T]):
+    """
+    Standard envelope returned by every Velvpay API endpoint.
+    """
+
+    model_config = ConfigDict(populate_by_name=True)
+
+    status: str | None = None
+    msg: str | None = None
+    success: bool | None = None
+    message: str | None = None
+    reason: str | None = None
+    err: str | None = None
+    data: T | None = None
+
+    @property
+    def is_success(self) -> bool:
+        """Helper property to check if the API call was successful."""
+        if self.status == "success":
+            return True
+        if self.success is True:
+            return True
+        if self.message == "Successful" or self.msg == "successful":
+            return True
+        return False
+
+
+# ---------------------------------------------------------------------------
+# Payment Links / Initiation
+# ---------------------------------------------------------------------------
+
+class CreatePaymentLinkRequest(BaseModel):
+    """Request body for ``POST /payment/initiate``."""
+
+    model_config = ConfigDict(populate_by_name=True)
+
+    title: str = Field(..., description="Payment title or name")
+    description: str = Field(..., description="Human-readable description")
+    amount: Decimal = Field(..., description="Payment amount in kobo or Naira")
+    is_naira: bool = Field(
+        default=False,
+        alias="isNaira",
+        description="True if amount is in Naira, False if in Kobo",
+    )
+    charge_customer: bool = Field(
+        default=True,
+        alias="chargeCustomer",
+        description="True if transaction fees should be charged to the customer",
+    )
+    post_payment_instructions: str | None = Field(
+        default=None,
+        alias="postPaymentInstructions",
+        description="Instructions to show after payment is complete",
+    )
+
+
+class PaymentLink(BaseModel):
+    """A Velvpay payment link / virtual account initiation object."""
+
+    model_config = ConfigDict(populate_by_name=True)
+
+    status: str
+    message: str | None = None
+    account_number: str = Field(alias="accountNumber")
+    reference: str
+    amount: Decimal
+    transaction_id: str = Field(alias="transactionId")
+    bank: str
+    validity_time: int = Field(alias="validityTime")
+
+
+# ---------------------------------------------------------------------------
+# Transactions
+# ---------------------------------------------------------------------------
+
+class TransactionData(BaseModel):
+    """Inner transaction details data."""
+
+    model_config = ConfigDict(populate_by_name=True)
+
+    status: str
+    message: str
+    account_number: str = Field(alias="accountNumber")
+    reference: str
+
+
+class Transaction(BaseModel):
+    """A Velvpay transaction record."""
+
+    model_config = ConfigDict(populate_by_name=True)
+
+    id: str = Field(alias="_id")
+    account_number: str = Field(alias="accountNumber")
+    tx_id: str = Field(alias="txId")
+    link: str | None = None
+    name: str | None = None
+    amount: Decimal
+    status: str
+    channel: str
+    type: str | None = None
+    method: str | None = None
+    date: str | None = None
+    description: str | None = None
+    metadata: list[dict[str, Any]] | None = None
+    webhook_url: str | None = Field(default=None, alias="webhook_url")
+    data: TransactionData | None = None
+
+
+class TransactionList(BaseModel):
+    """Paginated list of transactions."""
+
+    model_config = ConfigDict(populate_by_name=True)
+
+    data: list[Transaction]
+    total: int
+    page: int

pyvelv/resources/__init__.py

@@ -0,0 +1,11 @@
+"""Resource namespace package for Velvpay API endpoints."""
+
+from pyvelv.resources.base import BaseResource
+from pyvelv.resources.payment_links import PaymentLinksResource
+from pyvelv.resources.transactions import TransactionsResource
+
+__all__ = [
+    "BaseResource",
+    "PaymentLinksResource",
+    "TransactionsResource",
+]

pyvelv/resources/base.py

@@ -0,0 +1,27 @@
+"""
+Base resource class that all Velvpay API resource namespaces inherit from.
+
+Each resource receives a reference to the parent :class:`~pyvelv.client.VelvpayClient`
+so it can make authenticated HTTP requests through the shared transport.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from pyvelv.client import VelvpayClient
+
+
+class BaseResource:
+    """
+    Abstract base for API resource namespaces.
+
+    Subclasses access ``self._client._request(...)`` to call the API.
+    """
+
+    def __init__(self, client: VelvpayClient) -> None:
+        self._client = client
+
+    def __repr__(self) -> str:
+        return f"<{self.__class__.__name__} client={self._client!r}>"

pyvelv/resources/payment_links.py

@@ -0,0 +1,42 @@
+"""
+Payment Links resource — ``client.payment_links.*`` operations.
+"""
+
+from __future__ import annotations
+
+from pyvelv.models import APIResponse, CreatePaymentLinkRequest, PaymentLink
+from pyvelv.resources.base import BaseResource
+
+
+class PaymentLinksResource(BaseResource):
+    """
+    Operations on Velvpay payment links (Payment Initiation).
+    """
+
+    async def create(self, data: CreatePaymentLinkRequest) -> APIResponse[PaymentLink]:
+        """
+        Initiate a new payment.
+
+        Args:
+            data: The payment initiation payload.
+
+        Returns:
+            An :class:`~pyvelv.models.APIResponse` wrapping a :class:`~pyvelv.models.PaymentLink`.
+        """
+        payload = data.model_dump(mode="json", by_alias=True, exclude_none=True)
+        raw = await self._client._request("POST", "/payment/initiate", json=payload)
+        return APIResponse[PaymentLink].model_validate(raw)
+
+    async def get(self, transaction_id: str) -> APIResponse[PaymentLink]:
+        """
+        Retrieve details of an initiated payment.
+
+        Args:
+            transaction_id: The unique transaction identifier (e.g. FR-...).
+        """
+        raw = await self._client._request(
+            "GET",
+            "/payment/collection/transaction/details",
+            params={"transaction_id": transaction_id},
+        )
+        return APIResponse[PaymentLink].model_validate(raw)

pyvelv/resources/transactions.py

@@ -0,0 +1,42 @@
+"""
+Transactions resource — ``client.transactions.*`` operations.
+"""
+
+from __future__ import annotations
+
+from pyvelv.models import APIResponse, Transaction
+from pyvelv.resources.base import BaseResource
+
+
+class TransactionsResource(BaseResource):
+    """
+    Operations on Velvpay transactions.
+    """
+
+    async def get(self, transaction_id: str) -> APIResponse[Transaction]:
+        """
+        Retrieve details of a transaction.
+
+        Args:
+            transaction_id: The unique transaction identifier (e.g. FR-...).
+        """
+        raw = await self._client._request(
+            "GET",
+            "/payment/collection/transaction/details",
+            params={"transaction_id": transaction_id},
+        )
+        return APIResponse[Transaction].model_validate(raw)
+
+    async def verify(self, transaction_id: str) -> APIResponse[Transaction]:
+        """
+        Resolve/verify a transaction status.
+
+        Args:
+            transaction_id: The unique transaction identifier (e.g. FR-...).
+        """
+        raw = await self._client._request(
+            "GET",
+            "/payment/collection/transaction/resolve",
+            params={"transaction_id": transaction_id},
+        )
+        return APIResponse[Transaction].model_validate(raw)

pyvelv-0.1.0.dist-info/METADATA

@@ -0,0 +1,76 @@
+Metadata-Version: 2.4
+Name: pyvelv
+Version: 0.1.0
+Summary: Async Python SDK for the Velvpay payment gateway
+Author: Velvpay SDK Team
+Requires-Python: >=3.10,<4.0
+Classifier: Programming Language :: Python :: 3
+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
+Requires-Dist: httpx (>=0.27.0)
+Requires-Dist: pycryptodome (>=3.20.0)
+Requires-Dist: pydantic (>=2.0)
+Description-Content-Type: text/markdown
+
+# Pyvelv
+
+> Async Python SDK for the **Velvpay** payment gateway.
+
+## Installation
+
+```bash
+pip install pyvelv
+# or
+poetry add pyvelv
+```
+
+## Quick Start
+
+```python
+import asyncio
+from pyvelv import Velvpay
+from pyvelv.models import CreatePaymentLinkRequest
+
+async def main():
+    async with Velvpay(secret_key="your-secret-key") as client:
+        # Create a payment link
+        response = await client.payment_links.create(
+            CreatePaymentLinkRequest(
+                amount=1500.00,
+                currency="NGN",
+                description="Order #12345",
+            )
+        )
+        print(response.data.url)
+
+        # Verify a transaction
+        txn = await client.transactions.verify(reference="ref_abc123")
+        print(txn.data.status)
+
+asyncio.run(main())
+```
+
+## Authentication
+
+Pyvelv handles authentication automatically. The SDK generates the required `api-key` header using a legacy OpenSSL `EVP_BytesToKey` routine (AES-256-CBC) with a random 8-byte salt on every request.
+
+Simply pass your Velvpay secret key when initializing the client:
+
+```python
+client = Velvpay(secret_key="sk_live_...")
+```
+
+## Resources
+
+| Resource              | Methods                        |
+|-----------------------|--------------------------------|
+| `payment_links`       | `create()`, `get()`, `list()`  |
+| `transactions`        | `get()`, `list()`, `verify()`  |
+
+## License
+
+MIT
+

pyvelv-0.1.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+pyvelv/__init__.py,sha256=P5c0FHHOYhtiJRSYouhT7Yko3ljbtJK7W_USI09p0h4,439
+pyvelv/client.py,sha256=F4JYemtoYuqnsKkrClTRzjGgPU5cHZPQiUaUOalV9jg,6756
+pyvelv/crypto.py,sha256=UHEdtUAXwX-QJc6dLL5paFA92blKe331GznEFVSxtPA,4200
+pyvelv/exceptions.py,sha256=71MSSrow-by6LaA0r1kFxu7nZ9fNxTciFGNgsWGm218,1796
+pyvelv/models.py,sha256=hGEjL_7JJzAewU4FFf6Qm7AH2yMpgLWrhk3aWU3juFQ,4030
+pyvelv/resources/__init__.py,sha256=4jq5OHs9cJQo9U5jCQBFR5qtSWZTKbGNizFy9hDw3_Q,326
+pyvelv/resources/base.py,sha256=njtr8k56QLARN4O3qKz2W7JEb3jzYpnuUYbB7xe85Po,721
+pyvelv/resources/payment_links.py,sha256=j9oHc4Z2nOQokO0bGBImBeyVqQg30V1ME8CsRN8Joks,1393
+pyvelv/resources/transactions.py,sha256=Cqu3dzeaWLqVhIkNIjqRujrnffhpj7ehonKvCwDrSmE,1264
+pyvelv-0.1.0.dist-info/METADATA,sha256=05qb4kSccdN30fIvoXA5Hm8UOdyBt6rM8gipRxiLjzU,2011
+pyvelv-0.1.0.dist-info/WHEEL,sha256=EGEvSphFYqXKs23-kQBeyNoJP1nrT8ZJKQoi5p5DYL8,88
+pyvelv-0.1.0.dist-info/RECORD,,

pyvelv-0.1.0.dist-info/WHEEL

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