owlproxy-sdk 0.1.0__py3-none-any.whl

owlproxy/__init__.py

@@ -0,0 +1,20 @@
+from .client import Client, OwlProxyClient
+from .exceptions import (
+    OwlProxyAPIError,
+    OwlProxyDecodeError,
+    OwlProxyError,
+    OwlProxyHTTPError,
+    OwlProxyTransportError,
+)
+
+__all__ = [
+    "Client",
+    "OwlProxyAPIError",
+    "OwlProxyClient",
+    "OwlProxyDecodeError",
+    "OwlProxyError",
+    "OwlProxyHTTPError",
+    "OwlProxyTransportError",
+]
+
+__version__ = "0.1.0"

owlproxy/client.py

@@ -0,0 +1,133 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any
+
+import requests
+from requests import Response, Session
+
+from .exceptions import (
+    OwlProxyAPIError,
+    OwlProxyDecodeError,
+    OwlProxyHTTPError,
+    OwlProxyTransportError,
+)
+from .resources import DynamicAPI, StaticIPAPI
+
+
+class OwlProxyClient:
+    """Client for OwlProxy's token-authenticated web API."""
+
+    def __init__(
+        self,
+        site_token: str,
+        *,
+        user_id: str | int | None = None,
+        base_url: str = "https://api.owlproxy.com",
+        origin: str = "https://proxy.owlproxy.com",
+        app_version: str = "2007800",
+        client_type: str = "web",
+        request_source: str = "wechat-miniapp",
+        supplier_type: str = "0",
+        timeout: float | tuple[float, float] = 30.0,
+        session: Session | None = None,
+        raise_for_api_errors: bool = True,
+    ) -> None:
+        if not site_token or not isinstance(site_token, str):
+            raise ValueError("site_token must be a non-empty string")
+        self.site_token = site_token
+        self.user_id = str(user_id) if user_id is not None else None
+        self.base_url = base_url.rstrip("/")
+        self.origin = origin.rstrip("/")
+        self.app_version = app_version
+        self.client_type = client_type
+        self.request_source = request_source
+        self.supplier_type = supplier_type
+        self.timeout = timeout
+        self.raise_for_api_errors = raise_for_api_errors
+        self.session = session or requests.Session()
+        self.static = StaticIPAPI(self)
+        self.dynamic = DynamicAPI(self)
+
+    def _headers(self, extra: Mapping[str, str] | None = None) -> dict[str, str]:
+        headers = {
+            "Accept": "application/json, text/plain, */*",
+            "Content-Type": "application/json",
+            "Origin": self.origin,
+            "Referer": f"{self.origin}/",
+            "User-Agent": "owlproxy-python/0.1.0",
+            "appversion": self.app_version,
+            "clienttype": self.client_type,
+            "requestsource": self.request_source,
+            "suppliertype": self.supplier_type,
+            "token": self.site_token,
+        }
+        if self.user_id is not None:
+            headers["userid"] = self.user_id
+        if extra:
+            headers.update(extra)
+        return headers
+
+    def _url(self, path: str) -> str:
+        return f"{self.base_url}/owlproxy/api/{path.lstrip('/')}"
+
+    def request(
+        self,
+        method: str,
+        path: str,
+        *,
+        params: Mapping[str, Any] | None = None,
+        json: Any = None,
+        headers: Mapping[str, str] | None = None,
+        timeout: float | tuple[float, float] | None = None,
+    ) -> Any:
+        query = {key: value for key, value in (params or {}).items() if value is not None}
+        try:
+            response = self.session.request(
+                method.upper(),
+                self._url(path),
+                params=query,
+                json=json,
+                headers=self._headers(headers),
+                timeout=self.timeout if timeout is None else timeout,
+            )
+        except requests.RequestException as exc:
+            raise OwlProxyTransportError(str(exc), cause=exc) from exc
+        body = self._decode(response)
+        if not response.ok:
+            raise OwlProxyHTTPError(
+                response.status_code,
+                response.reason or "request failed",
+                response=response,
+                body=body,
+            )
+        if (
+            self.raise_for_api_errors
+            and isinstance(body, Mapping)
+            and body.get("code") not in (None, 200, "200")
+        ):
+            raise OwlProxyAPIError(
+                body.get("code"),
+                str(body.get("msg", "request failed")),
+                data=body.get("data"),
+                response=response,
+            )
+        return body
+
+    def get(self, path: str, **params: Any) -> Any:
+        return self.request("GET", path, params=params)
+
+    def post(self, path: str, json: Any = None, **params: Any) -> Any:
+        return self.request("POST", path, params=params or None, json=json)
+
+    def _decode(self, response: Response) -> Any:
+        try:
+            return response.json()
+        except ValueError as exc:
+            raise OwlProxyDecodeError(
+                "OwlProxy returned a non-JSON response",
+                response=response,
+            ) from exc
+
+
+Client = OwlProxyClient

