ogu-api 0.1.0__py3-none-any.whl

ogu_api/__init__.py

@@ -0,0 +1,59 @@
+from __future__ import annotations
+
+from importlib.metadata import PackageNotFoundError, version as _package_version
+
+from ._http import HttpClient, HttpClientConfig
+from .client import OguClient
+from .errors import (
+    OguAPIError,
+    OguAuthenticationError,
+    OguAuthorizationError,
+    OguCreditsError,
+    OguError,
+    OguLoginError,
+    OguNetworkError,
+    OguNotFoundError,
+    OguParseError,
+    OguRateLimitError,
+    OguReputationError,
+    OguServerError,
+    OguSessionError,
+    OguTimeoutError,
+    OguValidationError,
+)
+from .models import ActionResult, Message, RecentTransaction, ReputationPage, UserProfile
+from .proxy import Proxy
+
+try:
+    __version__ = _package_version('ogu-api')
+
+except PackageNotFoundError:
+    __version__ = '0.0.0+unknown'
+
+__all__ = [
+    '__version__',
+    'OguClient',
+    'HttpClient',
+    'HttpClientConfig',
+    'Proxy',
+    'ActionResult',
+    'Message',
+    'RecentTransaction',
+    'ReputationPage',
+    'UserProfile',
+    'OguError',
+    'OguAPIError',
+    'OguAuthenticationError',
+    'OguAuthorizationError',
+    'OguNotFoundError',
+    'OguValidationError',
+    'OguRateLimitError',
+    'OguServerError',
+    'OguNetworkError',
+    'OguTimeoutError',
+    'OguParseError',
+    'OguSessionError',
+    'OguLoginError',
+    'OguReputationError',
+    'OguCreditsError',
+]

ogu_api/_http.py

