checkmax-phone-utils 0.2.0__py3-none-any.whl

checkmax_phone_utils/__init__.py

@@ -0,0 +1,56 @@
+"""checkmax-phone-utils — Phone validation utilities + CheckMaxApp API client.
+
+Companion library to CheckMaxApp (https://checkmaxapp.com), a phone
+validation service for the MAX messenger. Format-validate numbers locally
+(E.164, libphonenumber), and verify messenger registration via the official
+REST API.
+
+Public API:
+    validate_e164  — format-validate a raw phone string and return E.164.
+    is_mobile      — check whether an E.164 number is mobile.
+    detect_region  — guess the ISO region of a raw phone string.
+    normalize      — convert any input to canonical E.164 form or None.
+    clean          — strip non-digit characters (preserving leading +).
+    CheckMaxClient — client for the CheckMaxApp REST API (registration check).
+
+Example:
+    >>> from checkmax_phone_utils import normalize, validate_e164
+    >>> normalize("+7 (916) 123-45-67")
+    '+79161234567'
+    >>> validate_e164("89161234567", region="RU")
+    (True, '+79161234567')
+"""
+
+from checkmax_phone_utils.client import CheckMaxClient
+from checkmax_phone_utils.exceptions import (
+    CheckMaxError,
+    InvalidPhoneNumberError,
+    APIError,
+    AuthError,
+    InsufficientBalanceError,
+    APINotAvailableError,
+)
+from checkmax_phone_utils.normalizer import clean, normalize
+from checkmax_phone_utils.validator import (
+    detect_region,
+    is_mobile,
+    validate_e164,
+)
+
+__version__ = "0.2.0"
+
+__all__ = [
+    "__version__",
+    "validate_e164",
+    "is_mobile",
+    "detect_region",
+    "normalize",
+    "clean",
+    "CheckMaxClient",
+    "CheckMaxError",
+    "InvalidPhoneNumberError",
+    "APIError",
+    "AuthError",
+    "InsufficientBalanceError",
+    "APINotAvailableError",
+]

checkmax_phone_utils/client.py

