jugs 1.0.0__py3-none-any.whl

jugs/__init__.py

@@ -0,0 +1,43 @@
+from __future__ import annotations
+
+from jugs.client import JugsClient
+from jugs.exceptions import (
+    AuthError,
+    JugsError,
+    NotFoundError,
+    ProxyError,
+    RateLimitError,
+    ValidationError,
+)
+from jugs.models import (
+    ActionResult,
+    ClickResult,
+    Comment,
+    CommentsResult,
+    DiscordMember,
+    DiscordUser,
+    PresenceResult,
+    StatusResult,
+    ViewResult,
+)
+
+__all__ = (
+    "JugsClient",
+    "JugsError",
+    "AuthError",
+    "RateLimitError",
+    "NotFoundError",
+    "ValidationError",
+    "ProxyError",
+    "ViewResult",
+    "StatusResult",
+    "Comment",
+    "CommentsResult",
+    "DiscordUser",
+    "DiscordMember",
+    "PresenceResult",
+    "ClickResult",
+    "ActionResult",
+)
+
+__version__ = "1.0.0"

jugs/auth.py

@@ -0,0 +1,172 @@
+from __future__ import annotations
+
+from typing import Any
+
+import orjson
+
+from jugs.constants import ANON_KEY, BASE_URL, SUPABASE_URL
+from jugs.exceptions import AuthError
+from jugs.http import HTTPSession
+
+
+class AuthManager:
+    __slots__ = ("_http", "_access_token", "_refresh_token", "_user")
+
+    def __init__(self, http: HTTPSession) -> None:
+        self._http = http
+        self._access_token: str | None = None
+        self._refresh_token: str | None = None
+        self._user: dict[str, Any] | None = None
+
+    @property
+    def access_token(self) -> str | None:
+        return self._access_token
+
+    @property
+    def is_authenticated(self) -> bool:
+        return self._access_token is not None
+
+    @property
+    def user(self) -> dict[str, Any] | None:
+        return self._user
+
+    def _supabase_headers(self) -> dict[str, str]:
+        headers = {
+            "apikey": ANON_KEY,
+            "Content-Type": "application/json",
+        }
+
+        if self._access_token:
+            headers["Authorization"] = f"Bearer {self._access_token}"
+
+        return headers
+
+    def login_email(self, email: str, password: str) -> dict[str, Any]:
+        url = f"{SUPABASE_URL}/auth/v1/token?grant_type=password"
+
+        payload = {
+            "email": email,
+            "password": password,
+        }
+
+        resp = self._http.post(
+            url,
+            headers=self._supabase_headers(),
+            json_data=payload,
+        )
+
+        if resp.status_code != 200:
+            raise AuthError(f"Login failed: {resp.status_code} {resp.text}")
+
+        data = orjson.loads(resp.content)
+
+        self._access_token = data.get("access_token")
+        self._refresh_token = data.get("refresh_token")
+        self._user = data.get("user")
+
+        if self._access_token:
+            self._http.set_cookie("sb-access-token", self._access_token)
+
+        return data
+
+    def signup_email(self, email: str, password: str) -> dict[str, Any]:
+        url = f"{SUPABASE_URL}/auth/v1/signup"
+
+        payload = {
+            "email": email,
+            "password": password,
+        }
+
+        resp = self._http.post(
+            url,
+            headers=self._supabase_headers(),
+            json_data=payload,
+        )
+
+        if resp.status_code not in (200, 201):
+            raise AuthError(f"Signup failed: {resp.status_code} {resp.text}")
+
+        data = orjson.loads(resp.content)
+
+        self._access_token = data.get("access_token")
+        self._refresh_token = data.get("refresh_token")
+        self._user = data.get("user") or (data if data.get("id") else None)
+
+        return data
+
+    def refresh(self) -> dict[str, Any]:
+        if not self._refresh_token:
+            raise AuthError("No refresh token available")
+
+        url = f"{SUPABASE_URL}/auth/v1/token?grant_type=refresh_token"
+
+        payload = {
+            "refresh_token": self._refresh_token,
+        }
+
+        resp = self._http.post(
+            url,
+            headers=self._supabase_headers(),
+            json_data=payload,
+        )
+
+        if resp.status_code != 200:
+            raise AuthError(f"Refresh failed: {resp.status_code} {resp.text}")
+
+        data = orjson.loads(resp.content)
+
+        self._access_token = data.get("access_token")
+        self._refresh_token = data.get("refresh_token")
+        self._user = data.get("user")
+
+        return data
+
+    def logout(self) -> None:
+        if not self._access_token:
+            return
+
+        url = f"{SUPABASE_URL}/auth/v1/logout"
+
+        self._http.post(
+            url,
+            headers=self._supabase_headers(),
+        )
+
+        self._access_token = None
+        self._refresh_token = None
+        self._user = None
+        self._http.clear_cookies()
+
+    def load_session(
+        self,
+        access_token: str,
+        refresh_token: str | None = None,
+    ) -> None:
+        self._access_token = access_token
+        self._refresh_token = refresh_token
+        self._http.set_cookie("sb-access-token", access_token)
+
+    def discord_oauth_url(self, redirect_to: str = f"{BASE_URL}/dashboard") -> str:
+        return (
+            f"{SUPABASE_URL}/auth/v1/authorize"
+            f"?provider=discord"
+            f"&redirect_to={redirect_to}"
+        )
+
+    def get_session(self) -> dict[str, Any] | None:
+        if not self._access_token:
+            return None
+
+        url = f"{SUPABASE_URL}/auth/v1/user"
+
+        resp = self._http.get(
+            url,
+            headers=self._supabase_headers(),
+        )
+
+        if resp.status_code != 200:
+            return None
+
+        self._user = orjson.loads(resp.content)
+
+        return self._user