@@ -0,0 +1,338 @@
+from __future__ import annotations
+
+import asyncio
+import logging
+from dataclasses import dataclass, field
+from typing import Any, Mapping, MutableMapping
+
+import tls_client
+import tls_client.response
+
+from .errors import (
+    OguAPIError,
+    OguAuthenticationError,
+    OguAuthorizationError,
+    OguNetworkError,
+    OguNotFoundError,
+    OguRateLimitError,
+    OguServerError,
+    OguTimeoutError,
+    OguValidationError,
+)
+from .proxy import Proxy
+
+__all__ = [
+    'HttpClientConfig',
+    'HttpClient',
+]
+
+
+logger = logging.getLogger(__name__)
+
+
+DEFAULT_BASE_URL = 'https://oguser.com'
+
+DEFAULT_TIMEOUT_SECONDS = 30.0
+
+DEFAULT_RETRIES = 0
+
+DEFAULT_RETRY_BACKOFF_SECONDS = 0.5
+
+DEFAULT_CLIENT_IDENTIFIER = 'chrome131'
+
+DEFAULT_HEADERS: Mapping[str, str] = {
+    'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
+    'Accept-Encoding': 'gzip, deflate, br, zstd',
+    'Accept-Language': 'en-US,en;q=0.5',
+    'Connection': 'keep-alive',
+    'Host': 'oguser.com',
+    'Priority': 'u=0, i',
+    'Referer': 'https://oguser.com/',
+    'Sec-Fetch-Dest': 'document',
+    'Sec-Fetch-Mode': 'navigate',
+    'Sec-Fetch-Site': 'same-origin',
+    'Sec-Fetch-User': '?1',
+    'Sec-GPC': '1',
+    'TE': 'trailers',
+    'Upgrade-Insecure-Requests': '1',
+    'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:140.0) Gecko/20100101 Firefox/140.0',
+}
+
+RETRYABLE_STATUS_CODES: frozenset[int] = frozenset({429, 500, 502, 503, 504})
+
+
+@dataclass(frozen = True)
+class HttpClientConfig:
+    base_url: str = DEFAULT_BASE_URL
+    timeout_seconds: float = DEFAULT_TIMEOUT_SECONDS
+    max_retries: int = DEFAULT_RETRIES
+    retry_backoff_seconds: float = DEFAULT_RETRY_BACKOFF_SECONDS
+    client_identifier: str = DEFAULT_CLIENT_IDENTIFIER
+    default_headers: Mapping[str, str] = field(default_factory = lambda: dict(DEFAULT_HEADERS))
+
+
+class HttpClient:
+    def __init__(
+        self,
+        *,
+        proxy: str | None = None,
+        config: HttpClientConfig | None = None,
+        session: tls_client.Session | None = None,
+    ) -> None:
+        self._config: HttpClientConfig = config or HttpClientConfig()
+        self._proxy: Proxy = Proxy(proxy)
+        self._session: tls_client.Session = session or self._create_session(
+            self._proxy,
+            client_identifier = self._config.client_identifier,
+        )
+        self._owns_session: bool = session is None
+
+        self._session.cookies.set('ogumybbuser', '1')
+        self._session.cookies.set('oguloginattempts', '1')
+
+    async def __aenter__(self) -> HttpClient:
+        return self
+
+    async def __aexit__(self, exc_type: Any, exc: Any, tb: Any) -> None:
+        self.close()
+
+    def close(self) -> None:
+        if self._owns_session:
+            close = getattr(self._session, 'close', None)
+            if callable(close):
+                close()
+
+    @property
+    def session(self) -> tls_client.Session:
+        return self._session
+
+    @property
+    def cookies(self) -> Any:
+        return self._session.cookies
+
+    @property
+    def base_url(self) -> str:
+        return self._config.base_url
+
+    async def get(
+        self,
+        path: str,
+        *,
+        query: Mapping[str, Any] | None = None,
+        extra_headers: Mapping[str, str] | None = None,
+        allow_redirects: bool = True,
+    ) -> tls_client.response.Response:
+        return await self.request(
+            'GET',
+            path,
+            query = query,
+            extra_headers = extra_headers,
+            allow_redirects = allow_redirects,
+        )
+
+    async def post(
+        self,
+        path: str,
+        *,
+        data: Mapping[str, Any] | None = None,
+        json_body: Any = None,
+        query: Mapping[str, Any] | None = None,
+        extra_headers: Mapping[str, str] | None = None,
+        allow_redirects: bool = True,
+    ) -> tls_client.response.Response:
+        return await self.request(
+            'POST',
+            path,
+            data = data,
+            json_body = json_body,
+            query = query,
+            extra_headers = extra_headers,
+            allow_redirects = allow_redirects,
+        )
+
+    async def request(
+        self,
+        method: str,
+        path: str,
+        *,
+        query: Mapping[str, Any] | None = None,
+        data: Mapping[str, Any] | None = None,
+        json_body: Any = None,
+        extra_headers: Mapping[str, str] | None = None,
+        allow_redirects: bool = True,
+    ) -> tls_client.response.Response:
+        url = self._build_url(path)
+        headers = self._build_headers(extra_headers, has_form_body = data is not None)
+
+        attempts = max(1, self._config.max_retries + 1)
+        last_error: Exception | None = None
+        for attempt in range(1, attempts + 1):
+            try:
+                response = await asyncio.to_thread(
+                    self._dispatch,
+                    method = method,
+                    url = url,
+                    query = query,
+                    data = data,
+                    json_body = json_body,
+                    headers = headers,
+                    allow_redirects = allow_redirects,
+                )
+
+            except OguTimeoutError as E:
+                last_error = E
+                if attempt >= attempts:
+                    raise
+
+                self._sleep_for_retry(attempt)
+                continue
+
+            except OguNetworkError as E:
+                last_error = E
+                if attempt >= attempts:
+                    raise
+
+                self._sleep_for_retry(attempt)
+                continue
+
+            if response.status_code in RETRYABLE_STATUS_CODES and attempt < attempts:
+                self._sleep_for_retry(attempt)
+                continue
+
+            return self._handle_response(response, method = method, url = url)
+
+        if last_error is not None:
+            raise last_error
+
+        raise OguNetworkError(f'Exhausted retries for {method} {url}')
+
+    @staticmethod
+    def _create_session(proxy: Proxy, *, client_identifier: str) -> tls_client.Session:
+        session = tls_client.Session(
+            client_identifier = client_identifier,
+            random_tls_extension_order = True,
+        )
+        if proxy.proxy:
+            session.proxies.update({
+                'http': proxy.proxy,
+                'https': proxy.proxy,
+            })
+
+        return session
+
+    def _dispatch(
+        self,
+        *,
+        method: str,
+        url: str,
+        query: Mapping[str, Any] | None,
+        data: Mapping[str, Any] | None,
+        json_body: Any,
+        headers: Mapping[str, str],
+        allow_redirects: bool,
+    ) -> tls_client.response.Response:
+        request_func = getattr(self._session, method.lower())
+        try:
+            return request_func(
+                url,
+                params = dict(query) if query else None,
+                data = dict(data) if data else None,
+                json = json_body,
+                headers = dict(headers),
+                allow_redirects = allow_redirects,
+            )
+
+        except Exception as E:
+            message = str(E) or E.__class__.__name__
+            if 'timeout' in message.lower() or 'timed out' in message.lower():
+                raise OguTimeoutError(f'Request timed out: {method} {url}') from E
+
+            raise OguNetworkError(f'Network error during {method} {url}: {message}') from E
+
+    def _build_url(self, path: str) -> str:
+        if path.startswith(('http://', 'https://')):
+            return path
+
+        base = self._config.base_url.rstrip('/')
+        if not path.startswith('/'):
+            path = '/' + path
+
+        return f'{base}{path}'
+
+    def _build_headers(
+        self,
+        extra_headers: Mapping[str, str] | None,
+        *,
+        has_form_body: bool,
+    ) -> MutableMapping[str, str]:
+        headers: MutableMapping[str, str] = dict(self._config.default_headers)
+        if has_form_body:
+            headers['Content-Type'] = 'application/x-www-form-urlencoded'
+
+        if extra_headers:
+            for key, value in extra_headers.items():
+                headers[key] = value
+
+        return headers
+
+    def _sleep_for_retry(self, attempt: int) -> None:
+        delay = self._config.retry_backoff_seconds * (2 ** (attempt - 1))
+        logger.debug('Retrying in %.2fs (attempt %d)', delay, attempt)
+
+    def _handle_response(
+        self,
+        response: tls_client.response.Response,
+        *,
+        method: str,
+        url: str,
+    ) -> tls_client.response.Response:
+        status = response.status_code
+        if status < 400:
+            return response
+
+        body = response.text if hasattr(response, 'text') else None
+        message = f'{method} {url} -> {status}'
+
+        if status == 401:
+            raise OguAuthenticationError(message, status_code = status, method = method, url = url, body = body)
+
+        if status == 403:
+            raise OguAuthorizationError(message, status_code = status, method = method, url = url, body = body)
+
+        if status == 404:
+            raise OguNotFoundError(message, status_code = status, method = method, url = url, body = body)
+
+        if status in (400, 422):
+            raise OguValidationError(message, status_code = status, method = method, url = url, body = body)
+
+        if status == 429:
+            retry_after = _parse_retry_after(response)
+            raise OguRateLimitError(
+                message,
+                status_code = status,
+                method = method,
+                url = url,
+                body = body,
+                retry_after_seconds = retry_after,
+            )
+
+        if 500 <= status < 600:
+            raise OguServerError(message, status_code = status, method = method, url = url, body = body)
+
+        raise OguAPIError(message, status_code = status, method = method, url = url, body = body)
+
+
+def _parse_retry_after(response: tls_client.response.Response) -> float | None:
+    raw = None
+    headers = getattr(response, 'headers', None)
+    if headers is not None:
+        raw = headers.get('Retry-After') or headers.get('retry-after')
+
+    if raw is None:
+        return None
+
+    try:
+        return float(raw)
+
+    except (TypeError, ValueError):
+        return None