owlproxy/exceptions.py

@@ -0,0 +1,50 @@
+from __future__ import annotations
+
+from typing import Any
+
+
+class OwlProxyError(Exception):
+    pass
+
+
+class OwlProxyTransportError(OwlProxyError):
+    def __init__(self, message: str, *, cause: Exception | None = None) -> None:
+        super().__init__(message)
+        self.cause = cause
+
+
+class OwlProxyHTTPError(OwlProxyError):
+    def __init__(
+        self,
+        status_code: int,
+        message: str,
+        *,
+        response: Any = None,
+        body: Any = None,
+    ) -> None:
+        super().__init__(f"HTTP {status_code}: {message}")
+        self.status_code = status_code
+        self.response = response
+        self.body = body
+
+
+class OwlProxyAPIError(OwlProxyError):
+    def __init__(
+        self,
+        code: int | str | None,
+        message: str,
+        *,
+        data: Any = None,
+        response: Any = None,
+    ) -> None:
+        super().__init__(f"OwlProxy API error {code}: {message}")
+        self.code = code
+        self.message = message
+        self.data = data
+        self.response = response
+
+
+class OwlProxyDecodeError(OwlProxyError):
+    def __init__(self, message: str, *, response: Any = None) -> None:
+        super().__init__(message)
+        self.response = response

owlproxy/resources.py

