threeypay-sdk 1.1.0__py3-none-any.whl

threeypay/__init__.py

@@ -0,0 +1,37 @@
+"""
+3YPay Python SDK
+"""
+
+__version__ = "1.1.0"
+__author__ = "3YPay Team"
+
+from threeypay.sdk import ThreeYPay
+from threeypay.config import Config
+from threeypay.client import Client
+from threeypay.exceptions import HttpException, InvalidSignException
+from threeypay.payment import Payment
+from threeypay.transfer import Transfer
+from threeypay.profitsharing import ProfitSharing
+from threeypay.account import Account
+from threeypay.merchant import Merchant
+from threeypay.payout import Payout
+from threeypay.balanceshare import BalanceShare
+from threeypay.nonmch import NonMch
+from threeypay.channel import Channel
+
+__all__ = [
+    "ThreeYPay",
+    "Config",
+    "Client",
+    "HttpException",
+    "InvalidSignException",
+    "Payment",
+    "Transfer",
+    "ProfitSharing",
+    "Account",
+    "Merchant",
+    "Payout",
+    "BalanceShare",
+    "NonMch",
+    "Channel",
+]

threeypay/account/__init__.py

@@ -0,0 +1,5 @@
+"""账户模块"""
+
+from threeypay.account.account import Account
+
+__all__ = ["Account"]

threeypay/account/account.py

@@ -0,0 +1,77 @@
+"""
+分账账户与提现类
+"""
+
+from typing import Any, Dict, List, Optional
+
+
+class Account:
+    """账户管理类"""
+
+    API_BALANCE_QUERY = "/mchShare/withdrawal/account"
+    API_WITHDRAW = "/mchShare/withdrawal/commit"
+    API_WITHDRAW_QUERY = "/mchShare/withdrawal/query"
+
+    def __init__(self, client):
+        self.client = client
+
+    def balance_query(self, params: Dict[str, Any]) -> Dict[str, Any]:
+        """账户余额查询（accountNo 必填）"""
+        self._validate_required(params, ["accountNo"])
+        response = self.client.post(self.API_BALANCE_QUERY, params)
+        return self.client.parse_response(response)
+
+    def query_balance(self, account_no: str) -> Dict[str, Any]:
+        return self.balance_query({"accountNo": account_no})
+
+    def withdraw(self, params: Dict[str, Any]) -> Dict[str, Any]:
+        """提现申请（mchSerialNo、accountNo、amount、remark 必填，notifyUrl 可选）"""
+        payload = dict(params)
+        self._validate_required(payload, ["mchSerialNo", "accountNo", "remark"])
+        payload["amount"] = self._amount(payload.get("amount"), "amount")
+
+        response = self.client.post(self.API_WITHDRAW, payload)
+        return self.client.parse_response(response)
+
+    def submit_withdraw(
+        self, mch_serial_no: str, account_no: str, amount: str, remark: str,
+        notify_url: str = "",
+    ) -> Dict[str, Any]:
+        params: Dict[str, Any] = {
+            "mchSerialNo": mch_serial_no,
+            "accountNo": account_no,
+            "amount": amount,
+            "remark": remark,
+        }
+        if notify_url:
+            params["notifyUrl"] = notify_url
+        return self.withdraw(params)
+
+    def withdraw_query(self, params: Dict[str, Any]) -> Dict[str, Any]:
+        """提现查询（mchSerialNo 与 serialNo 二选一）"""
+        self._validate_one_of(params, ["mchSerialNo", "serialNo"])
+        response = self.client.post(self.API_WITHDRAW_QUERY, params)
+        return self.client.parse_response(response)
+
+    @staticmethod
+    def _amount(value: Any, field: str) -> float:
+        try:
+            amount = float(value)
+        except (TypeError, ValueError):
+            raise ValueError(f"金额参数无效：{field}")
+        if amount <= 0:
+            raise ValueError(f"金额参数无效：{field}")
+        return amount
+
+    @staticmethod
+    def _validate_required(params: Dict[str, Any], fields: List[str]) -> None:
+        for field in fields:
+            if field not in params or params[field] is None or params[field] == "":
+                raise ValueError(f"必填参数不能为空：{field}")
+
+    @staticmethod
+    def _validate_one_of(params: Dict[str, Any], fields: List[str]) -> None:
+        for field in fields:
+            if field in params and params[field] is not None and params[field] != "":
+                return
+        raise ValueError(f"以下参数至少填一个：{', '.join(fields)}")

