petchr 1.0.0__tar.gz

petchr-1.0.0/LICENSE

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

petchr-1.0.0/PKG-INFO

@@ -0,0 +1,145 @@
+Metadata-Version: 2.4
+Name: petchr
+Version: 1.0.0
+Summary: A zero-dependency HTTP client for Python with retry, timeout, and rate-limiting
+Author: eritrouib
+License: MIT
+Project-URL: Homepage, https://github.com/eritrouib/petchr-py
+Project-URL: Repository, https://github.com/eritrouib/petchr-py
+Project-URL: Issues, https://github.com/eritrouib/petchr-py/issues
+Keywords: http,client,retry,timeout,rate-limit,requests,httpx
+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.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 :: Internet :: WWW/HTTP
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# petchr
+
+A zero-dependency HTTP client for Python with retry, timeout, and rate-limiting built in.
+
+```bash
+pip install petchr
+```
+
+> **Requires Python 3.9+**
+
+---
+
+## Why petchr?
+
+`requests` is great but has no built-in retry or rate-limiting. `httpx` is modern but requires extra packages for resilience. `petchr` wraps Python's built-in `urllib` with everything you need — zero dependencies.
+
+| Feature | urllib | requests | **petchr** |
+|---|---|---|---|
+| Zero dependencies | ✅ | ❌ | ✅ |
+| Auto-retry w/ backoff | ❌ | ❌ | ✅ |
+| Timeout | ✅ | ✅ | ✅ |
+| Rate limiting | ❌ | ❌ | ✅ |
+| JSON body shorthand | ❌ | ✅ | ✅ |
+| Query params object | ❌ | ✅ | ✅ |
+| Shared instance config | ❌ | ✅ | ✅ |
+
+---
+
+## Quick Start
+
+```python
+from petchr import petch
+
+resp = petch("https://api.example.com/users/1")
+print(resp.data)  # parsed JSON
+```
+
+---
+
+## Instance API
+
+```python
+from petchr import Petchr
+
+api = Petchr(
+    base_url="https://api.example.com",
+    headers={"Authorization": f"Bearer {token}"},
+    timeout=10.0,
+    retry=3,
+)
+
+user = api.get("/users/1")
+post = api.post("/posts", json={"title": "Hello"})
+api.delete("/posts/123")
+```
+
+---
+
+## Retry
+
+```python
+resp = petch("https://api.example.com/data",
+    retry=5,
+    retry_delay=1.0,       # initial delay in seconds
+    retry_backoff=2.0,     # exponential multiplier
+    retry_max_delay=30.0,  # cap
+    retry_on={429, 503},   # status codes to retry
+    on_retry=lambda attempt, err, resp: print(f"Retry {attempt}"),
+)
+```
+
+---
+
+## Timeout
+
+```python
+from petchr import PetchrTimeoutError
+
+try:
+    resp = petch("https://slow-api.example.com", timeout=5.0)
+except PetchrTimeoutError as e:
+    print(f"Timed out after {e.timeout}s")
+```
+
+---
+
+## Rate Limiting
+
+```python
+from petchr import Petchr, RateLimiter
+
+api = Petchr(
+    base_url="https://api.example.com",
+    rate_limiter=RateLimiter(max_requests=10, window_seconds=1.0),
+)
+```
+
+---
+
+## Error Handling
+
+```python
+from petchr import petch, PetchrError, PetchrTimeoutError, PetchrRateLimitError
+
+try:
+    resp = petch("https://api.example.com/users/1")
+except PetchrTimeoutError as e:
+    print(f"Timed out after {e.timeout}s")
+except PetchrRateLimitError as e:
+    print(f"Rate limited. Retry after {e.retry_after}s")
+except PetchrError as e:
+    print(f"HTTP {e.status_code}: {e}")
+```
+
+---
+
+## License
+
+MIT

petchr-1.0.0/README.md