@@ -0,0 +1,201 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from .client import OwlProxyClient
+
+
+class StaticIPAPI:
+    def __init__(self, client: OwlProxyClient) -> None:
+        self._client = client
+
+    def proxy_types(self, proxy_mode: int | None = None) -> Any:
+        return self._client.get("vcProxyShop/getProxyTypeList", proxyMode=proxy_mode)
+
+    def countries(self, proxy_type: int) -> Any:
+        return self._client.get("vcProxyGood/getProxyCountry", proxyType=proxy_type)
+
+    def quality_options(self, proxy_type: int) -> Any:
+        return self._client.get("vcProxyGood/proxyIdType", proxyType=proxy_type)
+
+    def providers(self, country_code: str, proxy_type: int | str, proxy_id_type: str) -> Any:
+        return self._client.post("vcProxyShop/getProxyShopList", {
+            "countryCode": country_code,
+            "proxyType": proxy_type,
+            "proxyIdType": proxy_id_type,
+        })
+
+    def packages(
+        self,
+        proxy_shop_id: int,
+        country_code: str,
+        proxy_type: int,
+        proxy_id_type: str,
+    ) -> Any:
+        return self._client.get(
+            "vcProxyGood/proxyGoodList",
+            proxyShopId=proxy_shop_id,
+            countryCode=country_code,
+            proxyType=proxy_type,
+            proxyIdType=proxy_id_type,
+        )
+
+    def create_order(
+        self,
+        proxy_good_id: int,
+        num: int,
+        country: str,
+        proxy_shop_id: int,
+        auto_renew: bool = False,
+        back_url: str | None = None,
+    ) -> Any:
+        body = {
+            "proxyGoodId": proxy_good_id,
+            "num": num,
+            "country": country,
+            "proxyShopId": proxy_shop_id,
+            "autoRenew": auto_renew,
+        }
+        if back_url is not None:
+            body["backUrl"] = back_url
+        return self._client.post("vcProxyGood/createProxyOrder", body)
+
+    def ip_info(self, order_ids: str | list[str]) -> Any:
+        if isinstance(order_ids, str):
+            order_ids = [order_ids]
+        return self._client.post("vcProxy/queryByorderIdList", {"orderIds": order_ids})
+
+    def list(
+        self,
+        current: int = 1,
+        size: int = 20,
+        proxy_name: str = "",
+        proxy_buy_status_id: int | str = "",
+        group_id_list: list[int] | None = None,
+    ) -> Any:
+        body = {
+            "current": current,
+            "size": size,
+            "proxyName": proxy_name,
+            "proxyBuyStatusId": proxy_buy_status_id,
+        }
+        if group_id_list is not None:
+            body["groupIdList"] = group_id_list
+        return self._client.post("vcProxy/queryList", body)
+
+    def update_name(self, proxy_id: int, proxy_name: str) -> Any:
+        return self._client.get(
+            "vcProxy/updateProxyName",
+            proxyName=proxy_name,
+            proxyId=proxy_id,
+        )
+
+    def renew(
+        self,
+        proxy_good_id: int,
+        proxy_shop_id: int,
+        proxy_ips: str | list[str],
+        back_url: str | None = None,
+    ) -> Any:
+        body = {
+            "proxyGoodId": proxy_good_id,
+            "proxyShopId": proxy_shop_id,
+            "proxyIps": ",".join(proxy_ips) if isinstance(proxy_ips, list) else proxy_ips,
+        }
+        if back_url is not None:
+            body["backurl"] = back_url
+        return self._client.post("vcProxyGood/createRenewProxyOrder", body)
+
+    def calculate_renew_price(self, proxy_ips: list[str], renewal_days: int) -> Any:
+        return self._client.post("vcProxy/batchCalculateRenewPrice", {
+            "proxyIps": proxy_ips,
+            "renewalDays": renewal_days,
+        })
+
+    def set_auto_renew(self, proxy_id: int, auto_renew: bool) -> Any:
+        return self._client.post("vcProxy/autoRenewClose", {
+            "proxyId": proxy_id,
+            "autoRenew": auto_renew,
+        })
+
+    def orders(
+        self,
+        page: int = 1,
+        rows: int = 20,
+        complete_start_time: str | None = None,
+        complete_end_time: str | None = None,
+    ) -> Any:
+        body = {"page": page, "rows": rows}
+        if complete_start_time is not None:
+            body["completeStartTime"] = complete_start_time
+        if complete_end_time is not None:
+            body["completeEndTime"] = complete_end_time
+        return self._client.post("vcProxyOrder/selectProxyOrderList", body)
+
+
+class DynamicAPI:
+    def __init__(self, client: OwlProxyClient) -> None:
+        self._client = client
+
+    def traffic_balance(self) -> Any:
+        return self._client.get("vcDynamicGood/queryCurrentTrafficBalance")
+
+    def packages(self) -> Any:
+        return self._client.get("vcDynamicGood/getDynamicGoodService")
+
+    def create_order(self, good_id: int, good_num: int = 1, auto_renew_order: int = 0) -> Any:
+        return self._client.post("vcDynamicGood/buyDynamicProxy", {
+            "goodId": good_id,
+            "goodNum": good_num,
+            "autoRenewOrder": auto_renew_order,
+        })
+
+    def regions(self) -> Any:
+        return self._client.get("vcDynamicGood/getDynamicProxyRegion")
+
+    def lines(self, region: str | None = None) -> Any:
+        params = {"region": region} if region is not None else {}
+        return self._client.get("vcDynamicGood/getDynamicProxyHost", **params)
+
+    def extract(
+        self,
+        country_code: str,
+        state: str,
+        city: str,
+        proxy_host: str,
+        proxy_type: str,
+        time: int,
+        good_num: int = 1,
+    ) -> Any:
+        return self._client.post("vcDynamicGood/createProxy", {
+            "countryCode": country_code,
+            "state": state,
+            "city": city,
+            "proxyHost": proxy_host,
+            "proxyType": proxy_type,
+            "time": time,
+            "goodNum": good_num,
+        })
+
+    def automatic_renewal(self) -> Any:
+        return self._client.get("vcDynamicGood/getDynamicProxyAutomaticRenewal")
+
+    def set_auto_renew(self, auto_renew_order: int | bool) -> Any:
+        return self._client.post("vcDynamicGood/setAutoRenewSwitch", {
+            "autoRenewOrder": int(auto_renew_order),
+        })
+
+    def orders(
+        self,
+        page: int = 1,
+        rows: int = 20,
+        complete_start_time: str | None = None,
+        complete_end_time: str | None = None,
+    ) -> Any:
+        body = {"page": page, "rows": rows}
+        if complete_start_time is not None:
+            body["completeStartTime"] = complete_start_time
+        if complete_end_time is not None:
+            body["completeEndTime"] = complete_end_time
+        return self._client.post("vcDynamicGood/getDynamicProxyOrders", body)

