easyid-python 1.0.2__py3-none-any.whl

easyid/__init__.py

@@ -0,0 +1,39 @@
+"""EasyID Python SDK."""
+
+from .bank import BankService, BankVerify4Result
+from .billing import BillingRecord, BillingRecordsResult, BillingService, BillingBalanceResult
+from .client import EasyID
+from .error import APIError, is_api_error
+from .face import CompareResult, FaceService, FaceVerifyResult, LivenessResult
+from .idcard import IDCardOCRResult, IDCardService, IDCardVerifyResult
+from .phone import PhoneService, PhoneStatusResult, PhoneVerify3Result
+from .risk import RiskDetails, RiskScoreResult, RiskService, StoreFingerprintResult
+
+__version__ = EasyID.version
+
+__all__ = [
+    "APIError",
+    "BankService",
+    "BankVerify4Result",
+    "BillingBalanceResult",
+    "BillingRecord",
+    "BillingRecordsResult",
+    "BillingService",
+    "CompareResult",
+    "EasyID",
+    "FaceService",
+    "FaceVerifyResult",
+    "IDCardOCRResult",
+    "IDCardService",
+    "IDCardVerifyResult",
+    "LivenessResult",
+    "PhoneService",
+    "PhoneStatusResult",
+    "PhoneVerify3Result",
+    "RiskDetails",
+    "RiskScoreResult",
+    "RiskService",
+    "StoreFingerprintResult",
+    "__version__",
+    "is_api_error",
+]

easyid/bank.py

@@ -0,0 +1,48 @@
+"""Bank APIs."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Optional
+
+from .transport import Transport
+
+
+@dataclass(frozen=True)
+class BankVerify4Result:
+    result: bool
+    match: bool
+    bank_name: str
+    supplier: str
+    score: float
+    masked_bank_card: str
+    card_type: str
+
+
+class BankService:
+    def __init__(self, transport: Transport) -> None:
+        self._transport = transport
+
+    def verify4(
+        self,
+        *,
+        name: str,
+        id_number: str,
+        bank_card: str,
+        mobile: Optional[str] = None,
+        trace_id: Optional[str] = None,
+    ) -> BankVerify4Result:
+        body = {
+            "name": name,
+            "id_number": id_number,
+            "bank_card": bank_card,
+            "mobile": mobile,
+            "trace_id": trace_id,
+        }
+        data = self._transport.request_json(
+            "POST",
+            "/v1/bank/verify4",
+            body={key: value for key, value in body.items() if value is not None},
+        )
+        return BankVerify4Result(**data)
+

easyid/billing.py

@@ -0,0 +1,62 @@
+"""Billing APIs."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import List
+
+from .transport import Transport
+
+
+@dataclass(frozen=True)
+class BillingBalanceResult:
+    app_id: str
+    available_cents: int
+
+
+@dataclass(frozen=True)
+class BillingRecord:
+    id: int
+    app_id: str
+    request_id: str
+    change_cents: int
+    balance_before: int
+    balance_after: int
+    reason: str
+    operator: str
+    created_at: int
+
+
+@dataclass(frozen=True)
+class BillingRecordsResult:
+    total: int
+    page: int
+    records: List[BillingRecord]
+
+
+class BillingService:
+    def __init__(self, transport: Transport) -> None:
+        self._transport = transport
+
+    def balance(self, *, app_id: str) -> BillingBalanceResult:
+        data = self._transport.request_json(
+            "GET",
+            "/v1/billing/balance",
+            query={"app_id": app_id},
+        )
+        return BillingBalanceResult(**data)
+
+    def records(self, *, app_id: str, page: int = 1, page_size: int = 20) -> BillingRecordsResult:
+        if page <= 0:
+            page = 1
+        if page_size <= 0:
+            page_size = 20
+        else:
+            page_size = min(page_size, 100)
+        data = self._transport.request_json(
+            "GET",
+            "/v1/billing/records",
+            query={"app_id": app_id, "page": page, "page_size": page_size},
+        )
+        records = [BillingRecord(**record) for record in data.get("records", [])]
+        return BillingRecordsResult(total=data["total"], page=data["page"], records=records)

easyid/client.py