@@ -0,0 +1,119 @@
+# petchr
+
+A zero-dependency HTTP client for Python with retry, timeout, and rate-limiting built in.
+
+```bash
+pip install petchr
+```
+
+> **Requires Python 3.9+**
+
+---
+
+## Why petchr?
+
+`requests` is great but has no built-in retry or rate-limiting. `httpx` is modern but requires extra packages for resilience. `petchr` wraps Python's built-in `urllib` with everything you need — zero dependencies.
+
+| Feature | urllib | requests | **petchr** |
+|---|---|---|---|
+| Zero dependencies | ✅ | ❌ | ✅ |
+| Auto-retry w/ backoff | ❌ | ❌ | ✅ |
+| Timeout | ✅ | ✅ | ✅ |
+| Rate limiting | ❌ | ❌ | ✅ |
+| JSON body shorthand | ❌ | ✅ | ✅ |
+| Query params object | ❌ | ✅ | ✅ |
+| Shared instance config | ❌ | ✅ | ✅ |
+
+---
+
+## Quick Start
+
+```python
+from petchr import petch
+
+resp = petch("https://api.example.com/users/1")
+print(resp.data)  # parsed JSON
+```
+
+---
+
+## Instance API
+
+```python
+from petchr import Petchr
+
+api = Petchr(
+    base_url="https://api.example.com",
+    headers={"Authorization": f"Bearer {token}"},
+    timeout=10.0,
+    retry=3,
+)
+
+user = api.get("/users/1")
+post = api.post("/posts", json={"title": "Hello"})
+api.delete("/posts/123")
+```
+
+---
+
+## Retry
+
+```python
+resp = petch("https://api.example.com/data",
+    retry=5,
+    retry_delay=1.0,       # initial delay in seconds
+    retry_backoff=2.0,     # exponential multiplier
+    retry_max_delay=30.0,  # cap
+    retry_on={429, 503},   # status codes to retry
+    on_retry=lambda attempt, err, resp: print(f"Retry {attempt}"),
+)
+```
+
+---
+
+## Timeout
+
+```python
+from petchr import PetchrTimeoutError
+
+try:
+    resp = petch("https://slow-api.example.com", timeout=5.0)
+except PetchrTimeoutError as e:
+    print(f"Timed out after {e.timeout}s")
+```
+
+---
+
+## Rate Limiting
+
+```python
+from petchr import Petchr, RateLimiter
+
+api = Petchr(
+    base_url="https://api.example.com",
+    rate_limiter=RateLimiter(max_requests=10, window_seconds=1.0),
+)
+```
+
+---
+
+## Error Handling
+
+```python
+from petchr import petch, PetchrError, PetchrTimeoutError, PetchrRateLimitError
+
+try:
+    resp = petch("https://api.example.com/users/1")
+except PetchrTimeoutError as e:
+    print(f"Timed out after {e.timeout}s")
+except PetchrRateLimitError as e:
+    print(f"Rate limited. Retry after {e.retry_after}s")
+except PetchrError as e:
+    print(f"HTTP {e.status_code}: {e}")
+```
+
+---
+
+## License
+
+MIT

petchr-1.0.0/pyproject.toml

@@ -0,0 +1,34 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "petchr"
+version = "1.0.0"
+description = "A zero-dependency HTTP client for Python with retry, timeout, and rate-limiting"
+readme = "README.md"
+license = { text = "MIT" }
+authors = [{ name = "eritrouib" }]
+requires-python = ">=3.9"
+keywords = ["http", "client", "retry", "timeout", "rate-limit", "requests", "httpx"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Internet :: WWW/HTTP",
+    "Topic :: Software Development :: Libraries",
+]
+
+[project.urls]
+Homepage = "https://github.com/eritrouib/petchr-py"
+Repository = "https://github.com/eritrouib/petchr-py"
+Issues = "https://github.com/eritrouib/petchr-py/issues"
+
+[tool.setuptools.packages.find]
+where = ["src"]

petchr-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

petchr-1.0.0/src/petchr/__init__.py

@@ -0,0 +1,15 @@
+from .client import Petchr, PetchrResponse, petch
+from .exceptions import PetchrError, PetchrRateLimitError, PetchrTimeoutError
+from .rate_limiter import RateLimiter
+
+__all__ = [
+    "petch",
+    "Petchr",
+    "PetchrResponse",
+    "PetchrError",
+    "PetchrTimeoutError",
+    "PetchrRateLimitError",
+    "RateLimiter",
+]
+
+__version__ = "1.0.0"

petchr-1.0.0/src/petchr/client.py

