antybrowser 1.0.2__tar.gz

antybrowser-1.0.2/PKG-INFO

@@ -0,0 +1,136 @@
+Metadata-Version: 2.4
+Name: antybrowser
+Version: 1.0.2
+Summary: Official Antybrowser SDK — Python client for the Antybrowser Local API
+Author: Antybrowser Team
+License: MIT
+Project-URL: Homepage, https://antybrowser.com
+Project-URL: Repository, https://github.com/antybrowser/SDK
+Project-URL: Documentation, https://github.com/antybrowser/SDK/tree/main/py
+Keywords: antybrowser,anti-detect,browser-automation,fingerprint,multi-accounting
+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: Typing :: Typed
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: httpx>=0.25.0
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: pytest-asyncio; extra == "dev"
+
+# @antybrowser/sdk (Python)
+
+Official Antybrowser Python SDK for the Local API.
+
+[![PyPI version](https://img.shields.io/pypi/v/antybrowser.svg)](https://pypi.org/project/antybrowser/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+## Installation
+
+```bash
+pip install antybrowser
+```
+
+## Quick Start
+
+```python
+import asyncio
+from antybrowser import AntybrowserClient, CreateProfileRequest
+
+async def main():
+    async with AntybrowserClient(api_key="your_key", port=5173) as client:
+        # List profiles
+        profiles = await client.get_profiles()
+        for p in profiles:
+            print(f"{p.name} (status: {p.status})")
+
+        # Create a profile
+        profile = await client.create_profile(CreateProfileRequest(
+            name="My Profile",
+            browser_type="Chrome",
+            os_fingerprint="Windows",
+            language="en-US",
+            use_fingerprint=True,
+        ))
+
+        # Start it — get debug port for Selenium/Playwright
+        result = await client.start_profile(profile.id)
+        print(f"Debug port: {result.data.debug_port}")
+
+asyncio.run(main())
+```
+
+## Configuration
+
+```python
+# Simple
+client = AntybrowserClient(api_key="my_key")
+
+# Custom port
+client = AntybrowserClient(api_key="my_key", port=5174)
+
+# Full override
+client = AntybrowserClient(api_key="my_key", base_url="http://10.0.0.5:5173")
+```
+
+## Context Manager
+
+```python
+async with AntybrowserClient(api_key="my_key") as client:
+    profiles = await client.get_profiles()
+# Connection automatically closed
+```
+
+## API Methods
+
+| Method | Description |
+|--------|-------------|
+| `get_status()` | Check API connection |
+| `get_settings()` | Get settings |
+| `get_sync_status()` | Get sync status |
+| `refresh_sync(profile_id?)` | Trigger sync |
+| `get_profiles()` | List profiles |
+| `create_profile(request)` | Create profile |
+| `update_profile(id, **fields)` | Update profile |
+| `delete_profile(id)` | Delete profile |
+| `start_profile(id)` | Start profile |
+| `stop_profile(id)` | Stop profile |
+| `duplicate_profile(id, opts?)` | Duplicate profile |
+| `get_automations()` | List automations |
+| `run_automation(id, request)` | Run automation |
+| `get_groups()` | List groups |
+| `create_group(request)` | Create group |
+| `update_group(id, **fields)` | Update group |
+| `delete_group(id)` | Delete group |
+| `get_proxies()` | List proxies |
+| `create_proxy(request)` | Create proxy |
+| `check_proxy(host, port, ...)` | Check proxy |
+| `check_proxies_bulk(proxies)` | Bulk check |
+| `delete_proxy(id)` | Delete proxy |
+| `get_extensions()` | List extensions |
+| `delete_extension(id)` | Delete extension |
+| `get_profile_extensions(id)` | Get profile extensions |
+| `set_profile_extensions(id, ids)` | Set profile extensions |
+
+## Error Handling
+
+```python
+from antybrowser import AntybrowserError
+
+try:
+    await client.get_profiles()
+except AntybrowserError as e:
+    print(f"Status: {e.status_code}")
+    print(f"Body: {e.response_body}")
+```
+
+## License
+
+MIT

antybrowser-1.0.2/README.md

@@ -0,0 +1,109 @@
+# @antybrowser/sdk (Python)
+
+Official Antybrowser Python SDK for the Local API.
+
+[![PyPI version](https://img.shields.io/pypi/v/antybrowser.svg)](https://pypi.org/project/antybrowser/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+## Installation
+
+```bash
+pip install antybrowser
+```
+
+## Quick Start
+
+```python
+import asyncio
+from antybrowser import AntybrowserClient, CreateProfileRequest
+
+async def main():
+    async with AntybrowserClient(api_key="your_key", port=5173) as client:
+        # List profiles
+        profiles = await client.get_profiles()
+        for p in profiles:
+            print(f"{p.name} (status: {p.status})")
+
+        # Create a profile
+        profile = await client.create_profile(CreateProfileRequest(
+            name="My Profile",
+            browser_type="Chrome",
+            os_fingerprint="Windows",
+            language="en-US",
+            use_fingerprint=True,
+        ))
+
+        # Start it — get debug port for Selenium/Playwright
+        result = await client.start_profile(profile.id)
+        print(f"Debug port: {result.data.debug_port}")
+
+asyncio.run(main())
+```
+
+## Configuration
+
+```python
+# Simple
+client = AntybrowserClient(api_key="my_key")
+
+# Custom port
+client = AntybrowserClient(api_key="my_key", port=5174)
+
+# Full override
+client = AntybrowserClient(api_key="my_key", base_url="http://10.0.0.5:5173")
+```
+
+## Context Manager
+
+```python
+async with AntybrowserClient(api_key="my_key") as client:
+    profiles = await client.get_profiles()
+# Connection automatically closed
+```
+
+## API Methods
+
+| Method | Description |
+|--------|-------------|
+| `get_status()` | Check API connection |
+| `get_settings()` | Get settings |
+| `get_sync_status()` | Get sync status |
+| `refresh_sync(profile_id?)` | Trigger sync |
+| `get_profiles()` | List profiles |
+| `create_profile(request)` | Create profile |
+| `update_profile(id, **fields)` | Update profile |
+| `delete_profile(id)` | Delete profile |
+| `start_profile(id)` | Start profile |
+| `stop_profile(id)` | Stop profile |
+| `duplicate_profile(id, opts?)` | Duplicate profile |
+| `get_automations()` | List automations |
+| `run_automation(id, request)` | Run automation |
+| `get_groups()` | List groups |
+| `create_group(request)` | Create group |
+| `update_group(id, **fields)` | Update group |
+| `delete_group(id)` | Delete group |
+| `get_proxies()` | List proxies |
+| `create_proxy(request)` | Create proxy |
+| `check_proxy(host, port, ...)` | Check proxy |
+| `check_proxies_bulk(proxies)` | Bulk check |
+| `delete_proxy(id)` | Delete proxy |
+| `get_extensions()` | List extensions |
+| `delete_extension(id)` | Delete extension |
+| `get_profile_extensions(id)` | Get profile extensions |
+| `set_profile_extensions(id, ids)` | Set profile extensions |
+
+## Error Handling
+
+```python
+from antybrowser import AntybrowserError
+
+try:
+    await client.get_profiles()
+except AntybrowserError as e:
+    print(f"Status: {e.status_code}")
+    print(f"Body: {e.response_body}")
+```
+
+## License
+
+MIT

antybrowser-1.0.2/antybrowser/__init__.py

@@ -0,0 +1,44 @@
+"""Official Antybrowser SDK — Python client for the Antybrowser Local API."""
+
+from antybrowser.client import AntybrowserClient
+from antybrowser.errors import AntybrowserError
+from antybrowser.types import (
+    Profile,
+    CreateProfileRequest,
+    Proxy,
+    CreateProxyRequest,
+    ProxyCheckResult,
+    Group,
+    CreateGroupRequest,
+    Extension,
+    Automation,
+    RunAutomationRequest,
+    RunAutomationResult,
+    Settings,
+    SyncStatus,
+    StatusResponse,
+    StartProfileResponse,
+    DuplicateProfileRequest,
+)
+
+__version__ = "1.0.2"
+__all__ = [
+    "AntybrowserClient",
+    "AntybrowserError",
+    "Profile",
+    "CreateProfileRequest",
+    "Proxy",
+    "CreateProxyRequest",
+    "ProxyCheckResult",
+    "Group",
+    "CreateGroupRequest",
+    "Extension",
+    "Automation",
+    "RunAutomationRequest",
+    "RunAutomationResult",
+    "Settings",
+    "SyncStatus",
+    "StatusResponse",
+    "StartProfileResponse",
+    "DuplicateProfileRequest",
+]

antybrowser-1.0.2/antybrowser/client.py

@@ -0,0 +1,268 @@
+from __future__ import annotations
+
+from typing import Any, Dict, List, Optional, Union
+
+import httpx
+
+from antybrowser.errors import AntybrowserError
+from antybrowser.types import (
+    Automation,
+    CreateGroupRequest,
+    CreateProfileRequest,
+    CreateProxyRequest,
+    Extension,
+    Group,
+    Profile,
+    Proxy,
+    ProxyCheckResult,
+    RunAutomationRequest,
+    RunAutomationResult,
+    Settings,
+    StartProfileData,
+    StartProfileResponse,
+    StatusResponse,
+    SyncStatus,
+    DuplicateProfileRequest,
+)
+
+
+class AntybrowserClient:
+    """Client for the Antybrowser Local API.
+
+    Args:
+        api_key: Your Antybrowser API key.
+        port: Local API port (default 5173).
+        base_url: Full base URL override (overrides port).
+        timeout: Request timeout in seconds (default 30).
+    """
+
+    def __init__(
+        self,
+        api_key: str,
+        port: int = 5173,
+        base_url: Optional[str] = None,
+        timeout: float = 30.0,
+    ):
+        self._api_key = api_key
+        self._base_url = base_url or f"http://127.0.0.1:{port}"
+        self._client = httpx.AsyncClient(
+            base_url=self._base_url,
+            headers={"x-api-key": api_key, "Content-Type": "application/json"},
+            timeout=timeout,
+        )
+
+    async def close(self) -> None:
+        await self._client.aclose()
+
+    async def __aenter__(self) -> AntybrowserClient:
+        return self
+
+    async def __aexit__(self, *args: Any) -> None:
+        await self.close()
+
+    # ─── System ──────────────────────────────────────────────────────────
+
+    async def get_status(self) -> StatusResponse:
+        data = await self._get("/api/status")
+        return StatusResponse(**data)
+
+    async def get_settings(self) -> Settings:
+        data = await self._get("/api/settings")
+        return Settings.from_dict(data)
+
+    async def get_sync_status(self) -> SyncStatus:
+        data = await self._get("/api/sync/status")
+        return SyncStatus.from_dict(data)
+
+    async def refresh_sync(self, profile_id: Optional[int] = None) -> Dict[str, Any]:
+        body = {"profileId": profile_id} if profile_id is not None else {}
+        return await self._post("/api/sync/refresh", body)
+
+    # ─── Profiles ────────────────────────────────────────────────────────
+
+    async def get_profiles(self) -> List[Profile]:
+        data = await self._get("/api/profiles")
+        return [Profile.from_dict(p) for p in data]
+
+    async def create_profile(self, request: CreateProfileRequest) -> Profile:
+        data = await self._post("/api/profiles", request.to_dict())
+        return Profile.from_dict(data)
+
+    async def update_profile(self, profile_id: int, **kwargs: Any) -> Profile:
+        data = await self._put(f"/api/profiles/{profile_id}", kwargs)
+        return Profile.from_dict(data)
+
+    async def delete_profile(self, profile_id: int) -> Dict[str, Any]:
+        return await self._delete(f"/api/profiles/{profile_id}")
+
+    async def start_profile(self, profile_id: int) -> StartProfileResponse:
+        data = await self._post(f"/api/profiles/{profile_id}/start")
+        return StartProfileResponse(
+            success=data.get("success", False),
+            data=StartProfileData(
+                debug_port=data.get("data", {}).get("debugPort"),
+                extra={k: v for k, v in data.get("data", {}).items() if k != "debugPort"},
+            ),
+        )
+
+    async def stop_profile(self, profile_id: int) -> Dict[str, Any]:
+        return await self._post(f"/api/profiles/{profile_id}/stop")
+
+    async def duplicate_profile(
+        self, profile_id: int, options: Optional[DuplicateProfileRequest] = None
+    ) -> Profile:
+        body = options.to_dict() if options else {}
+        data = await self._post(f"/api/profiles/{profile_id}/duplicate", body)
+        return Profile.from_dict(data)
+
+    # ─── Automations ─────────────────────────────────────────────────────
+
+    async def get_automations(self) -> List[Automation]:
+        data = await self._get("/api/automations")
+        return [Automation.from_dict(a) for a in data]
+
+    async def run_automation(
+        self, automation_id: int, request: RunAutomationRequest
+    ) -> RunAutomationResult:
+        data = await self._post(f"/api/automations/{automation_id}/run", request.to_dict())
+        return RunAutomationResult(
+            success=data.get("success", False),
+            message=data.get("message", ""),
+            variables=data.get("variables"),
+        )
+
+    # ─── Groups ──────────────────────────────────────────────────────────
+
+    async def get_groups(self) -> List[Group]:
+        data = await self._get("/api/groups")
+        return [Group.from_dict(g) for g in data]
+
+    async def create_group(self, request: CreateGroupRequest) -> Group:
+        data = await self._post("/api/groups", request.to_dict())
+        return Group.from_dict(data)
+
+    async def update_group(self, group_id: int, **kwargs: Any) -> Group:
+        data = await self._put(f"/api/groups/{group_id}", kwargs)
+        return Group.from_dict(data)
+
+    async def delete_group(self, group_id: int) -> None:
+        await self._delete(f"/api/groups/{group_id}")
+
+    # ─── Proxies ─────────────────────────────────────────────────────────
+
+    async def get_proxies(self) -> List[Proxy]:
+        data = await self._get("/api/proxies")
+        return [Proxy.from_dict(p) for p in data]
+
+    async def create_proxy(self, request: CreateProxyRequest) -> Proxy:
+        data = await self._post("/api/proxies", request.to_dict())
+        return Proxy.from_dict(data)
+
+    async def check_proxy(
+        self,
+        host: str,
+        port: int,
+        username: Optional[str] = None,
+        password: Optional[str] = None,
+        type: Optional[str] = None,
+    ) -> ProxyCheckResult:
+        body: Dict[str, Any] = {"host": host, "port": port}
+        if username:
+            body["username"] = username
+        if password:
+            body["password"] = password
+        if type:
+            body["type"] = type
+        data = await self._post("/api/proxies/check", body)
+        return ProxyCheckResult(
+            success=data.get("success", False),
+            details=data.get("details"),
+            error_message=data.get("errorMessage"),
+        )
+
+    async def check_proxies_bulk(
+        self, proxies: List[Union[str, Dict[str, Any]]]
+    ) -> List[ProxyCheckResult]:
+        data = await self._post("/api/proxies/check-bulk", {"proxies": proxies})
+        results = data.get("results", data) if isinstance(data, dict) else data
+        return [
+            ProxyCheckResult(
+                success=r.get("success", False),
+                details=r.get("details"),
+                error_message=r.get("errorMessage"),
+            )
+            for r in results
+        ]
+
+    async def delete_proxy(self, proxy_id: int) -> None:
+        await self._delete(f"/api/proxies/{proxy_id}")
+
+    # ─── Extensions ──────────────────────────────────────────────────────
+
+    async def get_extensions(self) -> List[Extension]:
+        data = await self._get("/api/extensions")
+        return [Extension.from_dict(e) for e in data]
+
+    async def delete_extension(self, extension_id: int) -> None:
+        await self._delete(f"/api/extensions/{extension_id}")
+
+    async def get_profile_extensions(
+        self, profile_id: int, details: bool = False
+    ) -> List[Extension]:
+        data = await self._get(f"/api/profiles/{profile_id}/extensions?details={str(details).lower()}")
+        return [Extension.from_dict(e) for e in data]
+
+    async def set_profile_extensions(
+        self, profile_id: int, extension_ids: List[int]
+    ) -> Dict[str, Any]:
+        return await self._post(
+            f"/api/profiles/{profile_id}/extensions", {"extensionIds": extension_ids}
+        )
+
+    # ─── HTTP Helpers ────────────────────────────────────────────────────
+
+    async def _get(self, path: str) -> Any:
+        try:
+            resp = await self._client.get(path)
+        except httpx.HTTPError as e:
+            raise AntybrowserError(f"Failed to connect to Antybrowser: {e}")
+        return self._handle(resp)
+
+    async def _post(self, path: str, body: Optional[Dict[str, Any]] = None) -> Any:
+        try:
+            resp = await self._client.post(path, json=body or {})
+        except httpx.HTTPError as e:
+            raise AntybrowserError(f"Failed to connect to Antybrowser: {e}")
+        return self._handle(resp)
+
+    async def _put(self, path: str, body: Dict[str, Any]) -> Any:
+        try:
+            resp = await self._client.put(path, json=body)
+        except httpx.HTTPError as e:
+            raise AntybrowserError(f"Failed to connect to Antybrowser: {e}")
+        return self._handle(resp)
+
+    async def _delete(self, path: str) -> Any:
+        try:
+            resp = await self._client.delete(path)
+        except httpx.HTTPError as e:
+            raise AntybrowserError(f"Failed to connect to Antybrowser: {e}")
+        return self._handle(resp)
+
+    def _handle(self, resp: httpx.Response) -> Any:
+        if not resp.is_success:
+            raise AntybrowserError(
+                f"API request failed with status {resp.status_code}",
+                status_code=resp.status_code,
+                response_body=resp.text,
+            )
+        if not resp.text or not resp.text.strip():
+            return {}
+        try:
+            return resp.json()
+        except Exception:
+            raise AntybrowserError(
+                "Invalid JSON response from API",
+                status_code=resp.status_code,
+                response_body=resp.text,
+            )

antybrowser-1.0.2/antybrowser/errors.py

@@ -0,0 +1,17 @@
+from __future__ import annotations
+
+from typing import Any, Optional
+
+
+class AntybrowserError(Exception):
+    """Raised when the Antybrowser API returns an error."""
+
+    def __init__(
+        self,
+        message: str,
+        status_code: Optional[int] = None,
+        response_body: Optional[str] = None,
+    ):
+        super().__init__(message)
+        self.status_code = status_code
+        self.response_body = response_body

antybrowser-1.0.2/antybrowser/py.typed

@@ -0,0 +1 @@
+"""Py.typed marker for PEP 561 compliance."""

antybrowser-1.0.2/antybrowser/types.py

@@ -0,0 +1,347 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any, Dict, List, Optional, Union
+
+
+@dataclass
+class StatusResponse:
+    success: bool
+    status: str
+    version: str
+
+
+@dataclass
+class StartProfileData:
+    debug_port: Optional[int] = None
+    extra: Dict[str, Any] = field(default_factory=dict)
+
+    def __getattr__(self, name: str) -> Any:
+        return self.extra.get(name)
+
+
+@dataclass
+class StartProfileResponse:
+    success: bool
+    data: StartProfileData
+
+
+@dataclass
+class Profile:
+    id: int
+    name: str
+    directory_name: Optional[str] = None
+    group_id: Optional[int] = None
+    proxy_id: Optional[int] = None
+    browser_type: Optional[str] = None
+    browser_version: Optional[str] = None
+    os_fingerprint: Optional[str] = None
+    screen_resolution: Optional[str] = None
+    language: Optional[str] = None
+    accept_language: Optional[str] = None
+    timezone: Optional[str] = None
+    use_fingerprint: Optional[bool] = None
+    fingerprint_id: Optional[str] = None
+    restore_session: Optional[bool] = None
+    low_bandwidth: Optional[bool] = None
+    notes: Optional[str] = None
+    start_url: Optional[str] = None
+    custom_flags: Optional[str] = None
+    status: Optional[str] = None
+    needs_sync: Optional[bool] = None
+    last_pid: Optional[int] = None
+    debug_port: Optional[int] = None
+    created_at: Optional[str] = None
+    updated_at: Optional[str] = None
+    last_synced_at: Optional[str] = None
+    s3_key: Optional[str] = None
+    trash: Optional[bool] = None
+    deleted_at: Optional[str] = None
+    hidden: Optional[bool] = None
+    extra: Dict[str, Any] = field(default_factory=dict)
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, Any]) -> Profile:
+        known = {f.name for f in cls.__dataclass_fields__.values()} | {"extra"}
+        extra = {k: v for k, v in d.items() if k not in known}
+        return cls(
+            id=d["id"],
+            name=d["name"],
+            directory_name=d.get("directoryName"),
+            group_id=d.get("groupId"),
+            proxy_id=d.get("proxyId"),
+            browser_type=d.get("browserType"),
+            browser_version=d.get("browserVersion"),
+            os_fingerprint=d.get("osFingerprint"),
+            screen_resolution=d.get("screenResolution"),
+            language=d.get("language"),
+            accept_language=d.get("acceptLanguage"),
+            timezone=d.get("timezone"),
+            use_fingerprint=d.get("useFingerprint"),
+            fingerprint_id=d.get("fingerprintId"),
+            restore_session=d.get("restoreSession"),
+            low_bandwidth=d.get("lowBandwidth"),
+            notes=d.get("notes"),
+            start_url=d.get("startUrl"),
+            custom_flags=d.get("customFlags"),
+            status=d.get("status"),
+            needs_sync=d.get("needsSync"),
+            last_pid=d.get("lastPid"),
+            debug_port=d.get("debugPort"),
+            created_at=d.get("createdAt"),
+            updated_at=d.get("updatedAt"),
+            last_synced_at=d.get("lastSyncedAt"),
+            s3_key=d.get("s3Key"),
+            trash=d.get("trash"),
+            deleted_at=d.get("deletedAt"),
+            hidden=d.get("hidden"),
+            extra=extra,
+        )
+
+
+@dataclass
+class CreateProfileRequest:
+    name: str
+    directory_name: Optional[str] = None
+    group_id: Optional[int] = None
+    proxy_id: Optional[int] = None
+    browser_type: Optional[str] = None
+    os_fingerprint: Optional[str] = None
+    screen_resolution: Optional[str] = None
+    language: Optional[str] = None
+    accept_language: Optional[str] = None
+    timezone: Optional[str] = None
+    use_fingerprint: Optional[bool] = None
+    fingerprint_id: Optional[str] = None
+    restore_session: Optional[bool] = None
+    low_bandwidth: Optional[bool] = None
+    notes: Optional[str] = None
+    start_url: Optional[str] = None
+    custom_flags: Optional[str] = None
+
+    def to_dict(self) -> Dict[str, Any]:
+        d: Dict[str, Any] = {"name": self.name}
+        mapping = {
+            "directory_name": "directoryName", "group_id": "groupId",
+            "proxy_id": "proxyId", "browser_type": "browserType",
+            "os_fingerprint": "osFingerprint", "screen_resolution": "screenResolution",
+            "accept_language": "acceptLanguage", "use_fingerprint": "useFingerprint",
+            "fingerprint_id": "fingerprintId", "restore_session": "restoreSession",
+            "low_bandwidth": "lowBandwidth", "start_url": "startUrl",
+            "custom_flags": "customFlags",
+        }
+        for py_key, api_key in mapping.items():
+            val = getattr(self, py_key)
+            if val is not None:
+                d[api_key] = val
+        for attr in ("language", "timezone", "notes"):
+            val = getattr(self, attr)
+            if val is not None:
+                d[attr] = val
+        return d
+
+
+@dataclass
+class Proxy:
+    id: int
+    name: Optional[str] = None
+    type: Optional[str] = None
+    host: Optional[str] = None
+    port: Optional[int] = None
+    username: Optional[str] = None
+    password: Optional[str] = None
+    status: Optional[str] = None
+    country_code: Optional[str] = None
+    ip: Optional[str] = None
+    country: Optional[str] = None
+    timezone: Optional[str] = None
+    asn: Optional[str] = None
+    isp: Optional[str] = None
+    extra: Dict[str, Any] = field(default_factory=dict)
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, Any]) -> Proxy:
+        known = {f.name for f in cls.__dataclass_fields__.values()} | {"extra"}
+        extra = {k: v for k, v in d.items() if k not in known}
+        return cls(
+            id=d["id"], name=d.get("name"), type=d.get("type"),
+            host=d.get("host"), port=d.get("port"),
+            username=d.get("username"), password=d.get("password"),
+            status=d.get("status"), country_code=d.get("countryCode"),
+            ip=d.get("ip"), country=d.get("country"),
+            timezone=d.get("timezone"), asn=d.get("asn"), isp=d.get("isp"),
+            extra=extra,
+        )
+
+
+@dataclass
+class CreateProxyRequest:
+    name: str
+    host: str
+    port: int
+    type: str
+    username: Optional[str] = None
+    password: Optional[str] = None
+
+    def to_dict(self) -> Dict[str, Any]:
+        d: Dict[str, Any] = {"name": self.name, "host": self.host, "port": self.port, "type": self.type}
+        if self.username is not None:
+            d["username"] = self.username
+        if self.password is not None:
+            d["password"] = self.password
+        return d
+
+
+@dataclass
+class ProxyCheckResult:
+    success: bool
+    details: Optional[Dict[str, Any]] = None
+    error_message: Optional[str] = None
+
+
+@dataclass
+class Group:
+    id: int
+    name: str
+    description: Optional[str] = None
+    color: Optional[str] = None
+    display_order: Optional[int] = None
+    created_at: Optional[str] = None
+    updated_at: Optional[str] = None
+    extra: Dict[str, Any] = field(default_factory=dict)
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, Any]) -> Group:
+        return cls(
+            id=d["id"], name=d["name"], description=d.get("description"),
+            color=d.get("color"), display_order=d.get("displayOrder"),
+            created_at=d.get("createdAt"), updated_at=d.get("updatedAt"),
+        )
+
+
+@dataclass
+class CreateGroupRequest:
+    name: str
+    description: Optional[str] = None
+    color: Optional[str] = None
+
+    def to_dict(self) -> Dict[str, Any]:
+        d: Dict[str, Any] = {"name": self.name}
+        if self.description is not None:
+            d["description"] = self.description
+        if self.color is not None:
+            d["color"] = self.color
+        return d
+
+
+@dataclass
+class Extension:
+    id: int
+    name: str
+    path: Optional[str] = None
+    description: Optional[str] = None
+    icon: Optional[str] = None
+    icon_data_url: Optional[str] = None
+    created_at: Optional[str] = None
+    extra: Dict[str, Any] = field(default_factory=dict)
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, Any]) -> Extension:
+        return cls(
+            id=d["id"], name=d["name"], path=d.get("path"),
+            description=d.get("description"), icon=d.get("icon"),
+            icon_data_url=d.get("iconDataUrl"), created_at=d.get("createdAt"),
+        )
+
+
+@dataclass
+class Automation:
+    id: int
+    name: str
+    description: Optional[str] = None
+    status: Optional[str] = None
+    last_run: Optional[str] = None
+    created_at: Optional[str] = None
+    updated_at: Optional[str] = None
+    extra: Dict[str, Any] = field(default_factory=dict)
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, Any]) -> Automation:
+        return cls(
+            id=d["id"], name=d["name"], description=d.get("description"),
+            status=d.get("status"), last_run=d.get("lastRun"),
+            created_at=d.get("createdAt"), updated_at=d.get("updatedAt"),
+        )
+
+
+@dataclass
+class RunAutomationRequest:
+    profile_id: int
+    delete_cookies: Optional[bool] = None
+    variables: Optional[Dict[str, str]] = None
+
+    def to_dict(self) -> Dict[str, Any]:
+        d: Dict[str, Any] = {"profileId": self.profile_id}
+        if self.delete_cookies is not None:
+            d["deleteCookies"] = self.delete_cookies
+        if self.variables is not None:
+            d["variables"] = self.variables
+        return d
+
+
+@dataclass
+class RunAutomationResult:
+    success: bool
+    message: str
+    variables: Optional[Dict[str, Any]] = None
+
+
+@dataclass
+class Settings:
+    id: Optional[int] = None
+    chrome_path: Optional[str] = None
+    api_key: Optional[str] = None
+    language: Optional[str] = None
+    extra: Dict[str, Any] = field(default_factory=dict)
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, Any]) -> Settings:
+        return cls(
+            id=d.get("id"), chrome_path=d.get("chromePath"),
+            api_key=d.get("apiKey"), language=d.get("language"),
+            extra={k: v for k, v in d.items() if k not in ("id", "chromePath", "apiKey", "language")},
+        )
+
+
+@dataclass
+class SyncStatus:
+    total: int
+    completed: int
+    is_syncing: bool
+    active: List[Any] = field(default_factory=list)
+    active_extensions: List[Any] = field(default_factory=list)
+    errors: Dict[str, Any] = field(default_factory=dict)
+    progress: Dict[str, Any] = field(default_factory=dict)
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, Any]) -> SyncStatus:
+        return cls(
+            total=d.get("total", 0), completed=d.get("completed", 0),
+            is_syncing=d.get("isSyncing", False), active=d.get("active", []),
+            active_extensions=d.get("activeExtensions", []),
+            errors=d.get("errors", {}), progress=d.get("progress", {}),
+        )
+
+
+@dataclass
+class DuplicateProfileRequest:
+    name: Optional[str] = None
+    directory_name: Optional[str] = None
+
+    def to_dict(self) -> Dict[str, Any]:
+        d: Dict[str, Any] = {}
+        if self.name is not None:
+            d["name"] = self.name
+        if self.directory_name is not None:
+            d["directoryName"] = self.directory_name
+        return d