jugs/client.py

@@ -0,0 +1,158 @@
+from __future__ import annotations
+
+from typing import Any, Sequence
+
+from jugs.auth import AuthManager
+from jugs.constants import RESERVED_USERNAMES
+from jugs.endpoints.actions import ActionsAPI
+from jugs.endpoints.discord import DiscordAPI
+from jugs.endpoints.sys import SysAPI
+from jugs.exceptions import ValidationError
+from jugs.http import HTTPSession
+from jugs.models import (
+    ActionResult,
+    ClickResult,
+    CommentsResult,
+    PresenceResult,
+    StatusResult,
+    ViewResult,
+)
+
+
+class JugsClient:
+    __slots__ = (
+        "_http",
+        "_auth",
+        "_sys",
+        "_discord",
+        "_actions",
+        "username",
+    )
+
+    def __init__(
+        self,
+        username: str = "c",
+        *,
+        proxies: Sequence[str] | None = None,
+        timeout: float = 10.0,
+        http2: bool = False,
+    ) -> None:
+        if username.lower() in RESERVED_USERNAMES:
+            raise ValidationError(f"Username '{username}' is reserved")
+
+        self.username = username
+        self._http = HTTPSession(proxies=proxies, timeout=timeout, http2=http2)
+        self._auth = AuthManager(self._http)
+        self._sys = SysAPI(self._http)
+        self._discord = DiscordAPI(self._http)
+        self._actions = ActionsAPI(self._http)
+
+    @property
+    def auth(self) -> AuthManager:
+        return self._auth
+
+    @property
+    def is_authenticated(self) -> bool:
+        return self._auth.is_authenticated
+
+    def view(self, username: str | None = None, *, rotate: bool = False) -> ViewResult:
+        return self._sys.view(username or self.username, rotate=rotate)
+
+    def status(self, username: str | None = None) -> StatusResult:
+        return self._sys.status(username or self.username)
+
+    def likes(self, username: str | None = None) -> StatusResult:
+        return self._sys.likes(username or self.username)
+
+    def click(self, target_url: str, username: str | None = None) -> ClickResult:
+        return self._sys.click(username or self.username, target_url)
+
+    def comments(self, username: str | None = None) -> CommentsResult:
+        return self._sys.comments(username or self.username)
+
+    def post_comment(self, content: str, username: str | None = None) -> dict[str, Any]:
+        return self._sys.post_comment(username or self.username, content)
+
+    def presence(self, discord_id: str) -> PresenceResult:
+        return self._discord.presence(discord_id)
+
+    def audio_proxy(self, audio_url: str) -> bytes:
+        return self._sys.audio_proxy(audio_url)
+
+    def tip(self, payload: list[Any] | None = None) -> ActionResult:
+        return self._actions.tip(payload)
+
+    def claim_drop(self, drop_id: str) -> ActionResult:
+        return self._actions.claim_drop(drop_id)
+
+    def claim_crate(self, crate_id: str) -> ActionResult:
+        return self._actions.claim_crate(crate_id)
+
+    def get_unseen_drops(self) -> ActionResult:
+        return self._actions.get_unseen_drops()
+
+    def get_unseen_crates(self) -> ActionResult:
+        return self._actions.get_unseen_crates()
+
+    def mark_drops_seen(self) -> ActionResult:
+        return self._actions.mark_drops_seen()
+
+    def mark_crates_seen(self) -> ActionResult:
+        return self._actions.mark_crates_seen()
+
+    def bug_check(self) -> dict[str, Any]:
+        return self._sys.bug_check()
+
+    def bug_report(
+        self,
+        title: str,
+        description: str,
+        steps: str,
+        expected: str,
+        actual: str,
+        browser: str = "",
+        device: str = "",
+    ) -> dict[str, Any]:
+        return self._sys.bug_report(
+            title, description, steps, expected, actual, browser, device
+        )
+
+    def suggest_check(self) -> dict[str, Any]:
+        return self._sys.suggest_check()
+
+    def suggest(self, suggestion: str, context: str = "") -> dict[str, Any]:
+        return self._sys.suggest(suggestion, context)
+
+    def login(self, email: str, password: str) -> dict[str, Any]:
+        return self._auth.login_email(email, password)
+
+    def signup(self, email: str, password: str) -> dict[str, Any]:
+        return self._auth.signup_email(email, password)
+
+    def logout(self) -> None:
+        self._auth.logout()
+
+    def load_session(
+        self,
+        access_token: str,
+        refresh_token: str | None = None,
+    ) -> None:
+        self._auth.load_session(access_token, refresh_token)
+
+    def refresh_session(self) -> dict[str, Any]:
+        return self._auth.refresh()
+
+    def discord_oauth_url(self, redirect_to: str | None = None) -> str:
+        if redirect_to is None:
+            return self._auth.discord_oauth_url()
+
+        return self._auth.discord_oauth_url(redirect_to)
+
+    def close(self) -> None:
+        self._http.close()
+
+    def __enter__(self) -> JugsClient:
+        return self
+
+    def __exit__(self, *args: object) -> None:
+        self.close()