@@ -0,0 +1,146 @@
+"""Client for the CheckMaxApp REST API.
+
+A small, dependency-free (stdlib ``urllib``) client for the CheckMaxApp
+phone-validation API — verify whether a phone number is registered on the
+MAX messenger and retrieve the public profile name, for anti-fraud,
+list hygiene and CRM enrichment.
+
+Get an API key from the CheckMaxApp Telegram bot, then:
+
+    >>> from checkmax_phone_utils import CheckMaxClient
+    >>> client = CheckMaxClient(api_key="mxk_...")
+    >>> client.check(["79001234567"])          # doctest: +SKIP
+    [{'phone': '79001234567', 'status': 'registered',
+      'first_name': 'Ivan', 'last_name': 'Petrov'}]
+
+Full docs: https://checkmaxapp.com/api
+"""
+
+from __future__ import annotations
+
+import json
+import urllib.error
+import urllib.request
+from typing import Any
+
+from checkmax_phone_utils.exceptions import (
+    APIError,
+    AuthError,
+    InsufficientBalanceError,
+)
+
+__all__ = ["CheckMaxClient"]
+
+
+class CheckMaxClient:
+    """Client for the CheckMaxApp phone-validation REST API.
+
+    Args:
+        api_key: Personal API key (``mxk_`` + 64 hex chars). Obtain and
+            rotate it via the CheckMaxApp Telegram bot. Sent only in the
+            ``X-API-Key`` header — never in the query string.
+        base_url: API root. Defaults to the public endpoint.
+        timeout: Per-request HTTP timeout in seconds.
+
+    See https://checkmaxapp.com/api for the full reference.
+    """
+
+    DEFAULT_BASE_URL = "https://api.maxcheck.online/v1"
+
+    def __init__(
+        self,
+        api_key: str,
+        base_url: str = DEFAULT_BASE_URL,
+        timeout: float = 30.0,
+    ) -> None:
+        self.api_key = api_key
+        self.base_url = base_url.rstrip("/")
+        self.timeout = timeout
+
+    # ---- HTTP plumbing -------------------------------------------------
+
+    def _request(
+        self,
+        method: str,
+        path: str,
+        body: dict[str, Any] | None = None,
+        auth: bool = True,
+    ) -> Any:
+        url = f"{self.base_url}{path}"
+        data = json.dumps(body).encode("utf-8") if body is not None else None
+        headers = {"Accept": "application/json"}
+        if data is not None:
+            headers["Content-Type"] = "application/json"
+        if auth:
+            headers["X-API-Key"] = self.api_key
+
+        req = urllib.request.Request(url, data=data, method=method, headers=headers)
+        try:
+            with urllib.request.urlopen(req, timeout=self.timeout) as resp:
+                raw = resp.read().decode("utf-8")
+                return json.loads(raw) if raw else None
+        except urllib.error.HTTPError as exc:
+            detail = exc.read().decode("utf-8", "ignore")
+            if exc.code == 401:
+                raise AuthError(detail or "invalid or missing API key") from exc
+            if exc.code == 402:
+                raise InsufficientBalanceError(detail or "insufficient balance") from exc
+            raise APIError(f"HTTP {exc.code}: {detail[:300]}", status_code=exc.code) from exc
+        except urllib.error.URLError as exc:
+            raise APIError(f"network error: {exc.reason}") from exc
+
+    # ---- Endpoints -----------------------------------------------------
+
+    def health(self) -> dict[str, Any]:
+        """``GET /health`` — service liveness for monitoring (no auth)."""
+        return self._request("GET", "/health", auth=False)
+
+    def balance(self) -> dict[str, Any]:
+        """``GET /balance`` — current balance, tier discount and effective price."""
+        return self._request("GET", "/balance")
+
+    def usage(self) -> dict[str, Any]:
+        """``GET /usage`` — counters of successfully billed checks per window."""
+        return self._request("GET", "/usage")
+
+    def check(self, phones: list[str]) -> list[dict[str, Any]]:
+        """``POST /check`` — synchronously verify a list of phone numbers.
+
+        Args:
+            phones: Phone numbers (digits, e.g. ``"79001234567"``). Best for
+                up to ~1000 numbers; for more, use :meth:`batch_create`.
+
+        Returns:
+            One result per input number, each with ``phone``, ``status``
+            (``registered`` / ``not_found`` / ``error``) and, when
+            registered, ``first_name`` / ``last_name``.
+        """
+        return self._request("POST", "/check", {"phones": phones})
+
+    def batch_create(self, phones: list[str]) -> dict[str, Any]:
+        """``POST /batch`` — submit an async batch job for large lists.
+
+        Returns a job descriptor including its ``id``; poll
+        :meth:`batch_status` and fetch results with :meth:`batch_download`.
+        """
+        return self._request("POST", "/batch", {"phones": phones})
+
+    def batch_status(self, job_id: str) -> dict[str, Any]:
+        """``GET /batch/{id}`` — status/progress of an async batch job."""
+        return self._request("GET", f"/batch/{job_id}")
+
+    def batch_download(self, job_id: str) -> bytes:
+        """``GET /batch/{id}/download`` — fetch finished batch results (CSV bytes)."""
+        url = f"{self.base_url}/batch/{job_id}/download"
+        req = urllib.request.Request(
+            url, method="GET", headers={"X-API-Key": self.api_key}
+        )
+        try:
+            with urllib.request.urlopen(req, timeout=self.timeout) as resp:
+                return resp.read()
+        except urllib.error.HTTPError as exc:
+            if exc.code == 401:
+                raise AuthError("invalid or missing API key") from exc
+            raise APIError(f"HTTP {exc.code}", status_code=exc.code) from exc
+        except urllib.error.URLError as exc:
+            raise APIError(f"network error: {exc.reason}") from exc

checkmax_phone_utils/exceptions.py