@@ -0,0 +1,56 @@
+"""Public client entrypoint for the EasyID SDK."""
+
+from __future__ import annotations
+
+import re
+from typing import Optional
+
+import requests
+
+from .bank import BankService
+from .billing import BillingService
+from .face import FaceService
+from .idcard import IDCardService
+from .phone import PhoneService
+from .risk import RiskService
+from .transport import DEFAULT_BASE_URL, SDK_VERSION, Transport
+
+_KEY_ID_RE = re.compile(r"^ak_[0-9a-f]+$")
+
+
+class EasyID:
+    """EasyID API client.
+
+    The client is safe to reuse across requests.
+    """
+
+    version = SDK_VERSION
+
+    def __init__(
+        self,
+        key_id: str,
+        secret: str,
+        *,
+        base_url: str = DEFAULT_BASE_URL,
+        timeout: float = 30.0,
+        session: Optional[requests.Session] = None,
+    ) -> None:
+        if not _KEY_ID_RE.fullmatch(key_id):
+            raise ValueError(f"easyid: key_id must match ak_<hex>, got: {key_id}")
+        if not secret:
+            raise ValueError("easyid: secret must not be empty")
+
+        self._transport = Transport(
+            key_id=key_id,
+            secret=secret,
+            base_url=base_url,
+            timeout=timeout,
+            session=session,
+        )
+        self.idcard = IDCardService(self._transport)
+        self.phone = PhoneService(self._transport)
+        self.face = FaceService(self._transport)
+        self.bank = BankService(self._transport)
+        self.risk = RiskService(self._transport)
+        self.billing = BillingService(self._transport)
+

easyid/error.py

@@ -0,0 +1,20 @@
+"""Error types for the EasyID SDK."""
+
+from __future__ import annotations
+
+
+class APIError(Exception):
+    """Business error returned by the EasyID API."""
+
+    def __init__(self, code: int, message: str, request_id: str) -> None:
+        self.code = code
+        self.message = message
+        self.request_id = request_id
+        super().__init__(f"easyid: code={code} message={message} request_id={request_id}")
+
+
+def is_api_error(exc: BaseException) -> bool:
+    """Return True when *exc* is an :class:`APIError`."""
+
+    return isinstance(exc, APIError)
+

easyid/face.py

@@ -0,0 +1,85 @@
+"""Face APIs."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Optional
+
+from .transport import FileInput, Transport, make_multipart_part
+
+
+@dataclass(frozen=True)
+class LivenessResult:
+    liveness: bool
+    score: float
+    method: str
+    frames_analyzed: int
+    attack_type: Optional[str]
+
+
+@dataclass(frozen=True)
+class CompareResult:
+    match: bool
+    score: float
+
+
+@dataclass(frozen=True)
+class FaceVerifyResult:
+    result: bool
+    supplier: str
+    score: float
+
+
+class FaceService:
+    def __init__(self, transport: Transport) -> None:
+        self._transport = transport
+
+    def liveness(
+        self,
+        *,
+        media: FileInput,
+        mode: Optional[str] = None,
+        filename: Optional[str] = None,
+    ) -> LivenessResult:
+        fields = {}
+        if mode is not None:
+            fields["mode"] = mode
+        data = self._transport.request_multipart(
+            "/v1/face/liveness",
+            fields=fields,
+            files=[make_multipart_part("media", media, filename)],
+        )
+        return LivenessResult(**data)
+
+    def compare(
+        self,
+        *,
+        image1: FileInput,
+        image2: FileInput,
+        filename1: Optional[str] = None,
+        filename2: Optional[str] = None,
+    ) -> CompareResult:
+        data = self._transport.request_multipart(
+            "/v1/face/compare",
+            files=[
+                make_multipart_part("image1", image1, filename1),
+                make_multipart_part("image2", image2, filename2),
+            ],
+        )
+        return CompareResult(**data)
+
+    def verify(
+        self,
+        *,
+        id_number: str,
+        media_key: Optional[str] = None,
+        callback_url: Optional[str] = None,
+    ) -> FaceVerifyResult:
+        body = {"id_number": id_number}
+        if media_key is not None:
+            body["media_key"] = media_key
+        if callback_url is not None:
+            body["callback_url"] = callback_url
+        data = self._transport.request_json("POST", "/v1/face/verify", body=body)
+        return FaceVerifyResult(**data)
+

easyid/idcard.py

@@ -0,0 +1,77 @@
+"""ID card APIs."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Dict, Optional
+
+from .transport import FileInput, Transport, make_multipart_part
+
+
+@dataclass(frozen=True)
+class IDCardVerifyResult:
+    result: bool
+    match: bool
+    supplier: str
+    score: float
+    raw: Optional[Dict[str, Any]] = None
+
+
+@dataclass(frozen=True)
+class IDCardOCRResult:
+    side: str
+    name: str = ""
+    id_number: str = ""
+    gender: str = ""
+    nation: str = ""
+    birth: str = ""
+    address: str = ""
+    issue: str = ""
+    valid: str = ""
+
+
+class IDCardService:
+    def __init__(self, transport: Transport) -> None:
+        self._transport = transport
+
+    def verify2(self, *, name: str, id_number: str, trace_id: Optional[str] = None) -> IDCardVerifyResult:
+        data = self._transport.request_json(
+            "POST",
+            "/v1/idcard/verify2",
+            body=_compact({"name": name, "id_number": id_number, "trace_id": trace_id}),
+        )
+        return IDCardVerifyResult(**data)
+
+    def verify3(
+        self,
+        *,
+        name: str,
+        id_number: str,
+        mobile: str,
+        trace_id: Optional[str] = None,
+    ) -> IDCardVerifyResult:
+        data = self._transport.request_json(
+            "POST",
+            "/v1/idcard/verify3",
+            body=_compact(
+                {
+                    "name": name,
+                    "id_number": id_number,
+                    "mobile": mobile,
+                    "trace_id": trace_id,
+                }
+            ),
+        )
+        return IDCardVerifyResult(**data)
+
+    def ocr(self, *, side: str, image: FileInput, filename: Optional[str] = None) -> IDCardOCRResult:
+        data = self._transport.request_multipart(
+            "/v1/ocr/idcard",
+            fields={"side": side},
+            files=[make_multipart_part("image", image, filename)],
+        )
+        return IDCardOCRResult(**data)
+
+
+def _compact(payload: Dict[str, Any]) -> Dict[str, Any]:
+    return {key: value for key, value in payload.items() if value is not None}