jugs/constants.py

@@ -0,0 +1,59 @@
+from __future__ import annotations
+
+BASE_URL: str = "https://www.jugs.lol"
+
+SUPABASE_URL: str = "https://ckenyrstsktunenpsubb.supabase.co"
+
+ANON_KEY: str = (
+    "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9."
+    "eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6ImNrZW55cnN0c2t0dW5lbnBzdWJiIiwicm9sZSI6ImFub24i"
+    "LCJpYXQiOjE3OTE3NzE5ODUsImV4cCI6MjEwNzM0Nzk4NX0."
+    "Ggla0o3HGl54t4nj_8gQ67EJDs9UhKlipfhkIrsxg8I"
+)
+
+DEFAULT_UA: str = (
+    "Mozilla/5.0 (Linux; Android 16; moto g play - 2026) "
+    "AppleWebKit/537.36 (KHTML, like Gecko) "
+    "Chrome/155.0.8059.43 Mobile Safari/537.36"
+)
+
+ACTION_TIP: str = "70111c9a8fae4bad063a0c4c19787ed3a85c2daa18"
+
+ACTION_CLAIM_DROP: str = "40f6997701608f4b9c8cb2f93bf435e26f320c02e9"
+
+ACTION_CLAIM_CRATE: str = "403ac738f0b8e509578fdd36336e1ba090ddd1f2d4"
+
+ACTION_GET_UNSEEN_DROPS: str = "005deb07fb33ea758655b1173a09d7b399321dfdb5"
+
+ACTION_GET_UNSEEN_CRATES: str = "00d777d5d051e684420de77ee2eb388b06c64ad77b"
+
+ACTION_MARK_DROPS_SEEN: str = "4035680f86329d45bf40e27a07881bb193653b9610"
+
+ACTION_MARK_CRATES_SEEN: str = "409baa837993b269490d97013b1c9529a010fcb913"
+
+RESERVED_USERNAMES: frozenset[str] = frozenset(
+    {
+        "login",
+        "signup",
+        "dashboard",
+        "api",
+        "admin",
+        "owner",
+        "auth",
+        "about",
+        "terms",
+        "privacy",
+        "leaderboard",
+        "directory",
+        "discord",
+        "shop",
+        "addons",
+        "claim",
+        "premium",
+        "crates",
+        "reset-password",
+        "account-restricted",
+        "_next",
+        "static",
+    }
+)