@@ -0,0 +1,65 @@
+"""Custom exceptions for checkmax-phone-utils."""
+
+from __future__ import annotations
+
+
+class CheckMaxError(Exception):
+    """Base exception for all checkmax-phone-utils errors."""
+
+
+class InvalidPhoneNumberError(CheckMaxError):
+    """Raised when a phone number cannot be parsed or is invalid.
+
+    Attributes:
+        raw: The original input string that failed to parse.
+    """
+
+    def __init__(self, raw: str, message: str | None = None) -> None:
+        self.raw = raw
+        super().__init__(message or f"Cannot parse phone number: {raw!r}")
+
+
+class APIError(CheckMaxError):
+    """Raised on a non-success response from the CheckMaxApp REST API.
+
+    Attributes:
+        status_code: HTTP status code, when available (else ``None``).
+    """
+
+    def __init__(self, message: str, status_code: int | None = None) -> None:
+        self.status_code = status_code
+        super().__init__(message)
+
+
+class AuthError(APIError):
+    """HTTP 401 — API key missing, malformed, or revoked.
+
+    Get or rotate your key via the CheckMaxApp Telegram bot. See
+    https://checkmaxapp.com/api.
+    """
+
+    def __init__(self, message: str | None = None) -> None:
+        super().__init__(message or "invalid or missing API key", status_code=401)
+
+
+class InsufficientBalanceError(APIError):
+    """HTTP 402 — key is valid but the balance cannot cover the request.
+
+    Nothing is charged on a 402. Top up and retry. See
+    https://checkmaxapp.com/pricing.
+    """
+
+    def __init__(self, message: str | None = None) -> None:
+        super().__init__(message or "insufficient balance", status_code=402)
+
+
+class APINotAvailableError(APIError):
+    """Deprecated. Kept for backwards compatibility with 0.1.x.
+
+    The public API is live; this is no longer raised by the client.
+    """
+
+    def __init__(self, message: str | None = None) -> None:
+        super().__init__(
+            message or "CheckMaxApp API. See https://checkmaxapp.com/api"
+        )

checkmax_phone_utils/normalizer.py

@@ -0,0 +1,95 @@
+"""Normalize raw phone strings to canonical E.164 form."""
+
+from __future__ import annotations
+
+import re
+from typing import Optional
+
+import phonenumbers
+from phonenumbers import NumberParseException
+
+
+_NON_DIGIT_OR_PLUS_RE = re.compile(r"[^\d+]")
+
+
+def clean(raw: str) -> str:
+    """Strip every character that is not a digit or a leading ``+``.
+
+    A ``+`` is preserved only when it appears at the very start; any
+    other ``+`` characters are removed. The result is a pure digit
+    string (optionally with a single leading ``+``).
+
+    Args:
+        raw: Any string that might contain a phone number.
+
+    Returns:
+        Cleaned string, possibly empty.
+
+    Examples:
+        >>> clean("+7 (916) 123-45-67")
+        '+79161234567'
+        >>> clean("8 916 123-45-67")
+        '89161234567'
+        >>> clean("phone: +1-415-555-2671 ext 99")
+        '+14155552671'
+        >>> clean("")
+        ''
+    """
+    if not raw or not isinstance(raw, str):
+        return ""
+
+    stripped = raw.strip()
+    has_plus = stripped.startswith("+")
+    digits = _NON_DIGIT_OR_PLUS_RE.sub("", stripped)
+    digits = digits.replace("+", "")
+    return ("+" + digits) if has_plus else digits
+
+
+def normalize(raw: str, default_region: str = "RU") -> Optional[str]:
+    """Convert any phone-shaped string to canonical E.164 form.
+
+    This is the safe high-level entry point: it cleans the input,
+    attempts a parse against ``default_region`` if no country code is
+    present, validates the result, and returns the canonical
+    ``+CCNNNNNNNNNNN`` form.
+
+    Args:
+        raw: User input, e.g. ``"+7 (916) 123-45-67"`` or
+            ``"8 916 123-45-67"``.
+        default_region: ISO 3166-1 alpha-2 region used when ``raw`` has
+            no international prefix. Defaults to ``"RU"``.
+
+    Returns:
+        Canonical E.164 string, or ``None`` if the input cannot be
+        parsed or is not a valid phone number.
+
+    Examples:
+        >>> normalize("+7 (916) 123-45-67")
+        '+79161234567'
+        >>> normalize("8 916 123-45-67", default_region="RU")
+        '+79161234567'
+        >>> normalize("+1 415 555 2671")
+        '+14155552671'
+        >>> normalize("garbage") is None
+        True
+        >>> normalize("") is None
+        True
+    """
+    if not raw or not isinstance(raw, str):
+        return None
+
+    cleaned = clean(raw)
+    if not cleaned:
+        return None
+
+    try:
+        parsed = phonenumbers.parse(cleaned, default_region)
+    except NumberParseException:
+        return None
+
+    if not phonenumbers.is_valid_number(parsed):
+        return None
+
+    return phonenumbers.format_number(
+        parsed, phonenumbers.PhoneNumberFormat.E164
+    )