easyid/phone.py

@@ -0,0 +1,44 @@
+"""Phone APIs."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from .transport import Transport
+
+
+@dataclass(frozen=True)
+class PhoneStatusResult:
+    status: str
+    carrier: str
+    province: str
+    roaming: bool
+
+
+@dataclass(frozen=True)
+class PhoneVerify3Result:
+    result: bool
+    match: bool
+    supplier: str
+    score: float
+
+
+class PhoneService:
+    def __init__(self, transport: Transport) -> None:
+        self._transport = transport
+
+    def status(self, *, phone: str) -> PhoneStatusResult:
+        data = self._transport.request_json(
+            "GET",
+            "/v1/phone/status",
+            query={"phone": phone},
+        )
+        return PhoneStatusResult(**data)
+
+    def verify3(self, *, name: str, id_number: str, mobile: str) -> PhoneVerify3Result:
+        data = self._transport.request_json(
+            "POST",
+            "/v1/phone/verify3",
+            body={"name": name, "id_number": id_number, "mobile": mobile},
+        )
+        return PhoneVerify3Result(**data)

easyid/py.typed

@@ -0,0 +1 @@
+

easyid/risk.py

@@ -0,0 +1,82 @@
+"""Risk APIs."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Dict, List, Optional
+
+from .transport import Transport
+
+
+@dataclass(frozen=True)
+class RiskDetails:
+    rule_score: Optional[int]
+    ml_score: Optional[int]
+
+
+@dataclass(frozen=True)
+class RiskScoreResult:
+    risk_score: int
+    reasons: List[str]
+    recommendation: str
+    details: RiskDetails
+
+
+@dataclass(frozen=True)
+class StoreFingerprintResult:
+    device_id: str
+    stored: bool
+
+
+class RiskService:
+    def __init__(self, transport: Transport) -> None:
+        self._transport = transport
+
+    def score(
+        self,
+        *,
+        ip: Optional[str] = None,
+        device_fingerprint: Optional[str] = None,
+        device_id: Optional[str] = None,
+        phone: Optional[str] = None,
+        email: Optional[str] = None,
+        user_agent: Optional[str] = None,
+        action: Optional[str] = None,
+        amount: Optional[int] = None,
+        context: Optional[Dict[str, Any]] = None,
+    ) -> RiskScoreResult:
+        body = {
+            "ip": ip,
+            "device_fingerprint": device_fingerprint,
+            "device_id": device_id,
+            "phone": phone,
+            "email": email,
+            "user_agent": user_agent,
+            "action": action,
+            "amount": amount,
+            "context": context,
+        }
+        data = self._transport.request_json(
+            "POST",
+            "/v1/risk/score",
+            body={key: value for key, value in body.items() if value is not None},
+        )
+        details = data.get("details", {})
+        return RiskScoreResult(
+            risk_score=data["risk_score"],
+            reasons=list(data.get("reasons", [])),
+            recommendation=data["recommendation"],
+            details=RiskDetails(
+                rule_score=details.get("rule_score"),
+                ml_score=details.get("ml_score"),
+            ),
+        )
+
+    def store_fingerprint(self, *, device_id: str, fingerprint: Dict[str, Any]) -> StoreFingerprintResult:
+        data = self._transport.request_json(
+            "POST",
+            "/v1/device/fingerprint",
+            body={"device_id": device_id, "fingerprint": fingerprint},
+        )
+        return StoreFingerprintResult(**data)
+