ogu_api/client.py

@@ -0,0 +1,112 @@
+from __future__ import annotations
+
+from typing import Any
+
+import tls_client
+
+from ._http import HttpClient, HttpClientConfig
+from .resources import (
+    CreditsResource,
+    FeedResource,
+    MembersResource,
+    MessagesResource,
+    NotificationsResource,
+    ReputationResource,
+    SearchResource,
+    SessionResource,
+    ThreadsResource,
+    UserCPResource,
+    UsersResource,
+)
+
+__all__ = ['OguClient']
+
+
+class OguClient:
+    def __init__(
+        self,
+        *,
+        proxy: str | None = None,
+        base_url: str | None = None,
+        timeout_seconds: float | None = None,
+        max_retries: int | None = None,
+        retry_backoff_seconds: float | None = None,
+        client_identifier: str | None = None,
+        config: HttpClientConfig | None = None,
+        session: tls_client.Session | None = None,
+    ) -> None:
+        resolved_config = self._resolve_config(
+            config = config,
+            base_url = base_url,
+            timeout_seconds = timeout_seconds,
+            max_retries = max_retries,
+            retry_backoff_seconds = retry_backoff_seconds,
+            client_identifier = client_identifier,
+        )
+        self._http: HttpClient = HttpClient(
+            proxy = proxy,
+            config = resolved_config,
+            session = session,
+        )
+
+        self.session: SessionResource = SessionResource(self._http)
+        self.users: UsersResource = UsersResource(self._http)
+        self.usercp: UserCPResource = UserCPResource(self._http)
+        self.reputation: ReputationResource = ReputationResource(self._http)
+        self.credits: CreditsResource = CreditsResource(self._http)
+        self.messages: MessagesResource = MessagesResource(self._http)
+        self.notifications: NotificationsResource = NotificationsResource(self._http)
+        self.feed: FeedResource = FeedResource(self._http)
+        self.threads: ThreadsResource = ThreadsResource(self._http)
+        self.search: SearchResource = SearchResource(self._http)
+        self.members: MembersResource = MembersResource(self._http)
+
+    async def __aenter__(self) -> OguClient:
+        return self
+
+    async def __aexit__(self, exc_type: Any, exc: Any, tb: Any) -> None:
+        self.close()
+
+    def close(self) -> None:
+        self._http.close()
+
+    @property
+    def http(self) -> HttpClient:
+        return self._http
+
+    @property
+    def cookies(self) -> Any:
+        return self._http.cookies
+
+    @staticmethod
+    def _resolve_config(
+        *,
+        config: HttpClientConfig | None,
+        base_url: str | None,
+        timeout_seconds: float | None,
+        max_retries: int | None,
+        retry_backoff_seconds: float | None,
+        client_identifier: str | None,
+    ) -> HttpClientConfig:
+        if config is None:
+            base = HttpClientConfig()
+
+        else:
+            base = config
+
+        return HttpClientConfig(
+            base_url = base_url if base_url is not None else base.base_url,
+            timeout_seconds = (
+                timeout_seconds if timeout_seconds is not None else base.timeout_seconds
+            ),
+            max_retries = max_retries if max_retries is not None else base.max_retries,
+            retry_backoff_seconds = (
+                retry_backoff_seconds
+                if retry_backoff_seconds is not None
+                else base.retry_backoff_seconds
+            ),
+            client_identifier = (
+                client_identifier if client_identifier is not None else base.client_identifier
+            ),
+            default_headers = base.default_headers,
+        )