jugs/endpoints/__init__.py

@@ -0,0 +1,7 @@
+from __future__ import annotations
+
+from jugs.endpoints.actions import ActionsAPI
+from jugs.endpoints.discord import DiscordAPI
+from jugs.endpoints.sys import SysAPI
+
+__all__ = ("SysAPI", "DiscordAPI", "ActionsAPI")

jugs/endpoints/actions.py

@@ -0,0 +1,89 @@
+from __future__ import annotations
+
+from typing import Any
+
+import orjson
+
+from jugs.constants import (
+    ACTION_CLAIM_CRATE,
+    ACTION_CLAIM_DROP,
+    ACTION_GET_UNSEEN_CRATES,
+    ACTION_GET_UNSEEN_DROPS,
+    ACTION_MARK_CRATES_SEEN,
+    ACTION_MARK_DROPS_SEEN,
+    ACTION_TIP,
+    BASE_URL,
+)
+from jugs.http import HTTPSession
+from jugs.models import ActionResult
+
+
+class ActionsAPI:
+    __slots__ = ("_http",)
+
+    def __init__(self, http: HTTPSession) -> None:
+        self._http = http
+
+    def _call(
+        self,
+        action_id: str,
+        payload: list[Any] | None = None,
+        *,
+        path: str = "/c",
+    ) -> ActionResult:
+        if payload is None:
+            payload = []
+
+        url = f"{BASE_URL}{path}"
+
+        body = orjson.dumps(payload)
+
+        headers = {
+            "Content-Type": "text/plain;charset=UTF-8",
+            "Accept": "text/x-component",
+            "next-action": action_id,
+            "Origin": BASE_URL,
+            "Referer": f"{BASE_URL}{path}",
+        }
+
+        resp = self._http.post(
+            url,
+            headers=headers,
+            content=body,
+        )
+
+        raw = resp.text
+        data: Any = None
+
+        try:
+            lines = raw.strip().split("\n")
+
+            for line in lines:
+                if line.startswith("1:"):
+                    data = orjson.loads(line[2:])
+                    break
+        except Exception:
+            data = raw
+
+        return ActionResult(raw=raw, data=data)
+
+    def tip(self, payload: list[Any] | None = None) -> ActionResult:
+        return self._call(ACTION_TIP, payload)
+
+    def claim_drop(self, drop_id: str) -> ActionResult:
+        return self._call(ACTION_CLAIM_DROP, [drop_id])
+
+    def claim_crate(self, crate_id: str) -> ActionResult:
+        return self._call(ACTION_CLAIM_CRATE, [crate_id])
+
+    def get_unseen_drops(self) -> ActionResult:
+        return self._call(ACTION_GET_UNSEEN_DROPS)
+
+    def get_unseen_crates(self) -> ActionResult:
+        return self._call(ACTION_GET_UNSEEN_CRATES)
+
+    def mark_drops_seen(self) -> ActionResult:
+        return self._call(ACTION_MARK_DROPS_SEEN)
+
+    def mark_crates_seen(self) -> ActionResult:
+        return self._call(ACTION_MARK_CRATES_SEEN)

jugs/endpoints/discord.py