threeypay/balanceshare/__init__.py

@@ -0,0 +1,5 @@
+"""余额分账模块"""
+
+from threeypay.balanceshare.balance_share import BalanceShare
+
+__all__ = ["BalanceShare"]

threeypay/balanceshare/balance_share.py

@@ -0,0 +1,86 @@
+"""
+余额分账类
+
+金额单位：元（number）。
+"""
+
+from typing import Any, Dict, List
+
+
+class BalanceShare:
+    """余额分账类"""
+
+    API_BALANCE_SHARE = "/mchShare/balance/share"
+    API_BALANCE_SHARE_QUERY = "/mchShare/balance/shareQuery"
+    API_BALANCE_REFUND = "/mchShare/balance/refund"
+    API_BALANCE_REFUND_QUERY = "/mchShare/balance/refundQuery"
+
+    def __init__(self, client):
+        self.client = client
+
+    def apply(self, params: Dict[str, Any]) -> Dict[str, Any]:
+        """余额分账申请（mchBatchNo、accountNo、appChannelSn 必填，acctInfos 子项需 accountNo/amount/description）"""
+        payload = dict(params)
+        self._validate_required(payload, ["mchBatchNo", "accountNo", "appChannelSn"])
+        self._validate_acct_infos(payload, ["accountNo", "amount", "description"])
+
+        response = self.client.post(self.API_BALANCE_SHARE, payload)
+        return self.client.parse_response(response)
+
+    def query(self, params: Dict[str, Any]) -> Dict[str, Any]:
+        """余额分账查询（batchNo 与 mchBatchNo 二选一）"""
+        self._validate_one_of(params, ["batchNo", "mchBatchNo"])
+        response = self.client.post(self.API_BALANCE_SHARE_QUERY, params)
+        return self.client.parse_response(response)
+
+    def refund(self, params: Dict[str, Any]) -> Dict[str, Any]:
+        """余额分账退款（mchRefundOrderNo 必填，批次二选一，acctInfos 子项需 accOrderNo/amount/description）"""
+        payload = dict(params)
+        self._validate_required(payload, ["mchRefundOrderNo"])
+        self._validate_one_of(payload, ["batchNo", "mchBatchNo"])
+        self._validate_acct_infos(payload, ["accOrderNo", "amount", "description"])
+
+        response = self.client.post(self.API_BALANCE_REFUND, payload)
+        return self.client.parse_response(response)
+
+    def refund_query(self, params: Dict[str, Any]) -> Dict[str, Any]:
+        """余额分账退款查询（batchNo 与 mchBatchNo 二选一）"""
+        self._validate_one_of(params, ["batchNo", "mchBatchNo"])
+        response = self.client.post(self.API_BALANCE_REFUND_QUERY, params)
+        return self.client.parse_response(response)
+
+    def _validate_acct_infos(self, params: Dict[str, Any], required_fields: List[str]) -> None:
+        acct_infos = params.get("acctInfos")
+        if not isinstance(acct_infos, list) or not acct_infos:
+            raise ValueError("acctInfos参数格式错误")
+
+        for index, item in enumerate(acct_infos):
+            if not isinstance(item, dict):
+                raise ValueError(f"acctInfos[{index}]格式错误")
+            for field in required_fields:
+                if field not in item or item[field] is None or item[field] == "":
+                    raise ValueError(f"acctInfos[{index}].{field}不能为空")
+            item["amount"] = self._amount(item["amount"], f"acctInfos[{index}].amount")
+
+    @staticmethod
+    def _amount(value: Any, field: str) -> float:
+        try:
+            amount = float(value)
+        except (TypeError, ValueError):
+            raise ValueError(f"金额参数无效：{field}")
+        if amount <= 0:
+            raise ValueError(f"金额参数无效：{field}")
+        return amount
+
+    @staticmethod
+    def _validate_required(params: Dict[str, Any], fields: List[str]) -> None:
+        for field in fields:
+            if field not in params or params[field] is None or params[field] == "":
+                raise ValueError(f"必填参数不能为空：{field}")
+
+    @staticmethod
+    def _validate_one_of(params: Dict[str, Any], fields: List[str]) -> None:
+        for field in fields:
+            if field in params and params[field] is not None and params[field] != "":
+                return
+        raise ValueError(f"以下参数至少填一个：{', '.join(fields)}")