@@ -0,0 +1,224 @@
+from __future__ import annotations
+
+import json as _json
+import random
+import time
+import urllib.error
+import urllib.parse
+import urllib.request
+from typing import Any, Callable
+
+from .exceptions import PetchrError, PetchrTimeoutError
+from .rate_limiter import RateLimiter
+
+DEFAULT_RETRY_ON = {429, 502, 503, 504}
+
+
+def _backoff(attempt: int, delay: float, backoff: float, max_delay: float) -> float:
+    raw = delay * (backoff ** (attempt - 1))
+    jitter = raw * 0.2 * (random.random() * 2 - 1)
+    return min(raw + jitter, max_delay)
+
+
+def petch(
+    url: str,
+    *,
+    method: str = "GET",
+    base_url: str | None = None,
+    params: dict[str, Any] | None = None,
+    json: Any = None,
+    data: bytes | None = None,
+    headers: dict[str, str] | None = None,
+    timeout: float = 30.0,
+    # Retry
+    retry: int = 3,
+    retry_delay: float = 0.5,
+    retry_backoff: float = 2.0,
+    retry_max_delay: float = 10.0,
+    retry_on: set[int] | None = None,
+    should_retry: Callable[[int, int], bool] | None = None,
+    # Rate limiting
+    rate_limiter: RateLimiter | None = None,
+    # Hooks
+    on_request: Callable[[str, dict], None] | None = None,
+    on_response: Callable[[urllib.request.Request, Any], None] | None = None,
+    on_retry: Callable[[int, Exception | None, Any], None] | None = None,
+) -> "PetchrResponse":
+    """Make an HTTP request with retry, timeout, and rate-limiting."""
+
+    if rate_limiter:
+        rate_limiter.wait()
+
+    # Build URL
+    if base_url:
+        url = urllib.parse.urljoin(base_url, url)
+    if params:
+        filtered = {k: str(v) for k, v in params.items() if v is not None}
+        url = f"{url}?{urllib.parse.urlencode(filtered)}"
+
+    # Build headers
+    req_headers = headers.copy() if headers else {}
+    body = data
+
+    if json is not None:
+        body = _json.dumps(json).encode()
+        req_headers.setdefault("Content-Type", "application/json")
+
+    _retry_on = retry_on if retry_on is not None else DEFAULT_RETRY_ON
+    max_attempts = retry + 1
+
+    last_error: Exception | None = None
+
+    for attempt in range(1, max_attempts + 1):
+        if on_request:
+            on_request(url, {"method": method, "headers": req_headers})
+
+        req = urllib.request.Request(url, data=body, headers=req_headers, method=method)
+
+        try:
+            with urllib.request.urlopen(req, timeout=timeout) as resp:
+                raw = resp.read()
+                content_type = resp.headers.get_content_type()
+
+                if "json" in content_type:
+                    response_data = _json.loads(raw)
+                else:
+                    response_data = raw.decode(resp.headers.get_content_charset("utf-8"))
+
+                result = PetchrResponse(
+                    data=response_data,
+                    status_code=resp.status,
+                    headers=dict(resp.headers),
+                    url=resp.url,
+                )
+
+                if on_response:
+                    on_response(req, result)
+
+                return result
+
+        except urllib.error.HTTPError as e:
+            status = e.code
+
+            if status in _retry_on and attempt < max_attempts:
+                do_retry = should_retry(status, attempt) if should_retry else True
+                if do_retry:
+                    last_error = PetchrError(
+                        f"Request failed with status {status}",
+                        status_code=status,
+                        attempt=attempt,
+                    )
+                    if on_retry:
+                        on_retry(attempt, last_error, None)
+                    time.sleep(_backoff(attempt, retry_delay, retry_backoff, retry_max_delay))
+                    continue
+
+            raise PetchrError(
+                f"Request failed with status {status}",
+                status_code=status,
+                attempt=attempt,
+            ) from e
+
+        except TimeoutError as e:
+            raise PetchrTimeoutError(timeout) from e
+
+        except urllib.error.URLError as e:
+            if "timed out" in str(e.reason).lower():
+                raise PetchrTimeoutError(timeout) from e
+
+            if attempt < max_attempts:
+                last_error = PetchrError(str(e), attempt=attempt)
+                if on_retry:
+                    on_retry(attempt, last_error, None)
+                time.sleep(_backoff(attempt, retry_delay, retry_backoff, retry_max_delay))
+                continue
+
+            raise PetchrError(str(e), attempt=attempt) from e
+
+    raise last_error or PetchrError("Request failed after all retry attempts")
+
+
+class PetchrResponse:
+    """Parsed HTTP response."""
+
+    def __init__(self, data: Any, status_code: int, headers: dict, url: str):
+        self.data = data
+        self.status_code = status_code
+        self.headers = headers
+        self.url = url
+
+    def __repr__(self):
+        return f"<PetchrResponse [{self.status_code}]>"
+
+
+class Petchr:
+    """
+    A configured petchr client instance.
+
+    Example:
+        api = Petchr(base_url="https://api.example.com", headers={"Authorization": "Bearer token"})
+        response = api.get("/users/1")
+    """
+
+    def __init__(
+        self,
+        base_url: str | None = None,
+        headers: dict[str, str] | None = None,
+        timeout: float = 30.0,
+        retry: int = 3,
+        retry_delay: float = 0.5,
+        retry_backoff: float = 2.0,
+        retry_max_delay: float = 10.0,
+        retry_on: set[int] | None = None,
+        rate_limiter: RateLimiter | None = None,
+        on_request: Callable | None = None,
+        on_response: Callable | None = None,
+        on_retry: Callable | None = None,
+    ):
+        self.base_url = base_url
+        self.headers = headers or {}
+        self.timeout = timeout
+        self.retry = retry
+        self.retry_delay = retry_delay
+        self.retry_backoff = retry_backoff
+        self.retry_max_delay = retry_max_delay
+        self.retry_on = retry_on
+        self.rate_limiter = rate_limiter
+        self.on_request = on_request
+        self.on_response = on_response
+        self.on_retry = on_retry
+
+    def request(self, method: str, url: str, **kwargs) -> PetchrResponse:
+        merged_headers = {**self.headers, **kwargs.pop("headers", {})}
+        return petch(
+            url,
+            method=method,
+            base_url=kwargs.pop("base_url", self.base_url),
+            headers=merged_headers,
+            timeout=kwargs.pop("timeout", self.timeout),
+            retry=kwargs.pop("retry", self.retry),
+            retry_delay=kwargs.pop("retry_delay", self.retry_delay),
+            retry_backoff=kwargs.pop("retry_backoff", self.retry_backoff),
+            retry_max_delay=kwargs.pop("retry_max_delay", self.retry_max_delay),
+            retry_on=kwargs.pop("retry_on", self.retry_on),
+            rate_limiter=kwargs.pop("rate_limiter", self.rate_limiter),
+            on_request=kwargs.pop("on_request", self.on_request),
+            on_response=kwargs.pop("on_response", self.on_response),
+            on_retry=kwargs.pop("on_retry", self.on_retry),
+            **kwargs,
+        )
+
+    def get(self, url: str, **kwargs) -> PetchrResponse:
+        return self.request("GET", url, **kwargs)
+
+    def post(self, url: str, **kwargs) -> PetchrResponse:
+        return self.request("POST", url, **kwargs)
+
+    def put(self, url: str, **kwargs) -> PetchrResponse:
+        return self.request("PUT", url, **kwargs)
+
+    def patch(self, url: str, **kwargs) -> PetchrResponse:
+        return self.request("PATCH", url, **kwargs)
+
+    def delete(self, url: str, **kwargs) -> PetchrResponse:
+        return self.request("DELETE", url, **kwargs)