easyid/signer.py

@@ -0,0 +1,24 @@
+"""Signing helpers for the EasyID SDK."""
+
+from __future__ import annotations
+
+import hashlib
+import hmac
+from typing import Mapping, Optional
+
+
+def sign(secret: str, timestamp: str, query: Optional[Mapping[str, str]], body: bytes) -> str:
+    """Return the lowercase hex HMAC-SHA256 signature for a request."""
+
+    parts = []
+    if query:
+        for key in sorted(query):
+            parts.append(f"{key}={query[key]}")
+    payload = "&".join(parts)
+    if body:
+        body_text = body.decode("utf-8")
+        payload = f"{payload}&{body_text}" if payload else body_text
+    to_sign = f"{timestamp}\n{payload}"
+    digest = hmac.new(secret.encode("utf-8"), to_sign.encode("utf-8"), hashlib.sha256)
+    return digest.hexdigest()
+

easyid/transport.py

@@ -0,0 +1,202 @@
+"""HTTP transport for the EasyID SDK."""
+
+from __future__ import annotations
+
+import json
+import os
+import time
+from dataclasses import dataclass
+from typing import Any, BinaryIO, Dict, Iterable, Mapping, Optional, Tuple, Union
+from urllib.parse import urlencode
+
+import requests
+
+from .error import APIError
+from .signer import sign
+
+DEFAULT_BASE_URL = "https://api.easyid.com"
+MAX_RESPONSE_BYTES = 10 << 20
+SDK_VERSION = "1.0.0"
+
+FileInput = Union[bytes, bytearray, BinaryIO]
+
+
+@dataclass(frozen=True)
+class MultipartPart:
+    field_name: str
+    filename: str
+    content: bytes
+    content_type: str = "application/octet-stream"
+
+
+class Transport:
+    """Low-level HTTP transport shared by all services."""
+
+    def __init__(
+        self,
+        *,
+        key_id: str,
+        secret: str,
+        base_url: str = DEFAULT_BASE_URL,
+        timeout: float = 30.0,
+        session: Optional[requests.Session] = None,
+        user_agent: Optional[str] = None,
+    ) -> None:
+        self.key_id = key_id
+        self.secret = secret
+        self.base_url = base_url.rstrip("/")
+        self.timeout = timeout
+        self.session = session or requests.Session()
+        self.user_agent = user_agent or f"easyid-python/{SDK_VERSION}"
+
+    def request_json(
+        self,
+        method: str,
+        path: str,
+        *,
+        query: Optional[Mapping[str, Any]] = None,
+        body: Optional[Mapping[str, Any]] = None,
+    ) -> Any:
+        body_bytes = b""
+        if body is not None:
+            body_bytes = json.dumps(
+                body,
+                ensure_ascii=False,
+                separators=(",", ":"),
+            ).encode("utf-8")
+        return self._send(
+            method=method,
+            path=path,
+            query=self._normalize_query(query),
+            body_bytes=body_bytes,
+            content_type="application/json",
+        )
+
+    def request_multipart(
+        self,
+        path: str,
+        *,
+        fields: Optional[Mapping[str, str]] = None,
+        files: Optional[Iterable[MultipartPart]] = None,
+    ) -> Any:
+        request = requests.Request(
+            method="POST",
+            url=self.base_url + path,
+            data=fields or {},
+            files=[
+                (
+                    part.field_name,
+                    (part.filename, part.content, part.content_type),
+                )
+                for part in (files or [])
+            ],
+        )
+        prepared = self.session.prepare_request(request)
+        body = prepared.body
+        if body is None:
+            body_bytes = b""
+        elif isinstance(body, bytes):
+            body_bytes = body
+        else:
+            body_bytes = body.encode("utf-8")
+        return self._send(
+            method="POST",
+            path=path,
+            query=None,
+            body_bytes=body_bytes,
+            content_type=prepared.headers["Content-Type"],
+        )
+
+    def _send(
+        self,
+        *,
+        method: str,
+        path: str,
+        query: Optional[Dict[str, str]],
+        body_bytes: bytes,
+        content_type: str,
+    ) -> Any:
+        timestamp = str(int(time.time()))
+        signature = sign(self.secret, timestamp, query, body_bytes)
+
+        url = self.base_url + path
+        if query:
+            url = f"{url}?{urlencode(sorted(query.items()))}"
+
+        request = requests.Request(method=method, url=url, data=body_bytes)
+        prepared = self.session.prepare_request(request)
+        prepared.headers["Content-Type"] = content_type
+        prepared.headers["X-Key-ID"] = self.key_id
+        prepared.headers["X-Timestamp"] = timestamp
+        prepared.headers["X-Signature"] = signature
+        prepared.headers["User-Agent"] = self.user_agent
+
+        response = self.session.send(prepared, timeout=self.timeout, stream=True)
+        raw = self._read_response(response)
+        if response.status_code < 200 or response.status_code >= 300:
+            api_error = self._maybe_api_error(raw)
+            if api_error is not None:
+                raise api_error
+            raise requests.HTTPError(
+                f"easyid: http status {response.status_code}",
+                response=response,
+            )
+
+        try:
+            envelope = json.loads(raw.decode("utf-8"))
+        except json.JSONDecodeError as exc:
+            raise ValueError(f"easyid: decode response (status={response.status_code}): {exc}") from exc
+
+        code = int(envelope.get("code", 0))
+        if code != 0:
+            raise APIError(code, str(envelope.get("message", "")), str(envelope.get("request_id", "")))
+        return envelope.get("data")
+
+    def _read_response(self, response: requests.Response) -> bytes:
+        chunks = []
+        total = 0
+        try:
+            for chunk in response.iter_content(chunk_size=8192):
+                if not chunk:
+                    continue
+                total += len(chunk)
+                if total > MAX_RESPONSE_BYTES:
+                    raise ValueError("easyid: response exceeds 10 MB limit")
+                chunks.append(chunk)
+        finally:
+            response.close()
+        return b"".join(chunks)
+
+    def _maybe_api_error(self, raw: bytes) -> Optional[APIError]:
+        try:
+            envelope = json.loads(raw.decode("utf-8"))
+        except (UnicodeDecodeError, json.JSONDecodeError):
+            return None
+        code_value = envelope.get("code", 0)
+        if code_value in (None, ""):
+            return None
+        code = int(code_value)
+        if code == 0:
+            return None
+        return APIError(code, str(envelope.get("message", "")), str(envelope.get("request_id", "")))
+
+    @staticmethod
+    def _normalize_query(query: Optional[Mapping[str, Any]]) -> Optional[Dict[str, str]]:
+        if not query:
+            return None
+        return {str(key): str(value) for key, value in query.items()}
+
+
+def make_multipart_part(field_name: str, file_obj: FileInput, filename: Optional[str]) -> MultipartPart:
+    """Create a :class:`MultipartPart` from bytes or a binary file-like object."""
+
+    if isinstance(file_obj, (bytes, bytearray)):
+        content = bytes(file_obj)
+        resolved_name = filename or "upload.bin"
+    else:
+        content = file_obj.read()
+        if not isinstance(content, bytes):
+            raise TypeError("easyid: file object must return bytes")
+        guessed_name = getattr(file_obj, "name", None)
+        resolved_name = filename or (os.path.basename(guessed_name) if guessed_name else "upload.bin")
+    return MultipartPart(field_name=field_name, filename=resolved_name, content=content)