threeypay/channel/__init__.py

@@ -0,0 +1,5 @@
+"""分账关系模块"""
+
+from threeypay.channel.channel import Channel
+
+__all__ = ["Channel"]

threeypay/channel/channel.py

@@ -0,0 +1,65 @@
+"""
+分账关系管理类
+"""
+
+from typing import Any, Dict, List
+
+
+class Channel:
+    """分账关系类"""
+
+    API_BINDING = "/mchShare/channel/binding"
+    API_UNBINDING = "/mchShare/channel/unBinding"
+    API_UPDATE = "/mchShare/channel/update"
+    API_BINDING_QUERY = "/mchShare/channel/bindingQuery"
+
+    def __init__(self, client):
+        self.client = client
+
+    def binding(self, params: Dict[str, Any]) -> Dict[str, Any]:
+        """分账关系绑定（accountNo、appChannelSn、fundName、defaultRate 必填）"""
+        self._validate_required(params, ["accountNo", "appChannelSn", "fundName", "defaultRate"])
+        self._validate_rate(params, "defaultRate")
+        self._validate_rate(params, "defaultFee", required=False)
+        response = self.client.post(self.API_BINDING, params)
+        return self.client.parse_response(response)
+
+    def unbind(self, params: Dict[str, Any]) -> Dict[str, Any]:
+        """分账关系解绑"""
+        self._validate_required(params, ["accountNo", "appChannelSn"])
+        response = self.client.post(self.API_UNBINDING, params)
+        return self.client.parse_response(response)
+
+    def update(self, params: Dict[str, Any]) -> Dict[str, Any]:
+        """分账关系更新（accountNo、appChannelSn、defaultRate 必填）"""
+        self._validate_required(params, ["accountNo", "appChannelSn", "defaultRate"])
+        self._validate_rate(params, "defaultRate")
+        self._validate_rate(params, "defaultFee", required=False)
+        response = self.client.post(self.API_UPDATE, params)
+        return self.client.parse_response(response)
+
+    def query(self, params: Dict[str, Any]) -> Dict[str, Any]:
+        """分账关系查询（appChannelSn 必填）"""
+        self._validate_required(params, ["appChannelSn"])
+        response = self.client.post(self.API_BINDING_QUERY, params)
+        return self.client.parse_response(response)
+
+    @staticmethod
+    def _validate_required(params: Dict[str, Any], fields: List[str]) -> None:
+        for field in fields:
+            if field not in params or params[field] is None or params[field] == "":
+                raise ValueError(f"必填参数不能为空：{field}")
+
+    @staticmethod
+    def _validate_rate(params: Dict[str, Any], field: str, required: bool = True) -> None:
+        if field not in params or params[field] is None or params[field] == "":
+            if required:
+                raise ValueError(f"必填参数不能为空：{field}")
+            return
+        try:
+            rate = float(params[field])
+        except (TypeError, ValueError):
+            raise ValueError(f"比例参数无效：{field}")
+        if rate < 0 or rate > 100:
+            raise ValueError(f"比例参数无效：{field}")
+        params[field] = rate

threeypay/client.py