owlproxy/types.py

@@ -0,0 +1,10 @@
+from __future__ import annotations
+
+from collections.abc import Mapping, Sequence
+from typing import Any, Union
+
+JsonPrimitive = Union[str, int, float, bool, None]
+JsonValue = Union[JsonPrimitive, list["JsonValue"], dict[str, "JsonValue"]]
+JsonObject = dict[str, JsonValue]
+Params = Mapping[str, Any]
+OrderIds = Union[str, Sequence[str]]

owlproxy_sdk-0.1.0.dist-info/METADATA

@@ -0,0 +1,256 @@
+Metadata-Version: 2.4
+Name: owlproxy-sdk
+Version: 0.1.0
+Summary: Python client for OwlProxy's token-authenticated site API
+Project-URL: Documentation, https://www.owlproxy.com/owlproxy/doc/zh/server/OpenAPI.html
+Project-URL: Homepage, https://www.owlproxy.com/
+Author: OwlProxy Python contributors
+License: MIT License
+        
+        Copyright (c) 2026 OwlProxy Python contributors
+        
+        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.
+License-File: LICENSE
+Keywords: api,owlproxy,proxy,sdk
+Classifier: Development Status :: 3 - Alpha
+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: Typing :: Typed
+Requires-Python: >=3.10
+Requires-Dist: requests<3,>=2.31
+Provides-Extra: dev
+Requires-Dist: build>=1.2; extra == 'dev'
+Requires-Dist: hatch>=1.12; extra == 'dev'
+Requires-Dist: pytest-cov>=5; extra == 'dev'
+Requires-Dist: pytest>=8; extra == 'dev'
+Requires-Dist: ruff>=0.9; extra == 'dev'
+Requires-Dist: twine>=5; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# OwlProxy Python
+
+A typed Python client for OwlProxy's token-authenticated site API. It adapts every callable endpoint in OwlProxy's public OpenAPI documentation to the equivalent working site route by removing the `openApi/` path segment and authenticating with a site token.
+
+This is an unofficial library. OwlProxy's site API is not the same stability contract as its documented HMAC OpenAPI and may change without notice.
+
+## Installation
+
+```bash
+pip install owlproxy
+```
+
+For local development:
+
+```bash
+git clone <repository-url>
+cd owlproxy
+python -m pip install -e '.[dev]'
+```
+
+## Authentication
+
+Create a client with the `token` header value used by `proxy.owlproxy.com`:
+
+```python
+import os
+
+from owlproxy import OwlProxyClient
+
+client = OwlProxyClient(os.environ["OWLPROXY_SITE_TOKEN"])
+```
+
+A user ID can be supplied if an account or endpoint requires it:
+
+```python
+client = OwlProxyClient(
+    os.environ["OWLPROXY_SITE_TOKEN"],
+    user_id=os.environ.get("OWLPROXY_USER_ID"),
+)
+```
+
+Never commit site tokens. A token grants access to account data and purchasing or renewal actions.
+
+## Response and error behavior
+
+Methods return OwlProxy's decoded JSON response:
+
+```python
+response = client.static.list()
+records = response["data"]["records"]
+```
+
+By default, a JSON response whose `code` is not `200` raises `OwlProxyAPIError`. HTTP, transport, and decoding failures raise dedicated exception classes:
+
+```python
+from owlproxy import OwlProxyAPIError, OwlProxyError
+
+try:
+    client.dynamic.traffic_balance()
+except OwlProxyAPIError as error:
+    print(error.code, error.message)
+except OwlProxyError as error:
+    print(error)
+```
+
+Set `raise_for_api_errors=False` to receive non-200 API responses directly.
+
+## Static IP API
+
+```python
+client.static.proxy_types(proxy_mode=1)
+client.static.countries(proxy_type=4)
+client.static.quality_options(proxy_type=4)
+client.static.providers("US", proxy_type=4, proxy_id_type="ord")
+client.static.packages(2, "US", proxy_type=4, proxy_id_type="ord")
+```
+
+List proxies:
+
+```python
+response = client.static.list(
+    current=1,
+    size=20,
+    proxy_name="",
+    proxy_buy_status_id="",
+    group_id_list=[],
+)
+```
+
+Find a proxy and disable automatic renewal:
+
+```python
+response = client.static.list(size=100, proxy_name="62.132.16.64")
+proxy = next(
+    item
+    for item in response["data"]["records"]
+    if item["proxyHost"] == "62.132.16.64"
+)
+client.static.set_auto_renew(proxy["proxyId"], False)
+```
+
+Purchase and order information:
+
+```python
+client.static.create_order(
+    proxy_good_id=1,
+    num=1,
+    country="US",
+    proxy_shop_id=1,
+    auto_renew=False,
+    back_url="https://example.com/owlproxy/callback",
+)
+client.static.ip_info(["Owl-PROXY123"])
+client.static.orders(page=1, rows=20)
+```
+
+Maintenance:
+
+```python
+client.static.update_name(proxy_id=93847, proxy_name="production")
+client.static.calculate_renew_price(["192.0.2.10"], renewal_days=30)
+client.static.renew(
+    proxy_good_id=1,
+    proxy_shop_id=1,
+    proxy_ips="192.0.2.10",
+    back_url="https://example.com/owlproxy/callback",
+)
+```
+
+## Dynamic proxy API
+
+```python
+client.dynamic.traffic_balance()
+client.dynamic.packages()
+client.dynamic.regions()
+client.dynamic.lines()
+client.dynamic.automatic_renewal()
+client.dynamic.orders(page=1, rows=20)
+```
+
+Purchase, extract, and renewal settings:
+
+```python
+client.dynamic.create_order(good_id=1, good_num=1, auto_renew_order=0)
+client.dynamic.extract(
+    country_code="AE",
+    state="Sharjah",
+    city="Sharjahcity",
+    proxy_host="change4.owlproxy.com:7778",
+    proxy_type="socks5",
+    time=5,
+    good_num=1,
+)
+client.dynamic.set_auto_renew(False)
+```
+
+## Complete endpoint mapping
+
+| Library method | Site route | Documented OpenAPI route |
+|---|---|---|
+| `static.proxy_types` | `GET /owlproxy/api/vcProxyShop/getProxyTypeList` | `GET /owlproxy/api/openApi/vcProxyShop/getProxyTypeList` |
+| `static.countries` | `GET /owlproxy/api/vcProxyGood/getProxyCountry` | `GET /owlproxy/api/openApi/vcProxyGood/getProxyCountry` |
+| `static.quality_options` | `GET /owlproxy/api/vcProxyGood/proxyIdType` | `GET /owlproxy/api/openApi/vcProxyGood/proxyIdType` |
+| `static.providers` | `POST /owlproxy/api/vcProxyShop/getProxyShopList` | `POST /owlproxy/api/openApi/vcProxyShop/getProxyShopList` |
+| `static.packages` | `GET /owlproxy/api/vcProxyGood/proxyGoodList` | `GET /owlproxy/api/openApi/vcProxyGood/proxyGoodList` |
+| `static.create_order` | `POST /owlproxy/api/vcProxyGood/createProxyOrder` | `POST /owlproxy/api/openApi/vcProxyGood/createProxyOrder` |
+| `static.ip_info` | `POST /owlproxy/api/vcProxy/queryByorderIdList` | `POST /owlproxy/api/openApi/vcProxy/queryByorderIdList` |
+| `static.list` | `POST /owlproxy/api/vcProxy/queryList` | `POST /owlproxy/api/openApi/vcProxy/queryList` |
+| `static.update_name` | `GET /owlproxy/api/vcProxy/updateProxyName` | `GET /owlproxy/api/openApi/vcProxy/updateProxyName` |
+| `static.renew` | `POST /owlproxy/api/vcProxyGood/createRenewProxyOrder` | `POST /owlproxy/api/openApi/vcProxyGood/createRenewProxyOrder` |
+| `static.calculate_renew_price` | `POST /owlproxy/api/vcProxy/batchCalculateRenewPrice` | `POST /owlproxy/api/openApi/vcProxy/batchCalculateRenewPrice` |
+| `static.set_auto_renew` | `POST /owlproxy/api/vcProxy/autoRenewClose` | `POST /owlproxy/api/openApi/vcProxy/autoRenewClose` |
+| `static.orders` | `POST /owlproxy/api/vcProxyOrder/selectProxyOrderList` | `POST /owlproxy/api/openApi/vcProxyOrder/selectProxyOrderList` |
+| `dynamic.traffic_balance` | `GET /owlproxy/api/vcDynamicGood/queryCurrentTrafficBalance` | `GET /owlproxy/api/openApi/vcDynamicGood/queryCurrentTrafficBalance` |
+| `dynamic.packages` | `GET /owlproxy/api/vcDynamicGood/getDynamicGoodService` | `GET /owlproxy/api/openApi/vcDynamicGood/getDynamicGoodService` |
+| `dynamic.create_order` | `POST /owlproxy/api/vcDynamicGood/buyDynamicProxy` | `POST /owlproxy/api/openApi/vcDynamicGood/buyDynamicProxy` |
+| `dynamic.regions` | `GET /owlproxy/api/vcDynamicGood/getDynamicProxyRegion` | `GET /owlproxy/api/openApi/vcDynamicGood/getDynamicProxyRegion` |
+| `dynamic.lines` | `GET /owlproxy/api/vcDynamicGood/getDynamicProxyHost` | `GET /owlproxy/api/openApi/vcDynamicGood/getDynamicProxyHost` |
+| `dynamic.extract` | `POST /owlproxy/api/vcDynamicGood/createProxy` | `POST /owlproxy/api/openApi/vcDynamicGood/createProxy` |
+| `dynamic.automatic_renewal` | `GET /owlproxy/api/vcDynamicGood/getDynamicProxyAutomaticRenewal` | `GET /owlproxy/api/openApi/vcDynamicGood/getDynamicProxyAutomaticRenewal` |
+| `dynamic.set_auto_renew` | `POST /owlproxy/api/vcDynamicGood/setAutoRenewSwitch` | `POST /owlproxy/api/openApi/vcDynamicGood/setAutoRenewSwitch` |
+| `dynamic.orders` | `POST /owlproxy/api/vcDynamicGood/getDynamicProxyOrders` | `POST /owlproxy/api/openApi/vcDynamicGood/getDynamicProxyOrders` |
+
+The payment callback is inbound rather than an OwlProxy request, so it is documented but is not a client method.
+
+## Raw requests
+
+New or undocumented site endpoints can be called without waiting for a release:
+
+```python
+client.get("vcDynamicGood/getDynamicGoodService")
+client.post("vcProxy/queryList", {"current": 1, "size": 20})
+client.request("POST", "some/path", json={"key": "value"})
+```
+
+## Publishing
+
+```bash
+python -m pytest
+python -m build
+python -m twine check dist/*
+python -m twine upload dist/*
+```
+
+Verify that the `owlproxy` package name is available on PyPI before publishing. Change `project.name` if it is already owned by another publisher.