checkmax_phone_utils/validator.py

@@ -0,0 +1,124 @@
+"""Format validation for phone numbers.
+
+Wraps Google's libphonenumber (Python port `phonenumbers`) and exposes
+ergonomic helpers that return plain types instead of library objects.
+
+These functions perform *format* validation only — they verify the input
+has a structurally valid E.164 shape for the given region. They do NOT
+check whether the number is in service or registered on MAX messenger;
+for that, use :class:`checkmax_phone_utils.CheckMaxClient`.
+"""
+
+from __future__ import annotations
+
+from typing import Optional
+
+import phonenumbers
+from phonenumbers import NumberParseException, PhoneNumberType
+
+
+def validate_e164(raw: str, region: str = "RU") -> tuple[bool, Optional[str]]:
+    """Validate a raw phone string and return the canonical E.164 form.
+
+    Args:
+        raw: User-supplied phone number, e.g. ``"+7 (916) 123-45-67"``.
+        region: ISO 3166-1 alpha-2 region used when the input has no
+            international prefix. Defaults to ``"RU"``.
+
+    Returns:
+        A tuple ``(is_valid, e164)``. When valid, ``e164`` is a string
+        like ``"+79161234567"``. When invalid, ``e164`` is ``None``.
+
+    Examples:
+        >>> validate_e164("+7 (916) 123-45-67")
+        (True, '+79161234567')
+        >>> validate_e164("89161234567", region="RU")
+        (True, '+79161234567')
+        >>> validate_e164("not a phone")
+        (False, None)
+        >>> validate_e164("")
+        (False, None)
+    """
+    if not raw or not isinstance(raw, str):
+        return False, None
+
+    try:
+        parsed = phonenumbers.parse(raw, region)
+    except NumberParseException:
+        return False, None
+
+    if not phonenumbers.is_valid_number(parsed):
+        return False, None
+
+    return True, phonenumbers.format_number(
+        parsed, phonenumbers.PhoneNumberFormat.E164
+    )
+
+
+def is_mobile(e164: str) -> bool:
+    """Return True if the given E.164 number is a mobile line.
+
+    Some carriers in some countries use overlapping ranges for mobile
+    and fixed lines; in those cases this returns ``True`` for
+    ``FIXED_LINE_OR_MOBILE`` as well.
+
+    Args:
+        e164: Phone number in E.164 form, e.g. ``"+79161234567"``.
+
+    Returns:
+        True if the number is mobile (or mobile-or-fixed), False
+        otherwise — including the case where the input cannot be parsed.
+
+    Examples:
+        >>> is_mobile("+79161234567")
+        True
+        >>> is_mobile("garbage")
+        False
+    """
+    if not e164 or not isinstance(e164, str):
+        return False
+
+    try:
+        parsed = phonenumbers.parse(e164, None)
+    except NumberParseException:
+        return False
+
+    number_type = phonenumbers.number_type(parsed)
+    return number_type in (
+        PhoneNumberType.MOBILE,
+        PhoneNumberType.FIXED_LINE_OR_MOBILE,
+    )
+
+
+def detect_region(raw: str) -> Optional[str]:
+    """Detect the ISO 3166-1 alpha-2 region of a raw phone number.
+
+    The input must contain a country prefix (``+`` or ``00``) for this
+    to succeed; otherwise we cannot disambiguate the region.
+
+    Args:
+        raw: A phone string with international prefix, e.g.
+            ``"+79161234567"``.
+
+    Returns:
+        Two-letter ISO region (e.g. ``"RU"``) or ``None`` if the number
+        cannot be parsed or its region cannot be determined.
+
+    Examples:
+        >>> detect_region("+79161234567")
+        'RU'
+        >>> detect_region("+14155552671")
+        'US'
+        >>> detect_region("89161234567")  # no country prefix
+        >>> detect_region("")
+    """
+    if not raw or not isinstance(raw, str):
+        return None
+
+    try:
+        parsed = phonenumbers.parse(raw, None)
+    except NumberParseException:
+        return None
+
+    region = phonenumbers.region_code_for_number(parsed)
+    return region if region and region != "ZZ" else None