@@ -0,0 +1,146 @@
+"""
+HTTP 客户端
+"""
+
+import json
+import time
+from typing import Any, Dict, Optional
+
+import requests
+
+from threeypay.config import Config
+from threeypay.exceptions import HttpException
+from threeypay.utils.signer import Signer
+
+
+class Client:
+    """3YPay HTTP 客户端类"""
+
+    def __init__(self, config: Config, session: Optional[requests.Session] = None):
+        self.config = config
+        self.session = session or requests.Session()
+        self.session.headers.update({
+            "Content-Type": "application/json",
+            "Accept": "application/json",
+        })
+        self.sub_sn = ""
+
+    def set_sub_sn(self, sub_sn: str) -> "Client":
+        self.sub_sn = sub_sn
+        return self
+
+    def set_timeout(self, timeout: int) -> "Client":
+        self.config.set_timeout(timeout)
+        return self
+
+    def post(self, endpoint: str, biz_content: Dict[str, Any]) -> Dict[str, Any]:
+        """发送 POST 请求"""
+        public_params = self._build_public_params(biz_content)
+        public_params["sign"] = Signer.sign(public_params, self.config.get_private_key())
+
+        url = self.config.get_gateway_url().rstrip("/") + endpoint
+
+        try:
+            response = self.session.post(
+                url,
+                json=public_params,
+                timeout=self.config.get_timeout(),
+            )
+        except requests.RequestException as exc:
+            raise HttpException(f"网络请求异常：{exc}") from exc
+
+        try:
+            response_data = response.json()
+        except ValueError as exc:
+            raise HttpException(
+                "无效的响应格式",
+                response_body=response.text,
+                status_code=response.status_code,
+            ) from exc
+
+        if not isinstance(response_data, dict):
+            raise HttpException(
+                "无效的响应格式",
+                response_body=response_data,
+                status_code=response.status_code,
+            )
+
+        if response.status_code < 200 or response.status_code >= 300:
+            code = response_data.get("code", response.status_code)
+            msg = response_data.get("msg") or f"HTTP {response.status_code}"
+            raise HttpException(
+                f"API 请求失败：{msg}",
+                self._to_int(code, response.status_code),
+                response_data,
+                response.status_code,
+            )
+
+        return response_data
+
+    def _build_public_params(self, biz_content: Dict[str, Any]) -> Dict[str, Any]:
+        """构建公共请求参数"""
+        params = {
+            "appId": self.config.get_app_id(),
+            "requestId": Signer.generate_request_id(),
+            "signType": self.config.get_sign_type(),
+            "timestamp": int(time.time() * 1000),
+            "version": self.config.get_version(),
+            "charset": self.config.get_charset(),
+            "bizContent": json.dumps(biz_content, ensure_ascii=False, separators=(",", ":")),
+        }
+
+        if self.sub_sn:
+            params["subSn"] = self.sub_sn
+
+        return params
+
+    def verify_notify(self, data: Dict[str, Any]) -> bool:
+        """验证回调通知签名"""
+        return Signer.verify(data, self.config.get_platform_public_key())
+
+    def verify_response(self, response: Dict[str, Any]) -> bool:
+        """验证响应签名"""
+        if not isinstance(response, dict) or not response.get("sign"):
+            return False
+        return Signer.verify(response, self.config.get_platform_public_key())
+
+    def is_success(self, response: Dict[str, Any]) -> bool:
+        """提现类接口文档以 0 表示成功，其余接口为 200。"""
+        if not isinstance(response, dict) or "code" not in response:
+            return False
+        try:
+            code = int(response["code"])
+        except (TypeError, ValueError):
+            return False
+        return code in (200, 0)
+
+    def parse_response(self, response: Dict[str, Any], verify_sign: bool = True) -> Dict[str, Any]:
+        """解析业务数据（先判断业务码，成功后再验签）"""
+        if not isinstance(response, dict) or "code" not in response:
+            raise HttpException("无效的响应格式", response_body=response)
+
+        if not self.is_success(response):
+            msg = response.get("msg", "未知错误")
+            raise HttpException(
+                f"API 请求失败：code={response['code']}, msg={msg}",
+                self._to_int(response["code"], 0),
+                response,
+            )
+
+        if verify_sign and not self.verify_response(response):
+            raise HttpException("签名验证失败", response_body=response)
+
+        if isinstance(response.get("data"), str) and response["data"] != "":
+            try:
+                response["data"] = json.loads(response["data"])
+            except ValueError:
+                pass
+
+        return response
+
+    @staticmethod
+    def _to_int(value: Any, default: int) -> int:
+        try:
+            return int(value)
+        except (TypeError, ValueError):
+            return default

threeypay/config.py

@@ -0,0 +1,68 @@
+"""
+配置类
+"""
+
+
+class Config:
+    """3YPay SDK 配置类"""
+    
+    GATEWAY_PROD = "https://openapi.3ypay.com"
+    GATEWAY_TEST = "https://test-openapi.3ypay.com"
+    
+    def __init__(self, app_id: str, private_key: str, platform_public_key: str, sandbox: bool = False):
+        self.app_id = app_id
+        self.private_key = private_key
+        self.platform_public_key = platform_public_key
+        self.sandbox = sandbox
+        self.gateway_url = self.GATEWAY_TEST if sandbox else self.GATEWAY_PROD
+        self.sign_type = "RSA2"
+        self.version = "1.0"
+        self.charset = "UTF-8"
+        self.timeout = 30
+    
+    def get_app_id(self) -> str:
+        return self.app_id
+    
+    def get_private_key(self) -> str:
+        return self.private_key
+    
+    def get_platform_public_key(self) -> str:
+        return self.platform_public_key
+    
+    def get_gateway_url(self) -> str:
+        return self.gateway_url
+    
+    def get_sign_type(self) -> str:
+        return self.sign_type
+    
+    def get_version(self) -> str:
+        return self.version
+    
+    def get_charset(self) -> str:
+        return self.charset
+    
+    def get_timeout(self) -> int:
+        return self.timeout
+
+    def set_timeout(self, timeout: int) -> "Config":
+        self.timeout = timeout
+        return self
+
+    def set_sign_type(self, sign_type: str) -> "Config":
+        self.sign_type = sign_type
+        return self
+
+    def set_version(self, version: str) -> "Config":
+        self.version = version
+        return self
+
+    def set_charset(self, charset: str) -> "Config":
+        self.charset = charset
+        return self
+
+    def set_gateway_url(self, gateway_url: str) -> "Config":
+        self.gateway_url = gateway_url.rstrip("/")
+        return self
+    
+    def is_sandbox(self) -> bool:
+        return self.sandbox