petchr-1.0.0/src/petchr/exceptions.py

@@ -0,0 +1,25 @@
+class PetchrError(Exception):
+    """Base exception for petchr."""
+
+    def __init__(self, message: str, status_code=None, response=None, attempt=None):
+        super().__init__(message)
+        self.status_code = status_code
+        self.response = response
+        self.attempt = attempt
+
+
+class PetchrTimeoutError(PetchrError):
+    """Raised when a request times out."""
+
+    def __init__(self, timeout: float):
+        super().__init__(f"Request timed out after {timeout}s")
+        self.timeout = timeout
+
+
+class PetchrRateLimitError(PetchrError):
+    """Raised when client-side rate limit is exceeded."""
+
+    def __init__(self, retry_after: float):
+        super().__init__(f"Rate limit exceeded. Retry after {retry_after:.2f}s")
+        self.retry_after = retry_after
+        self.status_code = 429

petchr-1.0.0/src/petchr/rate_limiter.py

@@ -0,0 +1,36 @@
+import time
+from .exceptions import PetchrRateLimitError
+
+
+class RateLimiter:
+    """Sliding window rate limiter."""
+
+    def __init__(self, max_requests: int, window_seconds: float = 1.0):
+        self.max_requests = max_requests
+        self.window_seconds = window_seconds
+        self._requests: list[float] = []
+
+    def _clean(self):
+        now = time.monotonic()
+        self._requests = [t for t in self._requests if now - t < self.window_seconds]
+
+    def throttle(self):
+        """Raise PetchrRateLimitError if rate limit exceeded."""
+        self._clean()
+        if len(self._requests) >= self.max_requests:
+            oldest = self._requests[0]
+            retry_after = self.window_seconds - (time.monotonic() - oldest)
+            raise PetchrRateLimitError(retry_after)
+        self._requests.append(time.monotonic())
+
+    def wait(self):
+        """Block until a request slot is available."""
+        while True:
+            self._clean()
+            if len(self._requests) < self.max_requests:
+                self._requests.append(time.monotonic())
+                return
+            oldest = self._requests[0]
+            wait_time = self.window_seconds - (time.monotonic() - oldest)
+            if wait_time > 0:
+                time.sleep(wait_time)