ogu_api/errors.py

@@ -0,0 +1,129 @@
+from __future__ import annotations
+
+from typing import Any
+
+__all__ = [
+    'OguError',
+    'OguAPIError',
+    'OguAuthenticationError',
+    'OguAuthorizationError',
+    'OguNotFoundError',
+    'OguValidationError',
+    'OguRateLimitError',
+    'OguServerError',
+    'OguNetworkError',
+    'OguTimeoutError',
+    'OguParseError',
+    'OguSessionError',
+    'OguLoginError',
+    'OguReputationError',
+    'OguCreditsError',
+]
+
+
+class OguError(Exception):
+    ...
+
+
+class OguNetworkError(OguError):
+    ...
+
+
+class OguTimeoutError(OguNetworkError):
+    ...
+
+
+class OguAPIError(OguError):
+    def __init__(
+        self,
+        message: str,
+        *,
+        status_code: int,
+        method: str,
+        url: str,
+        body: str | None = None,
+    ) -> None:
+        super().__init__(message)
+
+        self.status_code: int = status_code
+        self.method: str = method
+        self.url: str = url
+        self.body: str | None = body
+
+    def __str__(self) -> str:
+        base = super().__str__()
+        return f'{base} [{self.method} {self.url} -> {self.status_code}]'
+
+
+class OguAuthenticationError(OguAPIError):
+    ...
+
+
+class OguAuthorizationError(OguAPIError):
+    ...
+
+
+class OguNotFoundError(OguAPIError):
+    ...
+
+
+class OguValidationError(OguAPIError):
+    ...
+
+
+class OguRateLimitError(OguAPIError):
+    def __init__(
+        self,
+        message: str,
+        *,
+        status_code: int,
+        method: str,
+        url: str,
+        body: str | None = None,
+        retry_after_seconds: float | None = None,
+    ) -> None:
+        super().__init__(
+            message,
+            status_code = status_code,
+            method = method,
+            url = url,
+            body = body,
+        )
+
+        self.retry_after_seconds: float | None = retry_after_seconds
+
+
+class OguServerError(OguAPIError):
+    ...
+
+
+class OguParseError(OguError):
+    def __init__(self, message: str = 'Failed to parse response') -> None:
+        super().__init__(message)
+
+
+class OguSessionError(OguError):
+    def __init__(self, message: str = 'Session is invalid or expired') -> None:
+        super().__init__(message)
+
+
+class OguLoginError(OguError):
+    def __init__(self, message: str = 'Login failed') -> None:
+        super().__init__(message)
+
+
+class OguReputationError(OguError):
+    def __init__(
+        self,
+        message: str = 'Reputation request failed',
+        *,
+        valid_amounts: list[str] | None = None,
+    ) -> None:
+        super().__init__(message)
+
+        self.valid_amounts: list[str] | None = valid_amounts
+
+
+class OguCreditsError(OguError):
+    def __init__(self, message: str = 'Credits request failed') -> None:
+        super().__init__(message)

ogu_api/models.py

@@ -0,0 +1,48 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any
+
+__all__ = [
+    'UserProfile',
+    'ReputationPage',
+    'ActionResult',
+    'Message',
+    'RecentTransaction',
+]
+
+
+@dataclass(frozen = True)
+class UserProfile:
+    user_id: str
+    username: str | None = None
+    reputation: str | None = None
+    vouches: str | None = None
+    credits: str | None = None
+
+
+@dataclass(frozen = True)
+class ReputationPage:
+    values: list[str] = field(default_factory = list)
+    hidden: dict[str, Any] = field(default_factory = dict)
+
+
+@dataclass(frozen = True)
+class ActionResult:
+    success: bool
+    message: str = ''
+
+
+@dataclass(frozen = True)
+class Message:
+    username: str
+    date: int
+    message: str
+
+
+@dataclass(frozen = True)
+class RecentTransaction:
+    sender: str
+    recipient: str
+    amount: int
+    date: int