checkmax_phone_utils-0.2.0.dist-info/METADATA

@@ -0,0 +1,174 @@
+Metadata-Version: 2.4
+Name: checkmax-phone-utils
+Version: 0.2.0
+Summary: Phone validation utilities (E.164 + libphonenumber) and the official REST client for the CheckMaxApp phone-verification API.
+Project-URL: Homepage, https://checkmaxapp.com
+Project-URL: Documentation, https://checkmaxapp.com/api
+Project-URL: Repository, https://github.com/abragimbaliev/checkmax-phone-utils
+Project-URL: Issues, https://github.com/abragimbaliev/checkmax-phone-utils/issues
+Author-email: CheckMax Team <dev@checkmaxapp.com>
+Maintainer-email: CheckMax Team <dev@checkmaxapp.com>
+License: MIT
+License-File: LICENSE
+Keywords: checkmaxapp,e164,libphonenumber,max-messenger,phone,validation
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+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: Topic :: Communications :: Telephony
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Requires-Dist: phonenumbers>=8.13
+Provides-Extra: dev
+Requires-Dist: pytest-cov>=4.0; extra == 'dev'
+Requires-Dist: pytest>=7.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# checkmax-phone-utils
+
+[![PyPI 0.2.0](https://img.shields.io/badge/PyPI-0.2.0-blue.svg)](https://pypi.org/project/checkmax-phone-utils/)
+[![Python 3.10+](https://img.shields.io/badge/Python-3.10%2B-blue.svg)](https://www.python.org/downloads/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-green.svg)](LICENSE)
+[![CheckMaxApp](https://img.shields.io/badge/Powered_by-CheckMaxApp-orange.svg)](https://checkmaxapp.com)
+
+A small, focused Python toolkit for phone-number **format validation**,
+**E.164 normalization**, and an **optional API client** for the
+[CheckMaxApp](https://checkmaxapp.com) service. Built on top of Google's
+[libphonenumber](https://github.com/google/libphonenumber) (Python port).
+Use it as a drop-in helper in your own code, or as the official client
+library for the live CheckMaxApp REST API.
+
+> **Powered by [CheckMaxApp](https://checkmaxapp.com) — phone validation
+> service for the MAX messenger.** This library handles *format* and
+> *region* validation. To check whether a number is actually registered
+> on MAX, use the hosted CheckMaxApp service.
+
+## Quickstart
+
+```bash
+pip install checkmax-phone-utils
+```
+
+```python
+from checkmax_phone_utils import normalize, validate_e164, is_mobile
+
+normalize("+7 (916) 123-45-67")          # '+79161234567'
+normalize("8 916 123-45-67", "RU")       # '+79161234567'
+validate_e164("+1 415 555 2671")         # (True, '+14155552671')
+is_mobile("+79161234567")                # True
+```
+
+## What it does
+
+| Function | Purpose |
+| --- | --- |
+| `normalize(raw, default_region)`       | Convert any phone-shaped input to canonical E.164, or `None`. |
+| `validate_e164(raw, region)`           | Return `(is_valid, e164_or_none)` for a raw input. |
+| `is_mobile(e164)`                      | True if the number is mobile (or mobile-or-fixed). |
+| `detect_region(raw)`                   | Return ISO 3166-1 alpha-2 region of an international number. |
+| `clean(raw)`                           | Strip everything that is not a digit or leading `+`. |
+| `CheckMaxClient(api_key).check([...])` | Verify numbers via the REST API — registration status + public name. |
+
+Full reference: see the docstrings — every public function has examples
+and edge-case notes.
+
+## API reference
+
+### `normalize(raw: str, default_region: str = "RU") -> str | None`
+
+Safe high-level entry point. Cleans, parses, validates, and returns the
+canonical `+CCNNNNNNNNNNN` form, or `None` if the input is not a valid
+phone number.
+
+```python
+>>> normalize("+7 (916) 123-45-67")
+'+79161234567'
+>>> normalize("garbage") is None
+True
+```
+
+### `validate_e164(raw: str, region: str = "RU") -> tuple[bool, str | None]`
+
+Returns `(is_valid, e164)`. When valid, `e164` is the canonical form;
+otherwise it is `None`. Useful when you want to keep both signals.
+
+### `is_mobile(e164: str) -> bool`
+
+True for `MOBILE` and `FIXED_LINE_OR_MOBILE` numbers; False otherwise,
+including when the input cannot be parsed.
+
+### `detect_region(raw: str) -> str | None`
+
+Detect the ISO region from an international-format number (with `+` or
+`00` prefix). Returns `None` when the input lacks a country prefix.
+
+### `CheckMaxClient(api_key: str)`
+
+Official client for the [CheckMaxApp REST API](https://checkmaxapp.com/api).
+Get an API key from the CheckMaxApp Telegram bot. Methods: `health()`,
+`balance()`, `usage()`, `check(phones)`, `batch_create(phones)`,
+`batch_status(id)`, `batch_download(id)`. Raises `AuthError` (401) and
+`InsufficientBalanceError` (402).
+
+```python
+from checkmax_phone_utils import CheckMaxClient
+
+client = CheckMaxClient(api_key="mxk_...")
+client.check(["79001234567"])
+# [{'phone': '79001234567', 'status': 'registered',
+#   'first_name': 'Ivan', 'last_name': 'Petrov'}]
+```
+
+The full machine-readable schema lives at
+[`openapi/checkmax-api.openapi.yaml`](openapi/checkmax-api.openapi.yaml)
+(OpenAPI 3.0) — also published to the API directories.
+
+## Examples
+
+The [`examples/`](examples) directory contains runnable scripts:
+
+- `examples/basic_validation.py` — single-number validation against a
+  small sample list.
+- `examples/bulk_normalize.py` — normalize a CSV file of phones in
+  bulk, emitting a CSV with `e164` and `valid` columns.
+- `examples/api_client_demo.py` — intended surface of the
+  CheckMaxApp client.
+
+## Roadmap
+
+- v0.1 — format validation, E.164 normalization, stub client.
+- v0.2 — live REST client (check / batch / balance / usage), structured
+  errors, OpenAPI 3.0 spec (current).
+- v0.3 — async client, retries, optional caching.
+- v0.4 — type stubs on PyPI, CLI entry point (`checkmax phone <num>`).
+
+## Development
+
+```bash
+git clone https://github.com/abragimbaliev/checkmax-phone-utils.git
+cd checkmax-phone-utils
+pip install -e ".[dev]"
+pytest
+```
+
+CI runs `pytest` against Python 3.10, 3.11, and 3.12 on every push.
+
+## License
+
+[MIT](LICENSE). Copyright (c) 2026 CheckMax Team.
+
+## Authors
+
+CheckMax Team — `dev@checkmaxapp.com`
+
+---
+
+Looking for the hosted service?
+**[CheckMaxApp](https://checkmaxapp.com)** — phone validation for the
+MAX messenger.

checkmax_phone_utils-0.2.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+checkmax_phone_utils/__init__.py,sha256=b0LQRu_uzeIW3bsCzHlV3Pa4_KTNENQkBJHvSFSriGk,1686
+checkmax_phone_utils/client.py,sha256=efuBisxcs3LY8rUktlbkxFpnlEHncg0C0sNzPN1Zu4M,5622
+checkmax_phone_utils/exceptions.py,sha256=zkWQzOAPOIZ9zZX-a7d8f_lZskFWKyehKxDhMb9Wr14,1953
+checkmax_phone_utils/normalizer.py,sha256=6BBodjG6gvbtA99rREydykH0Inzh1h3dFUinaJ1Cpx0,2672
+checkmax_phone_utils/validator.py,sha256=37vKkXG9xV0g17fWthKgfoTiL38y-XiRay9Elrus3o0,3779
+checkmax_phone_utils-0.2.0.dist-info/METADATA,sha256=Oo8nouUXb4sdCQRQUeVMAvJf6la60igfRCBMaFKJcTQ,6531
+checkmax_phone_utils-0.2.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+checkmax_phone_utils-0.2.0.dist-info/licenses/LICENSE,sha256=-doPs4yonX8rLlFA3O2OMLvdZxScth0tQ9y_JG08R2g,1070
+checkmax_phone_utils-0.2.0.dist-info/RECORD,,

checkmax_phone_utils-0.2.0.dist-info/WHEEL

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

checkmax_phone_utils-0.2.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 CheckMax Team
+
+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.