antybrowser-1.0.2/antybrowser.egg-info/PKG-INFO

@@ -0,0 +1,136 @@
+Metadata-Version: 2.4
+Name: antybrowser
+Version: 1.0.2
+Summary: Official Antybrowser SDK — Python client for the Antybrowser Local API
+Author: Antybrowser Team
+License: MIT
+Project-URL: Homepage, https://antybrowser.com
+Project-URL: Repository, https://github.com/antybrowser/SDK
+Project-URL: Documentation, https://github.com/antybrowser/SDK/tree/main/py
+Keywords: antybrowser,anti-detect,browser-automation,fingerprint,multi-accounting
+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: Typing :: Typed
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: httpx>=0.25.0
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: pytest-asyncio; extra == "dev"
+
+# @antybrowser/sdk (Python)
+
+Official Antybrowser Python SDK for the Local API.
+
+[![PyPI version](https://img.shields.io/pypi/v/antybrowser.svg)](https://pypi.org/project/antybrowser/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+## Installation
+
+```bash
+pip install antybrowser
+```
+
+## Quick Start
+
+```python
+import asyncio
+from antybrowser import AntybrowserClient, CreateProfileRequest
+
+async def main():
+    async with AntybrowserClient(api_key="your_key", port=5173) as client:
+        # List profiles
+        profiles = await client.get_profiles()
+        for p in profiles:
+            print(f"{p.name} (status: {p.status})")
+
+        # Create a profile
+        profile = await client.create_profile(CreateProfileRequest(
+            name="My Profile",
+            browser_type="Chrome",
+            os_fingerprint="Windows",
+            language="en-US",
+            use_fingerprint=True,
+        ))
+
+        # Start it — get debug port for Selenium/Playwright
+        result = await client.start_profile(profile.id)
+        print(f"Debug port: {result.data.debug_port}")
+
+asyncio.run(main())
+```
+
+## Configuration
+
+```python
+# Simple
+client = AntybrowserClient(api_key="my_key")
+
+# Custom port
+client = AntybrowserClient(api_key="my_key", port=5174)
+
+# Full override
+client = AntybrowserClient(api_key="my_key", base_url="http://10.0.0.5:5173")
+```
+
+## Context Manager
+
+```python
+async with AntybrowserClient(api_key="my_key") as client:
+    profiles = await client.get_profiles()
+# Connection automatically closed
+```
+
+## API Methods
+
+| Method | Description |
+|--------|-------------|
+| `get_status()` | Check API connection |
+| `get_settings()` | Get settings |
+| `get_sync_status()` | Get sync status |
+| `refresh_sync(profile_id?)` | Trigger sync |
+| `get_profiles()` | List profiles |
+| `create_profile(request)` | Create profile |
+| `update_profile(id, **fields)` | Update profile |
+| `delete_profile(id)` | Delete profile |
+| `start_profile(id)` | Start profile |
+| `stop_profile(id)` | Stop profile |
+| `duplicate_profile(id, opts?)` | Duplicate profile |
+| `get_automations()` | List automations |
+| `run_automation(id, request)` | Run automation |
+| `get_groups()` | List groups |
+| `create_group(request)` | Create group |
+| `update_group(id, **fields)` | Update group |
+| `delete_group(id)` | Delete group |
+| `get_proxies()` | List proxies |
+| `create_proxy(request)` | Create proxy |
+| `check_proxy(host, port, ...)` | Check proxy |
+| `check_proxies_bulk(proxies)` | Bulk check |
+| `delete_proxy(id)` | Delete proxy |
+| `get_extensions()` | List extensions |
+| `delete_extension(id)` | Delete extension |
+| `get_profile_extensions(id)` | Get profile extensions |
+| `set_profile_extensions(id, ids)` | Set profile extensions |
+
+## Error Handling
+
+```python
+from antybrowser import AntybrowserError
+
+try:
+    await client.get_profiles()
+except AntybrowserError as e:
+    print(f"Status: {e.status_code}")
+    print(f"Body: {e.response_body}")
+```
+
+## License
+
+MIT

antybrowser-1.0.2/antybrowser.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+README.md
+pyproject.toml
+antybrowser/__init__.py
+antybrowser/client.py
+antybrowser/errors.py
+antybrowser/py.typed
+antybrowser/types.py
+antybrowser.egg-info/PKG-INFO
+antybrowser.egg-info/SOURCES.txt
+antybrowser.egg-info/dependency_links.txt
+antybrowser.egg-info/requires.txt
+antybrowser.egg-info/top_level.txt

antybrowser-1.0.2/antybrowser.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

antybrowser-1.0.2/antybrowser.egg-info/requires.txt

@@ -0,0 +1,5 @@
+httpx>=0.25.0
+
+[dev]
+pytest
+pytest-asyncio

antybrowser-1.0.2/antybrowser.egg-info/top_level.txt

@@ -0,0 +1 @@
+antybrowser

antybrowser-1.0.2/pyproject.toml

@@ -0,0 +1,42 @@
+[build-system]
+requires = ["setuptools>=68.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "antybrowser"
+version = "1.0.2"
+description = "Official Antybrowser SDK — Python client for the Antybrowser Local API"
+readme = "README.md"
+license = { text = "MIT" }
+requires-python = ">=3.9"
+authors = [{ name = "Antybrowser Team" }]
+keywords = ["antybrowser", "anti-detect", "browser-automation", "fingerprint", "multi-accounting"]
+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",
+    "Typing :: Typed",
+]
+dependencies = [
+    "httpx>=0.25.0",
+]
+
+[project.urls]
+Homepage = "https://antybrowser.com"
+Repository = "https://github.com/antybrowser/SDK"
+Documentation = "https://github.com/antybrowser/SDK/tree/main/py"
+
+[project.optional-dependencies]
+dev = ["pytest", "pytest-asyncio"]
+
+[tool.setuptools.packages.find]
+include = ["antybrowser*"]
+
+[tool.setuptools.package-data]
+antybrowser = ["py.typed"]

antybrowser-1.0.2/setup.cfg

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