fxsocket 0.2__tar.gz → 0.3.0__tar.gz

{fxsocket-0.2 → fxsocket-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fxsocket
-Version: 0.2
+Version: 0.3.0
 Summary: Python SDK for the FxSocket API — MT4/MT5 account management, trading, and real-time streaming.
 Project-URL: Homepage, https://fxsocket.com
 Project-URL: Documentation, https://api.fxsocket.com/v1/docs
@@ -40,6 +40,8 @@ interfaces.
 ## Features
 
 - **Account management** — link, list, fetch, and disconnect MT4/MT5 accounts.
+- **Private servers** — list your dedicated hosting servers and manage the
+  accounts on them.
 - **Trading** — market & pending orders, modify, close, plus margin/profit calculators.
 - **Market data** — quotes, symbol specifications, OHLC history, account state & info.
 - **Live streaming** — ticks, bars, account, positions, trades, and terminal status
@@ -238,11 +240,41 @@ except AccountCapError as e:
 
 ## Private hosting
 
-Privately-hosted accounts (a dedicated droplet) are listed, traded, and streamed
-exactly like shared-cluster accounts — their `rest_url` / `ws_url` simply point
-at the droplet. The droplet serves a self-signed certificate, so reach it with
-`Client(..., verify_terminal_tls=False)` (or supply a pinned CA). *Creating* a
-private-hosted account is done in the dashboard.
+Dedicated private servers are managed through `client.private_servers`:
+
+```python
+import time
+
+from fxsocket import Client, PrivateAccountStatus, SlotsFullError
+
+with Client(api_key="fxs_live_...", verify_terminal_tls=False) as fx:
+    [server] = fx.private_servers.list()
+    print(server.name, server.status, f"{server.used_slots}/{server.purchased_slots}")
+
+    try:
+        account = fx.private_servers.add_account(
+            server, server="ICMarkets-Demo", login=1150125, password="..."
+        )
+    except SlotsFullError as err:
+        print(f"Server full ({err.used}/{err.cap}) — raise the limit in the dashboard.")
+
+    # Poll until the on-server agent has the terminal up, then trade as usual.
+    while True:
+        server = fx.private_servers.get(server)
+        account = next(a for a in server.accounts if a.id == account.id)
+        if account.status == PrivateAccountStatus.READY:
+            break
+        time.sleep(5)
+
+    print(fx.terminal(account).account_summary())
+```
+
+Accounts on a private server are traded and streamed exactly like
+shared-cluster accounts — their `rest_url` / `ws_url` simply point at the
+server's dedicated IP. The server presents a self-signed certificate, so reach
+it with `Client(..., verify_terminal_tls=False)` (or supply a pinned CA).
+*Purchasing* a server, canceling, and slot changes happen in the dashboard;
+the API deliberately exposes no billing operations.
 
 ## Timestamps
 

{fxsocket-0.2 → fxsocket-0.3.0}/README.md

@@ -13,6 +13,8 @@ interfaces.
 ## Features
 
 - **Account management** — link, list, fetch, and disconnect MT4/MT5 accounts.
+- **Private servers** — list your dedicated hosting servers and manage the
+  accounts on them.
 - **Trading** — market & pending orders, modify, close, plus margin/profit calculators.
 - **Market data** — quotes, symbol specifications, OHLC history, account state & info.
 - **Live streaming** — ticks, bars, account, positions, trades, and terminal status
@@ -211,11 +213,41 @@ except AccountCapError as e:
 
 ## Private hosting
 
-Privately-hosted accounts (a dedicated droplet) are listed, traded, and streamed
-exactly like shared-cluster accounts — their `rest_url` / `ws_url` simply point
-at the droplet. The droplet serves a self-signed certificate, so reach it with
-`Client(..., verify_terminal_tls=False)` (or supply a pinned CA). *Creating* a
-private-hosted account is done in the dashboard.
+Dedicated private servers are managed through `client.private_servers`:
+
+```python
+import time
+
+from fxsocket import Client, PrivateAccountStatus, SlotsFullError
+
+with Client(api_key="fxs_live_...", verify_terminal_tls=False) as fx:
+    [server] = fx.private_servers.list()
+    print(server.name, server.status, f"{server.used_slots}/{server.purchased_slots}")
+
+    try:
+        account = fx.private_servers.add_account(
+            server, server="ICMarkets-Demo", login=1150125, password="..."
+        )
+    except SlotsFullError as err:
+        print(f"Server full ({err.used}/{err.cap}) — raise the limit in the dashboard.")
+
+    # Poll until the on-server agent has the terminal up, then trade as usual.
+    while True:
+        server = fx.private_servers.get(server)
+        account = next(a for a in server.accounts if a.id == account.id)
+        if account.status == PrivateAccountStatus.READY:
+            break
+        time.sleep(5)
+
+    print(fx.terminal(account).account_summary())
+```
+
+Accounts on a private server are traded and streamed exactly like
+shared-cluster accounts — their `rest_url` / `ws_url` simply point at the
+server's dedicated IP. The server presents a self-signed certificate, so reach
+it with `Client(..., verify_terminal_tls=False)` (or supply a pinned CA).
+*Purchasing* a server, canceling, and slot changes happen in the dashboard;
+the API deliberately exposes no billing operations.
 
 ## Timestamps
 

{fxsocket-0.2 → fxsocket-0.3.0}/src/fxsocket/__init__.py

@@ -16,6 +16,8 @@ from .enums import (
     OrderOperation,
     OrderOutcome,
     Platform,
+    PrivateAccountStatus,
+    PrivateServerStatus,
     Timeframe,
     TradingStatus,
 )
@@ -28,6 +30,7 @@ from .errors import (
     NoSubscriptionError,
     NotFoundError,
     RateLimitError,
+    SlotsFullError,
     StreamError,
     TerminalNotReadyError,
     TerminalTimeoutError,
@@ -46,6 +49,8 @@ from .models import (
     OpenedOrder,
     OrderResult,
     PositionTrade,
+    PrivateServer,
+    PrivateServerAccount,
     ProfitCalc,
     Quote,
     ServerTimezone,
@@ -97,6 +102,8 @@ __all__ = [
     "TradeEventData",
     "TerminalStatusData",
     "Account",
+    "PrivateServer",
+    "PrivateServerAccount",
     "AccountSummary",
     "AccountInfo",
     "OpenedOrder",
@@ -112,6 +119,8 @@ __all__ = [
     "Health",
     "HealthChecks",
     "Platform",
+    "PrivateAccountStatus",
+    "PrivateServerStatus",
     "TradingStatus",
     "OrderOperation",
     "OrderOutcome",
@@ -128,6 +137,7 @@ __all__ = [
     "AccountCapError",
     "NoSubscriptionError",
     "DuplicateAccountError",
+    "SlotsFullError",
     "ConnectFailedError",
     "TerminalNotReadyError",
     "TerminalTimeoutError",

fxsocket-0.3.0/src/fxsocket/_version.py

@@ -0,0 +1 @@
+__version__ = "0.3.0"

{fxsocket-0.2 → fxsocket-0.3.0}/src/fxsocket/client.py

@@ -15,8 +15,13 @@ import httpx
 from ._http import AsyncHTTP, SyncHTTP, auth_headers
 from .config import DEFAULT_BASE_URL, DEFAULT_TIMEOUT, ENV_API_KEY
 from .errors import AuthError, TerminalNotReadyError
-from .management import Accounts, AsyncAccounts
-from .models import Account
+from .management import (
+    Accounts,
+    AsyncAccounts,
+    AsyncPrivateServers,
+    PrivateServers,
+)
+from .models import Account, PrivateServerAccount
 from .terminal.client import AsyncTerminalClient, TerminalClient
 from .terminal.stream import AsyncStream, Stream
 
@@ -63,11 +68,13 @@ class Client:
         )
         #: Account management (the v1 API).
         self.accounts = Accounts(SyncHTTP(self._http_client))
+        #: Private hosting servers (the v1 API).
+        self.private_servers = PrivateServers(SyncHTTP(self._http_client))
         self._terminals: dict[tuple[str, str], TerminalClient] = {}
 
     def terminal(
         self,
-        account: Account,
+        account: Account | PrivateServerAccount,
         *,
         verify: bool | None = None,
         timeout: float | None = None,
@@ -100,7 +107,7 @@ class Client:
 
     def stream(
         self,
-        account: Account,
+        account: Account | PrivateServerAccount,
         *,
         verify: bool | None = None,
         auto_reconnect: bool = True,
@@ -178,11 +185,12 @@ class AsyncClient:
             timeout=timeout,
         )
         self.accounts = AsyncAccounts(AsyncHTTP(self._http_client))
+        self.private_servers = AsyncPrivateServers(AsyncHTTP(self._http_client))
         self._terminals: dict[tuple[str, str], AsyncTerminalClient] = {}
 
     def terminal(
         self,
-        account: Account,
+        account: Account | PrivateServerAccount,
         *,
         verify: bool | None = None,
         timeout: float | None = None,
@@ -212,7 +220,7 @@ class AsyncClient:
 
     def stream(
         self,
-        account: Account,
+        account: Account | PrivateServerAccount,
         *,
         verify: bool | None = None,
         auto_reconnect: bool = True,

{fxsocket-0.2 → fxsocket-0.3.0}/src/fxsocket/enums.py

@@ -76,6 +76,25 @@ class OrderOutcome(str, Enum):
     REJECTED = "rejected"     #: anything else — inspect ``retcode`` / ``comment``
 
 
+class PrivateServerStatus(str, Enum):
+    """Lifecycle of a private hosting server (v1 ``status``)."""
+
+    PENDING_PAYMENT = "pending_payment"
+    PROVISIONING = "provisioning"
+    READY = "ready"
+    RESIZING = "resizing"
+    EXPIRED = "expired"
+
+
+class PrivateAccountStatus(str, Enum):
+    """Lifecycle of an account living on a private server (v1 ``status``)."""
+
+    PROVISIONING = "provisioning"
+    READY = "ready"
+    ERROR = "error"
+    EXPIRED = "expired"
+
+
 class OrderKind(str, Enum):
     """Whether an opened row is a live position or a resting pending order."""
 

{fxsocket-0.2 → fxsocket-0.3.0}/src/fxsocket/errors.py

@@ -74,6 +74,24 @@ class DuplicateAccountError(FxSocketError):
     """This account is already linked (HTTP 409)."""
 
 
+class SlotsFullError(FxSocketError):
+    """Every purchased slot on the private server is taken (HTTP 409
+    ``slots_full``). Raise the server's limit from the dashboard."""
+
+    def __init__(
+        self,
+        message: str,
+        *,
+        used: int | None = None,
+        cap: int | None = None,
+        **kw: Any,
+    ):
+        super().__init__(message, **kw)
+        self.used = used
+        self.cap = cap
+
+
+
 class ConnectFailedError(FxSocketError):
     """The broker rejected the login during account creation (HTTP 400).
 
@@ -145,6 +163,10 @@ def error_from_response(resp: httpx.Response) -> FxSocketError:
     if status == 404:
         return NotFoundError(message, **common)
     if status == 409:
+        if code == "slots_full" and isinstance(body, dict):
+            return SlotsFullError(
+                message, used=body.get("used"), cap=body.get("cap"), **common
+            )
         return DuplicateAccountError(message, **common)
     if status == 402:
         if code == "account_cap_reached" and isinstance(body, dict):

fxsocket-0.3.0/src/fxsocket/management.py

@@ -0,0 +1,264 @@
+"""Account management — the public v1 API (``/v1/accounts``).
+
+Accessible as ``client.accounts`` on both :class:`~fxsocket.Client` and
+:class:`~fxsocket.AsyncClient`.
+"""
+
+from __future__ import annotations
+
+from ._http import AsyncHTTP, SyncHTTP
+from .enums import Platform
+from .models import Account, PrivateServer, PrivateServerAccount
+
+
+def account_id_of(account: Account | str) -> str:
+    """Accept either an :class:`Account` or a bare id string."""
+    return account.id if isinstance(account, Account) else str(account)
+
+
+def _create_payload(
+    *,
+    server: str,
+    login: int,
+    password: str,
+    platform: Platform | str,
+    nickname: str,
+) -> dict[str, object]:
+    return {
+        "platform": Platform(platform).value,
+        "server": server,
+        "login": login,
+        "password": password,
+        "nickname": nickname,
+    }
+
+
+class Accounts:
+    """Synchronous account operations."""
+
+    def __init__(self, http: SyncHTTP) -> None:
+        self._http = http
+
+    def list(self) -> list[Account]:
+        """List every account owned by the authenticated user."""
+        data = self._http.request("GET", "/accounts")
+        return [Account.model_validate(row) for row in data]
+
+    def get(self, account: Account | str) -> Account:
+        """Fetch one account by id (use this to poll connection status)."""
+        data = self._http.request("GET", f"/accounts/{account_id_of(account)}")
+        return Account.model_validate(data)
+
+    def create(
+        self,
+        *,
+        server: str,
+        login: int,
+        password: str,
+        platform: Platform | str = Platform.MT5,
+        nickname: str = "",
+    ) -> Account:
+        """Link (connect) a new MT4/MT5 account. Returns it in ``connecting``
+        state when terminal pods are enabled, else ``connected``."""
+        data = self._http.request(
+            "POST",
+            "/accounts",
+            json=_create_payload(
+                server=server,
+                login=login,
+                password=password,
+                platform=platform,
+                nickname=nickname,
+            ),
+        )
+        return Account.model_validate(data)
+
+    def delete(self, account: Account | str) -> None:
+        """Unlink (disconnect) an account and tear down its terminal."""
+        self._http.request("DELETE", f"/accounts/{account_id_of(account)}")
+
+
+class AsyncAccounts:
+    """Asynchronous mirror of :class:`Accounts`."""
+
+    def __init__(self, http: AsyncHTTP) -> None:
+        self._http = http
+
+    async def list(self) -> list[Account]:
+        data = await self._http.request("GET", "/accounts")
+        return [Account.model_validate(row) for row in data]
+
+    async def get(self, account: Account | str) -> Account:
+        data = await self._http.request("GET", f"/accounts/{account_id_of(account)}")
+        return Account.model_validate(data)
+
+    async def create(
+        self,
+        *,
+        server: str,
+        login: int,
+        password: str,
+        platform: Platform | str = Platform.MT5,
+        nickname: str = "",
+    ) -> Account:
+        data = await self._http.request(
+            "POST",
+            "/accounts",
+            json=_create_payload(
+                server=server,
+                login=login,
+                password=password,
+                platform=platform,
+                nickname=nickname,
+            ),
+        )
+        return Account.model_validate(data)
+
+    async def delete(self, account: Account | str) -> None:
+        await self._http.request("DELETE", f"/accounts/{account_id_of(account)}")
+
+
+# --------------------------------------------------------------------------- #
+# Private servers (``/v1/private-servers``)
+# --------------------------------------------------------------------------- #
+
+
+def private_server_id_of(server: PrivateServer | str) -> str:
+    """Accept either a :class:`PrivateServer` or a bare id string."""
+    return server.id if isinstance(server, PrivateServer) else str(server)
+
+
+def _private_account_payload(
+    *,
+    server: str,
+    login: int,
+    password: str,
+    platform: Platform | str,
+    nickname: str,
+    trade_ea_symbol: str,
+) -> dict[str, object]:
+    return {
+        "platform": Platform(platform).value,
+        "server": server,
+        "login": login,
+        "password": password,
+        "nickname": nickname,
+        "trade_ea_symbol": trade_ea_symbol,
+    }
+
+
+class PrivateServers:
+    """Synchronous private-server operations.
+
+    Read + on-server account management only: purchasing a server,
+    canceling, and slot changes happen in the dashboard.
+    """
+
+    def __init__(self, http: SyncHTTP) -> None:
+        self._http = http
+
+    def list(self) -> list[PrivateServer]:
+        """List every private server owned by the authenticated user."""
+        data = self._http.request("GET", "/private-servers")
+        return [PrivateServer.model_validate(row) for row in data]
+
+    def get(self, server: PrivateServer | str) -> PrivateServer:
+        """Fetch one server by id (use this to poll account readiness)."""
+        data = self._http.request(
+            "GET", f"/private-servers/{private_server_id_of(server)}"
+        )
+        return PrivateServer.model_validate(data)
+
+    def add_account(
+        self,
+        private_server: PrivateServer | str,
+        *,
+        server: str,
+        login: int,
+        password: str,
+        platform: Platform | str = Platform.MT5,
+        nickname: str = "",
+        trade_ea_symbol: str = "",
+    ) -> PrivateServerAccount:
+        """Connect an MT4/MT5 account onto the server.
+
+        The on-server agent brings the terminal up asynchronously — poll
+        :meth:`get` until the account's ``status`` reaches ``ready``.
+        Raises :class:`~fxsocket.SlotsFullError` when every purchased slot
+        is taken and :class:`~fxsocket.DuplicateAccountError` when the
+        account is already linked.
+        """
+        data = self._http.request(
+            "POST",
+            f"/private-servers/{private_server_id_of(private_server)}/accounts",
+            json=_private_account_payload(
+                server=server,
+                login=login,
+                password=password,
+                platform=platform,
+                nickname=nickname,
+                trade_ea_symbol=trade_ea_symbol,
+            ),
+        )
+        return PrivateServerAccount.model_validate(data)
+
+    def remove_account(
+        self,
+        private_server: PrivateServer | str,
+        account: PrivateServerAccount | str,
+    ) -> None:
+        """Detach an account from the server, freeing its slot."""
+        sid = private_server_id_of(private_server)
+        aid = account.id if isinstance(account, PrivateServerAccount) else str(account)
+        self._http.request("DELETE", f"/private-servers/{sid}/accounts/{aid}")
+
+
+class AsyncPrivateServers:
+    """Asynchronous mirror of :class:`PrivateServers`."""
+
+    def __init__(self, http: AsyncHTTP) -> None:
+        self._http = http
+
+    async def list(self) -> list[PrivateServer]:
+        data = await self._http.request("GET", "/private-servers")
+        return [PrivateServer.model_validate(row) for row in data]
+
+    async def get(self, server: PrivateServer | str) -> PrivateServer:
+        data = await self._http.request(
+            "GET", f"/private-servers/{private_server_id_of(server)}"
+        )
+        return PrivateServer.model_validate(data)
+
+    async def add_account(
+        self,
+        private_server: PrivateServer | str,
+        *,
+        server: str,
+        login: int,
+        password: str,
+        platform: Platform | str = Platform.MT5,
+        nickname: str = "",
+        trade_ea_symbol: str = "",
+    ) -> PrivateServerAccount:
+        data = await self._http.request(
+            "POST",
+            f"/private-servers/{private_server_id_of(private_server)}/accounts",
+            json=_private_account_payload(
+                server=server,
+                login=login,
+                password=password,
+                platform=platform,
+                nickname=nickname,
+                trade_ea_symbol=trade_ea_symbol,
+            ),
+        )
+        return PrivateServerAccount.model_validate(data)
+
+    async def remove_account(
+        self,
+        private_server: PrivateServer | str,
+        account: PrivateServerAccount | str,
+    ) -> None:
+        sid = private_server_id_of(private_server)
+        aid = account.id if isinstance(account, PrivateServerAccount) else str(account)
+        await self._http.request("DELETE", f"/private-servers/{sid}/accounts/{aid}")

{fxsocket-0.2 → fxsocket-0.3.0}/src/fxsocket/models.py

@@ -70,6 +70,67 @@ class Account(BaseModel):
         return bool(self.rest_url)
 
 
+class PrivateServerAccount(BaseModel):
+    """An MT4/MT5 account living on a private server (v1 API).
+
+    ``status`` is the private-hosting lifecycle — compare against
+    :class:`fxsocket.PrivateAccountStatus` (provisioning / ready / error /
+    expired). ``rest_url`` / ``ws_url`` are the account's terminal API on
+    the server's dedicated IP. Private servers use a self-signed TLS
+    certificate, so pass ``verify=False`` (or construct the client with
+    ``verify_terminal_tls=False``) when calling ``client.terminal(...)``.
+    """
+
+    model_config = ConfigDict(populate_by_name=True, extra="ignore")
+
+    id: str
+    nickname: str = ""
+    platform: Platform
+    server: str
+    login: int
+    status: str
+    rest_url: str = ""
+    ws_url: str = ""
+    trade_ea_symbol: str = ""
+    created_at: datetime
+
+    @property
+    def has_terminal(self) -> bool:
+        """True when this account exposes a reachable terminal API."""
+        return bool(self.rest_url)
+
+
+class PrivateServer(BaseModel):
+    """A dedicated private hosting server (v1 API).
+
+    ``status`` is the server lifecycle — compare against
+    :class:`fxsocket.PrivateServerStatus`. ``purchased_slots`` is the paid
+    limit; ``used_slots`` how many accounts currently live on the server.
+    Purchasing, canceling and slot changes happen in the dashboard, not
+    the API.
+    """
+
+    model_config = ConfigDict(populate_by_name=True, extra="ignore")
+
+    id: str
+    name: str = ""
+    status: str
+    region: str = ""
+    ip: str = ""
+    purchased_slots: int = 0
+    used_slots: int = 0
+    period_end: datetime | None = None
+    accounts: list[PrivateServerAccount] = []
+
+    @property
+    def is_ready(self) -> bool:
+        return self.status == "ready"
+
+    @property
+    def free_slots(self) -> int:
+        return max(self.purchased_slots - self.used_slots, 0)
+
+
 # --------------------------------------------------------------------------- #
 # Terminal — account state
 # --------------------------------------------------------------------------- #

fxsocket-0.3.0/tests/test_private_servers.py

@@ -0,0 +1,181 @@
+"""Tests for the private-server management client (sync + async)."""
+
+from __future__ import annotations
+
+import httpx
+import pytest
+import respx
+
+from fxsocket import (
+    AsyncClient,
+    Client,
+    DuplicateAccountError,
+    PrivateAccountStatus,
+    PrivateServerStatus,
+    SlotsFullError,
+)
+
+BASE = "https://api.fxsocket.com/v1"
+
+SERVER_ID = "ecf2fa95-4177-4402-8a00-dea33ae0e79a"
+
+SERVER_ACCOUNT = {
+    "id": "22222222-2222-2222-2222-222222222222",
+    "nickname": "prop-1",
+    "platform": "mt5",
+    "server": "ICMarkets-Demo",
+    "login": 7001,
+    "status": "ready",
+    "rest_url": f"https://159.223.244.125/22222222-2222-2222-2222-222222222222",
+    "ws_url": f"wss://159.223.244.125/22222222-2222-2222-2222-222222222222/ws",
+    "trade_ea_symbol": "",
+    "created_at": "2026-07-16T08:00:00Z",
+}
+
+SERVER = {
+    "id": SERVER_ID,
+    "name": "My Prop Guard",
+    "status": "ready",
+    "region": "lon1",
+    "ip": "159.223.244.125",
+    "purchased_slots": 2,
+    "used_slots": 1,
+    "period_end": "2026-08-16T07:01:08Z",
+    "accounts": [SERVER_ACCOUNT],
+}
+
+
+def _client() -> Client:
+    return Client(api_key="fxs_live_test")
+
+
+@respx.mock
+def test_list_servers_parses_models() -> None:
+    respx.get(f"{BASE}/private-servers").mock(
+        return_value=httpx.Response(200, json=[SERVER])
+    )
+    with _client() as fx:
+        [server] = fx.private_servers.list()
+    assert server.name == "My Prop Guard"
+    assert server.status == PrivateServerStatus.READY
+    assert server.is_ready
+    assert server.ip == "159.223.244.125"
+    assert server.free_slots == 1
+    [account] = server.accounts
+    assert account.status == PrivateAccountStatus.READY
+    assert account.has_terminal
+
+
+@respx.mock
+def test_get_accepts_model_or_id() -> None:
+    route = respx.get(f"{BASE}/private-servers/{SERVER_ID}").mock(
+        return_value=httpx.Response(200, json=SERVER)
+    )
+    with _client() as fx:
+        by_id = fx.private_servers.get(SERVER_ID)
+        by_model = fx.private_servers.get(by_id)
+    assert route.call_count == 2
+    assert by_model.id == SERVER_ID
+
+
+@respx.mock
+def test_add_account_payload_and_model() -> None:
+    route = respx.post(f"{BASE}/private-servers/{SERVER_ID}/accounts").mock(
+        return_value=httpx.Response(201, json=SERVER_ACCOUNT)
+    )
+    with _client() as fx:
+        account = fx.private_servers.add_account(
+            SERVER_ID,
+            server="ICMarkets-Demo",
+            login=7001,
+            password="pw",
+            nickname="prop-1",
+        )
+    import json
+
+    sent = json.loads(route.calls.last.request.content)
+    assert sent == {
+        "platform": "mt5",
+        "server": "ICMarkets-Demo",
+        "login": 7001,
+        "password": "pw",
+        "nickname": "prop-1",
+        "trade_ea_symbol": "",
+    }
+    assert account.login == 7001
+
+
+@respx.mock
+def test_slots_full_maps_to_typed_error() -> None:
+    respx.post(f"{BASE}/private-servers/{SERVER_ID}/accounts").mock(
+        return_value=httpx.Response(
+            409,
+            json={
+                "error": "slots_full",
+                "detail": "Server is full (2/2).",
+                "used": 2,
+                "cap": 2,
+            },
+        )
+    )
+    with _client() as fx:
+        with pytest.raises(SlotsFullError) as err:
+            fx.private_servers.add_account(
+                SERVER_ID, server="Demo", login=1, password="pw"
+            )
+    assert err.value.used == 2
+    assert err.value.cap == 2
+
+
+@respx.mock
+def test_duplicate_still_maps_to_duplicate_error() -> None:
+    respx.post(f"{BASE}/private-servers/{SERVER_ID}/accounts").mock(
+        return_value=httpx.Response(
+            409, json={"error": "duplicate", "detail": "Already linked."}
+        )
+    )
+    with _client() as fx:
+        with pytest.raises(DuplicateAccountError):
+            fx.private_servers.add_account(
+                SERVER_ID, server="Demo", login=1, password="pw"
+            )
+
+
+@respx.mock
+def test_remove_account() -> None:
+    account_id = SERVER_ACCOUNT["id"]
+    route = respx.delete(
+        f"{BASE}/private-servers/{SERVER_ID}/accounts/{account_id}"
+    ).mock(return_value=httpx.Response(204))
+    with _client() as fx:
+        fx.private_servers.remove_account(SERVER_ID, account_id)
+    assert route.called
+
+
+@respx.mock
+def test_terminal_client_from_private_account() -> None:
+    respx.get(f"{BASE}/private-servers").mock(
+        return_value=httpx.Response(200, json=[SERVER])
+    )
+    with _client() as fx:
+        [server] = fx.private_servers.list()
+        term = fx.terminal(server.accounts[0], verify=False)
+    assert term is not None
+
+
+@pytest.mark.asyncio
+@respx.mock
+async def test_async_mirror() -> None:
+    respx.get(f"{BASE}/private-servers").mock(
+        return_value=httpx.Response(200, json=[SERVER])
+    )
+    respx.post(f"{BASE}/private-servers/{SERVER_ID}/accounts").mock(
+        return_value=httpx.Response(201, json=SERVER_ACCOUNT)
+    )
+    async with AsyncClient(api_key="fxs_live_test") as fx:
+        [server] = await fx.private_servers.list()
+        account = await fx.private_servers.add_account(
+            server, server="ICMarkets-Demo", login=7001, password="pw"
+        )
+    assert server.is_ready
+    assert account.login == 7001

fxsocket-0.2/src/fxsocket/_version.py

@@ -1 +0,0 @@
-__version__ = "0.2"

fxsocket-0.2/src/fxsocket/management.py

@@ -1,118 +0,0 @@
-"""Account management — the public v1 API (``/v1/accounts``).
-
-Accessible as ``client.accounts`` on both :class:`~fxsocket.Client` and
-:class:`~fxsocket.AsyncClient`.
-"""
-
-from __future__ import annotations
-
-from ._http import AsyncHTTP, SyncHTTP
-from .enums import Platform
-from .models import Account
-
-
-def account_id_of(account: Account | str) -> str:
-    """Accept either an :class:`Account` or a bare id string."""
-    return account.id if isinstance(account, Account) else str(account)
-
-
-def _create_payload(
-    *,
-    server: str,
-    login: int,
-    password: str,
-    platform: Platform | str,
-    nickname: str,
-) -> dict[str, object]:
-    return {
-        "platform": Platform(platform).value,
-        "server": server,
-        "login": login,
-        "password": password,
-        "nickname": nickname,
-    }
-
-
-class Accounts:
-    """Synchronous account operations."""
-
-    def __init__(self, http: SyncHTTP) -> None:
-        self._http = http
-
-    def list(self) -> list[Account]:
-        """List every account owned by the authenticated user."""
-        data = self._http.request("GET", "/accounts")
-        return [Account.model_validate(row) for row in data]
-
-    def get(self, account: Account | str) -> Account:
-        """Fetch one account by id (use this to poll connection status)."""
-        data = self._http.request("GET", f"/accounts/{account_id_of(account)}")
-        return Account.model_validate(data)
-
-    def create(
-        self,
-        *,
-        server: str,
-        login: int,
-        password: str,
-        platform: Platform | str = Platform.MT5,
-        nickname: str = "",
-    ) -> Account:
-        """Link (connect) a new MT4/MT5 account. Returns it in ``connecting``
-        state when terminal pods are enabled, else ``connected``."""
-        data = self._http.request(
-            "POST",
-            "/accounts",
-            json=_create_payload(
-                server=server,
-                login=login,
-                password=password,
-                platform=platform,
-                nickname=nickname,
-            ),
-        )
-        return Account.model_validate(data)
-
-    def delete(self, account: Account | str) -> None:
-        """Unlink (disconnect) an account and tear down its terminal."""
-        self._http.request("DELETE", f"/accounts/{account_id_of(account)}")
-
-
-class AsyncAccounts:
-    """Asynchronous mirror of :class:`Accounts`."""
-
-    def __init__(self, http: AsyncHTTP) -> None:
-        self._http = http
-
-    async def list(self) -> list[Account]:
-        data = await self._http.request("GET", "/accounts")
-        return [Account.model_validate(row) for row in data]
-
-    async def get(self, account: Account | str) -> Account:
-        data = await self._http.request("GET", f"/accounts/{account_id_of(account)}")
-        return Account.model_validate(data)
-
-    async def create(
-        self,
-        *,
-        server: str,
-        login: int,
-        password: str,
-        platform: Platform | str = Platform.MT5,
-        nickname: str = "",
-    ) -> Account:
-        data = await self._http.request(
-            "POST",
-            "/accounts",
-            json=_create_payload(
-                server=server,
-                login=login,
-                password=password,
-                platform=platform,
-                nickname=nickname,
-            ),
-        )
-        return Account.model_validate(data)
-
-    async def delete(self, account: Account | str) -> None:
-        await self._http.request("DELETE", f"/accounts/{account_id_of(account)}")