@@ -0,0 +1,63 @@
+from __future__ import annotations
+
+from typing import Any
+
+import orjson
+
+from jugs.constants import BASE_URL
+from jugs.http import HTTPSession
+from jugs.models import DiscordMember, DiscordUser, PresenceResult
+
+
+class DiscordAPI:
+    __slots__ = ("_http",)
+
+    def __init__(self, http: HTTPSession) -> None:
+        self._http = http
+
+    def presence(self, discord_id: str) -> PresenceResult:
+        url = f"{BASE_URL}/api/discord/presence/{discord_id}"
+
+        resp = self._http.get(
+            url,
+            headers={"Referer": BASE_URL},
+        )
+
+        data = orjson.loads(resp.content)
+
+        user_data = data.get("user")
+        member_data = data.get("member")
+
+        user = None
+
+        if user_data:
+            user = DiscordUser(
+                id=str(user_data.get("id") or ""),
+                username=str(user_data.get("username") or ""),
+                global_name=user_data.get("global_name"),
+                avatar_url=user_data.get("avatar_url"),
+                avatar_decoration_url=user_data.get("avatar_decoration_url"),
+            )
+
+        member = None
+
+        if member_data:
+            roles = tuple(str(r) for r in (member_data.get("roles") or []))
+
+            member = DiscordMember(
+                display_name=member_data.get("display_name"),
+                guild_avatar_url=member_data.get("guild_avatar_url"),
+                server_booster=bool(member_data.get("server_booster")),
+                roles=roles,
+            )
+
+        activities = tuple(data.get("activities") or [])
+
+        return PresenceResult(
+            ok=bool(data.get("ok")),
+            joined=bool(data.get("joined")),
+            status=str(data.get("status") or "offline"),
+            activities=activities,
+            user=user,
+            member=member,
+        )

jugs/endpoints/sys.py