petchr-1.0.0/src/petchr.egg-info/PKG-INFO

@@ -0,0 +1,145 @@
+Metadata-Version: 2.4
+Name: petchr
+Version: 1.0.0
+Summary: A zero-dependency HTTP client for Python with retry, timeout, and rate-limiting
+Author: eritrouib
+License: MIT
+Project-URL: Homepage, https://github.com/eritrouib/petchr-py
+Project-URL: Repository, https://github.com/eritrouib/petchr-py
+Project-URL: Issues, https://github.com/eritrouib/petchr-py/issues
+Keywords: http,client,retry,timeout,rate-limit,requests,httpx
+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.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 :: Internet :: WWW/HTTP
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# petchr
+
+A zero-dependency HTTP client for Python with retry, timeout, and rate-limiting built in.
+
+```bash
+pip install petchr
+```
+
+> **Requires Python 3.9+**
+
+---
+
+## Why petchr?
+
+`requests` is great but has no built-in retry or rate-limiting. `httpx` is modern but requires extra packages for resilience. `petchr` wraps Python's built-in `urllib` with everything you need — zero dependencies.
+
+| Feature | urllib | requests | **petchr** |
+|---|---|---|---|
+| Zero dependencies | ✅ | ❌ | ✅ |
+| Auto-retry w/ backoff | ❌ | ❌ | ✅ |
+| Timeout | ✅ | ✅ | ✅ |
+| Rate limiting | ❌ | ❌ | ✅ |
+| JSON body shorthand | ❌ | ✅ | ✅ |
+| Query params object | ❌ | ✅ | ✅ |
+| Shared instance config | ❌ | ✅ | ✅ |
+
+---
+
+## Quick Start
+
+```python
+from petchr import petch
+
+resp = petch("https://api.example.com/users/1")
+print(resp.data)  # parsed JSON
+```
+
+---
+
+## Instance API
+
+```python
+from petchr import Petchr
+
+api = Petchr(
+    base_url="https://api.example.com",
+    headers={"Authorization": f"Bearer {token}"},
+    timeout=10.0,
+    retry=3,
+)
+
+user = api.get("/users/1")
+post = api.post("/posts", json={"title": "Hello"})
+api.delete("/posts/123")
+```
+
+---
+
+## Retry
+
+```python
+resp = petch("https://api.example.com/data",
+    retry=5,
+    retry_delay=1.0,       # initial delay in seconds
+    retry_backoff=2.0,     # exponential multiplier
+    retry_max_delay=30.0,  # cap
+    retry_on={429, 503},   # status codes to retry
+    on_retry=lambda attempt, err, resp: print(f"Retry {attempt}"),
+)
+```
+
+---
+
+## Timeout
+
+```python
+from petchr import PetchrTimeoutError
+
+try:
+    resp = petch("https://slow-api.example.com", timeout=5.0)
+except PetchrTimeoutError as e:
+    print(f"Timed out after {e.timeout}s")
+```
+
+---
+
+## Rate Limiting
+
+```python
+from petchr import Petchr, RateLimiter
+
+api = Petchr(
+    base_url="https://api.example.com",
+    rate_limiter=RateLimiter(max_requests=10, window_seconds=1.0),
+)
+```
+
+---
+
+## Error Handling
+
+```python
+from petchr import petch, PetchrError, PetchrTimeoutError, PetchrRateLimitError
+
+try:
+    resp = petch("https://api.example.com/users/1")
+except PetchrTimeoutError as e:
+    print(f"Timed out after {e.timeout}s")
+except PetchrRateLimitError as e:
+    print(f"Rate limited. Retry after {e.retry_after}s")
+except PetchrError as e:
+    print(f"HTTP {e.status_code}: {e}")
+```
+
+---
+
+## License
+
+MIT