easyid_python-1.0.2.dist-info/METADATA

@@ -0,0 +1,89 @@
+Metadata-Version: 2.4
+Name: easyid-python
+Version: 1.0.2
+Summary: Official Python SDK for the EasyID identity verification API.
+Project-URL: Homepage, https://github.com/easyid-com-cn/easyid-python
+Project-URL: Repository, https://github.com/easyid-com-cn/easyid-python
+Project-URL: Documentation, https://www.easyid.com.cn
+Author: EasyID Team
+License: MIT
+License-File: LICENSE
+Keywords: easyid,identity,kyc,risk,verification
+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 :: Only
+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: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.9
+Requires-Dist: requests<3,>=2.31.0
+Provides-Extra: test
+Requires-Dist: pytest<9,>=8; extra == 'test'
+Description-Content-Type: text/markdown
+
+# EasyID Python SDK
+
+Official Python SDK for the EasyID identity verification API.
+
+EasyID 易验云 focuses on identity verification and security risk control APIs, including real-name verification, liveness detection, face recognition, phone verification, and fraud-risk related capabilities.
+
+中文文档： [README.zh-CN.md](README.zh-CN.md)
+
+## Install
+
+```bash
+pip install easyid-python
+```
+
+## Quick Start
+
+```python
+from easyid import EasyID
+
+client = EasyID("ak_xxx", "sk_xxx")
+result = client.idcard.verify2(name="张三", id_number="110101199001011234")
+
+print(result.match)
+```
+
+## Supported APIs
+
+- IDCard: `verify2`, `verify3`, `ocr`
+- Phone: `status`, `verify3`
+- Face: `liveness`, `compare`, `verify`
+- Bank: `verify4`
+- Risk: `score`, `store_fingerprint`
+- Billing: `balance`, `records`
+
+## Configuration
+
+- `base_url`
+- `timeout`
+- `session`
+
+## Error Handling
+
+Service-side business errors raise `APIError`.
+
+```python
+from easyid import APIError
+
+try:
+    client.phone.status(phone="13800138000")
+except APIError as exc:
+    print(exc.code, exc.message, exc.request_id)
+```
+
+## Security Notice
+
+This is a server-side SDK. Never expose `secret` in browsers, mobile apps, or other untrusted clients.
+
+## Official Resources
+
+- Official website: `https://www.easyid.com.cn/`
+- GitHub organization: `https://github.com/easyid-com-cn/`