@@ -0,0 +1,215 @@
+from __future__ import annotations
+
+from typing import Any
+
+import orjson
+
+from jugs.constants import BASE_URL
+from jugs.exceptions import ValidationError
+from jugs.http import HTTPSession
+from jugs.models import (
+    ClickResult,
+    Comment,
+    CommentsResult,
+    StatusResult,
+    ViewResult,
+)
+
+
+class SysAPI:
+    __slots__ = ("_http",)
+
+    def __init__(self, http: HTTPSession) -> None:
+        self._http = http
+
+    def _headers(self, username: str) -> dict[str, str]:
+        return {
+            "Origin": BASE_URL,
+            "Referer": f"{BASE_URL}/{username}",
+        }
+
+    def view(self, username: str, *, rotate: bool = False) -> ViewResult:
+        url = f"{BASE_URL}/api/sys/v"
+
+        resp = self._http.post(
+            url,
+            headers={**self._headers(username), "Content-Type": "application/json"},
+            json_data={},
+            params={"username": username},
+            rotate=rotate,
+        )
+
+        data = orjson.loads(resp.content)
+
+        return ViewResult(
+            ok=bool(data.get("ok")),
+            counted=bool(data.get("counted")),
+        )
+
+    def status(self, username: str) -> StatusResult:
+        url = f"{BASE_URL}/api/sys/b"
+
+        resp = self._http.get(
+            url,
+            headers=self._headers(username),
+            params={"username": username},
+        )
+
+        data = orjson.loads(resp.content)
+
+        return StatusResult(
+            ok=bool(data.get("ok")),
+            bookmarked=bool(data.get("bookmarked")),
+            liked=bool(data.get("liked")),
+            bookmarks=int(data.get("bookmarks") or 0),
+            likes=int(data.get("likes") or 0),
+        )
+
+    def likes(self, username: str) -> StatusResult:
+        url = f"{BASE_URL}/api/sys/l"
+
+        resp = self._http.get(
+            url,
+            headers=self._headers(username),
+            params={"username": username},
+        )
+
+        data = orjson.loads(resp.content)
+
+        return StatusResult(
+            ok=bool(data.get("ok")),
+            bookmarked=bool(data.get("bookmarked")),
+            liked=bool(data.get("liked")),
+            bookmarks=int(data.get("bookmarks") or 0),
+            likes=int(data.get("likes") or 0),
+        )
+
+    def click(self, username: str, target_url: str) -> ClickResult:
+        url = f"{BASE_URL}/api/sys/click"
+
+        payload = orjson.dumps({"username": username, "url": target_url})
+
+        resp = self._http.post(
+            url,
+            headers={**self._headers(username), "Content-Type": "text/plain"},
+            content=payload,
+        )
+
+        data = orjson.loads(resp.content)
+
+        return ClickResult(ok=bool(data.get("ok")))
+
+    def comments(self, username: str) -> CommentsResult:
+        url = f"{BASE_URL}/api/sys/comments"
+
+        resp = self._http.get(
+            url,
+            headers=self._headers(username),
+            params={"username": username},
+        )
+
+        data = orjson.loads(resp.content)
+
+        raw_comments = data.get("comments") or []
+
+        comments = tuple(
+            Comment(
+                id=str(c.get("id") or ""),
+                author_username=str(c.get("author_username") or ""),
+                author_avatar_url=str(c.get("author_avatar_url") or ""),
+                content=str(c.get("content") or ""),
+                created_at=str(c.get("created_at") or ""),
+            )
+            for c in raw_comments
+        )
+
+        return CommentsResult(
+            ok=bool(data.get("ok")),
+            comments_enabled=bool(data.get("commentsEnabled")),
+            pinned=data.get("pinned"),
+            comments=comments,
+        )
+
+    def post_comment(self, username: str, content: str) -> dict[str, Any]:
+        url = f"{BASE_URL}/api/sys/comments"
+
+        resp = self._http.post(
+            url,
+            headers={**self._headers(username), "Content-Type": "application/json"},
+            json_data={"username": username, "content": content},
+        )
+
+        return orjson.loads(resp.content)
+
+    def audio_proxy(self, audio_url: str) -> bytes:
+        url = f"{BASE_URL}/api/sys/audio-proxy"
+
+        resp = self._http.get(
+            url,
+            params={"url": audio_url},
+        )
+
+        if resp.status_code != 200:
+            raise ValidationError(f"Audio proxy failed: {resp.status_code}")
+
+        return resp.content
+
+    def bug_check(self) -> dict[str, Any]:
+        url = f"{BASE_URL}/api/sys/bug"
+
+        resp = self._http.get(url)
+
+        return orjson.loads(resp.content)
+
+    def bug_report(
+        self,
+        title: str,
+        description: str,
+        steps: str,
+        expected: str,
+        actual: str,
+        browser: str = "",
+        device: str = "",
+    ) -> dict[str, Any]:
+        url = f"{BASE_URL}/api/sys/bug"
+
+        payload = {
+            "title": title,
+            "description": description,
+            "steps": steps,
+            "expected": expected,
+            "actual": actual,
+            "browser": browser,
+            "device": device,
+        }
+
+        resp = self._http.post(
+            url,
+            headers={"Content-Type": "application/json", "Origin": BASE_URL},
+            json_data=payload,
+        )
+
+        return orjson.loads(resp.content)
+
+    def suggest_check(self) -> dict[str, Any]:
+        url = f"{BASE_URL}/api/sys/suggest"
+
+        resp = self._http.get(url)
+
+        return orjson.loads(resp.content)
+
+    def suggest(self, suggestion: str, context: str = "") -> dict[str, Any]:
+        url = f"{BASE_URL}/api/sys/suggest"
+
+        payload = {
+            "suggestion": suggestion,
+            "context": context,
+        }
+
+        resp = self._http.post(
+            url,
+            headers={"Content-Type": "application/json", "Origin": BASE_URL},
+            json_data=payload,
+        )
+
+        return orjson.loads(resp.content)

jugs/exceptions.py

@@ -0,0 +1,29 @@
+from __future__ import annotations
+
+
+class JugsError(Exception):
+    __slots__ = ("message",)
+
+    def __init__(self, message: str) -> None:
+        self.message = message
+        super().__init__(message)
+
+
+class AuthError(JugsError):
+    pass
+
+
+class RateLimitError(JugsError):
+    pass
+
+
+class NotFoundError(JugsError):
+    pass
+
+
+class ValidationError(JugsError):
+    pass
+
+
+class ProxyError(JugsError):
+    pass

jugs/http.py