threeypay/exceptions/__init__.py

@@ -0,0 +1,27 @@
+"""
+HTTP 客户端异常
+"""
+
+from typing import Any, Optional
+
+
+class HttpException(Exception):
+    """HTTP / 业务异常类"""
+
+    def __init__(
+        self,
+        message: str,
+        code: int = 0,
+        response_body: Optional[Any] = None,
+        status_code: Optional[int] = None,
+    ):
+        super().__init__(message)
+        self.code = code
+        self.status_code = status_code
+        self.response_body = response_body
+
+
+class InvalidSignException(Exception):
+    """无效签名异常类"""
+
+    pass

threeypay/merchant/__init__.py

@@ -0,0 +1,5 @@
+"""商户模块"""
+
+from threeypay.merchant.merchant import Merchant
+
+__all__ = ["Merchant"]

threeypay/merchant/merchant.py

@@ -0,0 +1,128 @@
+"""
+商户进件与 AUT 类
+"""
+
+import base64
+import mimetypes
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+from threeypay.utils.signer import Signer
+
+
+class Merchant:
+    """商户管理类"""
+
+    API_FILE_UPLOAD = "/mchAccess/mch/fileUp"
+    API_MERCHANT_ACCESS = "/mchAccess/mch/access"
+    API_ACCESS_QUERY = "/mchAccess/mch/query"
+    API_MODIFY_MCH_CARD = "/mchAccess/mch/modify/mchCard"
+    API_MODIFY_PRODUCT = "/mchAccess/mch/modify/product"
+    API_MODIFY_QUERY = "/mchAccess/mch/modify/query"
+    API_AUT_QUERY = "/mchAccess/mch/aut/query"
+    API_AUT_CONFIG = "/mchAccess/mch/aut/config"
+    API_AUT_CONFIG_INFO = "/mchAccess/mch/aut/config/info"
+    API_AUT_SPLIT = "/mchAccess/mch/aut/split"
+
+    def __init__(self, client):
+        self.client = client
+
+    def file_upload(self, params: Dict[str, Any]) -> Dict[str, Any]:
+        """进件文件上传（fileContent 必填，传 Base64；fileName/contentType 可选）"""
+        self._validate_required(params, ["fileContent"])
+        payload = dict(params)
+        content = str(payload["fileContent"])
+        if not Signer.is_base64(content):
+            payload["fileContent"] = base64.b64encode(content.encode("utf-8")).decode("utf-8")
+
+        if not payload.get("contentType") and payload.get("fileName"):
+            payload["contentType"] = self._detect_content_type(str(payload["fileName"]))
+
+        response = self.client.post(self.API_FILE_UPLOAD, payload)
+        return self.client.parse_response(response)
+
+    def file_upload_from_path(self, file_path: str) -> Dict[str, Any]:
+        path = Path(file_path)
+        if not path.is_file():
+            raise ValueError(f"文件不存在或不可读：{file_path}")
+        return self.file_upload({
+            "fileName": path.name,
+            "contentType": self._detect_content_type(str(path)),
+            "fileContent": base64.b64encode(path.read_bytes()).decode("utf-8"),
+        })
+
+    @staticmethod
+    def _detect_content_type(file_name: str) -> str:
+        return mimetypes.guess_type(file_name)[0] or "application/octet-stream"
+
+    def access(self, params: Dict[str, Any]) -> Dict[str, Any]:
+        """商户入网申请（mchAccessNo、mchInfo、mchBusiness、mchCard、products 必填）"""
+        self._validate_required(params, ["mchAccessNo", "mchInfo", "mchBusiness", "mchCard", "products"])
+        response = self.client.post(self.API_MERCHANT_ACCESS, params)
+        return self.client.parse_response(response)
+
+    def query(self, params: Dict[str, Any]) -> Dict[str, Any]:
+        """商户入网信息查询（accessSn、mchAccessNo、requestId 三选一）"""
+        self._validate_one_of(params, ["accessSn", "mchAccessNo", "requestId"])
+        response = self.client.post(self.API_ACCESS_QUERY, params)
+        return self.client.parse_response(response)
+
+    def modify_mch_card(self, params: Dict[str, Any]) -> Dict[str, Any]:
+        """商户结算信息变更（mchModifyNo、mchCard 必填，accessSn/mchAccessNo 二选一）"""
+        self._validate_required(params, ["mchModifyNo", "mchCard"])
+        self._validate_one_of(params, ["accessSn", "mchAccessNo"])
+        response = self.client.post(self.API_MODIFY_MCH_CARD, params)
+        return self.client.parse_response(response)
+
+    def modify_product(self, params: Dict[str, Any]) -> Dict[str, Any]:
+        """商户产品信息变更（mchModifyNo、products 必填，accessSn/mchAccessNo 二选一）"""
+        self._validate_required(params, ["mchModifyNo", "products"])
+        self._validate_one_of(params, ["accessSn", "mchAccessNo"])
+        response = self.client.post(self.API_MODIFY_PRODUCT, params)
+        return self.client.parse_response(response)
+
+    def modify_query(self, params: Dict[str, Any]) -> Dict[str, Any]:
+        """商户信息变更查询（accessSn/mchAccessNo、modifyId/mchModifyNo 分别二选一）"""
+        self._validate_one_of(params, ["accessSn", "mchAccessNo"])
+        self._validate_one_of(params, ["modifyId", "mchModifyNo"])
+        response = self.client.post(self.API_MODIFY_QUERY, params)
+        return self.client.parse_response(response)
+
+    def aut_query(self, params: Dict[str, Any]) -> Dict[str, Any]:
+        """商户 AUT 报备查询（accessSn/mchAccessNo 二选一）"""
+        self._validate_one_of(params, ["accessSn", "mchAccessNo"])
+        response = self.client.post(self.API_AUT_QUERY, params)
+        return self.client.parse_response(response)
+
+    def aut_config(self, params: Dict[str, Any]) -> Dict[str, Any]:
+        """微信支付配置（accessSn/mchAccessNo 二选一，code 必填）"""
+        self._validate_required(params, ["code"])
+        self._validate_one_of(params, ["accessSn", "mchAccessNo"])
+        response = self.client.post(self.API_AUT_CONFIG, params)
+        return self.client.parse_response(response)
+
+    def aut_config_info(self, params: Dict[str, Any]) -> Dict[str, Any]:
+        """微信支付配置查询（accessSn/mchAccessNo 二选一，code 必填）"""
+        self._validate_required(params, ["code"])
+        self._validate_one_of(params, ["accessSn", "mchAccessNo"])
+        response = self.client.post(self.API_AUT_CONFIG_INFO, params)
+        return self.client.parse_response(response)
+
+    def aut_split(self, params: Dict[str, Any]) -> Dict[str, Any]:
+        """商户 AUT 拆分（accessSn/mchAccessNo 二选一）"""
+        self._validate_one_of(params, ["accessSn", "mchAccessNo"])
+        response = self.client.post(self.API_AUT_SPLIT, params)
+        return self.client.parse_response(response)
+
+    @staticmethod
+    def _validate_required(params: Dict[str, Any], fields: List[str]) -> None:
+        for field in fields:
+            if field not in params or params[field] is None or params[field] == "":
+                raise ValueError(f"必填参数不能为空：{field}")
+
+    @staticmethod
+    def _validate_one_of(params: Dict[str, Any], fields: List[str]) -> None:
+        for field in fields:
+            if field in params and params[field] is not None and params[field] != "":
+                return
+        raise ValueError(f"以下参数至少填一个：{', '.join(fields)}")

threeypay/nonmch/__init__.py

@@ -0,0 +1,5 @@
+"""非收单商户模块"""
+
+from threeypay.nonmch.non_mch import NonMch
+
+__all__ = ["NonMch"]