rulhub 0.1.0__tar.gz

rulhub-0.1.0/.gitignore

@@ -0,0 +1,88 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# Virtual environment
+venv/
+.venv/
+
+# Environment files (secrets)
+/.env
+.env
+.env.local
+.env.production
+.env.staging
+.env.development
+.env.test
+*.env
+.env.*
+!.env.example
+
+# IDE settings
+.vscode/
+.idea/
+
+# Migrations
+alembic/versions/*.pyc
+alembic/__pycache__/
+
+# Logs
+*.log
+
+# OS junk
+.DS_Store
+Thumbs.db
+
+# Security files
+*.pem
+*.key
+*.crt
+*.p12
+*.pfx
+secrets/
+credentials/
+.secrets
+api_keys.txt
+.password
+.token
+
+# Database files (may contain sensitive data)
+*.db-journal
+*.sqlite-journal
+
+# Backup files (may contain secrets)
+*.bak
+*.backup
+*.old
+*~
+
+# Docker secrets
+.docker/
+docker-compose.override.yml
+
+# Temporary files
+temp/
+tmp/
+.tmp/
+
+# Editor temp files
+.swp
+.swo
+*~
+
+# Node modules
+node_modules/
+admin/node_modules/
+landing/node_modules/
+
+# Problematic Windows device filename
+/nul
+
+# Playwright artifacts
+playwright-report/
+test-results/
+admin/playwright-report/
+admin/test-results/
+
+.vercel

rulhub-0.1.0/PKG-INFO

@@ -0,0 +1,116 @@
+Metadata-Version: 2.4
+Name: rulhub
+Version: 0.1.0
+Summary: RulHub SDK — Trade finance compliance API client
+Project-URL: Homepage, https://rulhub.com
+Project-URL: Documentation, https://api.rulhub.com/swagger
+Project-URL: Repository, https://github.com/ripclass/RulEngine
+Project-URL: Issues, https://github.com/ripclass/RulEngine/issues
+Author-email: Enso Intelligence Labs <api@rulhub.com>
+License-Expression: MIT
+Keywords: api,compliance,icc,letter-of-credit,sanctions,trade-finance,ucp600
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Financial and Insurance Industry
+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 :: Python :: 3.13
+Classifier: Topic :: Office/Business :: Financial
+Classifier: Typing :: Typed
+Requires-Python: >=3.8
+Requires-Dist: requests>=2.28.0
+Description-Content-Type: text/markdown
+
+# RulHub Python SDK
+
+Trade finance compliance API — validate documents against 5,400+ ICC rules with AI-powered semantic matching.
+
+## Install
+
+```bash
+pip install rulhub
+```
+
+## Quick Start
+
+```python
+from rulhub import RulHub
+
+client = RulHub(api_key="ak_your_key_here")
+
+# Validate a letter of credit
+result = client.validate(
+    rules="ucp600",
+    document_type="lc",
+    document={
+        "beneficiary_name": "ABC Trading Co",
+        "amount": 50000,
+        "currency": "USD",
+        "goods_description": "1000 MT Thai White Rice 5% Broken",
+        "expiry_date": "2026-06-30",
+    }
+)
+
+print(f"Score: {result['score']:.0%}")
+print(f"Compliant: {result['compliant']}")
+
+for d in result["discrepancies"]:
+    print(f"  [{d['severity']}] {d['finding']}")
+    if d.get("recommendation"):
+        print(f"    Fix: {d['recommendation']}")
+```
+
+## Validate Multiple Documents
+
+```python
+result = client.validate_set(documents=[
+    {"type": "lc", "fields": {"amount": 50000, "currency": "USD"}},
+    {"type": "invoice", "fields": {"total_amount": 49500, "currency": "USD"}},
+])
+
+for d in result["cross_document_discrepancies"]:
+    print(f"  {d['finding']} ({', '.join(d['documents_involved'])})")
+```
+
+## Sanctions Screening
+
+```python
+result = client.screen_sanctions(entity="Acme Corp", country="IR")
+print(f"Clear: {result['clear']}, Risk: {result['risk_level']}")
+```
+
+## All Methods
+
+| Method | Description |
+|--------|-------------|
+| `validate()` | Single document validation |
+| `validate_set()` | Multi-document cross-doc validation |
+| `screen_sanctions()` | OFAC/EU/UN/UK sanctions screening |
+| `screen_entity()` | UBO/PEP/shell company risk |
+| `screen_export_controls()` | EAR/ITAR/EU dual-use |
+| `screen_tbml()` | FATF money laundering indicators |
+| `screen_route()` | Route sanctions + transport |
+| `search_rules()` | Keyword search across all rules |
+| `lookup_rules()` | Structured rule retrieval |
+| `get_requirements()` | Document field requirements |
+| `get_bank_profiles()` | Bank behavior data |
+| `get_country_requirements()` | Country compliance rules |
+| `get_fta_origin()` | FTA eligibility rules |
+| `get_commodities()` | Commodity compliance |
+
+## Sign Up
+
+Free plan: 50 validations/month. No credit card.
+
+```bash
+curl -X POST https://api.rulhub.com/v1/signup \
+  -H "Content-Type: application/json" \
+  -d '{"email":"you@co.com","password":"secure123","company_name":"Your Co"}'
+```
+
+**API Docs:** https://api.rulhub.com/swagger | **Website:** https://rulhub.com | **By:** Enso Intelligence Labs, Inc.

rulhub-0.1.0/README.md

@@ -0,0 +1,88 @@
+# RulHub Python SDK
+
+Trade finance compliance API — validate documents against 5,400+ ICC rules with AI-powered semantic matching.
+
+## Install
+
+```bash
+pip install rulhub
+```
+
+## Quick Start
+
+```python
+from rulhub import RulHub
+
+client = RulHub(api_key="ak_your_key_here")
+
+# Validate a letter of credit
+result = client.validate(
+    rules="ucp600",
+    document_type="lc",
+    document={
+        "beneficiary_name": "ABC Trading Co",
+        "amount": 50000,
+        "currency": "USD",
+        "goods_description": "1000 MT Thai White Rice 5% Broken",
+        "expiry_date": "2026-06-30",
+    }
+)
+
+print(f"Score: {result['score']:.0%}")
+print(f"Compliant: {result['compliant']}")
+
+for d in result["discrepancies"]:
+    print(f"  [{d['severity']}] {d['finding']}")
+    if d.get("recommendation"):
+        print(f"    Fix: {d['recommendation']}")
+```
+
+## Validate Multiple Documents
+
+```python
+result = client.validate_set(documents=[
+    {"type": "lc", "fields": {"amount": 50000, "currency": "USD"}},
+    {"type": "invoice", "fields": {"total_amount": 49500, "currency": "USD"}},
+])
+
+for d in result["cross_document_discrepancies"]:
+    print(f"  {d['finding']} ({', '.join(d['documents_involved'])})")
+```
+
+## Sanctions Screening
+
+```python
+result = client.screen_sanctions(entity="Acme Corp", country="IR")
+print(f"Clear: {result['clear']}, Risk: {result['risk_level']}")
+```
+
+## All Methods
+
+| Method | Description |
+|--------|-------------|
+| `validate()` | Single document validation |
+| `validate_set()` | Multi-document cross-doc validation |
+| `screen_sanctions()` | OFAC/EU/UN/UK sanctions screening |
+| `screen_entity()` | UBO/PEP/shell company risk |
+| `screen_export_controls()` | EAR/ITAR/EU dual-use |
+| `screen_tbml()` | FATF money laundering indicators |
+| `screen_route()` | Route sanctions + transport |
+| `search_rules()` | Keyword search across all rules |
+| `lookup_rules()` | Structured rule retrieval |
+| `get_requirements()` | Document field requirements |
+| `get_bank_profiles()` | Bank behavior data |
+| `get_country_requirements()` | Country compliance rules |
+| `get_fta_origin()` | FTA eligibility rules |
+| `get_commodities()` | Commodity compliance |
+
+## Sign Up
+
+Free plan: 50 validations/month. No credit card.
+
+```bash
+curl -X POST https://api.rulhub.com/v1/signup \
+  -H "Content-Type: application/json" \
+  -d '{"email":"you@co.com","password":"secure123","company_name":"Your Co"}'
+```
+
+**API Docs:** https://api.rulhub.com/swagger | **Website:** https://rulhub.com | **By:** Enso Intelligence Labs, Inc.

rulhub-0.1.0/icc_rule_engine/__init__.py

@@ -0,0 +1,22 @@
+"""
+ICC Rule Engine Python SDK
+
+A comprehensive Python SDK for interacting with the ICC Rule Engine API.
+"""
+
+from .client import ICCRuleEngineClient
+from .models import Rule, ValidationRequest, ValidationResult, RuleCondition, ExpectedOutcome
+from .exceptions import ICCRuleEngineError, ValidationError, APIError
+
+__version__ = "1.0.0"
+__all__ = [
+    "ICCRuleEngineClient",
+    "Rule",
+    "ValidationRequest",
+    "ValidationResult",
+    "RuleCondition",
+    "ExpectedOutcome",
+    "ICCRuleEngineError",
+    "ValidationError",
+    "APIError"
+]

rulhub-0.1.0/icc_rule_engine/client.py

@@ -0,0 +1,365 @@
+"""
+ICC Rule Engine Python SDK Client
+"""
+import asyncio
+from typing import Any, Dict, List, Optional, Union
+from urllib.parse import urljoin
+
+import httpx
+from pydantic import ValidationError as PydanticValidationError
+
+from .models import (
+    Rule,
+    ValidationRequest,
+    ValidationResult,
+    BatchValidationRequest,
+    BatchValidationResult,
+    HealthStatus,
+    MetricsResponse
+)
+from .exceptions import (
+    APIError,
+    AuthenticationError,
+    NetworkError,
+    RateLimitError,
+    TimeoutError,
+    ValidationError
+)
+
+
+class ICCRuleEngineClient:
+    """
+    ICC Rule Engine API Client
+
+    A comprehensive client for interacting with the ICC Rule Engine API.
+    """
+
+    def __init__(
+        self,
+        base_url: str,
+        api_key: str,
+        timeout: float = 30.0,
+        max_retries: int = 3,
+        retry_delay: float = 1.0
+    ):
+        """
+        Initialize the ICC Rule Engine client
+
+        Args:
+            base_url: Base URL of the ICC Rule Engine API
+            api_key: API key for authentication
+            timeout: Request timeout in seconds
+            max_retries: Maximum number of retries for failed requests
+            retry_delay: Delay between retries in seconds
+        """
+        self.base_url = base_url.rstrip("/")
+        self.api_key = api_key
+        self.timeout = timeout
+        self.max_retries = max_retries
+        self.retry_delay = retry_delay
+
+        self._client = httpx.Client(
+            timeout=timeout,
+            headers={
+                "X-API-Key": api_key,
+                "Content-Type": "application/json",
+                "User-Agent": "ICC-Rule-Engine-SDK/1.0.0"
+            }
+        )
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.close()
+
+    def close(self):
+        """Close the HTTP client"""
+        self._client.close()
+
+    def _make_request(
+        self,
+        method: str,
+        endpoint: str,
+        json_data: Optional[Dict[str, Any]] = None,
+        params: Optional[Dict[str, Any]] = None
+    ) -> Dict[str, Any]:
+        """Make HTTP request with error handling and retries"""
+
+        url = urljoin(self.base_url + "/", endpoint.lstrip("/"))
+
+        for attempt in range(self.max_retries + 1):
+            try:
+                response = self._client.request(
+                    method=method,
+                    url=url,
+                    json=json_data,
+                    params=params
+                )
+
+                if response.status_code == 401:
+                    raise AuthenticationError("Invalid API key")
+                elif response.status_code == 429:
+                    raise RateLimitError("Rate limit exceeded")
+                elif response.status_code >= 400:
+                    error_data = {}
+                    try:
+                        error_data = response.json()
+                    except Exception:
+                        pass
+
+                    raise APIError(
+                        message=error_data.get("detail", f"API error: {response.status_code}"),
+                        status_code=response.status_code,
+                        response_data=error_data
+                    )
+
+                return response.json()
+
+            except httpx.TimeoutException:
+                if attempt == self.max_retries:
+                    raise TimeoutError("Request timed out")
+            except httpx.NetworkError as e:
+                if attempt == self.max_retries:
+                    raise NetworkError(f"Network error: {e}")
+            except (APIError, AuthenticationError, RateLimitError):
+                raise
+
+            if attempt < self.max_retries:
+                import time
+                time.sleep(self.retry_delay * (2 ** attempt))
+
+    # Health and Status Methods
+
+    def health_check(self) -> HealthStatus:
+        """Check API health status"""
+        data = self._make_request("GET", "/health")
+        return HealthStatus(**data)
+
+    def get_metrics(self) -> MetricsResponse:
+        """Get API metrics"""
+        data = self._make_request("GET", "/metrics/")
+        return MetricsResponse(**data)
+
+    # Rule Management Methods
+
+    def create_rule(self, rule: Union[Rule, Dict[str, Any]]) -> Rule:
+        """Create a new rule"""
+        if isinstance(rule, Rule):
+            rule_data = rule.model_dump(exclude_unset=True)
+        else:
+            rule_data = rule
+
+        data = self._make_request("POST", "/rules/", json_data=rule_data)
+        return Rule(**data)
+
+    def get_rule(self, rule_id: str) -> Rule:
+        """Get rule by ID"""
+        data = self._make_request("GET", f"/rules/{rule_id}")
+        return Rule(**data)
+
+    def update_rule(self, rule_id: str, rule: Union[Rule, Dict[str, Any]]) -> Rule:
+        """Update an existing rule"""
+        if isinstance(rule, Rule):
+            rule_data = rule.model_dump(exclude_unset=True)
+        else:
+            rule_data = rule
+
+        data = self._make_request("PUT", f"/rules/{rule_id}", json_data=rule_data)
+        return Rule(**data)
+
+    def delete_rule(self, rule_id: str) -> Dict[str, str]:
+        """Delete a rule"""
+        return self._make_request("DELETE", f"/rules/{rule_id}")
+
+    def list_rules(
+        self,
+        source: Optional[str] = None,
+        article: Optional[str] = None,
+        tags: Optional[List[str]] = None,
+        severity: Optional[str] = None,
+        active: Optional[bool] = None,
+        limit: Optional[int] = None,
+        skip: Optional[int] = None
+    ) -> List[Rule]:
+        """List rules with optional filters"""
+        params = {}
+        if source:
+            params["source"] = source
+        if article:
+            params["article"] = article
+        if tags:
+            params["tags"] = ",".join(tags)
+        if severity:
+            params["severity"] = severity
+        if active is not None:
+            params["active"] = active
+        if limit:
+            params["limit"] = limit
+        if skip:
+            params["skip"] = skip
+
+        data = self._make_request("GET", "/rules/", params=params)
+        return [Rule(**rule) for rule in data]
+
+    # Validation Methods
+
+    def validate_document(
+        self,
+        document: Dict[str, Any],
+        ruleset: Dict[str, Any]
+    ) -> ValidationResult:
+        """Validate a single document"""
+        request_data = ValidationRequest(document=document, ruleset=ruleset)
+        data = self._make_request("POST", "/validate/", json_data=request_data.model_dump())
+        return ValidationResult(**data)
+
+    def validate_batch(
+        self,
+        documents: List[Dict[str, Any]],
+        ruleset: Dict[str, Any],
+        parallel: bool = True
+    ) -> BatchValidationResult:
+        """Validate multiple documents"""
+        request_data = BatchValidationRequest(
+            documents=documents,
+            ruleset=ruleset,
+            parallel=parallel
+        )
+        data = self._make_request("POST", "/validate/batch", json_data=request_data.model_dump())
+        return BatchValidationResult(**data)
+
+    # Convenience Methods
+
+    def validate_letter_of_credit(
+        self,
+        document: Dict[str, Any],
+        source: str = "UCP600",
+        article: Optional[str] = None
+    ) -> ValidationResult:
+        """Convenience method for validating letters of credit"""
+        ruleset = {"source": source}
+        if article:
+            ruleset["article"] = article
+
+        return self.validate_document(document, ruleset)
+
+    def get_rules_by_source(self, source: str) -> List[Rule]:
+        """Get all rules for a specific source"""
+        return self.list_rules(source=source)
+
+    def get_active_rules(self) -> List[Rule]:
+        """Get all active rules"""
+        return self.list_rules(active=True)
+
+
+class AsyncICCRuleEngineClient:
+    """
+    Async ICC Rule Engine API Client
+
+    An async version of the ICC Rule Engine client for high-performance applications.
+    """
+
+    def __init__(
+        self,
+        base_url: str,
+        api_key: str,
+        timeout: float = 30.0,
+        max_retries: int = 3,
+        retry_delay: float = 1.0
+    ):
+        """
+        Initialize the async ICC Rule Engine client
+
+        Args:
+            base_url: Base URL of the ICC Rule Engine API
+            api_key: API key for authentication
+            timeout: Request timeout in seconds
+            max_retries: Maximum number of retries for failed requests
+            retry_delay: Delay between retries in seconds
+        """
+        self.base_url = base_url.rstrip("/")
+        self.api_key = api_key
+        self.timeout = timeout
+        self.max_retries = max_retries
+        self.retry_delay = retry_delay
+
+        self._client = httpx.AsyncClient(
+            timeout=timeout,
+            headers={
+                "X-API-Key": api_key,
+                "Content-Type": "application/json",
+                "User-Agent": "ICC-Rule-Engine-SDK/1.0.0"
+            }
+        )
+
+    async def __aenter__(self):
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        await self.aclose()
+
+    async def aclose(self):
+        """Close the HTTP client"""
+        await self._client.aclose()
+
+    async def _make_request(
+        self,
+        method: str,
+        endpoint: str,
+        json_data: Optional[Dict[str, Any]] = None,
+        params: Optional[Dict[str, Any]] = None
+    ) -> Dict[str, Any]:
+        """Make async HTTP request with error handling and retries"""
+
+        url = urljoin(self.base_url + "/", endpoint.lstrip("/"))
+
+        for attempt in range(self.max_retries + 1):
+            try:
+                response = await self._client.request(
+                    method=method,
+                    url=url,
+                    json=json_data,
+                    params=params
+                )
+
+                if response.status_code == 401:
+                    raise AuthenticationError("Invalid API key")
+                elif response.status_code == 429:
+                    raise RateLimitError("Rate limit exceeded")
+                elif response.status_code >= 400:
+                    error_data = {}
+                    try:
+                        error_data = response.json()
+                    except Exception:
+                        pass
+
+                    raise APIError(
+                        message=error_data.get("detail", f"API error: {response.status_code}"),
+                        status_code=response.status_code,
+                        response_data=error_data
+                    )
+
+                return response.json()
+
+            except httpx.TimeoutException:
+                if attempt == self.max_retries:
+                    raise TimeoutError("Request timed out")
+            except httpx.NetworkError as e:
+                if attempt == self.max_retries:
+                    raise NetworkError(f"Network error: {e}")
+            except (APIError, AuthenticationError, RateLimitError):
+                raise
+
+            if attempt < self.max_retries:
+                await asyncio.sleep(self.retry_delay * (2 ** attempt))
+
+    async def validate_document(
+        self,
+        document: Dict[str, Any],
+        ruleset: Dict[str, Any]
+    ) -> ValidationResult:
+        """Validate a single document (async)"""
+        request_data = ValidationRequest(document=document, ruleset=ruleset)
+        data = await self._make_request("POST", "/validate/", json_data=request_data.model_dump())
+        return ValidationResult(**data)