@@ -0,0 +1,179 @@
+from __future__ import annotations
+
+import itertools
+import random
+from typing import Any, Iterator, Mapping, Sequence
+
+import httpx
+import orjson
+
+from jugs.constants import BASE_URL, DEFAULT_UA
+from jugs.exceptions import ProxyError
+
+
+class ProxyRotator:
+    __slots__ = ("_proxies", "_cycle", "_lock_idx")
+
+    def __init__(self, proxies: Sequence[str] | None = None) -> None:
+        self._proxies: list[str] = list(proxies) if proxies else []
+        self._cycle: Iterator[str] | None = None
+        self._lock_idx: int = 0
+
+        if self._proxies:
+            self._cycle = itertools.cycle(self._proxies)
+
+    def next(self) -> str | None:
+        if not self._cycle:
+            return None
+
+        return next(self._cycle)
+
+    def random(self) -> str | None:
+        if not self._proxies:
+            return None
+
+        return random.choice(self._proxies)
+
+    def __len__(self) -> int:
+        return len(self._proxies)
+
+    def add(self, proxy: str) -> None:
+        self._proxies.append(proxy)
+        self._cycle = itertools.cycle(self._proxies)
+
+
+class HTTPSession:
+    __slots__ = (
+        "_client",
+        "_rotator",
+        "_base_headers",
+        "_timeout",
+    )
+
+    def __init__(
+        self,
+        *,
+        proxies: Sequence[str] | None = None,
+        timeout: float = 10.0,
+        http2: bool = False,
+        follow_redirects: bool = True,
+    ) -> None:
+        self._rotator = ProxyRotator(proxies)
+        self._timeout = timeout
+        self._base_headers: dict[str, str] = {
+            "User-Agent": DEFAULT_UA,
+            "Accept": "*/*",
+            "Accept-Language": "en-US,en;q=0.9",
+        }
+
+        proxy = self._rotator.next()
+
+        self._client = httpx.Client(
+            http2=http2,
+            timeout=timeout,
+            follow_redirects=follow_redirects,
+            proxy=proxy,
+            headers=self._base_headers,
+        )
+
+    def _rotate(self) -> None:
+        proxy = self._rotator.next()
+
+        if proxy is None:
+            return
+
+        cookies = self._client.cookies
+        self._client.close()
+
+        self._client = httpx.Client(
+            http2=False,
+            timeout=self._timeout,
+            follow_redirects=True,
+            proxy=proxy,
+            headers=self._base_headers,
+            cookies=cookies,
+        )
+
+    def request(
+        self,
+        method: str,
+        url: str,
+        *,
+        headers: Mapping[str, str] | None = None,
+        content: bytes | None = None,
+        json_data: Any = None,
+        params: Mapping[str, str] | None = None,
+        rotate: bool = False,
+    ) -> httpx.Response:
+        if rotate and self._rotator:
+            self._rotate()
+
+        req_headers = dict(self._base_headers)
+
+        if headers:
+            req_headers.update(headers)
+
+        body: bytes | None = content
+
+        if json_data is not None:
+            body = orjson.dumps(json_data)
+            req_headers.setdefault("Content-Type", "application/json")
+
+        try:
+            return self._client.request(
+                method,
+                url,
+                headers=req_headers,
+                content=body,
+                params=params,
+            )
+        except httpx.ProxyError as exc:
+            raise ProxyError(str(exc)) from exc
+
+    def get(
+        self,
+        url: str,
+        *,
+        headers: Mapping[str, str] | None = None,
+        params: Mapping[str, str] | None = None,
+        rotate: bool = False,
+    ) -> httpx.Response:
+        return self.request("GET", url, headers=headers, params=params, rotate=rotate)
+
+    def post(
+        self,
+        url: str,
+        *,
+        headers: Mapping[str, str] | None = None,
+        content: bytes | None = None,
+        json_data: Any = None,
+        params: Mapping[str, str] | None = None,
+        rotate: bool = False,
+    ) -> httpx.Response:
+        return self.request(
+            "POST",
+            url,
+            headers=headers,
+            content=content,
+            json_data=json_data,
+            params=params,
+            rotate=rotate,
+        )
+
+    def set_cookie(self, name: str, value: str, domain: str = "www.jugs.lol") -> None:
+        self._client.cookies.set(name, value, domain=domain)
+
+    def get_cookies(self) -> httpx.Cookies:
+        return self._client.cookies
+
+    def clear_cookies(self) -> None:
+        self._client.cookies.clear()
+
+    def close(self) -> None:
+        self._client.close()
+
+    def __enter__(self) -> HTTPSession:
+        return self
+
+    def __exit__(self, *args: object) -> None:
+        self.close()