easyid_python-1.0.2.dist-info/RECORD

@@ -0,0 +1,16 @@
+easyid/__init__.py,sha256=njg6-q6YluVxXZh-E9DQaQxW5Xt2P4NZ2Udwd_O35mo,1119
+easyid/bank.py,sha256=LAPYl-5buGWQjJICTRVekarxmBzkidnvivGkI3as-xM,1081
+easyid/billing.py,sha256=e-QrqSR1AFmKqDUDwfQJkdXHk5RehfsTs2tJPmcbEm8,1562
+easyid/client.py,sha256=28wH-1rQcW3EJ7Fn_3ck7z5zp7WSg6xj1RmWW34d2ec,1511
+easyid/error.py,sha256=i7lYC9VDU6Upa39Sew_PJJSgQiqFh9V7cT12uG9UZmQ,560
+easyid/face.py,sha256=faX-B7rk9_-wN9_i4Z-Y318nY-xeaF7jOgpLHgFCcU8,2111
+easyid/idcard.py,sha256=eMubWiSZUp_Caj8xc8C5MT2c-nwsn_SMZA3I23OGDJk,2083
+easyid/phone.py,sha256=0urP0PQoEmqMrYW_9nTYh_fpYyttZTqlMeYhU3TbTiY,1031
+easyid/py.typed,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+easyid/risk.py,sha256=X9vdoXrGVbYXhppjYrr6yLCF46tASZ_QjYA3PVgGOWk,2281
+easyid/signer.py,sha256=uto372PqeRJdaN_EWmyREe5OpMvJv5krkaxe8Q3PU2E,735
+easyid/transport.py,sha256=7AE_tM5UBNkhtPm289nSf3JM5BfJJe3PmKkaiCZLx4I,6586
+easyid_python-1.0.2.dist-info/METADATA,sha256=IG1O7BoWnC2iKz8RfDQitay86_e7-5zRMGl9JKTL2RY,2512
+easyid_python-1.0.2.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+easyid_python-1.0.2.dist-info/licenses/LICENSE,sha256=kCoyPvOpIJB7kNFFsIm0nnd2yEcynll2t0Dg-AvJqVU,1068
+easyid_python-1.0.2.dist-info/RECORD,,

easyid_python-1.0.2.dist-info/WHEEL

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

easyid_python-1.0.2.dist-info/licenses/LICENSE

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