semvec/pypi-packages huggingface dataset:
structocr 1.1.4
The official Python SDK for StructOCR API - Passport, ID card, Driver License OCR, Invoice and VIN OCR.
Requires Python: >=3.6

# StructOCR Python SDK

[![PyPI version](https://badge.fury.io/py/structocr.svg)](https://badge.fury.io/py/structocr)
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)

**The official Python client for [StructOCR](https://structocr.com).**

StructOCR is a powerful API tailored for developers to extract structured data from identity documents with high accuracy. This SDK helps you integrate **Passport OCR**, **National ID OCR**,  **Driver License OCR**, **Invoice OCR** and **VIN OCR** into your Python applications in minutes.

👉 **[Get your Free API Key here](https://structocr.com)**

## Features

- **Passport OCR API**: Instantly extract MRZ, name, DOB, and expiry date from passports of 200+ countries.
- **National ID OCR**: Support for ID cards with automatic field mapping.
- **Driver License OCR**: Extract vehicle class, license number, and personal details. 
- **Invoice OCR**:  Extract invoice number, currency, merchant, customer.
- **VIN OCR**: Extract VIN (Vehicle Identification Number) from windshield or engine bay images.
- **Secure & Fast**: Enterprise-grade encryption and sub-second response times.

## Installation

Install the package via pip:

```bash
pip install structocr

```

## Quick Start

### 1. Initialize the Client

```python
from structocr import StructOCR

# Initialize with your API Key
client = StructOCR(api_key="sk_live_xxxxxxxx")

```

### 2. Scan a Passport (Passport OCR)

```python
# Pass the path to the passport image file
result = client.scan_passport('./docs/passport_sample.jpg')

print(f"Name: {result['data']['name']}")
print(f"Passport Number: {result['data']['document_number']}")

```

### 3. Scan a National ID, Driver License, Invoice or VIN

```python
# National ID OCR
id_data = client.scan_national_id('./docs/id_card.png')

# Driver License OCR
license_data = client.scan_driver_license('./docs/license.jpg')

# Invoice OCR
invoice_data = client.scan_invoice('./docs/invoice.jpg')

# VIN OCR
vin_data = client.scan_vin('./docs/vin.jpg')

```

## Documentation

For full API documentation, response examples, and error codes, please visit the [StructOCR Developer Docs](https://www.structocr.com/developers?ref=github).

## Requirements

* Python 3.6+
* `requests` library

## License

MIT License. See [LICENSE](https://www.google.com/search?q=LICENSE) for details.cd
ovinc-client 0.4.9
A Tool for OVINC Union API
Requires Python: >=3.12

# OVINC Union Api SDK

[![PyPI version](https://badge.fury.io/py/ovinc-client.svg)](https://badge.fury.io/py/ovinc-client)
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
[![Python](https://img.shields.io/badge/python-3.12+-blue.svg)](https://www.python.org/downloads/)

[中文文档](README_CN.md)

A Python client for OVINC Union API, providing easy access to authentication, notifications, and TCaptcha verification.

## Installation

```bash
pip install ovinc-client
```

## Usage

### Initialization

```python
from ovinc_client.client import OVINCClient

APP_CODE = "your_app_code"
APP_SECRET = "your_app_secret"
OVINC_API_URL = "https://api.ovinc.cn"

client = OVINCClient(app_code=APP_CODE, app_secret=APP_SECRET, union_api_url=OVINC_API_URL)
```

### Notifications (Notice)

#### Send Email

```python
response = client.notice.mail({
    "to": "user@example.com",
    "subject": "Hello",
    "content": "This is a test email."
})
print(response.data)
```

#### Send SMS

```python
response = client.notice.sms({
    "phone": "13800138000",
    "template_id": "123456",
    "params": ["1234"]
})
print(response.data)
```

#### Send Robot Message

```python
response = client.notice.robot({
    "channel": "wecom",
    "content": "Hello from robot"
})
print(response.data)
```

### Authentication (Auth)

#### Verify Code

```python
response = client.auth.verify_code({
    "code": "123456",
    "key": "user_identifier"
})
print(response.data)
```

### TCaptcha Verification

This module requires Django settings configuration.

**Settings:**

```python
# settings.py
CAPTCHA_TCLOUD_ID = "your_tencent_cloud_id"
CAPTCHA_TCLOUD_KEY = "your_tencent_cloud_key"
CAPTCHA_APP_ID = "your_captcha_app_id"
CAPTCHA_APP_SECRET = "your_captcha_app_secret"
CAPTCHA_ENABLED = True
```

**Usage:**

```python
from ovinc_client.tcaptcha.utils import TCaptchaVerify

# In your view or API
def verify_captcha(request):
    user_ip = request.META.get("REMOTE_ADDR")
    ticket = request.data.get("ticket")
    randstr = request.data.get("randstr")
    ret = request.data.get("ret")
    
    verifier = TCaptchaVerify(
        user_ip=user_ip,
        ticket=ticket,
        randstr=randstr,
        ret=ret
    )
    
    if verifier.verify():
        return "Success"
    else:
        return "Failed"
```

## License

This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
zmp-openapi 1.0.0
SDK for ZaloMiniApp OpenAPI with Python
Requires Python: >=3.10

# Zalo Mini App Open API SDK for Python

A Python SDK for server-to-server integration with Zalo Mini App Open API.

## What is this SDK?

This SDK provides automated management and development tools for Zalo Mini Apps through server-to-server API integration.
It is designed for Zalo Mini App solution partners.

With this SDK, you can create, deploy, publish, and manage Mini Apps programmatically without manual intervention through the web console.

## Requirements

- Python 3.10 or higher
- API Key from Zalo Mini App
- Zalo App ID

## Install

```bash
pip install zmp_openapi
```

### Development version

```bash
pip install git+https://github.com/thedtvn/zmp-openapi.git
```

## Sync client

```python
from zmp_openapi import OpenAPIClient

client = OpenAPIClient(api_key="YOUR_API_KEY", zalo_app_id="YOUR_APP_ID")
apps = client.get_mini_apps({"offset": 0, "limit": 10})
print(apps)
```

## Async client

```python
import asyncio

from zmp_openapi import AsyncOpenAPIClient


async def main() -> None:
    client = AsyncOpenAPIClient(api_key="YOUR_API_KEY", zalo_app_id="YOUR_APP_ID")
    apps = await client.get_mini_apps({"offset": 0, "limit": 10})
    print(apps)


asyncio.run(main())
```

## Module-level helpers

```python
from zmp_openapi import openapi

apps = openapi.get_apps(offset=0, limit=10)
```

## Documentation

- Local docs landing page: `docs/templates/preload/index.html`

## FAQ

**What can this SDK do?**
It can create Mini Apps, deploy new versions, publish apps to production, list apps and versions, and verify webhook signatures. All operations are automated through server-to-server API calls.

**Is this SDK official?**
This SDK is built based on the official Zalo Mini App Open API documentation available at https://miniapp.zaloplatforms.com/documents/open-apis/partner/.

**Can I use this for both sync and async operations?**
Yes. The SDK provides both `OpenAPIClient` for synchronous operations and `AsyncOpenAPIClient` for asynchronous operations using aiohttp.

## Notes

- Responses return raw JSON or raw text when JSON is not available.
- HTTP errors raise exceptions (requests or aiohttp) on non-2xx responses.
ethio-pay-verifier 0.1.0
Verify Ethiopian payment receipts (CBE, Telebirr, Abyssinia, Dashen, CBE Birr) directly from official bank endpoints.
Requires Python: >=3.10
Keywords: abyssinia, cbe, cbebirr, dashen, ethiopia, payment, receipt, scraper, telebirr, verification

# Ethio-Pay-Verifier

A lightweight, pure-Python library to verify payment receipts from major Ethiopian banks directly against their official public endpoints. No third-party APIs, no middleware—just direct verification.

## 🚀 Features

- **Direct Verification**: Hits the official bank endpoints directly.
- **Support for Major Banks**:
    - **CBE** (Commercial Bank of Ethiopia) - PDF Parsing
    - **Telebirr** (Ethio Telecom) - HTML Scraping
    - **Bank of Abyssinia** - JSON API
    - **Dashen Bank** - PDF Parsing
    - **CBE Birr** - PDF Parsing
- **Clean Business Logic**: Includes utilities for name normalization, masked account matching, and amount verification.
- **Lightweight**: Just a few dependencies (`requests`, `beautifulsoup4`, `PyPDF2`, `pdfplumber`).

## 📦 Installation

```bash
pip install ethio-pay-verifier
```

## 🛠 Usage

### Using the Unified Verifier

The `PaymentVerifier` class provides a single interface for all banks and includes common business rules like amount checking and receiver validation.

```python
from python_verifier import PaymentVerifier

v = PaymentVerifier()

# 1. Telebirr
result = v.verify("telebirr", reference="CE2513001XYT")

# 2. CBE (Requires 8-digit account suffix)
result = v.verify("cbe", reference="FT2513001V2G", account_suffix="12345678")

# 3. Abyssinia (Requires 5-digit account suffix)
result = v.verify("abyssinia", reference="FT23062669JJ", suffix="12345")

# 4. Dashen
result = v.verify("dashen", reference="TXN123456")

# 5. CBE Birr
result = v.verify("cbebirr", receipt_number="CGU9REIHHB", phone_number="251912345678")

if result.success:
    print(f"Verified {result.amount} ETB from {result.payer_name}")
```

### Direct Scraper Access

You can also call the scrapers directly if you don't need the high-level dispatcher rules:

```python
from python_verifier import verify_telebirr, verify_cbe

# Get Telebirr receipt object
receipt = verify_telebirr("CE2513001XYT")
if receipt.success:
    print(receipt.settled_amount)

# Get CBE result
cbe = verify_cbe("FT2513001V2G", "12345678")
```

## ⚖️ License

MIT License. See [LICENSE](LICENSE) for details.

## ⚠️ Disclaimer

This library is not affiliated with, maintained, or endorsed by any of the banks listed. It relies on scraping public endpoints, which may change without notice. Use in production at your own risk.