jugs/models.py

@@ -0,0 +1,74 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+
+@dataclass(slots=True, frozen=True)
+class ViewResult:
+    ok: bool
+    counted: bool
+
+
+@dataclass(slots=True, frozen=True)
+class StatusResult:
+    ok: bool
+    bookmarked: bool
+    liked: bool
+    bookmarks: int
+    likes: int
+
+
+@dataclass(slots=True, frozen=True)
+class Comment:
+    id: str
+    author_username: str
+    author_avatar_url: str
+    content: str
+    created_at: str
+
+
+@dataclass(slots=True, frozen=True)
+class CommentsResult:
+    ok: bool
+    comments_enabled: bool
+    pinned: Any
+    comments: tuple[Comment, ...]
+
+
+@dataclass(slots=True, frozen=True)
+class DiscordUser:
+    id: str
+    username: str
+    global_name: str | None
+    avatar_url: str | None
+    avatar_decoration_url: str | None
+
+
+@dataclass(slots=True, frozen=True)
+class DiscordMember:
+    display_name: str | None
+    guild_avatar_url: str | None
+    server_booster: bool
+    roles: tuple[str, ...]
+
+
+@dataclass(slots=True, frozen=True)
+class PresenceResult:
+    ok: bool
+    joined: bool
+    status: str
+    activities: tuple[dict[str, Any], ...]
+    user: DiscordUser | None
+    member: DiscordMember | None
+
+
+@dataclass(slots=True, frozen=True)
+class ClickResult:
+    ok: bool
+
+
+@dataclass(slots=True, frozen=True)
+class ActionResult:
+    raw: str
+    data: Any

jugs-1.0.0.dist-info/METADATA

@@ -0,0 +1,10 @@
+Metadata-Version: 2.5
+Name: jugs
+Version: 1.0.0
+Summary: High-performance Python client for jugs.lol
+Requires-Python: >=3.10
+Requires-Dist: httpx[http2]>=0.27.0
+Requires-Dist: orjson>=3.10.0
+Provides-Extra: dev
+Requires-Dist: pytest; extra == 'dev'
+Requires-Dist: pytest-asyncio; extra == 'dev'

jugs-1.0.0.dist-info/RECORD

@@ -0,0 +1,14 @@
+jugs/__init__.py,sha256=vrQQezHzTDJf6DWFNGRtFOllHCEezj-4LCNe3r1S1WI,745
+jugs/auth.py,sha256=q0_2voJlVtCrUkn0lgE6HuTkcZBOWRax_rqGnfzGOuk,4636
+jugs/client.py,sha256=cx6vTisZRHiWj1bpg0lBJn3SglDKFnyCqOu1U_rNwVc,4839
+jugs/constants.py,sha256=2p08gIK6dRvIA1dhygOW3cSjWSzGnj8iEV9m1Vnj_xE,1566
+jugs/exceptions.py,sha256=k5VeincwB2rZivCqdKaqPHTzKYh94PQfIAqQwkBZ0vA,417
+jugs/http.py,sha256=Ins0LoSfwm3j-7FDz2IzLy-GbETUKg79WsqQOUgHxMU,4580
+jugs/models.py,sha256=CE_p9vRBB9WZHRopAbGX-9QSKUfl--DySO3xHNlMvw0,1345
+jugs/endpoints/__init__.py,sha256=REU8O3wbb4X-9OuLZA86tDuJyfXa0J9m5-tvH6G4_Lg,216
+jugs/endpoints/actions.py,sha256=qcl0tqU81YNTJa5caoLMSJoXq7nF5rCPWJIMJyy77dw,2238
+jugs/endpoints/discord.py,sha256=yj94-ZomI0auvntS09s5Tna-CQi2mpJurPFvSzixdGc,1811
+jugs/endpoints/sys.py,sha256=Oek0WVUm_tSnqgwsog3Janw4f4XSAn8iLLAK9XKrrZk,5844
+jugs-1.0.0.dist-info/METADATA,sha256=OHQ74R72k-vcxCKOiWSWvkRYHYlDOPae434qu40NQwI,295
+jugs-1.0.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+jugs-1.0.0.dist-info/RECORD,,

jugs-1.0.0.dist-info/WHEEL

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