owlproxy_sdk-0.1.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+owlproxy/__init__.py,sha256=aIzLOtFSjIsmdVoWyblKSHUugS3YMoxHvHDW9e_-32g,389
+owlproxy/client.py,sha256=by41FCBPx2SqhudmkFujvB1QTsccdYxjgsU1UkoK9ZE,4517
+owlproxy/exceptions.py,sha256=MTGHKYF0EgTITA0mOmpbnmOCUEKDpXAKK6cac3Acdmo,1222
+owlproxy/resources.py,sha256=IatqLT7WBhH2wSTLhJhDudDKVYFRaOg9BKV6idZTge0,6630
+owlproxy/types.py,sha256=3EZqYfGnrmxJn0Sn3mjSfOW1Sia6QtmENjBk5lQhlic,338
+owlproxy_sdk-0.1.0.dist-info/METADATA,sha256=nNvhwJvT54dy_B3avSNEyITkVxhddws4Ynk52mBjSMM,9932
+owlproxy_sdk-0.1.0.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
+owlproxy_sdk-0.1.0.dist-info/licenses/LICENSE,sha256=vLax0gWH_rR6A2XHHJc0EvjyYvrE_s0VxAs4S6ZVWGE,1085
+owlproxy_sdk-0.1.0.dist-info/RECORD,,

owlproxy_sdk-0.1.0.dist-info/WHEEL

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

owlproxy_sdk-0.1.0.dist-info/licenses/LICENSE

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