petchr-1.0.0/src/petchr.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+LICENSE
+README.md
+pyproject.toml
+src/petchr/__init__.py
+src/petchr/client.py
+src/petchr/exceptions.py
+src/petchr/rate_limiter.py
+src/petchr.egg-info/PKG-INFO
+src/petchr.egg-info/SOURCES.txt
+src/petchr.egg-info/dependency_links.txt
+src/petchr.egg-info/top_level.txt
+tests/test_petchr.py

petchr-1.0.0/src/petchr.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

petchr-1.0.0/src/petchr.egg-info/top_level.txt

@@ -0,0 +1 @@
+petchr

petchr-1.0.0/tests/test_petchr.py

@@ -0,0 +1,171 @@
+import json
+import urllib.error
+from io import BytesIO
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+from petchr import Petchr, PetchrError, PetchrTimeoutError, RateLimiter, petch
+
+
+def make_response(body, status=200, content_type="application/json"):
+    resp = MagicMock()
+    resp.status = status
+    resp.url = "https://example.com/api"
+    resp.read.return_value = json.dumps(body).encode() if isinstance(body, dict) else body.encode()
+    resp.headers.get_content_type.return_value = content_type
+    resp.headers.get_content_charset.return_value = "utf-8"
+    resp.headers.__iter__ = MagicMock(return_value=iter([]))
+    resp.__enter__ = lambda s: s
+    resp.__exit__ = MagicMock(return_value=False)
+    return resp
+
+
+class TestPetch:
+    @patch("urllib.request.urlopen")
+    def test_basic_get(self, mock_urlopen):
+        mock_urlopen.return_value = make_response({"hello": "world"})
+        resp = petch("https://example.com/api", retry=0)
+        assert resp.data == {"hello": "world"}
+        assert resp.status_code == 200
+
+    @patch("urllib.request.urlopen")
+    def test_json_body_sets_content_type(self, mock_urlopen):
+        mock_urlopen.return_value = make_response({"ok": True})
+        petch("https://example.com/api", method="POST", json={"name": "test"}, retry=0)
+        req = mock_urlopen.call_args[0][0]
+        assert req.get_header("Content-type") == "application/json"
+        assert json.loads(req.data) == {"name": "test"}
+
+    @patch("urllib.request.urlopen")
+    def test_params_appended_to_url(self, mock_urlopen):
+        mock_urlopen.return_value = make_response({})
+        petch("https://example.com/api", params={"page": 1, "q": "hello", "empty": None}, retry=0)
+        url = mock_urlopen.call_args[0][0].full_url
+        assert "page=1" in url
+        assert "q=hello" in url
+        assert "empty" not in url
+
+    @patch("urllib.request.urlopen")
+    def test_base_url(self, mock_urlopen):
+        mock_urlopen.return_value = make_response({})
+        petch("/users", base_url="https://api.example.com", retry=0)
+        url = mock_urlopen.call_args[0][0].full_url
+        assert url.startswith("https://api.example.com/users")
+
+    @patch("urllib.request.urlopen")
+    def test_text_response(self, mock_urlopen):
+        resp = make_response("hello plain", content_type="text/plain")
+        mock_urlopen.return_value = resp
+        result = petch("https://example.com/text", retry=0)
+        assert result.data == "hello plain"
+
+    @patch("urllib.request.urlopen")
+    def test_raises_on_http_error(self, mock_urlopen):
+        mock_urlopen.side_effect = urllib.error.HTTPError(
+            url="https://example.com", code=404, msg="Not Found", hdrs=None, fp=None
+        )
+        with pytest.raises(PetchrError) as exc:
+            petch("https://example.com/api", retry=0)
+        assert exc.value.status_code == 404
+
+
+class TestRetry:
+    @patch("petchr.client.time.sleep")
+    @patch("urllib.request.urlopen")
+    def test_retries_on_503(self, mock_urlopen, mock_sleep):
+        mock_urlopen.side_effect = [
+            urllib.error.HTTPError(url="", code=503, msg="", hdrs=None, fp=None),
+            urllib.error.HTTPError(url="", code=503, msg="", hdrs=None, fp=None),
+            make_response({"ok": True}),
+        ]
+        resp = petch("https://example.com/api", retry=3, retry_delay=0.01)
+        assert resp.data == {"ok": True}
+        assert mock_urlopen.call_count == 3
+
+    @patch("petchr.client.time.sleep")
+    @patch("urllib.request.urlopen")
+    def test_raises_after_exhausting_retries(self, mock_urlopen, mock_sleep):
+        mock_urlopen.side_effect = urllib.error.HTTPError(
+            url="", code=503, msg="", hdrs=None, fp=None
+        )
+        with pytest.raises(PetchrError):
+            petch("https://example.com/api", retry=2, retry_delay=0.01)
+        assert mock_urlopen.call_count == 3
+
+    @patch("petchr.client.time.sleep")
+    @patch("urllib.request.urlopen")
+    def test_on_retry_called(self, mock_urlopen, mock_sleep):
+        mock_urlopen.side_effect = [
+            urllib.error.HTTPError(url="", code=503, msg="", hdrs=None, fp=None),
+            make_response({"ok": True}),
+        ]
+        on_retry = MagicMock()
+        petch("https://example.com/api", retry=2, retry_delay=0.01, on_retry=on_retry)
+        assert on_retry.call_count == 1
+
+    @patch("urllib.request.urlopen")
+    def test_no_retry_on_404(self, mock_urlopen):
+        mock_urlopen.side_effect = urllib.error.HTTPError(
+            url="", code=404, msg="", hdrs=None, fp=None
+        )
+        with pytest.raises(PetchrError) as exc:
+            petch("https://example.com/api", retry=3)
+        assert mock_urlopen.call_count == 1
+        assert exc.value.status_code == 404
+
+
+class TestTimeout:
+    @patch("urllib.request.urlopen")
+    def test_raises_timeout_error(self, mock_urlopen):
+        mock_urlopen.side_effect = urllib.error.URLError("timed out")
+        with pytest.raises(PetchrTimeoutError):
+            petch("https://example.com/api", timeout=1, retry=0)
+
+
+class TestPetchrClient:
+    @patch("urllib.request.urlopen")
+    def test_instance_with_defaults(self, mock_urlopen):
+        mock_urlopen.return_value = make_response({"id": 1})
+        api = Petchr(
+            base_url="https://api.example.com",
+            headers={"Authorization": "Bearer token"},
+            retry=0,
+        )
+        api.get("/users/1")
+        req = mock_urlopen.call_args[0][0]
+        assert "api.example.com/users/1" in req.full_url
+        assert req.get_header("Authorization") == "Bearer token"
+
+    @patch("urllib.request.urlopen")
+    def test_merges_headers(self, mock_urlopen):
+        mock_urlopen.return_value = make_response({})
+        api = Petchr(headers={"Authorization": "Bearer token"}, retry=0)
+        api.get("https://example.com/api", headers={"X-Custom": "yes"})
+        req = mock_urlopen.call_args[0][0]
+        assert req.get_header("Authorization") == "Bearer token"
+        assert req.get_header("X-custom") == "yes"
+
+    @patch("urllib.request.urlopen")
+    def test_convenience_methods(self, mock_urlopen):
+        for method in ["get", "post", "put", "patch", "delete"]:
+            mock_urlopen.return_value = make_response({})
+            api = Petchr(retry=0)
+            getattr(api, method)("https://example.com/api")
+            req = mock_urlopen.call_args[0][0]
+            assert req.method == method.upper()
+
+
+class TestRateLimiter:
+    def test_allows_requests_within_limit(self):
+        limiter = RateLimiter(max_requests=5, window_seconds=1.0)
+        for _ in range(5):
+            limiter.throttle()
+
+    def test_raises_when_limit_exceeded(self):
+        from petchr import PetchrRateLimitError
+        limiter = RateLimiter(max_requests=2, window_seconds=1.0)
+        limiter.throttle()
+        limiter.throttle()
+        with pytest.raises(PetchrRateLimitError):
+            limiter.throttle()